amness 0.0.0-stage → 0.1.2

package/dist/src/lsp.js

@@ -0,0 +1,147 @@
+// Language-server diagnostics after edits: the compiler's opinion of the file you just changed, one step after the edit instead of at the end of the task. A tiny LSP client over stdio
+// (no dependencies). Servers are started lazily, only when one is installed, kept alive between edits and stopped on dispose(). Errors only, capped, and silent when all is well.
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+export const DEFAULT_SERVERS = [
+    { name: "typescript", command: "typescript-language-server", args: ["--stdio"], extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"], languageId: (e) => ({ ".ts": "typescript", ".tsx": "typescriptreact", ".jsx": "javascriptreact", ".mts": "typescript", ".cts": "typescript" })[e] ?? "javascript" },
+    { name: "python", command: "pyright-langserver", args: ["--stdio"], extensions: [".py"], languageId: () => "python" },
+    { name: "go", command: "gopls", args: [], extensions: [".go"], languageId: () => "go" },
+    { name: "rust", command: "rust-analyzer", args: [], extensions: [".rs"], languageId: () => "rust" },
+];
+const onPath = (bin) => spawnSync(process.platform === "win32" ? "where" : "which", [bin], { stdio: "ignore" }).status === 0;
+class Client {
+    p;
+    buf = Buffer.alloc(0);
+    id = 0;
+    pending = new Map();
+    diags = new Map();
+    versions = new Map();
+    ready;
+    dead = false;
+    server;
+    root;
+    constructor(server, root) {
+        this.server = server;
+        this.root = root;
+        this.p = spawn(server.command, server.args, { cwd: root, stdio: ["pipe", "pipe", "ignore"] });
+        this.p.on("error", () => { this.dead = true; });
+        this.p.on("close", () => { this.dead = true; for (const w of this.pending.values())
+            w(undefined); });
+        this.p.stdout.on("data", (d) => this.onData(d));
+        this.p.stdin.on("error", () => { this.dead = true; });
+        this.ready = this.request("initialize", { processId: process.pid, rootUri: pathToFileURL(root).href, capabilities: { textDocument: { publishDiagnostics: { relatedInformation: false }, synchronization: { didSave: true } } }, workspaceFolders: [{ uri: pathToFileURL(root).href, name: "ws" }] }, 15_000).then((r) => { if (!r)
+            return false; this.notify("initialized", {}); return true; });
+    }
+    send(msg) { if (this.dead)
+        return; const body = JSON.stringify({ jsonrpc: "2.0", ...msg }); this.p.stdin.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`); }
+    notify(method, params) { this.send({ method, params }); }
+    request(method, params, timeout = 8000) {
+        if (this.dead)
+            return Promise.resolve(undefined);
+        return new Promise((res) => { const id = ++this.id, t = setTimeout(() => { this.pending.delete(id); res(undefined); }, timeout); this.pending.set(id, (v) => { clearTimeout(t); res(v); }); this.send({ id, method, params }); });
+    }
+    onData(d) {
+        this.buf = Buffer.concat([this.buf, d]);
+        for (;;) {
+            const h = this.buf.indexOf("\r\n\r\n");
+            if (h < 0)
+                return;
+            const m = /Content-Length:\s*(\d+)/i.exec(this.buf.slice(0, h).toString());
+            if (!m) {
+                this.buf = this.buf.slice(h + 4);
+                continue;
+            }
+            const len = Number(m[1]), end = h + 4 + len;
+            if (this.buf.length < end)
+                return;
+            const body = this.buf.slice(h + 4, end).toString("utf8");
+            this.buf = this.buf.slice(end);
+            let msg;
+            try {
+                msg = JSON.parse(body);
+            }
+            catch {
+                continue;
+            }
+            if (msg.id !== undefined && msg.method)
+                this.send({ id: msg.id, result: null }); // a request from the server (configuration, registerCapability...): acknowledge it
+            else if (msg.id !== undefined)
+                this.pending.get(msg.id)?.(msg.result ?? {}), this.pending.delete(msg.id);
+            else if (msg.method === "textDocument/publishDiagnostics") {
+                const uri = msg.params.uri, e = this.diags.get(uri) ?? { version: 0, list: [], waiters: [] };
+                e.list = (msg.params.diagnostics ?? []).map((x) => ({ line: (x.range?.start?.line ?? 0) + 1, col: (x.range?.start?.character ?? 0) + 1, message: String(x.message ?? "").split("\n")[0], severity: x.severity ?? 1, source: x.source }));
+                e.version++;
+                this.diags.set(uri, e);
+                for (const w of e.waiters.splice(0))
+                    w();
+            }
+        }
+    }
+    /** Tell the server about the file's new content and wait (briefly) for its verdict. */
+    async check(file, languageId, ms = 5000) {
+        if (!(await this.ready) || this.dead)
+            return undefined;
+        const uri = pathToFileURL(file).href, text = readFileSync(file, "utf8"), v = (this.versions.get(uri) ?? 0) + 1, had = this.versions.has(uri);
+        this.versions.set(uri, v);
+        const e = this.diags.get(uri) ?? { version: 0, list: [], waiters: [] };
+        this.diags.set(uri, e);
+        const before = e.version;
+        if (!had)
+            this.notify("textDocument/didOpen", { textDocument: { uri, languageId, version: v, text } });
+        else {
+            this.notify("textDocument/didChange", { textDocument: { uri, version: v }, contentChanges: [{ text }] });
+            this.notify("textDocument/didSave", { textDocument: { uri }, text });
+        }
+        if (e.version === before)
+            await new Promise((res) => { const t = setTimeout(res, ms); e.waiters.push(() => { clearTimeout(t); setTimeout(res, 150); }); }); // a short grace period lets a second, fuller publish arrive
+        return e.version === before ? undefined : e.list;
+    }
+    async stop() { if (this.dead)
+        return; try {
+        await this.request("shutdown", {}, 1500);
+        this.notify("exit", {});
+    }
+    catch { /* gone */ } setTimeout(() => this.p.kill(), 300).unref(); }
+}
+export class Diagnostics {
+    clients = new Map();
+    root;
+    servers;
+    missing = new Set();
+    constructor(root, o = {}) { this.root = resolve(root); this.servers = o.servers ?? DEFAULT_SERVERS; }
+    /** Which server would handle this file, if one is installed. */
+    serverFor(path) { const ext = extname(path).toLowerCase(), s = this.servers.find((x) => x.extensions.includes(ext)); if (!s || this.missing.has(s.name))
+        return undefined; if (!onPath(s.command)) {
+        this.missing.add(s.name);
+        return undefined;
+    } return s; }
+    async errors(path) {
+        const s = this.serverFor(path);
+        if (!s)
+            return undefined;
+        const abs = resolve(this.root, path);
+        if (!existsSync(abs))
+            return undefined;
+        let c = this.clients.get(s.name);
+        if (!c || c.dead) {
+            c = new Client(s, this.root);
+            this.clients.set(s.name, c);
+        }
+        const all = await c.check(abs, s.languageId(extname(path).toLowerCase()));
+        return all?.filter((d) => d.severity === 1);
+    }
+    /** Text to append to an edit result: the errors the language server reports for these files, or "" when there are none (or no server). */
+    async report(paths) {
+        const out = [];
+        for (const p of [...new Set(paths)].slice(0, 4)) {
+            const errs = await this.errors(p).catch(() => undefined);
+            for (const d of (errs ?? []).slice(0, 6))
+                out.push(`${p}:${d.line}:${d.col}  ${d.message}${d.source ? ` (${d.source})` : ""}`);
+        }
+        return out.length ? `\n\n[language server: ${out.length} error(s) in the file${new Set(paths).size > 1 ? "s" : ""} you just changed; fix them before moving on]\n${out.join("\n")}` : "";
+    }
+    async dispose() { await Promise.all([...this.clients.values()].map((c) => c.stop())); this.clients.clear(); }
+    installed() { return this.servers.filter((s) => onPath(s.command)).map((s) => s.name); }
+}

package/dist/src/memory.d.ts

@@ -0,0 +1,128 @@
+import { type Embedder } from "./embed.ts";
+import { type Model, type Tool } from "./harness.ts";
+export type MemoryType = "user" | "project" | "feedback" | "reference";
+export type Scope = "project" | "global";
+export type MemoryEntry = {
+    name: string;
+    type: MemoryType;
+    description: string;
+    content: string;
+    scope: Scope;
+    updated: string; /** how often it was surfaced to the model */
+    hits?: number; /** last time it was surfaced (YYYY-MM-DD) */
+    used?: string; /** runs that used this note and ended well / badly: the evidence behind its ranking */
+    wins?: number;
+    losses?: number;
+};
+/** Chance a note helps, from the runs it was part of (Laplace-smoothed, so a new note starts at 0.5). */
+export declare const utility: (e: {
+    wins?: number;
+    losses?: number;
+}) => number;
+/** Plain markdown files with frontmatter + a MEMORY.md index: human-editable, diffable, and portable between tools and machines. */
+/**
+ * What the agent needs from a memory: save, find, list, forget, and the two places memory is injected (the first message of a conversation, and later messages).
+ * `MemoryStore` (files on disk, BM25 ranking, outcome learning) is the built-in one; a plugin can provide another (a vector database, a wiki, a ticket system).
+ */
+export interface MemoryBackend {
+    list(): MemoryEntry[];
+    save(e: {
+        name: string;
+        type: MemoryType;
+        description: string;
+        content: string;
+        scope?: Scope;
+    }): MemoryEntry & {
+        merged?: string;
+    };
+    forget(name: string, scope?: Scope): boolean;
+    search(q: string, n?: number): MemoryEntry[] | Promise<MemoryEntry[]>;
+    /** notes to add to the first message of a conversation (empty string for none) */
+    context(task: string, maxChars?: number, seen?: Set<string>): string;
+    /** only the notes that are new and relevant for a follow-up message (so the cached prefix stays intact) */
+    delta(text: string, seen: Set<string>): string;
+    /** the run ended: true = finished and verified, false = gave up or got stuck, undefined = unknown (a backend can learn from this) */
+    endTurn(success: boolean | undefined): void;
+    /** optional: prepare a semantic search for this query */
+    warmQuery?(q: string): Promise<void>;
+}
+export declare const isMemoryBackend: (x: unknown) => x is MemoryBackend;
+export declare class MemoryStore implements MemoryBackend {
+    dirs: Partial<Record<Scope, string>>;
+    /** Optional: enables semantic (embedding) retrieval on top of BM25. */
+    embedder?: Embedder;
+    private qv;
+    private vecs;
+    private turn;
+    constructor(dirs: Partial<Record<Scope, string>>);
+    static forWorkspace(cwd: string, globalDir?: string): MemoryStore;
+    list(): MemoryEntry[];
+    private write;
+    /**
+     * Save a note. A note that says nearly the same thing as an existing one (same type and scope) updates that note instead of piling up
+     * duplicates; the newer wording wins, and `merged` names the note that was updated.
+     */
+    save(e: {
+        name: string;
+        type: MemoryType;
+        description: string;
+        content: string;
+        scope?: Scope;
+    }): MemoryEntry & {
+        merged?: string;
+    };
+    forget(name: string, scope?: Scope): boolean;
+    private reindex;
+    /** BM25 over name, description and content (name and description count extra), nudged by how often a note has proved useful and how fresh it is. */
+    rank(q: string, from?: MemoryEntry[]): {
+        e: MemoryEntry;
+        score: number;
+    }[];
+    private vecFile;
+    /** Embed notes that have no current vector. Call before retrieval when an embedder is set; failures are ignored (BM25 still works). */
+    index(): Promise<number>;
+    /** Embed a query so the next (synchronous) rank() for the same text can use semantic similarity. */
+    warmQuery(q: string): Promise<void>;
+    /** Close a turn: credit (or blame) every note surfaced since the last call. `undefined` = inconclusive (a chat reply), nothing changes. */
+    endTurn(success: boolean | undefined): void;
+    search(q: string, n?: number): MemoryEntry[];
+    private linksFile;
+    private readLinks;
+    /** Notes tied to `e`: ones it links with [[name]], ones that link to it, and ones that were retrieved together with it at least twice. */
+    neighbors(e: MemoryEntry, all?: MemoryEntry[]): MemoryEntry[];
+    private coRetrieved;
+    /** Move a note out of the active set without deleting it (reversible forgetting). */
+    archive(name: string): boolean;
+    /**
+     * Ask a model to tidy memory (Infini Memory style maintenance): merge notes about one topic, drop ones that are obsolete or contradicted by newer ones.
+     * Returns a PLAN and changes nothing; show it to the user, then `applyPlan`.
+     */
+    consolidate(model: Model): Promise<ConsolidationPlan>;
+    applyPlan(plan: ConsolidationPlan): {
+        merged: number;
+        archived: number;
+    };
+    /** Record that these notes were surfaced to the model (feeds ranking and the decision to forget). */
+    touch(es: MemoryEntry[]): void;
+    /** Notes that were never useful (older than `days`, surfaced at most once) or that keep showing up in runs that fail (4+ runs, under 25% good). */
+    stale(days?: number): MemoryEntry[];
+    /** Forgetting that can be undone: stale notes move to an `archive/` folder next to the notes. */
+    prune(days?: number): string[];
+    /** Text to put in front of the model: the full index plus the few entries most relevant to the task. Framed as data, not orders. */
+    context(task: string, maxChars?: number, seen?: Set<string>): string;
+    /**
+     * Later turns of a conversation: only notes that match the new message and were not shown yet, appended at the END of that message.
+     * (The earlier part of the conversation never changes, so the provider's prompt cache keeps hitting.)
+     */
+    delta(text: string, seen: Set<string>, minScore?: number): string;
+}
+export type ConsolidationPlan = {
+    merges: {
+        keep: string;
+        from: string[];
+        description: string;
+        content: string;
+    }[];
+    archive: string[];
+};
+export declare function memoryTools(store: MemoryBackend, onSave?: (e: MemoryEntry) => void): Tool[];