agent-sh 0.14.8 → 0.14.10

package/dist/agent/session-store.js

@@ -0,0 +1,288 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+export function newEntryId() {
+    return crypto.randomBytes(4).toString("hex");
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((p) => {
+            if (typeof p === "string")
+                return p;
+            const part = p;
+            return part?.text ?? part?.content ?? "";
+        }).join(" ");
+    }
+    return "";
+}
+function snippet(text, max) {
+    const cleaned = String(text ?? "").replace(/\s+/g, " ").trim();
+    if (cleaned.length <= max)
+        return cleaned || "(empty)";
+    return cleaned.slice(0, max) + "…";
+}
+export function summarizeMessage(m) {
+    const role = m.role ?? "?";
+    if (role === "assistant") {
+        const tc = m.tool_calls;
+        if (Array.isArray(tc) && tc.length > 0) {
+            const tools = tc.map((t) => {
+                const name = t.function?.name ?? "tool";
+                const args = t.function?.arguments;
+                return args ? `${name}(${snippet(args, 200)})` : name;
+            }).join(", ");
+            const text = extractText(m.content);
+            const prefix = text ? `${snippet(text, 400)} → ` : "";
+            return `assistant: ${prefix}called ${tools}`;
+        }
+    }
+    if (role === "tool") {
+        const text = typeof m.content === "string" ? m.content : extractText(m.content);
+        const isErr = /^error\b|: error\b/i.test(text.slice(0, 200));
+        return `tool result: ${snippet(text, isErr ? 1000 : 400)}`;
+    }
+    if (role === "user") {
+        return `user: ${snippet(extractText(m.content), 1000)}`;
+    }
+    return `${role}: ${snippet(extractText(m.content), 500)}`;
+}
+/** For displayed user text. Loops because both wrappers can stack at the head. */
+export function stripContextWrappers(content) {
+    let out = content;
+    for (;;) {
+        const next = out.replace(/^\s*<(query_context|dynamic_context)>[\s\S]*?<\/\1>\s*/, "");
+        if (next === out)
+            return out;
+        out = next;
+    }
+}
+export function renderEvictedSummary(evicted) {
+    const lines = evicted.map((m) => `- ${summarizeMessage(m)}`);
+    return `${lines.length} message(s) elided\n${lines.join("\n")}`;
+}
+export class SessionStore {
+    entriesPath;
+    leafPath;
+    entries = new Map();
+    rootId = "";
+    activeLeaf = "";
+    pendingHeader = null;
+    id;
+    constructor(filePath, opts) {
+        this.entriesPath = filePath;
+        this.leafPath = filePath + ".leaf";
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        if (opts?.create) {
+            this.id = opts.create.sessionId;
+            const header = {
+                type: "session",
+                id: opts.create.sessionId,
+                parentId: null,
+                timestamp: Date.now(),
+                cwd: opts.create.cwd,
+                version: 1,
+            };
+            this.entries.set(header.id, header);
+            this.rootId = header.id;
+            this.activeLeaf = header.id;
+            this.pendingHeader = header;
+        }
+        else {
+            this.id = "";
+            this.load();
+            if (!this.rootId)
+                throw new Error(`session file lacks a session header: ${filePath}`);
+            this.id = this.rootId;
+        }
+    }
+    /** Deferred so an opened-but-unused session leaves no files on disk. */
+    flushHeader() {
+        if (!this.pendingHeader)
+            return;
+        const headerLine = JSON.stringify(this.pendingHeader) + "\n";
+        this.pendingHeader = null;
+        fs.writeFileSync(this.entriesPath, headerLine);
+        this.persistLeaf();
+    }
+    getActiveLeaf() { return this.activeLeaf; }
+    setActiveLeaf(id) {
+        if (!this.entries.has(id))
+            throw new Error(`unknown entry: ${id}`);
+        this.activeLeaf = id;
+        this.persistLeaf();
+    }
+    getRootId() { return this.rootId; }
+    getEntry(id) { return this.entries.get(id); }
+    getAllEntries() { return [...this.entries.values()]; }
+    async appendMessages(messages) {
+        if (messages.length === 0)
+            return [];
+        this.flushHeader();
+        let parent = this.activeLeaf;
+        const lines = [];
+        const newIds = [];
+        for (const m of messages) {
+            const e = {
+                type: "message",
+                id: newEntryId(),
+                parentId: parent,
+                timestamp: Date.now(),
+                message: m,
+            };
+            this.entries.set(e.id, e);
+            lines.push(JSON.stringify(e));
+            newIds.push(e.id);
+            parent = e.id;
+        }
+        this.activeLeaf = parent;
+        await fsp.appendFile(this.entriesPath, lines.join("\n") + "\n");
+        this.persistLeaf();
+        return newIds;
+    }
+    async appendShellExchange(e) {
+        this.flushHeader();
+        const entry = {
+            type: "shell-exchange",
+            id: newEntryId(),
+            parentId: this.activeLeaf,
+            timestamp: Date.now(),
+            command: e.command,
+            output: e.output,
+            exitCode: e.exitCode,
+            ...(e.cwd !== undefined ? { cwd: e.cwd } : {}),
+            ...(e.private ? { private: true } : {}),
+        };
+        this.entries.set(entry.id, entry);
+        this.activeLeaf = entry.id;
+        await fsp.appendFile(this.entriesPath, JSON.stringify(entry) + "\n");
+        this.persistLeaf();
+        return entry.id;
+    }
+    async appendCompaction(firstKeptId, tokensBefore, summary) {
+        if (!this.entries.has(firstKeptId))
+            throw new Error(`firstKeptId unknown: ${firstKeptId}`);
+        this.flushHeader();
+        const e = {
+            type: "compaction",
+            id: newEntryId(),
+            parentId: this.activeLeaf,
+            timestamp: Date.now(),
+            firstKeptId,
+            tokensBefore,
+            ...(summary !== undefined ? { summary } : {}),
+        };
+        this.entries.set(e.id, e);
+        this.activeLeaf = e.id;
+        await fsp.appendFile(this.entriesPath, JSON.stringify(e) + "\n");
+        this.persistLeaf();
+        return e.id;
+    }
+    /** Returns oldest-first. */
+    getBranch(leafId = this.activeLeaf) {
+        const out = [];
+        const seen = new Set();
+        let cur = leafId;
+        while (cur && !seen.has(cur)) {
+            seen.add(cur);
+            const e = this.entries.get(cur);
+            if (!e)
+                break;
+            out.push(e);
+            cur = e.parentId;
+        }
+        return out.reverse();
+    }
+    /** Latest compaction on the branch replaces the evicted prefix with
+     *  its stored summary, or a rendered one if no summary was stored. */
+    buildMessages(leafId = this.activeLeaf) {
+        return this.buildBranchWithIds(leafId).messages;
+    }
+    /** Parallel entryIds array — null for the synthetic compaction-summary
+     *  slot — so callers can map message indices back to on-disk ids. */
+    buildBranchWithIds(leafId = this.activeLeaf) {
+        const branch = this.getBranch(leafId);
+        let compactionIdx = -1;
+        for (let i = branch.length - 1; i >= 0; i--) {
+            if (branch[i].type === "compaction") {
+                compactionIdx = i;
+                break;
+            }
+        }
+        const messages = [];
+        const entryIds = [];
+        let startIdx = 0;
+        if (compactionIdx >= 0) {
+            const c = branch[compactionIdx];
+            const firstKeptIdx = branch.findIndex((e) => e.id === c.firstKeptId);
+            startIdx = firstKeptIdx >= 0 ? firstKeptIdx : 0;
+            const summary = c.summary ?? renderEvictedSummary(branch.slice(0, startIdx)
+                .filter((e) => e.type === "message")
+                .map((e) => e.message));
+            messages.push({ role: "user", content: `[Compacted conversation summary]\n${summary}` });
+            entryIds.push(null);
+        }
+        for (let i = startIdx; i < branch.length; i++) {
+            const e = branch[i];
+            if (e.type === "message") {
+                messages.push(e.message);
+                entryIds.push(e.id);
+            }
+        }
+        return { messages, entryIds };
+    }
+    getPreview() {
+        for (const e of this.entries.values()) {
+            if (e.type === "message" && e.message.role === "user") {
+                const raw = typeof e.message.content === "string" ? e.message.content : "";
+                const txt = stripContextWrappers(raw);
+                if (txt)
+                    return txt.slice(0, 80);
+            }
+        }
+        return "(empty)";
+    }
+    load() {
+        let raw;
+        try {
+            raw = fs.readFileSync(this.entriesPath, "utf-8");
+        }
+        catch {
+            return;
+        }
+        for (const line of raw.split("\n")) {
+            if (!line)
+                continue;
+            try {
+                const e = JSON.parse(line);
+                if (!e.id)
+                    continue;
+                this.entries.set(e.id, e);
+                if (e.type === "session")
+                    this.rootId = e.id;
+            }
+            catch { /* skip malformed */ }
+        }
+        try {
+            this.activeLeaf = fs.readFileSync(this.leafPath, "utf-8").trim();
+            if (!this.entries.has(this.activeLeaf))
+                this.activeLeaf = this.rootId;
+        }
+        catch {
+            this.activeLeaf = this.lastEntryId();
+        }
+    }
+    lastEntryId() {
+        let lastId = this.rootId;
+        for (const e of this.entries.values())
+            lastId = e.id;
+        return lastId;
+    }
+    persistLeaf() {
+        if (this.pendingHeader)
+            return;
+        fs.writeFileSync(this.leafPath, this.activeLeaf);
+    }
+}

package/dist/agent/store.d.ts

@@ -0,0 +1,74 @@
+export interface Entry {
+    id: string;
+    parentId?: string;
+    ts: number;
+    kind: string;
+    payload: Record<string, unknown>;
+}
+export interface AppendOpts {
+    /** Memory-only; never persisted. */
+    ephemeral?: boolean;
+}
+export interface SearchHit {
+    entry: Entry;
+    line: string;
+}
+/** Append-only — no edit or delete. Implementations may apply bulk
+ *  retention (front-truncation, GC), but strategies cannot remove a
+ *  specific entry. */
+export interface Store {
+    append(entries: Entry[], opts?: AppendOpts): Promise<void>;
+    findById(id: string): Promise<Entry | null>;
+    readRecent(n?: number): Promise<Entry[]>;
+    search(query: string): Promise<SearchHit[]>;
+}
+export interface TreeStore extends Store {
+    getBranch(leafId?: string): Promise<Entry[]>;
+    setLeaf(id: string): void;
+    getLeaf(): string;
+}
+export declare function newEntryId(): string;
+export declare function isTreeStore(s: Store): s is TreeStore;
+export declare class NoopStore implements Store {
+    append(): Promise<void>;
+    findById(): Promise<Entry | null>;
+    readRecent(): Promise<Entry[]>;
+    search(): Promise<SearchHit[]>;
+}
+export declare class InMemoryStore implements TreeStore {
+    private entries;
+    private order;
+    private leaf;
+    constructor(opts?: {
+        root?: Entry;
+    });
+    append(entries: Entry[]): Promise<void>;
+    findById(id: string): Promise<Entry | null>;
+    readRecent(n?: number): Promise<Entry[]>;
+    search(query: string): Promise<SearchHit[]>;
+    getBranch(leafId?: string): Promise<Entry[]>;
+    setLeaf(id: string): void;
+    getLeaf(): string;
+}
+export interface SharedFileStoreOpts {
+    filePath: string;
+    /** Front-truncate above this size; truncation fires at 150% of the
+     *  cap to avoid frequent rewrites. */
+    maxBytes?: number;
+}
+export declare class SharedFileStore implements Store {
+    private filePath;
+    private lockPath;
+    private maxBytes;
+    constructor(opts: SharedFileStoreOpts);
+    append(entries: Entry[], opts?: AppendOpts): Promise<void>;
+    findById(id: string): Promise<Entry | null>;
+    readRecent(n?: number): Promise<Entry[]>;
+    search(query: string): Promise<SearchHit[]>;
+    /** Yield lines newest-first by reading reverse-chunked blocks,
+     *  stitching across boundaries. */
+    private streamReverseLines;
+    private maybeTruncate;
+    private acquireLock;
+    private releaseLock;
+}

package/dist/agent/store.js

@@ -0,0 +1,284 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+export function newEntryId() {
+    return crypto.randomBytes(4).toString("hex");
+}
+export function isTreeStore(s) {
+    return (typeof s.setLeaf === "function" &&
+        typeof s.getLeaf === "function" &&
+        typeof s.getBranch === "function");
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileSearchRegex(query) {
+    return new RegExp(escapeRegex(query), "i");
+}
+function matchEntry(entry, re) {
+    const line = JSON.stringify(entry);
+    return re.test(line) ? { entry, line } : null;
+}
+export class NoopStore {
+    async append() { }
+    async findById() { return null; }
+    async readRecent() { return []; }
+    async search() { return []; }
+}
+export class InMemoryStore {
+    entries = new Map();
+    order = [];
+    leaf;
+    constructor(opts) {
+        if (opts?.root) {
+            this.entries.set(opts.root.id, opts.root);
+            this.order.push(opts.root.id);
+            this.leaf = opts.root.id;
+        }
+        else {
+            this.leaf = "";
+        }
+    }
+    async append(entries) {
+        for (const e of entries) {
+            this.entries.set(e.id, e);
+            this.order.push(e.id);
+        }
+    }
+    async findById(id) {
+        return this.entries.get(id) ?? null;
+    }
+    async readRecent(n) {
+        const slice = n == null ? this.order : this.order.slice(-n);
+        return slice.map((id) => this.entries.get(id));
+    }
+    async search(query) {
+        if (!query.trim())
+            return [];
+        const re = compileSearchRegex(query);
+        const out = [];
+        for (let i = this.order.length - 1; i >= 0; i--) {
+            const m = matchEntry(this.entries.get(this.order[i]), re);
+            if (m)
+                out.push(m);
+        }
+        return out;
+    }
+    async getBranch(leafId = this.leaf) {
+        const out = [];
+        const seen = new Set();
+        let cur = leafId;
+        while (cur && !seen.has(cur)) {
+            seen.add(cur);
+            const e = this.entries.get(cur);
+            if (!e)
+                break;
+            out.push(e);
+            cur = e.parentId;
+        }
+        return out.reverse();
+    }
+    setLeaf(id) {
+        if (!this.entries.has(id))
+            throw new Error(`unknown entry: ${id}`);
+        this.leaf = id;
+    }
+    getLeaf() {
+        return this.leaf;
+    }
+}
+/** Multi-writer JSONL Store. O_APPEND with PIPE_BUF-bounded line
+ *  writes for atomic concurrent appends; lock-based front-truncation
+ *  for retention; reads stream the tail for cheap recent slices. */
+const LOCK_STALE_MS = 10_000;
+const DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+export class SharedFileStore {
+    filePath;
+    lockPath;
+    maxBytes;
+    constructor(opts) {
+        this.filePath = opts.filePath;
+        this.lockPath = opts.filePath + ".lock";
+        this.maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+        try {
+            fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        }
+        catch { /* ignore */ }
+    }
+    async append(entries, opts) {
+        if (entries.length === 0)
+            return;
+        if (opts?.ephemeral)
+            return; // memory-only writes are a no-op on a file-only store
+        const lines = entries.map((e) => JSON.stringify(e) + "\n").join("");
+        await fsp.appendFile(this.filePath, lines, { flag: "a" });
+        await this.maybeTruncate();
+    }
+    async findById(id) {
+        for await (const line of this.streamReverseLines()) {
+            try {
+                const e = JSON.parse(line);
+                if (e.id === id)
+                    return e;
+            }
+            catch { /* skip malformed */ }
+        }
+        return null;
+    }
+    async readRecent(n) {
+        const want = n ?? Infinity;
+        const recent = []; // newest-first
+        for await (const line of this.streamReverseLines()) {
+            try {
+                const e = JSON.parse(line);
+                if (!e.id)
+                    continue;
+                recent.push(e);
+                if (recent.length >= want)
+                    break;
+            }
+            catch { /* skip malformed */ }
+        }
+        return recent.reverse();
+    }
+    async search(query) {
+        if (!query.trim())
+            return [];
+        const re = compileSearchRegex(query);
+        const budgetBytes = 20 * 1024 * 1024;
+        let scanned = 0;
+        const out = [];
+        for await (const line of this.streamReverseLines()) {
+            scanned += line.length + 1;
+            if (scanned > budgetBytes)
+                break;
+            try {
+                const e = JSON.parse(line);
+                const m = matchEntry(e, re);
+                if (m)
+                    out.push(m);
+            }
+            catch { /* skip malformed */ }
+        }
+        return out;
+    }
+    /** Yield lines newest-first by reading reverse-chunked blocks,
+     *  stitching across boundaries. */
+    async *streamReverseLines(chunkBytes = 1 << 20) {
+        let handle;
+        let fileSize;
+        try {
+            const stat = await fsp.stat(this.filePath);
+            fileSize = stat.size;
+            if (fileSize === 0)
+                return;
+            handle = await fsp.open(this.filePath, "r");
+        }
+        catch {
+            return;
+        }
+        try {
+            let position = fileSize;
+            let pending = Buffer.alloc(0);
+            while (position > 0) {
+                const readSize = Math.min(chunkBytes, position);
+                position -= readSize;
+                const buf = Buffer.alloc(readSize);
+                await handle.read(buf, 0, readSize, position);
+                const combined = Buffer.concat([buf, pending]);
+                const newlineIdxs = [];
+                for (let i = 0; i < combined.length; i++) {
+                    if (combined[i] === 0x0A)
+                        newlineIdxs.push(i);
+                }
+                if (newlineIdxs.length === 0) {
+                    pending = combined;
+                    continue;
+                }
+                const firstNl = newlineIdxs[0];
+                const lastNl = newlineIdxs[newlineIdxs.length - 1];
+                const trailing = combined.subarray(lastNl + 1);
+                if (trailing.length > 0)
+                    yield trailing.toString("utf-8");
+                for (let i = newlineIdxs.length - 1; i >= 1; i--) {
+                    const seg = combined.subarray(newlineIdxs[i - 1] + 1, newlineIdxs[i]);
+                    if (seg.length > 0)
+                        yield seg.toString("utf-8");
+                }
+                const leading = combined.subarray(0, firstNl);
+                if (position === 0) {
+                    if (leading.length > 0)
+                        yield leading.toString("utf-8");
+                    pending = Buffer.alloc(0);
+                }
+                else {
+                    pending = leading;
+                }
+            }
+            if (pending.length > 0)
+                yield pending.toString("utf-8");
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async maybeTruncate() {
+        let size = 0;
+        try {
+            size = (await fsp.stat(this.filePath)).size;
+        }
+        catch {
+            return;
+        }
+        if (size <= this.maxBytes * 1.5)
+            return;
+        if (!(await this.acquireLock()))
+            return;
+        try {
+            let content;
+            try {
+                content = await fsp.readFile(this.filePath, "utf-8");
+            }
+            catch {
+                return;
+            }
+            const lines = content.split("\n").filter(Boolean);
+            let totalBytes = Buffer.byteLength(content, "utf-8");
+            let dropCount = 0;
+            while (totalBytes > this.maxBytes && dropCount < lines.length - 1) {
+                totalBytes -= Buffer.byteLength(lines[dropCount] + "\n", "utf-8");
+                dropCount++;
+            }
+            if (dropCount === 0)
+                return;
+            const remaining = lines.slice(dropCount).join("\n") + "\n";
+            const tmpPath = this.filePath + ".tmp." + process.pid;
+            await fsp.writeFile(tmpPath, remaining);
+            await fsp.rename(tmpPath, this.filePath);
+        }
+        finally {
+            await this.releaseLock();
+        }
+    }
+    async acquireLock() {
+        try {
+            try {
+                const stat = await fsp.stat(this.lockPath);
+                if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                    await fsp.unlink(this.lockPath).catch(() => { });
+                }
+            }
+            catch { /* lock absent — good */ }
+            const fd = await fsp.open(this.lockPath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
+            await fd.close();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async releaseLock() {
+        await fsp.unlink(this.lockPath).catch(() => { });
+    }
+}

package/dist/agent/subagent.js

@@ -1,5 +1,5 @@
 import { contentText } from "./types.js";
-import { ConversationState } from "./conversation-state.js";
+import { LiveView } from "./live-view.js";
 import { normalizeToolArgs } from "./normalize-args.js";
 import { wrapTrailingWithDynamicContext } from "../utils/message-utils.js";
 /**
@@ -17,7 +17,7 @@ export async function runSubagent(opts) {
             parameters: t.input_schema,
         },
     }));
-    const conversation = new ConversationState();
+    const conversation = new LiveView();
     conversation.addUserMessage(task);
     let fullResponseText = "";
     let iterations = 0;