@sean.holung/minicode 0.3.2 → 0.3.3

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

@@ -1,12 +1,19 @@
 import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
+import { readFile } from "node:fs/promises";
+import { watch } from "node:fs";
+import path from "node:path";
+import { analyzeProjectStructure } from "../analysis/structural-analysis.js";
 import { loadAgentConfig } from "../agent/config.js";
 import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "../indexer/cache.js";
 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 { getSymbolDisplayName } from "../indexer/symbol-names.js";
 export class AgentBridge {
     agent;
     config;
+    modelClient;
     projectIndex;
     buildAgent;
     busy = false;
@@ -16,6 +23,8 @@ export class AgentBridge {
     listeners = new Set();
     pinnedSymbols = new Set();
     annotations = new Map();
+    fileWatcher = null;
+    reindexTimers = new Map();
     constructor(broadcast, verbose) {
         this.broadcast = broadcast;
         this.verbose = verbose;
@@ -34,7 +43,14 @@ export class AgentBridge {
     }
     async init() {
         const config = await loadAgentConfig();
-        const modelClient = createModelClient(config);
+        let modelClient;
+        try {
+            modelClient = createModelClient(config);
+        }
+        catch {
+            // Model client may fail to initialize if API keys are missing.
+            // Serve mode continues so the web UI can show setup instructions.
+        }
         let projectIndex;
         try {
             const cacheDir = getWorkspaceCacheDir(config.workspaceRoot);
@@ -60,23 +76,94 @@ export class AgentBridge {
         };
         this.config = config;
         this.projectIndex = projectIndex;
-        this.buildAgent = (session, onUiUpdate) => {
-            return new CodingAgent({
-                config,
-                modelClient,
-                toolRegistry,
-                verbose: this.verbose,
-                ...(session ? { session } : {}),
-                ...(projectIndex !== undefined
-                    ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
-                    : {}),
-                onUiUpdate: onUiUpdate ?? ((event) => {
-                    this.emit(event);
-                }),
-                getSystemPromptSuffix: () => this.buildAnnotationSuffix(),
+        if (modelClient) {
+            this.modelClient = modelClient;
+            this.buildAgent = (session, onUiUpdate) => {
+                return new CodingAgent({
+                    config,
+                    modelClient,
+                    toolRegistry,
+                    verbose: this.verbose,
+                    ...(session ? { session } : {}),
+                    ...(projectIndex !== undefined
+                        ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
+                        : {}),
+                    onUiUpdate: onUiUpdate ?? ((event) => {
+                        this.emit(event);
+                    }),
+                    getSystemPromptSuffix: () => this.buildAnnotationSuffix(),
+                });
+            };
+            this.agent = this.buildAgent();
+        }
+    }
+    // ── File watcher for automatic reindexing ──
+    static WATCH_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
+    static SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "coverage"]);
+    static REINDEX_DEBOUNCE_MS = 300;
+    /**
+     * Start watching the workspace for file changes and reindex automatically.
+     * Call after init(). Safe to call if no project index exists (no-ops).
+     */
+    startFileWatcher() {
+        if (!this.projectIndex || this.fileWatcher)
+            return;
+        const workspaceRoot = this.config.workspaceRoot;
+        try {
+            this.fileWatcher = watch(workspaceRoot, { recursive: true }, (_event, filename) => {
+                if (!filename || !this.projectIndex)
+                    return;
+                const normalized = filename.replace(/\\/g, "/");
+                // Skip ignored directories
+                const parts = normalized.split("/");
+                if (parts.some((p) => AgentBridge.SKIP_DIRS.has(p) || p.startsWith(".")))
+                    return;
+                // Skip non-indexable extensions
+                const ext = path.extname(normalized).toLowerCase();
+                if (!AgentBridge.WATCH_EXTENSIONS.has(ext))
+                    return;
+                // Debounce: if same file changes rapidly, only reindex once
+                const existing = this.reindexTimers.get(normalized);
+                if (existing)
+                    clearTimeout(existing);
+                this.reindexTimers.set(normalized, setTimeout(() => {
+                    this.reindexTimers.delete(normalized);
+                    void this.reindexChangedFile(normalized);
+                }, AgentBridge.REINDEX_DEBOUNCE_MS));
             });
-        };
-        this.agent = this.buildAgent();
+        }
+        catch {
+            console.warn("[warn] File watcher could not start (recursive fs.watch may not be supported on this platform).\n" +
+                "       File changes will not trigger automatic reindexing. Restart minicode serve to pick up changes.");
+        }
+    }
+    stopFileWatcher() {
+        if (this.fileWatcher) {
+            this.fileWatcher.close();
+            this.fileWatcher = null;
+        }
+        for (const timer of this.reindexTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.reindexTimers.clear();
+    }
+    async reindexChangedFile(relPath) {
+        if (!this.projectIndex)
+            return;
+        const absPath = path.resolve(this.config.workspaceRoot, relPath);
+        try {
+            const content = await readFile(absPath, "utf-8");
+            this.projectIndex.reindexFile(relPath, content);
+            if (this.verbose) {
+                console.error(`[watch] Reindexed: ${relPath}`);
+            }
+        }
+        catch {
+            // File may have been deleted — ignore
+        }
+    }
+    isReady() {
+        return this.agent !== undefined;
     }
     isBusy() {
         return this.busy;
@@ -84,10 +171,20 @@ export class AgentBridge {
     getConfig() {
         return this.config;
     }
-    getAgent() {
+    requireAgent() {
+        if (!this.agent) {
+            throw new Error("Agent is not configured. Set MODEL and provider settings in ~/.minicode/.env");
+        }
         return this.agent;
     }
+    getAgent() {
+        return this.requireAgent();
+    }
+    getCurrentSessionId() {
+        return this.requireAgent().getSession().id;
+    }
     async runTurn(message) {
+        const agent = this.requireAgent();
         if (this.busy) {
             throw new Error("busy");
         }
@@ -95,7 +192,7 @@ export class AgentBridge {
         this.abortController = new AbortController();
         try {
             this.emit({ type: "turn_start" });
-            const result = await this.agent.runTurn(message, {
+            const result = await agent.runTurn(message, {
                 signal: this.abortController.signal,
             });
             this.emit({
@@ -126,12 +223,16 @@ export class AgentBridge {
     }
     // Session operations
     async saveSess(label) {
+        const agent = this.requireAgent();
         const annotationsObj = this.annotations.size > 0
             ? Object.fromEntries(this.annotations)
             : undefined;
-        return saveSession(this.agent.getSession(), label, annotationsObj);
+        return saveSession(agent.getSession(), label, annotationsObj);
     }
     async loadSess(label) {
+        if (!this.buildAgent) {
+            throw new Error("Agent is not configured.");
+        }
         const result = (await loadSessionByLabel(label)) ?? (await loadSession(label));
         if (!result)
             return null;
@@ -158,7 +259,7 @@ export class AgentBridge {
         const symbols = [];
         for (const sym of this.projectIndex.symbols.values()) {
             symbols.push({
-                name: sym.name,
+                name: getSymbolDisplayName(sym),
                 qualifiedName: sym.qualifiedName,
                 kind: sym.kind,
                 filePath: sym.filePath,
@@ -182,7 +283,7 @@ export class AgentBridge {
         if (cone.length === 0)
             return undefined;
         return cone.map((sym) => ({
-            name: sym.name,
+            name: getSymbolDisplayName(sym),
             qualifiedName: sym.qualifiedName,
             kind: sym.kind,
             filePath: sym.filePath,
@@ -198,7 +299,14 @@ export class AgentBridge {
         // Find all edges pointing TO this symbol
         const refs = this.projectIndex.dependencyEdges
             .filter((e) => e.to === sym.qualifiedName || e.to === sym.name)
-            .map((e) => ({ from: e.from, kind: e.kind }));
+            .map((e) => {
+            const fromSymbol = this.projectIndex.getSymbol(e.from);
+            return {
+                from: e.from,
+                kind: e.kind,
+                ...(fromSymbol ? { name: getSymbolDisplayName(fromSymbol) } : {}),
+            };
+        });
         return refs;
     }
     getCodeMap(tokenBudget) {
@@ -214,7 +322,7 @@ export class AgentBridge {
         for (const sym of this.projectIndex.symbols.values()) {
             nodes.push({
                 id: sym.qualifiedName,
-                name: sym.name,
+                name: getSymbolDisplayName(sym),
                 kind: sym.kind,
                 filePath: sym.filePath,
                 exported: sym.exported,
@@ -227,6 +335,11 @@ export class AgentBridge {
         }));
         return { nodes, edges };
     }
+    getStructuralAnalysis() {
+        if (!this.projectIndex)
+            return undefined;
+        return analyzeProjectStructure(this.projectIndex);
+    }
     getPinnedSymbols() {
         return [...this.pinnedSymbols];
     }
@@ -337,10 +450,22 @@ export class AgentBridge {
         }
         return result;
     }
+    // ── Model selection ──
+    async listModels() {
+        if (this.modelClient?.listModels) {
+            return sortModelsAlphabetically(await this.modelClient.listModels());
+        }
+        return [];
+    }
+    switchModel(modelId) {
+        this.config.model = modelId;
+    }
     // ── Explain ──
     async explainSymbol(name, onEvent, signal) {
         if (!this.projectIndex)
             throw new Error("No project index");
+        if (!this.buildAgent)
+            throw new Error("Agent is not configured.");
         const sym = this.projectIndex.getSymbol(name);
         if (!sym)
             throw new Error(`Symbol "${name}" not found`);
@@ -353,4 +478,58 @@ Be concise but thorough.`;
         const result = await explainAgent.runTurn(prompt, opts);
         return result.text;
     }
+    async explainStructuralFinding(findingId, onEvent, signal) {
+        const report = this.getStructuralAnalysis();
+        if (!report)
+            throw new Error("No project index");
+        if (!this.buildAgent)
+            throw new Error("Agent is not configured.");
+        const finding = report.findings.find((item) => item.id === findingId);
+        if (!finding)
+            throw new Error(`Structural finding "${findingId}" not found`);
+        const explainAgent = this.buildAgent(undefined, onEvent);
+        const affectedSymbols = finding.symbols.length > 0
+            ? finding.symbols.slice(0, 8).join(", ")
+            : "(none)";
+        const affectedFiles = finding.files.length > 0
+            ? finding.files.slice(0, 6).join(", ")
+            : "(none)";
+        const rationale = finding.rationale.map((item) => `- ${item}`).join("\n");
+        const metrics = Object.entries(finding.metrics)
+            .map(([key, value]) => `- ${key}: ${String(value)}`)
+            .join("\n");
+        const prompt = `Interpret this deterministic structural analysis finding for the current codebase.
+
+Finding type: ${finding.type}
+Severity: ${finding.severity}
+Title: ${finding.title}
+Summary: ${finding.summary}
+
+Affected symbols:
+${affectedSymbols}
+
+Affected files:
+${affectedFiles}
+
+Deterministic rationale:
+${rationale || "- No extra rationale provided."}
+
+Metrics:
+${metrics || "- No metrics provided."}
+
+Important constraints:
+- This finding came from deterministic graph analysis, not from the model.
+- Your job is to interpret the finding, not to replace it.
+- Keep the explanation advisory and note where the signal may be noisy or incomplete.
+- If useful, inspect a few affected symbols with read_symbol, get_dependencies, and find_references before explaining.
+
+Respond with short sections for:
+1. What this likely means
+2. Why it may matter
+3. Caveats / false-positive risk
+4. Potential next steps`;
+        const opts = signal ? { signal } : undefined;
+        const result = await explainAgent.runTurn(prompt, opts);
+        return result.text;
+    }
 }