@sean.holung/minicode 0.2.4 → 0.3.1

package/dist/src/indexer/code-map.js

@@ -10,7 +10,8 @@ function formatSymbol(symbol, indent, isMethod) {
     return `${indent}${symbol.kind} ${symbol.qualifiedName}\n${indent}  ${symbol.signature}`;
 }
 function isEntryPointFile(filePath) {
-    return filePath === "src/index.ts" || filePath.endsWith("/index.ts");
+    const name = filePath.replace(/\\/g, "/");
+    return /(?:^|\/)index\.[jt]sx?$/.test(name);
 }
 /**
  * Build the set of symbols related to focus symbols via dependency edges.

package/dist/src/indexer/plugins/typescript.js

@@ -17,7 +17,7 @@ function extractSignature(node, sourceFile) {
         if (ts.isArrowFunction(node) && ts.isBlock(node.body)) {
             return node.body.getStart(sourceFile);
         }
-        if (ts.isClassDeclaration(node)) {
+        if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
             const text = sourceText.slice(node.getStart(), node.getEnd());
             const braceIdx = text.indexOf("{");
             return braceIdx >= 0 ? node.getStart() + braceIdx : null;
@@ -84,7 +84,8 @@ function createPlugin() {
                     });
                     return;
                 }
-                if (ts.isClassDeclaration(node) && node.name) {
+                if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) &&
+                    node.name) {
                     const name = node.name.getText(sourceFile);
                     const prevClass = currentClass;
                     currentClass = name;
@@ -97,7 +98,7 @@ function createPlugin() {
                         startLine: getLine(sourceFile, node.getStart(sourceFile)),
                         endLine: getLine(sourceFile, node.getEnd()),
                         signature: extractSignature(node, sourceFile),
-                        exported: isExported(node),
+                        exported: ts.isClassDeclaration(node) ? isExported(node) : false,
                         dependencies: [],
                         ...(doc && { docComment: doc }),
                     });
@@ -183,9 +184,9 @@ function createPlugin() {
                     const doc = extractJSDoc(node, sourceFile);
                     for (const decl of node.declarationList.declarations) {
                         const init = decl.initializer;
-                        if (ts.isIdentifier(decl.name) &&
-                            init &&
-                            (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+                        if (!ts.isIdentifier(decl.name) || !init)
+                            continue;
+                        if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
                             const name = decl.name.getText(sourceFile);
                             symbols.push({
                                 name,
@@ -200,6 +201,25 @@ function createPlugin() {
                                 ...(doc && { docComment: doc }),
                             });
                         }
+                        else if (ts.isClassExpression(init)) {
+                            const name = decl.name.getText(sourceFile);
+                            const prevClass = currentClass;
+                            currentClass = name;
+                            symbols.push({
+                                name,
+                                qualifiedName: name,
+                                kind: "class",
+                                filePath,
+                                startLine: getLine(sourceFile, decl.getStart(sourceFile)),
+                                endLine: getLine(sourceFile, decl.getEnd()),
+                                signature: extractSignature(init, sourceFile),
+                                exported,
+                                dependencies: [],
+                                ...(doc && { docComment: doc }),
+                            });
+                            ts.forEachChild(init, visit);
+                            currentClass = prevClass;
+                        }
                     }
                     return;
                 }
@@ -236,10 +256,11 @@ function createPlugin() {
                     if (ts.isIdentifier(expr)) {
                         addEdge(from, expr.getText(), "calls");
                     }
-                    else if (ts.isNewExpression(expr) && expr.expression) {
-                        if (ts.isIdentifier(expr.expression)) {
-                            addEdge(from, expr.expression.getText(), "calls");
-                        }
+                }
+                if (ts.isNewExpression(node)) {
+                    const expr = node.expression;
+                    if (ts.isIdentifier(expr)) {
+                        addEdge(from, expr.getText(), "calls");
                     }
                 }
                 ts.forEachChild(node, (n) => collectCalls(n, from));
@@ -248,29 +269,33 @@ function createPlugin() {
                 const fullPath = path.join(rootDir, filePath);
                 const sourceFile = ts.createSourceFile(fullPath, content, ts.ScriptTarget.Latest, true);
                 let currentClass = null;
-                function visit(node) {
-                    if (ts.isClassDeclaration(node) && node.name) {
-                        const name = node.name.getText(sourceFile);
-                        const prevClass = currentClass;
-                        currentClass = name;
-                        if (symbolSet.has(name)) {
-                            for (const clause of node.heritageClauses ?? []) {
-                                for (const type of clause.types) {
-                                    const expr = type.expression;
-                                    const target = ts.isIdentifier(expr)
-                                        ? expr.getText()
-                                        : ts.isPropertyAccessExpression(expr)
-                                            ? expr.expression.getText()
-                                            : expr.getText();
-                                    const kind = clause.token === ts.SyntaxKind.ExtendsKeyword
-                                        ? "extends"
-                                        : "implements";
-                                    addEdge(name, target, kind);
-                                }
+                function visitClassNode(node, name) {
+                    const prevClass = currentClass;
+                    currentClass = name;
+                    if (symbolSet.has(name)) {
+                        for (const clause of node.heritageClauses ?? []) {
+                            for (const type of clause.types) {
+                                const expr = type.expression;
+                                const target = ts.isIdentifier(expr)
+                                    ? expr.getText()
+                                    : ts.isPropertyAccessExpression(expr)
+                                        ? expr.expression.getText()
+                                        : expr.getText();
+                                const kind = clause.token === ts.SyntaxKind.ExtendsKeyword
+                                    ? "extends"
+                                    : "implements";
+                                addEdge(name, target, kind);
                             }
                         }
-                        ts.forEachChild(node, visit);
-                        currentClass = prevClass;
+                    }
+                    ts.forEachChild(node, visit);
+                    currentClass = prevClass;
+                }
+                function visit(node) {
+                    if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) &&
+                        node.name) {
+                        const name = node.name.getText(sourceFile);
+                        visitClassNode(node, name);
                         return;
                     }
                     if (ts.isConstructorDeclaration(node)) {
@@ -304,15 +329,19 @@ function createPlugin() {
                     if (ts.isVariableStatement(node)) {
                         for (const decl of node.declarationList.declarations) {
                             const init = decl.initializer;
-                            if (ts.isIdentifier(decl.name) &&
-                                init &&
-                                (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {
+                            if (!ts.isIdentifier(decl.name) || !init)
+                                continue;
+                            if (ts.isArrowFunction(init) || ts.isFunctionExpression(init)) {
                                 const name = decl.name.getText(sourceFile);
                                 if (symbolSet.has(name)) {
                                     collectTypeRefs(decl, name);
                                     collectCalls(decl, name);
                                 }
                             }
+                            else if (ts.isClassExpression(init)) {
+                                const name = decl.name.getText(sourceFile);
+                                visitClassNode(init, name);
+                            }
                         }
                         return;
                     }

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(),