@sean.holung/minicode 0.2.2 → 0.2.4

package/dist/src/serve/openai-compat.js

@@ -0,0 +1,144 @@
+import { randomUUID } from "node:crypto";
+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);
+    });
+}
+export function handleModels(_req, res) {
+    sendJson(res, 200, {
+        object: "list",
+        data: [
+            {
+                id: "minicode-agent",
+                object: "model",
+                created: Math.floor(Date.now() / 1000),
+                owned_by: "minicode",
+            },
+        ],
+    });
+}
+export async function handleChatCompletions(req, res, bridge) {
+    let body;
+    try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+    }
+    catch {
+        sendJson(res, 400, { error: { message: "Invalid JSON body", type: "invalid_request_error" } });
+        return;
+    }
+    const messages = body.messages;
+    if (!messages || messages.length === 0) {
+        sendJson(res, 400, { error: { message: "messages array is required", type: "invalid_request_error" } });
+        return;
+    }
+    // Extract last user message
+    let userMessage;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+            userMessage = messages[i].content;
+            break;
+        }
+    }
+    if (!userMessage) {
+        sendJson(res, 400, { error: { message: "No user message found", type: "invalid_request_error" } });
+        return;
+    }
+    if (bridge.isBusy()) {
+        sendJson(res, 429, { error: { message: "Agent is busy with another request. Try again later.", type: "rate_limit_error" } });
+        return;
+    }
+    const completionId = `chatcmpl-${randomUUID()}`;
+    const created = Math.floor(Date.now() / 1000);
+    if (body.stream) {
+        await handleStreaming(res, bridge, userMessage, completionId, created);
+    }
+    else {
+        await handleNonStreaming(res, bridge, userMessage, completionId, created);
+    }
+}
+async function handleNonStreaming(res, bridge, message, completionId, created) {
+    try {
+        const result = await bridge.runTurn(message);
+        sendJson(res, 200, {
+            id: completionId,
+            object: "chat.completion",
+            created,
+            model: "minicode-agent",
+            choices: [
+                {
+                    index: 0,
+                    message: { role: "assistant", content: result.text },
+                    finish_reason: "stop",
+                },
+            ],
+            usage: result.usage
+                ? {
+                    prompt_tokens: result.usage.inputTokens,
+                    completion_tokens: result.usage.outputTokens,
+                    total_tokens: result.usage.inputTokens + result.usage.outputTokens,
+                }
+                : undefined,
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        sendJson(res, 500, { error: { message: msg, type: "server_error" } });
+    }
+}
+async function handleStreaming(res, bridge, message, completionId, created) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
+    function sendSSE(data) {
+        res.write(`data: ${JSON.stringify(data)}\n\n`);
+    }
+    // Send initial role chunk
+    sendSSE({
+        id: completionId,
+        object: "chat.completion.chunk",
+        created,
+        model: "minicode-agent",
+        choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }],
+    });
+    const listener = (msg) => {
+        if (msg.type === "streaming_chunk" && msg.content) {
+            sendSSE({
+                id: completionId,
+                object: "chat.completion.chunk",
+                created,
+                model: "minicode-agent",
+                choices: [{ index: 0, delta: { content: msg.content }, finish_reason: null }],
+            });
+        }
+    };
+    bridge.addListener(listener);
+    try {
+        await bridge.runTurn(message);
+        sendSSE({
+            id: completionId,
+            object: "chat.completion.chunk",
+            created,
+            model: "minicode-agent",
+            choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+        });
+        res.write("data: [DONE]\n\n");
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error";
+        sendSSE({ error: { message: msg, type: "server_error" } });
+    }
+    finally {
+        bridge.removeListener(listener);
+        res.end();
+    }
+}

package/dist/src/serve/server.js

@@ -0,0 +1,251 @@
+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: works in both dev (src/serve/) and dist (dist/src/serve/)
+const webDir = __dirname.includes(`${path.sep}dist${path.sep}`)
+    ? path.resolve(__dirname, "../../src/web")
+    : path.resolve(__dirname, "../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 === "/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;
+            }
+            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/ui/cli-ink.js

@@ -85,7 +85,7 @@ export async function runInkCli(verbose, initialTask) {
             verbose,
             ...(session ? { session } : {}),
             ...(projectIndex !== undefined
-                ? { getCodeMap: () => projectIndex.getCodeMap() }
+                ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
                 : {}),
             ...(verbose
                 ? {
@@ -121,7 +121,7 @@ export async function runInkCli(verbose, initialTask) {
         if (trimmed === "/help") {
             store.addItem({
                 type: "system",
-                content: 'Commands: "/help", "/config", "/save [label]", "/load [label]", "/sessions", "/exit".',
+                content: 'Commands: "/help", "/config", "/compact", "/save [label]", "/load [label]", "/sessions", "/exit".',
             });
             return;
         }
@@ -132,6 +132,26 @@ export async function runInkCli(verbose, initialTask) {
             });
             return;
         }
+        if (trimmed === "/compact") {
+            const session = agent.getSession();
+            const result = await agent.compactContext();
+            if (result) {
+                const method = config.compactionModel ? "LLM" : "mechanical";
+                store.addItem({
+                    type: "system",
+                    content: `Compacted (${method}): ${result.removedMessages} messages summarized, ` +
+                        `${result.previousTokens} → ${result.newTokens} tokens ` +
+                        `(saved ${result.previousTokens - result.newTokens} tokens)`,
+                });
+            }
+            else {
+                store.addItem({
+                    type: "system",
+                    content: `Nothing to compact (${session.getTokenEstimate()} tokens, ${session.getMessages().length} messages).`,
+                });
+            }
+            return;
+        }
         if (trimmed === "/save" || trimmed.startsWith("/save ")) {
             const label = trimmed.slice("/save".length).trim() || undefined;
             try {