oakode 0.0.0-stage → 0.5.1

package/dist/session.js

@@ -0,0 +1,452 @@
+/** Append-only JSONL sessions. Nothing is ever rewritten: compaction is just another entry. */
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, truncateSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { createHash, randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { home } from "./config.js";
+import { maskTail } from "./mask.js";
+export const INTERRUPTED = "Interrupted: this tool call did not complete (the operation was cancelled or the session ended).";
+export const estimateTokens = (m) => Math.ceil((("content" in m && m.content ? m.content.length : 0) + ("tool_calls" in m && m.tool_calls ? JSON.stringify(m.tool_calls).length : 0)) / 4) + 4 + (m.role === "user" && m.images ? m.images.length * 1500 : 0);
+export class Session {
+    id;
+    file;
+    cwd;
+    model;
+    raw = [];
+    summary;
+    keepFrom = 0;
+    system;
+    changes = [];
+    /** Delegations recorded in this session (subagents), oldest first. */
+    delegations = [];
+    /** The last recorded run end in the session file (undefined for sessions written before 0.2.2). */
+    lastTurn;
+    files = { read: [], modified: [] };
+    /** Verbatim user request of a turn that a compaction cut through. */
+    request;
+    /** Set while the session file cannot be written; history is then only in memory (and `backlog`). */
+    persistError;
+    onPersist;
+    backlog = [];
+    needsNewline = false;
+    lockPath;
+    /** Prompt size reported by the last request, and how many raw messages it covered. */
+    lastPrompt;
+    constructor(file, id, cwd, model) {
+        this.file = file;
+        this.id = id;
+        this.cwd = cwd;
+        this.model = model;
+    }
+    /** One directory per project, keyed by a hash of the real path so distinct paths can never share one. */
+    static dir(cwd) {
+        const name = (cwd.split(/[\\/]/).filter(Boolean).pop() ?? "root").replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 40);
+        return join(home(), "sessions", `${name}-${createHash("sha256").update(cwd).digest("hex").slice(0, 16)}`);
+    }
+    static create(cwd, model) {
+        const id = randomUUID().slice(0, 8);
+        const dir = Session.dir(cwd);
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const s = new Session(join(dir, `${new Date().toISOString().replace(/[:.]/g, "-")}_${id}.jsonl`), id, cwd, model);
+        s.acquire();
+        // The file appears with the first message: a session that never had one leaves nothing behind, so it neither
+        // clutters /sessions nor gets picked by `oakode -c`.
+        s.deferred = true;
+        s.write({ type: "session", id, cwd, created: new Date().toISOString(), version: 1 });
+        s.write({ type: "model", ts: new Date().toISOString(), model });
+        return s;
+    }
+    /**
+     * A subagent's own transcript, kept beside its parent's: <parent's dir>/<parent id>/agents/<name>.jsonl.
+     * Session.list reads only the top level, so it never shows up as a session of its own. `cwd` is where its tools act
+     * (the parent's workspace, or later an isolated worktree).
+     */
+    static createChild(parent, name, model, cwd = parent.cwd) {
+        if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
+            throw new Error(`Invalid subagent session name: ${name}`);
+        const dir = join(dirname(parent.file), parent.id, "agents");
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const file = join(dir, `${name}.jsonl`);
+        if (existsSync(file))
+            throw new Error(`A subagent session named ${name} already exists for session ${parent.id}.`);
+        const s = new Session(file, `${parent.id}.${name}`, cwd, model);
+        s.acquire();
+        s.write({ type: "session", id: s.id, cwd, created: new Date().toISOString(), version: 1, parent: parent.id });
+        s.write({ type: "model", ts: new Date().toISOString(), model });
+        return s;
+    }
+    /** Opens a session file. Refuses sessions recorded for another directory: tools would act on the wrong project. */
+    static open(file, fallbackModel, expectedCwd) {
+        const text = readFileSync(file, "utf8");
+        const lines = text.split("\n").filter(Boolean);
+        let header;
+        const s = new Session(file, "", "", fallbackModel);
+        for (const line of lines) {
+            let e;
+            try {
+                e = JSON.parse(line);
+            }
+            catch {
+                continue; // a torn last line from a crash: skip it, keep everything else
+            }
+            if (e.type === "session")
+                header = e;
+            else if (e.type === "message")
+                s.raw.push(e.message);
+            else if (e.type === "model")
+                s.model = e.model;
+            else if (e.type === "system") {
+                const { type: _t, ts: _ts, ...snap } = e;
+                if (snap.text !== undefined || s.system?.keepFrom === snap.keepFrom)
+                    s.system = { ...s.system, ...snap };
+            }
+            else if (e.type === "turn")
+                s.lastTurn = { ts: e.ts, reason: e.reason, detail: e.detail };
+            else if (e.type === "change")
+                s.changes.push({ ts: e.ts, tool: e.tool, diff: e.diff });
+            else if (e.type === "delegation")
+                s.delegations.push({ id: e.id, ts: e.ts, goal: e.goal, plan: e.plan, results: [] });
+            else if (e.type === "agent_end")
+                s.delegations.find((d) => d.id === e.delegation)?.results.push(e.result);
+            else if (e.type === "compaction") {
+                s.summary = e.summary;
+                s.keepFrom = e.keepFrom;
+                s.files = e.files ?? { read: [], modified: [] };
+                s.request = e.request;
+            }
+        }
+        if (!header)
+            throw new Error(`Not an OAKODE session file: ${file}`);
+        if (header.cwd !== expectedCwd) {
+            throw new Error(`Session ${header.id} belongs to ${header.cwd}, not ${expectedCwd}. Run oakode from that directory to resume it.`);
+        }
+        s.id = header.id;
+        s.cwd = header.cwd;
+        s.needsNewline = text.length > 0 && !text.endsWith("\n"); // a crash left a torn last line: don't glue the next entry to it
+        s.acquire();
+        return s;
+    }
+    /**
+     * Sessions recorded for exactly this directory, newest first. Only the `limit` newest files are opened, and only their
+     * first 128 KB is read (header + first prompt); message counts are exact for files up to 2 MB, else unknown.
+     */
+    static list(cwd, limit = Infinity) {
+        const dir = Session.dir(cwd);
+        let names = [];
+        try {
+            names = readdirSync(dir).filter((n) => n.endsWith(".jsonl"));
+        }
+        catch { }
+        const files = names
+            .map((n) => {
+            try {
+                const st = statSync(join(dir, n));
+                return { n, file: join(dir, n), mtime: st.mtime, size: st.size };
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((x) => x !== null)
+            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        const out = [];
+        for (const f of files) {
+            if (out.length >= limit)
+                break;
+            let head;
+            try {
+                const fd = openSync(f.file, "r");
+                try {
+                    const buf = Buffer.alloc(Math.min(f.size, 128 * 1024));
+                    readSync(fd, buf, 0, buf.length, 0);
+                    head = buf.toString("utf8");
+                }
+                finally {
+                    closeSync(fd);
+                }
+            }
+            catch {
+                continue;
+            }
+            const lines = head.split("\n");
+            let created;
+            try {
+                const h = JSON.parse(lines[0]);
+                if (h.cwd !== cwd)
+                    continue;
+                if (h.created && !Number.isNaN(Date.parse(h.created)))
+                    created = new Date(h.created);
+            }
+            catch {
+                continue;
+            }
+            let preview = "(empty)";
+            const prompts = [];
+            for (const l of lines) {
+                if (prompts.length >= 6)
+                    break;
+                if (!l.includes('"type":"message"'))
+                    continue;
+                try {
+                    const m = JSON.parse(l).message;
+                    if (m.role === "user" && !m.content.startsWith("[OAKODE notice]")) {
+                        const t = m.content.replace(/\s+/g, " ");
+                        if (!prompts.length)
+                            preview = t.slice(0, 70);
+                        prompts.push(t.slice(0, 300));
+                    }
+                }
+                catch { }
+            }
+            let messages;
+            if (f.size <= 2 * 1024 * 1024) {
+                try {
+                    messages = readFileSync(f.file, "utf8").split('"type":"message"').length - 1;
+                }
+                catch { }
+            }
+            out.push({ file: f.file, id: f.n.replace(/\.jsonl$/, "").split("_").pop(), mtime: f.mtime, created, cwd, preview, prompts, messages });
+        }
+        return out;
+    }
+    /**
+     * Append durably (fsync). If the disk refuses, the entries stay in memory and are retried on the next write:
+     * the conversation continues, and the user is told once that it is not being saved.
+     */
+    write(e) {
+        this.backlog.push(JSON.stringify(e) + "\n");
+        // only the header, the model and notices wait; any real content (a message, a delegation, …) makes the file
+        if (this.deferred && (e.type === "session" || e.type === "model" || e.type === "notice" || e.type === "system"))
+            return;
+        this.deferred = false;
+        this.flush();
+    }
+    /** Not written to disk until its first message (see create). */
+    deferred = false;
+    flush() {
+        if (!this.backlog.length || this.deferred)
+            return true;
+        let pre = 0;
+        try {
+            try {
+                pre = statSync(this.file).size;
+            }
+            catch { }
+            const fd = openSync(this.file, "a", 0o600);
+            try {
+                writeSync(fd, (this.needsNewline ? "\n" : "") + this.backlog.join(""));
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            this.backlog = [];
+            this.needsNewline = false;
+            if (this.persistError) {
+                this.persistError = undefined;
+                this.onPersist?.("recovered");
+            }
+            return true;
+        }
+        catch (err) {
+            // roll back a partial append so the retry cannot duplicate entries
+            try {
+                truncateSync(this.file, pre);
+            }
+            catch {
+                this.needsNewline = true;
+            }
+            const msg = err.code ?? err.message;
+            const first = !this.persistError;
+            this.persistError = String(msg);
+            if (first)
+                this.onPersist?.("failed", String(msg));
+            return false;
+        }
+    }
+    /** Last resort at exit: unsaved entries go to a temp file so the conversation is not lost silently. */
+    emergencyDump() {
+        if (!this.backlog.length || this.deferred)
+            return undefined;
+        const f = join(tmpdir(), `oakode-unsaved-${this.id}-${Date.now()}.jsonl`);
+        try {
+            writeFileSync(f, this.backlog.join(""), { mode: 0o600 });
+            return f;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // ---- one OAKODE process per session file ----
+    acquire() {
+        const lock = this.file + ".lock";
+        try {
+            mkdirSync(join(this.file, ".."), { recursive: true });
+            const fd = openSync(lock, "wx", 0o600);
+            writeSync(fd, String(process.pid));
+            closeSync(fd);
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                return; // cannot lock (read-only dir?): proceed unlocked
+            const pid = Number(readFileSync(lock, "utf8").trim());
+            if (pid && pid !== process.pid && alive(pid))
+                throw new Error(`Session ${this.id} is open in another OAKODE process (pid ${pid}). Close it first, or start a new session.`);
+            writeFileSync(lock, String(process.pid), { mode: 0o600 }); // stale or our own
+        }
+        this.lockPath = lock;
+        held.add(this);
+    }
+    release() {
+        held.delete(this);
+        if (!this.lockPath)
+            return;
+        try {
+            if (Number(readFileSync(this.lockPath, "utf8").trim()) === process.pid)
+                unlinkSync(this.lockPath);
+        }
+        catch { }
+        this.lockPath = undefined;
+    }
+    /** Become another session (used when switching sessions) without losing lock bookkeeping. */
+    adopt(other) {
+        this.release();
+        held.delete(other);
+        Object.assign(this, other);
+        if (this.lockPath)
+            held.add(this);
+    }
+    /** How the last run ended, for the resume notice. */
+    interruption() {
+        const tail = this.raw.slice(this.keepFrom);
+        const synthesized = repair(tail).filter((m) => m.role === "tool" && m.content === INTERRUPTED).length - tail.filter((m) => m.role === "tool" && m.content === INTERRUPTED).length;
+        return { danglingCalls: synthesized, lastRole: this.context().at(-1)?.role };
+    }
+    add(message) {
+        this.raw.push(message);
+        this.write({ type: "message", ts: new Date().toISOString(), message });
+    }
+    recordChange(tool, diff) {
+        const ts = new Date().toISOString();
+        this.changes.push({ ts, tool, diff });
+        this.write({ type: "change", ts, tool, diff });
+    }
+    recordTurnEnd(reason, detail, requests) {
+        const ts = new Date().toISOString();
+        this.lastTurn = { ts, reason, detail };
+        this.write({ type: "turn", ts, reason, ...(detail ? { detail: detail.slice(0, 2000) } : {}), model: this.model, ...(requests !== undefined ? { requests } : {}) });
+    }
+    /** One request's usage as OICKI reported it (cache, reasoning, credits), for later analysis of where tokens went. */
+    recordUsage(usage, model, ms) {
+        this.write({ type: "usage", ts: new Date().toISOString(), model, ...(ms !== undefined ? { ms } : {}), usage });
+    }
+    recordDelegation(d) {
+        const ts = new Date().toISOString();
+        this.delegations.push({ id: d.id, ts, goal: d.goal, plan: d.plan, results: [] });
+        this.write({ type: "delegation", ts, approved: "user", ...d });
+    }
+    recordAgentEnd(delegation, result) {
+        this.delegations.find((d) => d.id === delegation)?.results.push(result);
+        this.write({ type: "agent_end", ts: new Date().toISOString(), delegation, result });
+    }
+    /** Delegations whose agents did not all end (the session stopped while they ran). */
+    interruptedDelegations() {
+        return this.delegations
+            .filter((d) => d.results.length < d.plan.agents.length)
+            .map((d) => ({ id: d.id, goal: d.goal, done: d.results.filter((r) => r.status === "done").length, total: d.plan.agents.length }));
+    }
+    recordNotice(text) {
+        this.write({ type: "notice", ts: new Date().toISOString(), text: text.slice(0, 2000) });
+    }
+    setSystem(snap) {
+        const same = this.system?.keepFrom === snap.keepFrom && this.system.text === snap.text;
+        this.system = snap;
+        this.write({ type: "system", ts: new Date().toISOString(), ...snap, ...(same ? { text: undefined } : {}) });
+    }
+    setModel(model) {
+        this.model = model;
+        this.write({ type: "model", ts: new Date().toISOString(), model });
+    }
+    compact(summary, keepFrom, files, request) {
+        this.summary = summary;
+        this.keepFrom = keepFrom;
+        this.files = files;
+        this.request = request;
+        this.lastPrompt = undefined;
+        this.write({ type: "compaction", ts: new Date().toISOString(), summary, keepFrom, files, request });
+    }
+    /** The synthetic first message that stands in for the compacted history. */
+    summaryMessage() {
+        if (!this.summary)
+            return undefined;
+        const list = (title, xs) => (xs.length ? `\n\n<${title}>\n${xs.slice(0, 100).join("\n")}${xs.length > 100 ? `\n… and ${xs.length - 100} more` : ""}\n</${title}>` : "");
+        return {
+            role: "user",
+            content: `[Summary of the earlier conversation, which was compacted to save context]\n\n${this.summary}` +
+                (this.request ? `\n\n## Request in progress (verbatim)\n${this.request}` : "") +
+                list("read-files", this.files.read) +
+                list("modified-files", this.files.modified),
+        };
+    }
+    /** The messages to send: summary + repaired tail. */
+    context() {
+        const tail = repair(this.raw.slice(this.keepFrom));
+        const head = this.summaryMessage();
+        return head ? [head, ...tail] : tail;
+    }
+    /** What is actually sent: like `context()`, but with old bulky tool traffic shrunk (see mask.ts). The stored history is untouched. */
+    requestContext() {
+        const tail = repair(maskTail(this.raw.slice(this.keepFrom)));
+        const head = this.summaryMessage();
+        return head ? [head, ...tail] : tail;
+    }
+    /** Estimated size of the next request (excluding system prompt/tools). */
+    estimateTokens() {
+        if (this.lastPrompt) {
+            return this.lastPrompt.tokens + this.raw.slice(this.lastPrompt.rawLen).reduce((n, m) => n + estimateTokens(m), 0);
+        }
+        return this.requestContext().reduce((n, m) => n + estimateTokens(m), 0);
+    }
+    firstPrompt() {
+        const m = this.raw.find((x) => x.role === "user");
+        return m?.role === "user" ? m.content : undefined;
+    }
+}
+/**
+ * Make a message list valid for the API: every assistant tool call gets exactly one tool result
+ * right after it (synthesized when the run was interrupted), and orphan tool messages are dropped.
+ */
+export function repair(messages) {
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        if (m.role === "tool")
+            continue; // orphan: its assistant message was compacted away or never saved
+        out.push(m);
+        if (m.role !== "assistant" || !m.tool_calls?.length)
+            continue;
+        const results = new Map();
+        let j = i + 1;
+        for (; j < messages.length && messages[j].role === "tool"; j++) {
+            const t = messages[j];
+            if (!results.has(t.tool_call_id))
+                results.set(t.tool_call_id, t);
+        }
+        for (const c of m.tool_calls) {
+            out.push(results.get(c.id) ?? { role: "tool", tool_call_id: c.id, content: INTERRUPTED });
+        }
+        i = j - 1;
+    }
+    return out;
+}
+const held = new Set();
+process.on("exit", () => [...held].forEach((x) => x.release()));
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+};

package/dist/shell.js

@@ -0,0 +1,40 @@
+/**
+ * The shell that runs the agent's commands. Models write POSIX shell, so on Windows Git Bash is used when it is
+ * installed (it is part of Git for Windows); otherwise cmd.exe, and the model is told so. Never the WSL launcher in
+ * System32 (bash.exe there starts a Linux distribution, if any, with a different filesystem). OAKODE_SHELL overrides.
+ */
+import { existsSync } from "node:fs";
+import { basename, join } from "node:path";
+let cached;
+export function gitBash(env = process.env) {
+    const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LocalAppData && join(env.LocalAppData, "Programs"), "C:\\Program Files"].filter(Boolean);
+    for (const r of roots) {
+        const p = join(r, "Git", "bin", "bash.exe");
+        if (existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+export function shell(env = process.env, platform = process.platform) {
+    if (cached && env === process.env && platform === process.platform)
+        return cached;
+    let s;
+    const override = env.OAKODE_SHELL;
+    if (override) {
+        const cmd = /^(cmd)(\.exe)?$/i.test(basename(override));
+        s = { bin: override, args: (c) => (cmd ? ["/d", "/s", "/c", `"${c}"`] : ["-c", c]), verbatim: cmd, name: basename(override), posix: !cmd };
+    }
+    else if (platform === "win32") {
+        const bash = gitBash(env);
+        s = bash
+            ? { bin: bash, args: (c) => ["-c", c], name: "bash (Git for Windows)", posix: true }
+            : { bin: env.ComSpec || "cmd.exe", args: (c) => ["/d", "/s", "/c", `"${c}"`], verbatim: true, name: "cmd.exe (install Git for Windows to get bash)", posix: false };
+    }
+    else {
+        const sh = env.SHELL?.endsWith("bash") || env.SHELL?.endsWith("zsh") ? env.SHELL : "/bin/sh";
+        s = { bin: sh, args: (c) => ["-c", c], name: basename(sh), posix: true };
+    }
+    if (env === process.env && platform === process.platform)
+        cached = s;
+    return s;
+}