@sean.holung/minicode 0.2.4 → 0.3.0

package/dist/src/serve/agent-bridge.js

@@ -15,6 +15,7 @@ export class AgentBridge {
     verbose;
     listeners = new Set();
     pinnedSymbols = new Set();
+    annotations = new Map();
     constructor(broadcast, verbose) {
         this.broadcast = broadcast;
         this.verbose = verbose;
@@ -51,9 +52,15 @@ export class AgentBridge {
             projectIndex = undefined;
         }
         const toolRegistry = createToolRegistry(config, projectIndex);
+        // Wrap tool registry execute to inject annotations into tool results
+        const originalExecute = toolRegistry.execute.bind(toolRegistry);
+        toolRegistry.execute = async (name, input) => {
+            const result = await originalExecute(name, input);
+            return this.appendAnnotationsToResult(name, input, result);
+        };
         this.config = config;
         this.projectIndex = projectIndex;
-        this.buildAgent = (session) => {
+        this.buildAgent = (session, onUiUpdate) => {
             return new CodingAgent({
                 config,
                 modelClient,
@@ -63,9 +70,10 @@ export class AgentBridge {
                 ...(projectIndex !== undefined
                     ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
                     : {}),
-                onUiUpdate: (event) => {
+                onUiUpdate: onUiUpdate ?? ((event) => {
                     this.emit(event);
-                },
+                }),
+                getSystemPromptSuffix: () => this.buildAnnotationSuffix(),
             });
         };
         this.agent = this.buildAgent();
@@ -118,13 +126,23 @@ export class AgentBridge {
     }
     // Session operations
     async saveSess(label) {
-        return saveSession(this.agent.getSession(), label);
+        const annotationsObj = this.annotations.size > 0
+            ? Object.fromEntries(this.annotations)
+            : undefined;
+        return saveSession(this.agent.getSession(), label, annotationsObj);
     }
     async loadSess(label) {
         const result = (await loadSessionByLabel(label)) ?? (await loadSession(label));
         if (!result)
             return null;
         this.agent = this.buildAgent(result.session);
+        // Restore annotations from saved session
+        this.annotations.clear();
+        if (result.annotations) {
+            for (const [name, notes] of Object.entries(result.annotations)) {
+                this.annotations.set(name, notes);
+            }
+        }
         return result;
     }
     async listSess() {
@@ -230,4 +248,109 @@ export class AgentBridge {
         this.pinnedSymbols.delete(sym.qualifiedName);
         return true;
     }
+    // ── Annotations ──
+    getAnnotations() {
+        this.evictStaleAnnotations();
+        return Object.fromEntries(this.annotations);
+    }
+    getAnnotationsForSymbol(name) {
+        return this.annotations.get(name) ?? [];
+    }
+    addAnnotation(name, text) {
+        if (!this.projectIndex)
+            return false;
+        const sym = this.projectIndex.getSymbol(name);
+        if (!sym)
+            return false;
+        const trimmed = text.slice(0, 500).trim();
+        if (trimmed.length === 0)
+            return false;
+        const key = sym.qualifiedName;
+        const existing = this.annotations.get(key) ?? [];
+        existing.push(trimmed);
+        this.annotations.set(key, existing);
+        return true;
+    }
+    removeAnnotation(name, index) {
+        const notes = this.annotations.get(name);
+        if (!notes || index < 0 || index >= notes.length)
+            return false;
+        notes.splice(index, 1);
+        if (notes.length === 0) {
+            this.annotations.delete(name);
+        }
+        return true;
+    }
+    clearAnnotations(name) {
+        this.annotations.delete(name);
+    }
+    evictStaleAnnotations() {
+        if (!this.projectIndex)
+            return;
+        for (const name of [...this.annotations.keys()]) {
+            if (!this.projectIndex.getSymbol(name)) {
+                this.annotations.delete(name);
+            }
+        }
+    }
+    buildAnnotationSuffix() {
+        this.evictStaleAnnotations();
+        if (this.annotations.size === 0)
+            return undefined;
+        return `[Annotated symbols: ${[...this.annotations.keys()].join(", ")}]`;
+    }
+    appendAnnotationsToResult(toolName, input, result) {
+        if (this.annotations.size === 0)
+            return result;
+        const inp = input;
+        if (toolName === "read_symbol" || toolName === "find_references" || toolName === "get_dependencies") {
+            const symName = (inp.name ?? inp.symbol ?? inp.query);
+            if (!symName)
+                return result;
+            // Try direct match, then resolve via index
+            let notes = this.annotations.get(symName);
+            if (!notes && this.projectIndex) {
+                const sym = this.projectIndex.getSymbol(symName);
+                if (sym)
+                    notes = this.annotations.get(sym.qualifiedName);
+            }
+            if (notes && notes.length > 0) {
+                return result + `\n[User annotation: ${notes.join("; ")}]`;
+            }
+        }
+        if (toolName === "read_file") {
+            const filePath = inp.path;
+            if (!filePath)
+                return result;
+            const fileAnnotations = [];
+            for (const [name, notes] of this.annotations) {
+                if (!this.projectIndex)
+                    continue;
+                const sym = this.projectIndex.getSymbol(name);
+                if (sym && (sym.filePath === filePath || filePath.endsWith(sym.filePath))) {
+                    fileAnnotations.push(`- ${sym.name}: ${notes.join("; ")}`);
+                }
+            }
+            if (fileAnnotations.length > 0) {
+                return result + `\n[User annotations for symbols in this file:]\n${fileAnnotations.join("\n")}`;
+            }
+        }
+        return result;
+    }
+    // ── Explain ──
+    async explainSymbol(name, onEvent, signal) {
+        if (!this.projectIndex)
+            throw new Error("No project index");
+        const sym = this.projectIndex.getSymbol(name);
+        if (!sym)
+            throw new Error(`Symbol "${name}" not found`);
+        const explainAgent = this.buildAgent(undefined, onEvent);
+        const prompt = `Explain "${sym.name}" (${sym.kind} in ${sym.filePath}).
+Use read_symbol, get_dependencies, find_references to gather context.
+Explain what it does, how it works, what depends on it, and key design decisions.
+Be concise but thorough.`;
+        const opts = signal ? { signal } : undefined;
+        const result = await explainAgent.runTurn(prompt, opts);
+        return result.text;
+    }
 }

package/dist/src/serve/server.js

@@ -7,10 +7,12 @@ import { createWebSocketServer } from "./websocket.js";
 import { handleChatCompletions, handleModels } from "./openai-compat.js";
 import { formatConfigForDisplay } from "../agent/config.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Resolve web dir: works in both dev (src/serve/) and dist (dist/src/serve/)
+// Resolve web dir: always serve from dist/src/web (built by scripts/build-web.mjs)
+// In dev (tsx): __dirname = src/serve → go up to project root, then dist/src/web
+// In prod (dist): __dirname = dist/src/serve → sibling dir dist/src/web
 const webDir = __dirname.includes(`${path.sep}dist${path.sep}`)
-    ? path.resolve(__dirname, "../../src/web")
-    : path.resolve(__dirname, "../web");
+    ? path.resolve(__dirname, "../web")
+    : path.resolve(__dirname, "../../dist/src/web");
 const MIME_TYPES = {
     ".html": "text/html",
     ".css": "text/css",
@@ -133,6 +135,26 @@ export function createRequestHandler(bridge) {
                 sendJson(res, 200, { symbol: name, references: result });
                 return;
             }
+            if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/source") && method === "GET") {
+                const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/source".length));
+                const sym = bridge.getSymbol(name);
+                if (!sym) {
+                    sendJson(res, 404, { error: `Symbol "${name}" not found` });
+                    return;
+                }
+                try {
+                    const fileContent = await readFile(path.resolve(config.workspaceRoot, sym.filePath), "utf8");
+                    const lines = fileContent.split(/\r?\n/);
+                    const start = Math.max(0, sym.startLine - 1);
+                    const end = Math.min(lines.length, sym.endLine);
+                    const source = lines.slice(start, end).join("\n");
+                    sendJson(res, 200, { symbol: name, filePath: sym.filePath, startLine: sym.startLine, endLine: sym.endLine, source });
+                }
+                catch {
+                    sendJson(res, 500, { error: `Could not read file: ${sym.filePath}` });
+                }
+                return;
+            }
             if (pathname === "/api/code-map" && method === "GET") {
                 const budgetParam = url.searchParams.get("budget");
                 const budget = budgetParam ? Number(budgetParam) : undefined;
@@ -180,6 +202,82 @@ export function createRequestHandler(bridge) {
                 sendJson(res, 400, { error: `Unknown action "${body.action}". Use "pin" or "unpin".` });
                 return;
             }
+            // ── Annotations API ──
+            if (pathname === "/api/annotations" && method === "GET") {
+                sendJson(res, 200, { annotations: bridge.getAnnotations() });
+                return;
+            }
+            if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/annotations") && method === "GET") {
+                const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/annotations".length));
+                const notes = bridge.getAnnotationsForSymbol(name);
+                sendJson(res, 200, { symbol: name, annotations: notes });
+                return;
+            }
+            if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/annotations") && method === "POST") {
+                const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/annotations".length));
+                const body = JSON.parse(await readBody(req));
+                if (!body.text) {
+                    sendJson(res, 400, { error: "text is required" });
+                    return;
+                }
+                const ok = bridge.addAnnotation(name, body.text);
+                if (!ok) {
+                    sendJson(res, 404, { error: `Symbol "${name}" not found or text empty` });
+                    return;
+                }
+                sendJson(res, 200, { symbol: name, annotations: bridge.getAnnotationsForSymbol(name) });
+                return;
+            }
+            // DELETE /api/symbols/:name/annotations/:index
+            {
+                const annoDeleteMatch = pathname.match(/^\/api\/symbols\/(.+)\/annotations\/(\d+)$/);
+                if (annoDeleteMatch && method === "DELETE") {
+                    const name = decodeURIComponent(annoDeleteMatch[1]);
+                    const index = Number(annoDeleteMatch[2]);
+                    const ok = bridge.removeAnnotation(name, index);
+                    if (!ok) {
+                        sendJson(res, 404, { error: "Annotation not found" });
+                        return;
+                    }
+                    sendJson(res, 200, { symbol: name, annotations: bridge.getAnnotationsForSymbol(name) });
+                    return;
+                }
+            }
+            if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/annotations") && method === "DELETE") {
+                const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/annotations".length));
+                bridge.clearAnnotations(name);
+                sendJson(res, 200, { symbol: name, annotations: [] });
+                return;
+            }
+            // ── Explain SSE ──
+            if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/explain") && method === "GET") {
+                const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/explain".length));
+                res.writeHead(200, {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    Connection: "keep-alive",
+                });
+                const abortController = new AbortController();
+                req.on("close", () => abortController.abort());
+                try {
+                    await bridge.explainSymbol(name, (event) => {
+                        if (!res.writableEnded) {
+                            res.write(`data: ${JSON.stringify(event)}\n\n`);
+                        }
+                    }, abortController.signal);
+                }
+                catch (error) {
+                    if (!res.writableEnded) {
+                        const msg = error instanceof Error ? error.message : "Unknown error";
+                        res.write(`data: ${JSON.stringify({ type: "error", message: msg })}\n\n`);
+                    }
+                }
+                if (!res.writableEnded) {
+                    res.write("data: [DONE]\n\n");
+                    res.end();
+                }
+                return;
+            }
             if (pathname === "/api/chat" && method === "POST") {
                 const body = JSON.parse(await readBody(req));
                 if (!body.message) {

package/dist/src/session/session-store.js

@@ -7,7 +7,7 @@ let sessionsDir = path.join(os.homedir(), ".minicode", "sessions");
 export function setSessionsDir(dir) {
     sessionsDir = dir;
 }
-export async function saveSession(session, label) {
+export async function saveSession(session, label, annotations) {
     await mkdir(sessionsDir, { recursive: true });
     const savedAt = new Date().toISOString();
     const snapshot = session.toJSON();
@@ -18,6 +18,7 @@ export async function saveSession(session, label) {
         label: resolvedLabel,
         savedAt,
         session: snapshot,
+        ...(annotations && Object.keys(annotations).length > 0 ? { annotations } : {}),
     };
     const filePath = path.join(sessionsDir, `${snapshot.id}.json`);
     await writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
@@ -67,6 +68,7 @@ export async function loadSession(sessionId) {
         return {
             session: Session.fromJSON(data.session),
             label: data.label,
+            ...(data.annotations ? { annotations: data.annotations } : {}),
         };
     }
     catch {

package/dist/src/ui/cli-ink.js

@@ -90,6 +90,7 @@ export async function runInkCli(verbose, initialTask) {
             ...(verbose
                 ? {
                     onProgress: (msg) => store.addItem({ type: "system", content: msg }),
+                    onVerbose: (msg) => store.addItem({ type: "system", content: msg }),
                 }
                 : {}),
             onUiUpdate: createUiUpdateHandler(),