opencode-diane 0.0.5

package/dist/ingest/adaptive.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Adaptive configuration — scale size-derived settings to the repo.
+ *
+ * The plugin's fixed defaults (gitHistoryDepth 500, a 4000-file
+ * code-map cap, a 5 MB budget) are a reasonable middle. They are
+ * wasteful on a 50-commit toy and inadequate on a 100k-commit
+ * monorepo. Rather than a pile of per-knob heuristics, this module
+ * takes ONE measured signal — commit count, or file count when
+ * there's no git — classifies the repo into one named tier, and a
+ * lookup table picks the numbers. One input, three tiers, inspectable
+ * and logged: that keeps adaptation predictable.
+ *
+ * Adaptation only fills knobs the user did NOT set explicitly
+ * (`ResolvedConfig.explicitKeys`); an explicit value always wins.
+ * It is gated by `config.adaptive` (default true).
+ */
+import type { ResolvedConfig } from "../types.js";
+export type RepoTier = "small" | "medium" | "large";
+export interface RepoSignal {
+    /** What was measured: a git commit count, or a tree file count. */
+    basis: "commits" | "files";
+    value: number;
+    tier: RepoTier;
+}
+/**
+ * Measure the repo with one cheap call and classify it. Uses
+ * `git rev-list --count HEAD` when git is present; otherwise counts
+ * files in the tree (bounded — we stop early once past the large
+ * threshold, since the exact number past that doesn't matter).
+ * Never throws — on any failure it returns the `medium` tier, i.e.
+ * the plugin's existing fixed defaults.
+ */
+export declare function measureRepo(root: string, hasGit: boolean): Promise<RepoSignal>;
+/**
+ * Apply size-derived tuning to a resolved config, **mutating it in
+ * place**. The config object is shared (the plugin's tools and hooks
+ * close over it at startup, before background prefill runs the
+ * measurement), so a returned copy wouldn't reach them — a one-time
+ * in-place settle does. Only knobs the user did NOT set explicitly
+ * are touched. Returns a short human-readable description of what
+ * changed, for the prefill log.
+ *
+ * When `config.adaptive` is false this is a no-op.
+ */
+export declare function applyAdaptiveTuning(config: ResolvedConfig, signal: RepoSignal): {
+    summary: string;
+};

package/dist/ingest/adaptive.js

@@ -0,0 +1,182 @@
+/**
+ * Adaptive configuration — scale size-derived settings to the repo.
+ *
+ * The plugin's fixed defaults (gitHistoryDepth 500, a 4000-file
+ * code-map cap, a 5 MB budget) are a reasonable middle. They are
+ * wasteful on a 50-commit toy and inadequate on a 100k-commit
+ * monorepo. Rather than a pile of per-knob heuristics, this module
+ * takes ONE measured signal — commit count, or file count when
+ * there's no git — classifies the repo into one named tier, and a
+ * lookup table picks the numbers. One input, three tiers, inspectable
+ * and logged: that keeps adaptation predictable.
+ *
+ * Adaptation only fills knobs the user did NOT set explicitly
+ * (`ResolvedConfig.explicitKeys`); an explicit value always wins.
+ * It is gated by `config.adaptive` (default true).
+ */
+import { runGit } from "../utils/shell.js";
+const TIERS = {
+    small: {
+        gitHistoryDepth: 250,
+        maxMemoryDiskMB: 50, // uniform across tiers — see the note above
+        codeMapMaxFiles: 1500,
+        coChangeMaxCommits: 5000,
+    },
+    medium: {
+        gitHistoryDepth: 500,
+        maxMemoryDiskMB: 50,
+        codeMapMaxFiles: 4000,
+        coChangeMaxCommits: 5000,
+    },
+    large: {
+        gitHistoryDepth: 1500,
+        maxMemoryDiskMB: 50,
+        codeMapMaxFiles: 10000,
+        // co-change is the one genuinely super-linear pass; on very large
+        // histories it is skipped rather than risking a stall.
+        coChangeMaxCommits: 5000,
+    },
+};
+/** Commit-count thresholds for the git-available path. */
+const SMALL_MAX_COMMITS = 150;
+const LARGE_MIN_COMMITS = 2000;
+/** File-count thresholds for the no-git fallback path. */
+const SMALL_MAX_FILES = 400;
+const LARGE_MIN_FILES = 5000;
+/**
+ * Measure the repo with one cheap call and classify it. Uses
+ * `git rev-list --count HEAD` when git is present; otherwise counts
+ * files in the tree (bounded — we stop early once past the large
+ * threshold, since the exact number past that doesn't matter).
+ * Never throws — on any failure it returns the `medium` tier, i.e.
+ * the plugin's existing fixed defaults.
+ */
+export async function measureRepo(root, hasGit) {
+    if (hasGit) {
+        const out = await runGit(["rev-list", "--count", "HEAD"], root);
+        const n = out ? parseInt(out.trim(), 10) : NaN;
+        if (Number.isFinite(n)) {
+            return { basis: "commits", value: n, tier: tierForCommits(n) };
+        }
+        // git present but rev-list failed (empty repo, detached, etc.) —
+        // fall through to the file-count basis.
+    }
+    const files = await countFiles(root);
+    return { basis: "files", value: files, tier: tierForFiles(files) };
+}
+function tierForCommits(n) {
+    if (n <= SMALL_MAX_COMMITS)
+        return "small";
+    if (n >= LARGE_MIN_COMMITS)
+        return "large";
+    return "medium";
+}
+function tierForFiles(n) {
+    if (n <= SMALL_MAX_FILES)
+        return "small";
+    if (n >= LARGE_MIN_FILES)
+        return "large";
+    return "medium";
+}
+/** Directories not worth walking when sizing the repo. */
+const SKIP = new Set([
+    ".git",
+    "node_modules",
+    ".venv",
+    "venv",
+    "__pycache__",
+    "dist",
+    "build",
+    "target",
+    "vendor",
+    ".next",
+    "coverage",
+]);
+/**
+ * Bounded file count: walks the tree but stops once it is clearly
+ * past the "large" threshold — the exact count beyond that point
+ * doesn't change the tier, so there's no reason to keep walking a
+ * huge tree.
+ */
+async function countFiles(root) {
+    const { readdir } = await import("node:fs/promises");
+    const { join } = await import("node:path");
+    const CEILING = LARGE_MIN_FILES + 1;
+    let count = 0;
+    async function walk(dir, depth) {
+        if (count >= CEILING || depth > 8)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (count >= CEILING)
+                return;
+            if (e.isDirectory()) {
+                if (SKIP.has(e.name) || e.name.startsWith("."))
+                    continue;
+                await walk(join(dir, e.name), depth + 1);
+            }
+            else if (e.isFile()) {
+                count += 1;
+            }
+        }
+    }
+    await walk(root, 0);
+    return count;
+}
+/**
+ * Apply size-derived tuning to a resolved config, **mutating it in
+ * place**. The config object is shared (the plugin's tools and hooks
+ * close over it at startup, before background prefill runs the
+ * measurement), so a returned copy wouldn't reach them — a one-time
+ * in-place settle does. Only knobs the user did NOT set explicitly
+ * are touched. Returns a short human-readable description of what
+ * changed, for the prefill log.
+ *
+ * When `config.adaptive` is false this is a no-op.
+ */
+export function applyAdaptiveTuning(config, signal) {
+    if (!config.adaptive) {
+        return { summary: "adaptive tuning off — using fixed defaults" };
+    }
+    const t = TIERS[signal.tier];
+    const changes = [];
+    if (!config.explicitKeys.has("gitHistoryDepth") && config.gitHistoryDepth !== t.gitHistoryDepth) {
+        config.gitHistoryDepth = t.gitHistoryDepth;
+        changes.push(`gitHistoryDepth=${t.gitHistoryDepth}`);
+    }
+    if (!config.explicitKeys.has("maxMemoryDiskMB")) {
+        // The budget is tier-independent (all tiers carry the 50 MB
+        // default), so this normally makes no change. Adaptation only ever
+        // RAISES the budget, never lowers it — `Math.max` keeps that
+        // invariant if a future tier table sets a larger value.
+        const mb = Math.max(50, t.maxMemoryDiskMB);
+        const bytes = mb * 1024 * 1024;
+        if (config.maxMemoryBytes !== bytes) {
+            config.maxMemoryBytes = bytes;
+            changes.push(`budget=${mb}MB`);
+        }
+    }
+    // codeMapMaxFiles and coChangeMaxCommits are user-exposable since
+    // v0.0.4 — respect an explicit override; otherwise follow the tier.
+    if (!config.explicitKeys.has("codeMapMaxFiles") && config.codeMapMaxFiles !== t.codeMapMaxFiles) {
+        config.codeMapMaxFiles = t.codeMapMaxFiles;
+        changes.push(`codeMapMaxFiles=${t.codeMapMaxFiles}`);
+    }
+    if (!config.explicitKeys.has("coChangeMaxCommits")) {
+        config.coChangeMaxCommits = t.coChangeMaxCommits;
+    }
+    const coChangeNote = signal.basis === "commits" && signal.value > t.coChangeMaxCommits
+        ? ", co-change skipped (history too large)"
+        : "";
+    const changeSummary = changes.length > 0 ? changes.join(", ") : "no changes (already at tier defaults)";
+    const summary = `repo tier=${signal.tier} (${signal.value} ${signal.basis}) — ` +
+        changeSummary +
+        coChangeNote;
+    return { summary };
+}

package/dist/ingest/code-health.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Code-health ingestion — turns OpenCode's LSP diagnostics into a
+ * live `code-health` memory category.
+ *
+ * Unlike git/project/session ingestion (one-shot, at startup), this
+ * is a LIVE signal: it's driven by the `lsp.client.diagnostics`
+ * plugin event, which fires whenever a language server re-analyses a
+ * file. Each fire upserts one memory per file — re-reporting REPLACES
+ * the prior state, so the store always reflects current diagnostics,
+ * never a pile of stale ones.
+ *
+ * Why this is convention-free and language-agnostic: LSP normalises
+ * diagnostics across 40+ servers into the same shape (severity 1-4,
+ * a message, a range). We read the compiler's / type-checker's own
+ * output — no heuristics, no per-language logic.
+ *
+ * The event payload shape is not nailed down across OpenCode
+ * versions, so extraction is deliberately defensive — it probes
+ * several plausible shapes and silently no-ops if none match, exactly
+ * like the session ingester does for SDK responses. The extraction
+ * logic is a pure function so it can be unit-tested against mock
+ * payloads without a running LSP.
+ */
+import type { MemoryRepository } from "../store/repository.js";
+/** Per-file diagnostic rollup extracted from an LSP event. */
+export interface FileDiagnostics {
+    path: string;
+    errors: number;
+    warnings: number;
+    infos: number;
+    hints: number;
+    /** A few representative messages, most-severe first. */
+    sampleMessages: string[];
+}
+export interface CodeHealthIngestResult {
+    filesUpdated: number;
+    filesCleared: number;
+}
+/**
+ * Ingest one `lsp.client.diagnostics` event payload. Returns how many
+ * file memories were updated / cleared. Never throws — a shape we
+ * don't recognise is simply a no-op.
+ */
+export declare function ingestCodeHealth(repo: MemoryRepository, payload: unknown): CodeHealthIngestResult;
+/**
+ * Pull per-file diagnostic rollups out of an LSP event payload of
+ * unknown shape. Handles the shapes seen / plausible across OpenCode
+ * versions:
+ *
+ *   { path|uri, diagnostics: [...] }
+ *   { properties: { path|uri, diagnostics: [...] } }
+ *   { type, properties: { ... } }                    (raw event)
+ *   { path|uri, diagnostics: { [uri]: [...] } }       (grouped)
+ *   { diagnostics: { [uri]: [...] } }                 (server-wide map)
+ *
+ * Anything unrecognised yields an empty array.
+ */
+export declare function extractDiagnostics(payload: unknown): FileDiagnostics[];

package/dist/ingest/code-health.js

@@ -0,0 +1,202 @@
+/**
+ * Code-health ingestion — turns OpenCode's LSP diagnostics into a
+ * live `code-health` memory category.
+ *
+ * Unlike git/project/session ingestion (one-shot, at startup), this
+ * is a LIVE signal: it's driven by the `lsp.client.diagnostics`
+ * plugin event, which fires whenever a language server re-analyses a
+ * file. Each fire upserts one memory per file — re-reporting REPLACES
+ * the prior state, so the store always reflects current diagnostics,
+ * never a pile of stale ones.
+ *
+ * Why this is convention-free and language-agnostic: LSP normalises
+ * diagnostics across 40+ servers into the same shape (severity 1-4,
+ * a message, a range). We read the compiler's / type-checker's own
+ * output — no heuristics, no per-language logic.
+ *
+ * The event payload shape is not nailed down across OpenCode
+ * versions, so extraction is deliberately defensive — it probes
+ * several plausible shapes and silently no-ops if none match, exactly
+ * like the session ingester does for SDK responses. The extraction
+ * logic is a pure function so it can be unit-tested against mock
+ * payloads without a running LSP.
+ */
+const CATEGORY = "code-health";
+/** LSP DiagnosticSeverity. 1=Error 2=Warning 3=Information 4=Hint. */
+const SEVERITY_ERROR = 1;
+const SEVERITY_WARNING = 2;
+/**
+ * Ingest one `lsp.client.diagnostics` event payload. Returns how many
+ * file memories were updated / cleared. Never throws — a shape we
+ * don't recognise is simply a no-op.
+ */
+export function ingestCodeHealth(repo, payload) {
+    const result = { filesUpdated: 0, filesCleared: 0 };
+    const perFile = extractDiagnostics(payload);
+    if (perFile.length === 0)
+        return result;
+    for (const fd of perFile) {
+        const total = fd.errors + fd.warnings + fd.infos + fd.hints;
+        if (total === 0) {
+            // File is clean now — drop any stale code-health memory for it.
+            // upsertBySubject with a "clean" body keeps one tiny memory so
+            // the agent can positively learn "this file currently has no
+            // diagnostics" rather than just missing-data.
+            repo.upsertBySubject({
+                category: CATEGORY,
+                subject: fd.path,
+                content: `${fd.path} currently has no LSP diagnostics (clean).`,
+                tags: ["code-health", "clean", fd.path],
+                source: "lsp:diagnostics",
+            });
+            result.filesCleared += 1;
+            continue;
+        }
+        const parts = [];
+        if (fd.errors > 0)
+            parts.push(`${fd.errors} error${fd.errors === 1 ? "" : "s"}`);
+        if (fd.warnings > 0)
+            parts.push(`${fd.warnings} warning${fd.warnings === 1 ? "" : "s"}`);
+        if (fd.infos > 0)
+            parts.push(`${fd.infos} info`);
+        if (fd.hints > 0)
+            parts.push(`${fd.hints} hint${fd.hints === 1 ? "" : "s"}`);
+        const sample = fd.sampleMessages.length > 0
+            ? ` Top: ${fd.sampleMessages.slice(0, 3).map((m) => `"${truncate(m, 100)}"`).join("; ")}.`
+            : "";
+        const tags = ["code-health", fd.path];
+        if (fd.errors > 0)
+            tags.push("has-errors");
+        else if (fd.warnings > 0)
+            tags.push("has-warnings");
+        repo.upsertBySubject({
+            category: CATEGORY,
+            subject: fd.path,
+            content: `${fd.path} currently has ${parts.join(", ")} reported by the language server.${sample}`,
+            tags,
+            source: "lsp:diagnostics",
+        });
+        result.filesUpdated += 1;
+    }
+    return result;
+}
+/* ─── defensive extraction ──────────────────────────────────────────── */
+/**
+ * Pull per-file diagnostic rollups out of an LSP event payload of
+ * unknown shape. Handles the shapes seen / plausible across OpenCode
+ * versions:
+ *
+ *   { path|uri, diagnostics: [...] }
+ *   { properties: { path|uri, diagnostics: [...] } }
+ *   { type, properties: { ... } }                    (raw event)
+ *   { path|uri, diagnostics: { [uri]: [...] } }       (grouped)
+ *   { diagnostics: { [uri]: [...] } }                 (server-wide map)
+ *
+ * Anything unrecognised yields an empty array.
+ */
+export function extractDiagnostics(payload) {
+    if (!payload || typeof payload !== "object")
+        return [];
+    // Unwrap a raw event envelope: { type, properties }
+    let p = payload;
+    if (p.properties && typeof p.properties === "object") {
+        p = p.properties;
+    }
+    const out = [];
+    // Shape A/B: a single file + a diagnostics array.
+    const singlePath = pickPath(p);
+    const diagField = p.diagnostics;
+    if (singlePath && Array.isArray(diagField)) {
+        out.push(rollup(singlePath, diagField));
+        return out;
+    }
+    // Shape D/E: diagnostics is a map of uri/path -> array.
+    if (diagField && typeof diagField === "object" && !Array.isArray(diagField)) {
+        for (const [key, val] of Object.entries(diagField)) {
+            if (Array.isArray(val))
+                out.push(rollup(normalisePath(key), val));
+        }
+        return out;
+    }
+    // Shape: the payload itself is a uri -> array map.
+    let looksLikeMap = false;
+    for (const val of Object.values(p)) {
+        if (Array.isArray(val)) {
+            looksLikeMap = true;
+            break;
+        }
+    }
+    if (looksLikeMap && !singlePath) {
+        for (const [key, val] of Object.entries(p)) {
+            if (Array.isArray(val))
+                out.push(rollup(normalisePath(key), val));
+        }
+    }
+    return out;
+}
+function pickPath(obj) {
+    const candidate = obj.path ?? obj.uri ?? obj.file ?? obj.filePath ?? obj.fileName;
+    return typeof candidate === "string" ? normalisePath(candidate) : null;
+}
+/** Strip a `file://` scheme and decode, so memories key on a plain path. */
+function normalisePath(p) {
+    let s = p;
+    if (s.startsWith("file://")) {
+        s = s.slice("file://".length);
+        try {
+            s = decodeURIComponent(s);
+        }
+        catch {
+            // leave as-is if it isn't valid percent-encoding
+        }
+    }
+    return s;
+}
+/** Roll a raw diagnostics array up into severity counts + samples. */
+function rollup(path, diagnostics) {
+    const fd = {
+        path,
+        errors: 0,
+        warnings: 0,
+        infos: 0,
+        hints: 0,
+        sampleMessages: [],
+    };
+    // Collect messages with their severity so we can sample most-severe first.
+    const withSeverity = [];
+    for (const d of diagnostics) {
+        if (!d || typeof d !== "object")
+            continue;
+        const obj = d;
+        const severity = typeof obj.severity === "number" ? obj.severity : SEVERITY_WARNING;
+        const message = typeof obj.message === "string"
+            ? obj.message
+            : typeof obj.msg === "string"
+                ? obj.msg
+                : "";
+        switch (severity) {
+            case SEVERITY_ERROR:
+                fd.errors += 1;
+                break;
+            case SEVERITY_WARNING:
+                fd.warnings += 1;
+                break;
+            case 3:
+                fd.infos += 1;
+                break;
+            case 4:
+                fd.hints += 1;
+                break;
+            default:
+                fd.warnings += 1;
+        }
+        if (message)
+            withSeverity.push({ severity, message });
+    }
+    withSeverity.sort((a, b) => a.severity - b.severity); // 1=error first
+    fd.sampleMessages = withSeverity.slice(0, 5).map((x) => x.message);
+    return fd;
+}
+function truncate(s, n) {
+    return s.length <= n ? s : s.slice(0, n - 1) + "…";
+}

package/dist/ingest/code-map.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Code-map ingestion — an Aider-style "repo map": for each source
+ * file, the *signatures* of its top-level definitions (functions,
+ * classes, methods, types) with the bodies stripped. The agent gets
+ * the shape of the codebase without reading every file.
+ *
+ * This is the one part of the plugin that is NOT convention-free or
+ * dependency-light, and that is a deliberate, opt-in trade:
+ *
+ *   - It needs `web-tree-sitter` (~290 KB) plus a vendored `.wasm`
+ *     grammar per supported language (~10.3 MB for the eleven below —
+ *     C++ alone is 4.7 MB and TypeScript 2.3 MB). The rest of the
+ *     plugin is a ~77 KB source drop with one tiny dependency; this
+ *     feature is most of the install weight.
+ *   - It is inherently language-aware: each grammar needs to know
+ *     which node types are "definitions" (or selectors / keys /
+ *     elements). That per-language table is the `LANG_SPECS` map
+ *     below — contained, declarative, and the only place language
+ *     knowledge lives.
+ *
+ * Because of that, code-map is gated behind `config.enableCodeMap`
+ * and defaults OFF. When disabled, none of this loads — `import()` of
+ * `web-tree-sitter` only happens inside `ingestCodeMap`. Languages we
+ * have no grammar for are simply skipped; the rest of the plugin is
+ * unaffected.
+ *
+ * Signatures are stored one `code-map` memory per file via
+ * `upsertBySubject`, so they're recallable, co-change-boosted, and
+ * token-budgeted like every other memory, and a re-scan replaces
+ * rather than accumulates.
+ */
+import type { MemoryRepository } from "../store/repository.js";
+export interface CodeMapIngestResult {
+    filesParsed: number;
+    filesSkippedUnsupported: number;
+    signaturesExtracted: number;
+    languagesSeen: string[];
+    /** Set when the feature couldn't run at all (e.g. web-tree-sitter missing). */
+    unavailableReason?: string;
+}
+/**
+ * Re-index the code-map for a SINGLE file. This is what keeps the index
+ * honest when the agent edits code mid-session: the edited file's stale
+ * signature memory is replaced (via `upsertBySubject`) with one parsed
+ * from the file as it is now. Reuses the cached engine, so after the
+ * initial prefill a refresh is just a one-file parse. Never throws.
+ *
+ * Returns: "updated" (re-indexed, incl. a newly created file),
+ * "unsupported" (extension has no grammar — nothing to do),
+ * "unavailable" (tree-sitter could not load), or "error".
+ */
+export declare function ingestCodeMapForFile(repo: MemoryRepository, root: string, absPath: string, packageDir?: string): Promise<"updated" | "unsupported" | "unavailable" | "error">;
+export declare function ingestCodeMap(repo: MemoryRepository, root: string, packageDir?: string, maxFiles?: number): Promise<CodeMapIngestResult>;
+/**
+ * Depth-first walk collecting one signature line per definition node.
+ * A "signature" is the node's source text up to (but not including)
+ * its body — i.e. up to the first `{` or the first newline, whichever
+ * comes first — trimmed and length-capped. That captures
+ * `func (s *Server) Start() error`, `def parse(self, text):`,
+ * `interface Config`, etc. without any of the body. Pure function of
+ * (tree, source) so it is unit-testable without a repo.
+ */
+export declare function extractSignatures(rootNode: any, src: string, defNodes: Set<string>): string[];
+/**
+ * JSON "shape": the TOP-LEVEL keys only (or a marker if the root is an
+ * array / scalar). A whole-tree walk would emit every nested key,
+ * which is noise — so this descends exactly one object level. Pure
+ * function of (tree, source); unit-testable without a repo.
+ */
+export declare function extractJsonShape(rootNode: any, src: string): string[];
+export declare function extractHtmlSkeleton(rootNode: any, src: string): string[];