@sean.holung/minicode 0.3.7 → 0.3.9

package/dist/src/agent/config.js

@@ -60,6 +60,31 @@ export function getConfigMissing(config) {
     }
     return missing;
 }
+function hasExplicitConfigValue(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function parseExplicitModelProvider(value) {
+    if (!hasExplicitConfigValue(value)) {
+        return undefined;
+    }
+    return parseModelProvider(value);
+}
+export function getConfiguredProvider(config, env = process.env) {
+    const explicitModelProvider = parseExplicitModelProvider(env.MODEL_PROVIDER);
+    if (config.modelProvider === "anthropic") {
+        return explicitModelProvider === "anthropic" || hasExplicitConfigValue(env.ANTHROPIC_API_KEY)
+            ? "anthropic"
+            : null;
+    }
+    const hasExplicitOpenAiCompatibleConfig = explicitModelProvider === "openai-compatible" ||
+        hasExplicitConfigValue(env.OPENAI_BASE_URL) ||
+        hasExplicitConfigValue(env.OPENROUTER_API_KEY);
+    if (!hasExplicitOpenAiCompatibleConfig) {
+        return null;
+    }
+    const baseUrl = (env.OPENAI_BASE_URL ?? config.openAiBaseUrl).trim().toLowerCase();
+    return baseUrl.includes("openrouter") ? "openrouter" : "openai-compatible";
+}
 export function getConfigSetupMessage(config) {
     const missing = getConfigMissing(config);
     if (missing.length === 0) {

package/dist/src/model-utils.js

@@ -1,4 +1,4 @@
-function getModelDisplayName(model) {
+export function getModelDisplayName(model) {
     return (model.name ?? model.id).trim();
 }
 export function sortModelsAlphabetically(models) {
@@ -16,3 +16,20 @@ export function sortModelsAlphabetically(models) {
         });
     });
 }
+function normalizeModelSearchValue(value) {
+    return value
+        .trim()
+        .toLocaleLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+}
+export function filterModelsByQuery(models, query) {
+    const tokens = normalizeModelSearchValue(query);
+    if (tokens.length === 0) {
+        return [...models];
+    }
+    return models.filter((model) => {
+        const haystack = `${getModelDisplayName(model)} ${model.id}`.toLocaleLowerCase();
+        return tokens.every((token) => haystack.includes(token));
+    });
+}

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

@@ -8,7 +8,7 @@ import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "
 import { buildProjectIndex } from "../indexer/project-index.js";
 import { sortModelsAlphabetically } from "../model-utils.js";
 import { createToolRegistry } from "../tools/registry.js";
-import { listSessions, loadSession, loadSessionByLabel, saveSession, } from "../session/session-store.js";
+import { deleteSession, listSessions, loadSession, loadSessionByLabel, saveSession, } from "../session/session-store.js";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 export class AgentBridge {
     agent;
@@ -17,7 +17,7 @@ export class AgentBridge {
     modelClient;
     projectIndex;
     toolRegistry;
-    sessionOpenRouterConnected = false;
+    sessionProviderConnection = null;
     busy = false;
     abortController = null;
     broadcast;
@@ -68,17 +68,10 @@ export class AgentBridge {
         catch {
             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.baseConfig = AgentBridge.cloneConfig(config);
         this.projectIndex = projectIndex;
-        this.toolRegistry = toolRegistry;
+        this.installToolRegistry(projectIndex);
         if (this.modelClient) {
             this.agent = this.createAgent();
         }
@@ -98,6 +91,16 @@ export class AgentBridge {
         }
         Object.assign(targetRecord, AgentBridge.cloneConfig(source));
     }
+    installToolRegistry(projectIndex) {
+        const toolRegistry = createToolRegistry(this.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.toolRegistry = toolRegistry;
+    }
     createAgent(session, onUiUpdate) {
         if (!this.modelClient || !this.toolRegistry) {
             throw new Error("Agent runtime is not initialized.");
@@ -179,7 +182,8 @@ export class AgentBridge {
             }
         }
         catch {
-            // File may have been deleted — ignore
+            // File may have been deleted or renamed. A workspace refresh prunes stale symbols.
+            await this.refreshIndex();
         }
     }
     isReady() {
@@ -192,7 +196,10 @@ export class AgentBridge {
         return this.config;
     }
     isOpenRouterSessionConnected() {
-        return this.sessionOpenRouterConnected;
+        return this.sessionProviderConnection === "openrouter";
+    }
+    isOpenAiCompatibleSessionConnected() {
+        return this.sessionProviderConnection === "openai-compatible";
     }
     connectOpenRouter(apiKey) {
         const trimmedKey = apiKey.trim();
@@ -206,7 +213,29 @@ export class AgentBridge {
         this.config.modelProvider = "openai-compatible";
         this.config.openAiBaseUrl = "https://openrouter.ai/api/v1";
         this.config.openAiApiKey = trimmedKey;
-        this.sessionOpenRouterConnected = true;
+        this.sessionProviderConnection = "openrouter";
+        this.modelClient = createModelClient(this.config);
+        this.agent = this.createAgent(currentSession);
+    }
+    connectOpenAiCompatible(baseUrl, apiKey) {
+        const trimmedBaseUrl = baseUrl.trim().replace(/\/+$/, "");
+        if (!trimmedBaseUrl) {
+            throw new Error("OpenAI-compatible endpoint is required.");
+        }
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        const currentSession = this.agent?.getSession();
+        this.config.modelProvider = "openai-compatible";
+        this.config.openAiBaseUrl = trimmedBaseUrl;
+        const trimmedApiKey = apiKey?.trim() ?? "";
+        if (trimmedApiKey) {
+            this.config.openAiApiKey = trimmedApiKey;
+        }
+        else {
+            delete this.config.openAiApiKey;
+        }
+        this.sessionProviderConnection = "openai-compatible";
         this.modelClient = createModelClient(this.config);
         this.agent = this.createAgent(currentSession);
     }
@@ -214,12 +243,24 @@ export class AgentBridge {
         if (this.busy) {
             throw new Error("busy");
         }
-        if (!this.sessionOpenRouterConnected) {
+        if (this.sessionProviderConnection !== "openrouter") {
+            return false;
+        }
+        return this.disconnectSessionProvider();
+    }
+    disconnectOpenAiCompatible() {
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        if (this.sessionProviderConnection !== "openai-compatible") {
             return false;
         }
+        return this.disconnectSessionProvider();
+    }
+    disconnectSessionProvider() {
         const currentSession = this.agent?.getSession();
         AgentBridge.applyConfig(this.config, this.baseConfig);
-        this.sessionOpenRouterConnected = false;
+        this.sessionProviderConnection = null;
         try {
             this.modelClient = createModelClient(this.config);
             this.agent = this.createAgent(currentSession);
@@ -308,10 +349,43 @@ export class AgentBridge {
     async listSess() {
         return listSessions();
     }
+    async deleteSess(sessionId) {
+        return deleteSession(sessionId);
+    }
     // ── Project index queries ──
     hasIndex() {
         return this.projectIndex !== undefined;
     }
+    async refreshIndex() {
+        try {
+            if (this.projectIndex) {
+                await this.projectIndex.refreshFromWorkspace();
+            }
+            else {
+                this.projectIndex = await buildProjectIndex(this.config.workspaceRoot);
+                this.installToolRegistry(this.projectIndex);
+                if (this.modelClient) {
+                    this.agent = this.createAgent(this.agent?.getSession());
+                }
+            }
+            const index = this.projectIndex;
+            if (!index) {
+                return false;
+            }
+            const cacheDir = getWorkspaceCacheDir(this.config.workspaceRoot);
+            const fileHashes = await computeFileHashes(this.config.workspaceRoot);
+            await saveIndex(index, cacheDir, fileHashes);
+            this.evictStaleAnnotations();
+            return true;
+        }
+        catch (error) {
+            if (this.verbose) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[index] Refresh failed: ${message}`);
+            }
+            return false;
+        }
+    }
     getSymbols() {
         if (!this.projectIndex)
             return [];

package/dist/src/serve/server.js

@@ -6,13 +6,14 @@ 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, getConfigMissing } from "../agent/config.js";
+import { formatConfigForDisplay, getConfiguredProvider, getConfigMissing, resolveConfigEnv } from "../agent/config.js";
 import { applyPersistedConfigUpdates, buildStructuredConfigPayload } from "../agent/editable-config.js";
 import { getHomeEnvPath, upsertHomeEnvValues } from "../agent/home-env.js";
 import { sortModelsAlphabetically } from "../model-utils.js";
 import { serializeSymbolMatch } from "../shared/symbol-resolution.js";
 import { handleMcpRequest } from "./mcp-server.js";
 import { buildSessionPreview } from "../session/session-preview.js";
+import { DuplicateSessionLabelError } from "../session/session-store.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
@@ -51,6 +52,9 @@ function readBody(req) {
         req.on("error", reject);
     });
 }
+function normalizeBaseUrl(value) {
+    return value.trim().replace(/\/+$/, "");
+}
 async function serveStatic(res, urlPath) {
     const fileName = urlPath === "/" ? "index.html" : urlPath.slice(1);
     const filePath = path.join(webDir, fileName);
@@ -107,13 +111,16 @@ export function createRequestHandler(bridge, emit, options = {}) {
             // Minicode REST API
             if (pathname === "/api/status" && method === "GET") {
                 const missing = getConfigMissing(config);
+                const resolvedEnv = await resolveConfigEnv({ ...(minicodeHome ? { minicodeHome } : {}) });
                 sendJson(res, 200, {
                     status: bridge.isBusy() ? "busy" : "ready",
                     workspace: config.workspaceRoot,
                     model: config.model,
                     provider: config.modelProvider,
                     baseUrl: config.openAiBaseUrl,
+                    configuredProvider: getConfiguredProvider(config, resolvedEnv.values),
                     sessionOpenRouterConnected: bridge.isOpenRouterSessionConnected(),
+                    sessionOpenAiCompatibleConnected: bridge.isOpenAiCompatibleSessionConnected(),
                     needsSetup: missing.length > 0,
                     missing,
                 });
@@ -223,6 +230,84 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 });
                 return;
             }
+            if (pathname === "/api/openai-compatible/connect" && method === "POST") {
+                const body = JSON.parse(await readBody(req));
+                if (!body.baseUrl || typeof body.baseUrl !== "string") {
+                    sendJson(res, 400, { error: "baseUrl is required" });
+                    return;
+                }
+                const normalizedBaseUrl = normalizeBaseUrl(body.baseUrl);
+                if (!normalizedBaseUrl) {
+                    sendJson(res, 400, { error: "baseUrl is required" });
+                    return;
+                }
+                try {
+                    const parsedUrl = new URL(normalizedBaseUrl);
+                    if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+                        throw new Error("invalid protocol");
+                    }
+                }
+                catch {
+                    sendJson(res, 400, { error: "baseUrl must be a valid absolute http(s) URL" });
+                    return;
+                }
+                try {
+                    bridge.connectOpenAiCompatible(normalizedBaseUrl, body.apiKey);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to configure the OpenAI-compatible provider";
+                    sendJson(res, message === "busy" ? 409 : 400, { error: message });
+                    return;
+                }
+                let persistedToEnv = false;
+                let persistedEnvPath = null;
+                let persistWarning = null;
+                const trimmedApiKey = body.apiKey?.trim() ?? "";
+                if (body.persistToEnv === true) {
+                    try {
+                        const result = await upsertHomeEnvValues({
+                            values: {
+                                MODEL_PROVIDER: "openai-compatible",
+                                OPENAI_BASE_URL: normalizedBaseUrl,
+                                OPENAI_API_KEY: trimmedApiKey.length > 0 ? trimmedApiKey : null,
+                            },
+                            ...(minicodeHome ? { minicodeHome } : {}),
+                        });
+                        persistedToEnv = true;
+                        persistedEnvPath = result.path;
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : "Failed to update ~/.minicode/.env";
+                        persistedEnvPath = getHomeEnvPath(minicodeHome);
+                        persistWarning = `The OpenAI-compatible provider connected for this serve session, but minicode could not update ${persistedEnvPath}: ${message}`;
+                    }
+                }
+                const missing = getConfigMissing(config);
+                const onlyModelMissing = missing.length === 1 && missing[0] === "MODEL is not set";
+                const message = persistWarning
+                    ? `${persistWarning}${onlyModelMissing ? " Select a model to continue." : ""}`
+                    : persistedToEnv
+                        ? (onlyModelMissing
+                            ? "The OpenAI-compatible provider connected for this serve session and was saved to ~/.minicode/.env. Select a model to continue, and minicode will remember this endpoint for future runs."
+                            : "The OpenAI-compatible provider connected for this serve session and was saved to ~/.minicode/.env for future runs.")
+                        : (onlyModelMissing
+                            ? "The OpenAI-compatible provider connected for this serve session. Select a model to continue."
+                            : "The OpenAI-compatible provider connected for this serve session.");
+                sendJson(res, 200, {
+                    ok: true,
+                    sessionOnly: true,
+                    persistedToEnv,
+                    persistedEnvPath,
+                    persistWarning,
+                    provider: config.modelProvider,
+                    model: config.model,
+                    baseUrl: config.openAiBaseUrl,
+                    needsSetup: missing.length > 0,
+                    missing,
+                    message,
+                });
+                return;
+            }
             if (pathname === "/api/openrouter/disconnect" && method === "POST") {
                 let disconnected = false;
                 try {
@@ -250,6 +335,33 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 sendJson(res, 200, body);
                 return;
             }
+            if (pathname === "/api/openai-compatible/disconnect" && method === "POST") {
+                let disconnected = false;
+                try {
+                    disconnected = bridge.disconnectOpenAiCompatible();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to remove the OpenAI-compatible session";
+                    sendJson(res, message === "busy" ? 409 : 400, { error: message });
+                    return;
+                }
+                const missing = getConfigMissing(config);
+                const body = {
+                    ok: true,
+                    disconnected,
+                    sessionOnly: true,
+                    provider: config.modelProvider,
+                    model: config.model,
+                    baseUrl: config.openAiBaseUrl,
+                    needsSetup: missing.length > 0,
+                    missing,
+                    message: disconnected
+                        ? "Removed the session-only OpenAI-compatible connection and restored your original provider settings."
+                        : "No session-only OpenAI-compatible connection was active.",
+                };
+                sendJson(res, 200, body);
+                return;
+            }
             if (pathname === "/api/model" && method === "POST") {
                 const body = JSON.parse(await readBody(req));
                 if (!body.model || typeof body.model !== "string") {
@@ -336,8 +448,16 @@ export function createRequestHandler(bridge, emit, options = {}) {
             }
             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);
+                try {
+                    const meta = await bridge.saveSess(body.label);
+                    sendJson(res, 200, meta);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : "Failed to save session";
+                    sendJson(res, error instanceof DuplicateSessionLabelError ? 409 : 500, {
+                        error: message,
+                    });
+                }
                 return;
             }
             if (pathname === "/api/sessions/load" && method === "POST") {
@@ -353,6 +473,20 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 });
                 return;
             }
+            if (pathname.startsWith("/api/sessions/") && method === "DELETE") {
+                const sessionId = decodeURIComponent(pathname.slice("/api/sessions/".length));
+                if (!sessionId) {
+                    sendJson(res, 400, { error: "Session id is required" });
+                    return;
+                }
+                const deleted = await bridge.deleteSess(sessionId);
+                if (!deleted) {
+                    sendJson(res, 404, { error: "Session not found" });
+                    return;
+                }
+                sendJson(res, 200, { ok: true, deleted: true, id: sessionId });
+                return;
+            }
             // ── Graph / Index API ──
             if (pathname === "/api/symbols" && method === "GET") {
                 if (!bridge.hasIndex()) {
@@ -472,6 +606,20 @@ export function createRequestHandler(bridge, emit, options = {}) {
                 sendJson(res, 200, result);
                 return;
             }
+            if (pathname === "/api/index/refresh" && method === "POST") {
+                const refreshed = await bridge.refreshIndex();
+                if (!refreshed) {
+                    sendJson(res, 404, { error: "No project index available" });
+                    return;
+                }
+                const graph = bridge.getGraph();
+                sendJson(res, 200, {
+                    ok: true,
+                    symbolCount: graph?.nodes.length ?? 0,
+                    edgeCount: graph?.edges.length ?? 0,
+                });
+                return;
+            }
             if (pathname === "/api/analysis" && method === "GET") {
                 const result = bridge.getStructuralAnalysis();
                 if (!result) {

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

@@ -1,12 +1,25 @@
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { Session } from "@minicode/agent-sdk";
 let sessionsDir = path.join(os.homedir(), ".minicode", "sessions");
+export class DuplicateSessionLabelError extends Error {
+    label;
+    existingSessionId;
+    constructor(label, existingSessionId) {
+        super(`A saved session named "${label}" already exists. Choose a different name or load that session to update it.`);
+        this.label = label;
+        this.existingSessionId = existingSessionId;
+        this.name = "DuplicateSessionLabelError";
+    }
+}
 /** Override sessions directory (for testing). */
 export function setSessionsDir(dir) {
     sessionsDir = dir;
 }
+function normalizeSessionLabel(label) {
+    return label.trim().toLowerCase();
+}
 export async function saveSession(session, label, annotations) {
     await mkdir(sessionsDir, { recursive: true });
     const savedAt = new Date().toISOString();
@@ -14,6 +27,11 @@ export async function saveSession(session, label, annotations) {
     const resolvedLabel = label && label.trim().length > 0
         ? label.trim()
         : new Date().toLocaleString();
+    const duplicate = (await listSessions()).find((savedSession) => savedSession.id !== snapshot.id &&
+        normalizeSessionLabel(savedSession.label) === normalizeSessionLabel(resolvedLabel));
+    if (duplicate) {
+        throw new DuplicateSessionLabelError(resolvedLabel, duplicate.id);
+    }
     const data = {
         label: resolvedLabel,
         savedAt,
@@ -82,3 +100,13 @@ export async function loadSessionByLabel(label) {
         return undefined;
     return loadSession(match.id);
 }
+export async function deleteSession(sessionId) {
+    const filePath = path.join(sessionsDir, `${sessionId}.json`);
+    try {
+        await unlink(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}