@sean.holung/minicode 0.2.3 → 0.3.0

package/dist/src/serve/server.js

@@ -0,0 +1,349 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { AgentBridge } from "./agent-bridge.js";
+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: 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, "../web")
+    : path.resolve(__dirname, "../../dist/src/web");
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".json": "application/json",
+};
+function sendJson(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+        req.on("error", reject);
+    });
+}
+async function serveStatic(res, urlPath) {
+    const fileName = urlPath === "/" ? "index.html" : urlPath.slice(1);
+    const filePath = path.join(webDir, fileName);
+    // Prevent path traversal
+    if (!filePath.startsWith(webDir)) {
+        res.writeHead(403);
+        res.end("Forbidden");
+        return;
+    }
+    try {
+        const content = await readFile(filePath);
+        const ext = path.extname(filePath);
+        const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+        res.writeHead(200, { "Content-Type": contentType });
+        res.end(content);
+    }
+    catch {
+        res.writeHead(404);
+        res.end("Not Found");
+    }
+}
+/** Create the HTTP request handler. Exported for testing. */
+export function createRequestHandler(bridge) {
+    const config = bridge.getConfig();
+    return (req, res) => {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        const method = req.method ?? "GET";
+        const pathname = url.pathname;
+        const handle = async () => {
+            // OpenAI-compatible routes
+            if (pathname === "/v1/models" && method === "GET") {
+                handleModels(req, res);
+                return;
+            }
+            if (pathname === "/v1/chat/completions" && method === "POST") {
+                await handleChatCompletions(req, res, bridge);
+                return;
+            }
+            // Minicode REST API
+            if (pathname === "/api/status" && method === "GET") {
+                sendJson(res, 200, {
+                    status: bridge.isBusy() ? "busy" : "ready",
+                    workspace: config.workspaceRoot,
+                    model: config.model,
+                    provider: config.modelProvider,
+                });
+                return;
+            }
+            if (pathname === "/api/config" && method === "GET") {
+                sendJson(res, 200, { config: formatConfigForDisplay(config) });
+                return;
+            }
+            if (pathname === "/api/sessions" && method === "GET") {
+                const sessions = await bridge.listSess();
+                sendJson(res, 200, { sessions });
+                return;
+            }
+            if (pathname === "/api/sessions/save" && method === "POST") {
+                const body = JSON.parse(await readBody(req));
+                const meta = await bridge.saveSess(body.label);
+                sendJson(res, 200, meta);
+                return;
+            }
+            if (pathname === "/api/sessions/load" && method === "POST") {
+                const body = JSON.parse(await readBody(req));
+                const result = await bridge.loadSess(body.label);
+                if (!result) {
+                    sendJson(res, 404, { error: "Session not found" });
+                    return;
+                }
+                sendJson(res, 200, { label: result.label });
+                return;
+            }
+            // ── Graph / Index API ──
+            if (pathname === "/api/symbols" && method === "GET") {
+                if (!bridge.hasIndex()) {
+                    sendJson(res, 404, { error: "No project index available" });
+                    return;
+                }
+                sendJson(res, 200, { symbols: bridge.getSymbols() });
+                return;
+            }
+            if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/dependencies") && method === "GET") {
+                const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/dependencies".length));
+                const depthParam = url.searchParams.get("depth");
+                const depth = depthParam ? Number(depthParam) : undefined;
+                const result = bridge.getDependencies(name, depth);
+                if (!result) {
+                    sendJson(res, 404, { error: `Symbol "${name}" not found` });
+                    return;
+                }
+                sendJson(res, 200, { symbol: name, dependencies: result });
+                return;
+            }
+            if (pathname.startsWith("/api/symbols/") && pathname.endsWith("/references") && method === "GET") {
+                const name = decodeURIComponent(pathname.slice("/api/symbols/".length, -"/references".length));
+                const result = bridge.getReferences(name);
+                if (!result) {
+                    sendJson(res, 404, { error: `Symbol "${name}" not found` });
+                    return;
+                }
+                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;
+                const result = bridge.getCodeMap(budget);
+                if (!result) {
+                    sendJson(res, 404, { error: "No project index available" });
+                    return;
+                }
+                sendJson(res, 200, result);
+                return;
+            }
+            if (pathname === "/api/graph" && method === "GET") {
+                const result = bridge.getGraph();
+                if (!result) {
+                    sendJson(res, 404, { error: "No project index available" });
+                    return;
+                }
+                sendJson(res, 200, result);
+                return;
+            }
+            if (pathname === "/api/focus" && method === "GET") {
+                sendJson(res, 200, { pinned: bridge.getPinnedSymbols() });
+                return;
+            }
+            if (pathname === "/api/focus" && method === "POST") {
+                const body = JSON.parse(await readBody(req));
+                if (!body.symbol || !body.action) {
+                    sendJson(res, 400, { error: "action and symbol are required" });
+                    return;
+                }
+                if (body.action === "pin") {
+                    const ok = bridge.pinSymbol(body.symbol);
+                    if (!ok) {
+                        sendJson(res, 404, { error: `Symbol "${body.symbol}" not found` });
+                        return;
+                    }
+                    sendJson(res, 200, { pinned: bridge.getPinnedSymbols() });
+                    return;
+                }
+                if (body.action === "unpin") {
+                    bridge.unpinSymbol(body.symbol);
+                    sendJson(res, 200, { pinned: bridge.getPinnedSymbols() });
+                    return;
+                }
+                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) {
+                    sendJson(res, 400, { error: "message is required" });
+                    return;
+                }
+                if (bridge.isBusy()) {
+                    sendJson(res, 429, { error: "Agent is busy" });
+                    return;
+                }
+                try {
+                    const result = await bridge.runTurn(body.message);
+                    sendJson(res, 200, { text: result.text, usage: result.usage });
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : "Unknown error";
+                    sendJson(res, 500, { error: msg });
+                }
+                return;
+            }
+            // Static files
+            await serveStatic(res, pathname);
+        };
+        handle().catch((error) => {
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            sendJson(res, 500, { error: msg });
+        });
+    };
+}
+export async function runServe(verbose, port) {
+    console.log("Initializing agent...");
+    // Set up broadcast plumbing
+    let broadcastFn = () => { };
+    const bridge = new AgentBridge((msg) => broadcastFn(msg), verbose);
+    await bridge.init();
+    const config = bridge.getConfig();
+    const handler = createRequestHandler(bridge);
+    const server = createServer(handler);
+    // WebSocket server — captures the real broadcast function
+    const wss = createWebSocketServer(server, bridge);
+    // Wire up the broadcast: WS clients receive all agent events
+    const { WebSocket } = await import("ws");
+    broadcastFn = (msg) => {
+        const data = JSON.stringify(msg);
+        for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(data);
+            }
+        }
+    };
+    // Graceful shutdown
+    process.on("SIGINT", () => {
+        console.log("\nShutting down...");
+        wss.close();
+        server.close(() => {
+            process.exit(0);
+        });
+    });
+    server.listen(port, "127.0.0.1", () => {
+        console.log(`\nminicode serve`);
+        console.log(`  Workspace: ${config.workspaceRoot}`);
+        console.log(`  Model:     ${config.model} (${config.modelProvider})`);
+        console.log(`  Web UI:    http://localhost:${port}`);
+        console.log(`  OpenAI:    http://localhost:${port}/v1`);
+        console.log(`\nPress Ctrl+C to stop.\n`);
+    });
+    // Keep alive
+    await new Promise(() => { });
+}

package/dist/src/serve/types.js

@@ -0,0 +1,2 @@
+/** WebSocket message protocol types for minicode serve mode. */
+export {};

package/dist/src/serve/websocket.js

@@ -0,0 +1,28 @@
+import { WebSocketServer } from "ws";
+export function createWebSocketServer(httpServer, bridge) {
+    const wss = new WebSocketServer({ server: httpServer });
+    wss.on("connection", (ws) => {
+        ws.on("message", (raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(String(raw));
+            }
+            catch {
+                return;
+            }
+            if (msg.type === "chat") {
+                if (bridge.isBusy()) {
+                    ws.send(JSON.stringify({ type: "busy" }));
+                    return;
+                }
+                bridge.runTurn(msg.message).catch(() => {
+                    // errors already broadcast via agent-bridge
+                });
+            }
+            else if (msg.type === "cancel") {
+                bridge.cancel();
+            }
+        });
+    });
+    return wss;
+}

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