@sean.holung/minicode 0.2.2 → 0.2.4

package/README.md

@@ -1,8 +1,6 @@
 # minicode
 
-A lightweight CLI coding agent optimized for **local models** by providing AST-based intelligent context for smaller models running on consumer hardware.
-
-> minicode gives local models a dependency-aware map of your codebase, so agents read less, reason better, and ship changes faster.
+A lightweight coding agent optimized for **local models** — CLI-first with a built-in web UI. Provides AST-based intelligent context for smaller models running on consumer hardware.
 
 Read operations dominate token usage in typical agent sessions; minicode addresses this by optimizing for **specific languages** — indexing your project at startup with language plugins (TypeScript/JavaScript built-in) and injecting a compact **code map** (signatures only) into the system prompt, plus symbol-level tools (`read_symbol`, `find_references`, `get_dependencies`) so the model reads only what it needs instead of entire files. This keeps prompts lean enough for smaller models in the 20B range, with faster inference and better attention over the relevant code.
 
@@ -23,7 +21,7 @@ OPENAI_BASE_URL=http://localhost:1234/v1
 OPENAI_API_KEY=
 MAX_STEPS=50
 MAX_TOKENS=4096
-MAX_CONTEXT_TOKENS=60000
+MAX_CONTEXT_TOKENS=24000
 WORKSPACE_ROOT=.
 COMMAND_TIMEOUT_MS=30000
 MAX_FILE_SIZE_BYTES=1000000
@@ -48,6 +46,15 @@ or you can also pass it an intial prompt from the start:
 minicode "Add error handling to src/api.ts"
 ```
 
+Start the web UI (chat, session management, project graph data):
+
+```bash
+minicode serve              # http://localhost:4567
+minicode serve --port 8080  # custom port
+```
+
+The serve mode also exposes an **OpenAI-compatible API** at `/v1/chat/completions`, so you can point any client that speaks the OpenAI protocol (OpenWebUI, TypingMind, ChatGPT-Next-Web, Lobe Chat, etc.) at `http://localhost:4567/v1` and use minicode as a backend.
+
 Run a single task and exit (useful for scripts/CI/orchestration):
 
 ```bash
@@ -81,13 +88,9 @@ npm run install:global
 - Agent loop with model tool-use support
 - In-memory session history with trimming
 - Safety guardrails for file paths and shell commands
-- Built-in tools:
-  - `read_file`
-  - `write_file`
-  - `edit_file`
-  - `search` (ripgrep, grep fallback)
-  - `list_files`
-  - `run_command`
+- Built-in tools: `read_file`, `write_file`, `edit_file`, `search`, `list_files`, `run_command`
+- **Web UI** — `minicode serve` starts an HTTP + WebSocket server with a bundled chat client, real-time streaming, session management, and project graph data endpoints
+- **OpenAI-compatible API** — any client that speaks the OpenAI protocol can use minicode as a backend at `/v1/chat/completions`
 - **Context optimization:** Code map in system prompt, `read_symbol`, `find_references`, `get_dependencies`
 - **Plugin system:** Extensible language support (TypeScript built-in)
 
@@ -194,6 +197,8 @@ Nothing is written inside your workspace; config and cache live under `~/.minico
 | `CONFIRM_DESTRUCTIVE`   | No              | `true`                     | If `true`, blocks destructive shell commands unless confirmed                                                                         |
 | `KEEP_RECENT_MESSAGES`  | No              | `12`                       | Minimum number of latest messages kept during trimming                                                                                |
 | `LOOP_DETECTION_WINDOW` | No              | `6`                        | Window for repeated tool-call loop detection                                                                                          |
+| `COMPACTION_THRESHOLD`  | No              | `0.8`                      | Context fullness ratio (0–1) at which auto-compaction triggers                                                                        |
+| `COMPACTION_MODEL`      | No              | none                       | Model for LLM-based compaction summaries. When set, `/compact` and auto-compaction use this model instead of mechanical truncation. Use a small, fast model (e.g. your local model). |
 
 
 ### `agent.config.json`
@@ -215,7 +220,8 @@ Create `agent.config.json` in `~/.minicode/` for user-level defaults, or in the
   "keepRecentMessages": 12,
   "loopDetectionWindow": 6,
   "openAiBaseUrl": "http://localhost:1234/v1",
-  "openAiApiKey": ""
+  "openAiApiKey": "",
+  "compactionModel": ""
 }
 ```
 
@@ -235,6 +241,8 @@ Field mapping:
 - `loopDetectionWindow` ↔ `LOOP_DETECTION_WINDOW`
 - `openAiBaseUrl` ↔ `OPENAI_BASE_URL`
 - `openAiApiKey` ↔ `OPENAI_API_KEY`
+- `compactionThreshold` ↔ `COMPACTION_THRESHOLD`
+- `compactionModel` ↔ `COMPACTION_MODEL`
 
 ## Usage
 

package/dist/src/agent/config.js

@@ -27,6 +27,11 @@ export function formatConfigForDisplay(config) {
         "commandDenylist: " + config.commandDenylist.length + " patterns",
         "openAiBaseUrl: " + config.openAiBaseUrl,
         "openAiApiKey: " + (config.openAiApiKey ? "***" : "(unset)"),
+        "enableFileReadDedup: " + (config.enableFileReadDedup ?? false),
+        "enableAdaptiveKeepRecent: " + (config.enableAdaptiveKeepRecent ?? false),
+        "enableToolOutputTruncation: " + (config.enableToolOutputTruncation ?? false),
+        "compactionThreshold: " + (config.compactionThreshold ?? "(disabled)"),
+        "compactionModel: " + (config.compactionModel ?? "(disabled — using mechanical compaction)"),
     ];
     return lines.join("\n");
 }
@@ -136,7 +141,7 @@ export async function loadAgentConfig(cwd = process.cwd()) {
             "zai-org/glm-4.7-flash",
         maxSteps: parseNumber(process.env.MAX_STEPS, fileConfig.maxSteps ?? 50),
         maxTokens: parseNumber(process.env.MAX_TOKENS, fileConfig.maxTokens ?? 4096),
-        maxContextTokens: parseNumber(process.env.MAX_CONTEXT_TOKENS, fileConfig.maxContextTokens ?? 120_000),
+        maxContextTokens: parseNumber(process.env.MAX_CONTEXT_TOKENS, fileConfig.maxContextTokens ?? 40_000),
         workspaceRoot,
         commandTimeoutMs: parseNumber(process.env.COMMAND_TIMEOUT_MS, fileConfig.commandTimeout ?? 30_000),
         maxFileSizeBytes: parseNumber(process.env.MAX_FILE_SIZE_BYTES, fileConfig.maxFileSizeBytes ?? 1_000_000),
@@ -144,8 +149,15 @@ export async function loadAgentConfig(cwd = process.cwd()) {
         confirmDestructive: parseBoolean(process.env.CONFIRM_DESTRUCTIVE, fileConfig.confirmDestructive ?? true),
         keepRecentMessages: parseNumber(process.env.KEEP_RECENT_MESSAGES, fileConfig.keepRecentMessages ?? 12),
         loopDetectionWindow: parseNumber(process.env.LOOP_DETECTION_WINDOW, fileConfig.loopDetectionWindow ?? 6),
-        maxToolOutputChars: parseNumber(process.env.MAX_TOOL_OUTPUT_CHARS, fileConfig.maxToolOutputChars ?? 15_000),
+        maxToolOutputChars: parseNumber(process.env.MAX_TOOL_OUTPUT_CHARS, fileConfig.maxToolOutputChars ?? 8_000),
         openAiBaseUrl: rawBaseUrl,
         ...(openAiApiKey !== undefined ? { openAiApiKey } : {}),
+        enableFileReadDedup: parseBoolean(process.env.ENABLE_FILE_READ_DEDUP, fileConfig.enableFileReadDedup ?? true),
+        enableAdaptiveKeepRecent: parseBoolean(process.env.ENABLE_ADAPTIVE_KEEP_RECENT, fileConfig.enableAdaptiveKeepRecent ?? true),
+        enableToolOutputTruncation: parseBoolean(process.env.ENABLE_TOOL_OUTPUT_TRUNCATION, fileConfig.enableToolOutputTruncation ?? true),
+        compactionThreshold: parseNumber(process.env.COMPACTION_THRESHOLD, fileConfig.compactionThreshold ?? 0.8),
+        ...(process.env.COMPACTION_MODEL ?? fileConfig.compactionModel
+            ? { compactionModel: process.env.COMPACTION_MODEL ?? fileConfig.compactionModel }
+            : {}),
     };
 }

package/dist/src/cli/args.js

@@ -10,12 +10,38 @@ export function parseCliArgs(argv) {
     let oneshot = false;
     let json = false;
     let outFile;
+    let serve = false;
+    let port = 4567;
     const taskParts = [];
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
         if (arg === undefined) {
             continue;
         }
+        if (arg === "serve") {
+            serve = true;
+            continue;
+        }
+        if (arg === "--port") {
+            const value = args[i + 1];
+            if (!value || value.startsWith("-")) {
+                throw new CliUsageError("--port requires a number. Example: --port 8080");
+            }
+            port = Number(value);
+            if (!Number.isFinite(port) || port <= 0) {
+                throw new CliUsageError("--port must be a positive number. Example: --port 8080");
+            }
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--port=")) {
+            const value = arg.slice("--port=".length).trim();
+            port = Number(value);
+            if (!Number.isFinite(port) || port <= 0) {
+                throw new CliUsageError("--port must be a positive number. Example: --port=8080");
+            }
+            continue;
+        }
         if (arg === "--verbose" || arg === "-v") {
             verbose = true;
             continue;
@@ -52,6 +78,8 @@ export function parseCliArgs(argv) {
         oneshot,
         json,
         ...(outFile ? { outFile } : {}),
+        serve,
+        port,
         task: taskParts.join(" ").trim(),
     };
 }
@@ -62,4 +90,7 @@ export function validateCliArgs(args) {
     if (!args.oneshot && (args.json || args.outFile)) {
         throw new CliUsageError("--json and --out are only supported with --oneshot.");
     }
+    if (args.serve && (args.oneshot || args.json || args.outFile)) {
+        throw new CliUsageError("serve mode is mutually exclusive with --oneshot, --json, and --out.");
+    }
 }

package/dist/src/index.js

@@ -44,7 +44,7 @@ async function createAgentRuntime(verbose, onProgress) {
             verbose,
             ...(session ? { session } : {}),
             ...(projectIndex !== undefined
-                ? { getCodeMap: () => projectIndex.getCodeMap() }
+                ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
                 : {}),
             ...(onProgress ? { onProgress } : {}),
         });
@@ -98,7 +98,7 @@ async function runInteractive(verbose, initialTask) {
             break;
         }
         if (trimmed === "/help") {
-            console.log('Commands: "/help", "/config", "/save [label]", "/load [label]", "/sessions", "/exit"');
+            console.log('Commands: "/help", "/config", "/compact", "/save [label]", "/load [label]", "/sessions", "/exit"');
             console.log("Start with --verbose or -v to log prompts, responses, and tool calls.");
             continue;
         }
@@ -106,6 +106,20 @@ async function runInteractive(verbose, initialTask) {
             console.log("\n" + formatConfigForDisplay(config) + "\n");
             continue;
         }
+        if (trimmed === "/compact") {
+            const session = agent.getSession();
+            const tokensBefore = session.getTokenEstimate();
+            const result = session.compact(config.keepRecentMessages);
+            if (result) {
+                console.log(`Compacted: ${result.removedMessages} messages summarized, ` +
+                    `${result.previousTokens} → ${result.newTokens} tokens ` +
+                    `(saved ${result.previousTokens - result.newTokens} tokens)`);
+            }
+            else {
+                console.log(`Nothing to compact (${tokensBefore} tokens, ${session.getMessages().length} messages).`);
+            }
+            continue;
+        }
         if (trimmed === "/save" || trimmed.startsWith("/save ")) {
             const label = trimmed.slice("/save".length).trim() || undefined;
             try {
@@ -196,6 +210,11 @@ async function runOneshot(params) {
 async function main() {
     const cliArgs = parseCliArgs(process.argv);
     validateCliArgs(cliArgs);
+    if (cliArgs.serve) {
+        const { runServe } = await import("./serve/server.js");
+        await runServe(cliArgs.verbose, cliArgs.port);
+        return;
+    }
     if (cliArgs.oneshot) {
         await runOneshot(cliArgs);
         process.exitCode = EXIT_CODE_SUCCESS;

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

@@ -12,12 +12,42 @@ function formatSymbol(symbol, indent, isMethod) {
 function isEntryPointFile(filePath) {
     return filePath === "src/index.ts" || filePath.endsWith("/index.ts");
 }
-function createSymbolRanker(edges) {
+/**
+ * Build the set of symbols related to focus symbols via dependency edges.
+ * Expands 1 hop outbound (what focus symbols depend on) and 1 hop inbound
+ * (what depends on focus symbols).
+ */
+function expandFocusSet(focusSymbols, edges) {
+    const expanded = new Set(focusSymbols);
+    for (const edge of edges) {
+        // Outbound: focus symbol depends on something
+        if (focusSymbols.has(edge.from)) {
+            expanded.add(edge.to);
+        }
+        // Inbound: something depends on focus symbol
+        if (focusSymbols.has(edge.to)) {
+            expanded.add(edge.from);
+        }
+    }
+    return expanded;
+}
+function createSymbolRanker(edges, focusSymbols) {
     const refCount = new Map();
     for (const e of edges) {
         refCount.set(e.to, (refCount.get(e.to) ?? 0) + 1);
     }
+    // Expand focus set to include 1-hop neighbors in the dependency graph
+    const boosted = focusSymbols?.size
+        ? expandFocusSet(focusSymbols, edges)
+        : undefined;
     return (a, b) => {
+        // Focus-boosted symbols always sort first
+        if (boosted) {
+            const aFocused = boosted.has(a.qualifiedName);
+            const bFocused = boosted.has(b.qualifiedName);
+            if (aFocused !== bFocused)
+                return aFocused ? -1 : 1;
+        }
         if (a.exported !== b.exported)
             return a.exported ? -1 : 1;
         const refA = refCount.get(a.qualifiedName) ?? 0;
@@ -31,20 +61,37 @@ function createSymbolRanker(edges) {
 }
 /**
  * Generate a compact code map from symbols grouped by file.
- * Ranks symbols by: exported > high reference count > entry points.
+ * Ranks symbols by: focus-boosted > exported > high reference count > entry points.
  * When over budget, truncates with a footer.
+ *
+ * @param focusSymbols Optional set of symbol qualified names to boost to the top.
+ *   These symbols (and their 1-hop dependency neighbors) will be ranked above all
+ *   others, ensuring they survive truncation within the token budget.
  */
-export function generateCodeMap(symbolsByFile, tokenBudget = DEFAULT_TOKEN_BUDGET, dependencyEdges) {
+export function generateCodeMap(symbolsByFile, tokenBudget = DEFAULT_TOKEN_BUDGET, dependencyEdges, focusSymbols) {
     const totalCount = [...symbolsByFile.values()].reduce((sum, syms) => sum + syms.length, 0);
     const lines = ["# Project Code Map", ""];
     const rank = dependencyEdges
-        ? createSymbolRanker(dependencyEdges)
+        ? createSymbolRanker(dependencyEdges, focusSymbols)
         : (a, b) => (a.exported === b.exported ? 0 : a.exported ? -1 : 1);
     let totalTokens = estimateTokens(lines.join("\n"));
     let truncatedSymbols = 0;
     let shownCount = 0;
     const filesWithTruncation = new Set();
-    const sortedFiles = [...symbolsByFile.keys()].sort();
+    // When we have focus symbols, sort files so that files containing
+    // focused symbols come first in the code map.
+    const boosted = focusSymbols?.size && dependencyEdges
+        ? expandFocusSet(focusSymbols, dependencyEdges)
+        : undefined;
+    const sortedFiles = [...symbolsByFile.keys()].sort((a, b) => {
+        if (boosted) {
+            const aHasFocus = symbolsByFile.get(a)?.some((s) => boosted.has(s.qualifiedName)) ?? false;
+            const bHasFocus = symbolsByFile.get(b)?.some((s) => boosted.has(s.qualifiedName)) ?? false;
+            if (aHasFocus !== bHasFocus)
+                return aHasFocus ? -1 : 1;
+        }
+        return a.localeCompare(b);
+    });
     for (const filePath of sortedFiles) {
         const symbols = symbolsByFile.get(filePath);
         if (!symbols?.length)

package/dist/src/indexer/focus-tracker.js

@@ -0,0 +1,63 @@
+/**
+ * Tracks which symbols the user/agent is actively working with.
+ * Used to dynamically re-rank the code map so that relevant symbols
+ * survive truncation within the fixed token budget.
+ *
+ * Focus is derived from:
+ * - Symbol names in tool calls (read_symbol, find_references, get_dependencies)
+ * - Symbol names mentioned in user messages (fuzzy match against index)
+ */
+const MAX_FOCUS_SYMBOLS = 30;
+export class FocusTracker {
+    focused = new Map();
+    generation = 0;
+    /**
+     * Record a symbol as being actively focused on.
+     * More recent additions have higher priority.
+     */
+    addSymbol(qualifiedName) {
+        this.generation += 1;
+        this.focused.set(qualifiedName, this.generation);
+        // Evict oldest entries if we exceed the limit
+        if (this.focused.size > MAX_FOCUS_SYMBOLS) {
+            let oldestKey = null;
+            let oldestGen = Infinity;
+            for (const [key, gen] of this.focused) {
+                if (gen < oldestGen) {
+                    oldestGen = gen;
+                    oldestKey = key;
+                }
+            }
+            if (oldestKey) {
+                this.focused.delete(oldestKey);
+            }
+        }
+    }
+    /**
+     * Record multiple symbols at once (e.g. from dependency expansion).
+     */
+    addSymbols(qualifiedNames) {
+        for (const name of qualifiedNames) {
+            this.addSymbol(name);
+        }
+    }
+    /**
+     * Get the current set of focused symbol qualified names.
+     */
+    getFocusedSymbols() {
+        return new Set(this.focused.keys());
+    }
+    /**
+     * Check if a symbol is currently focused.
+     */
+    hasFocus(qualifiedName) {
+        return this.focused.has(qualifiedName);
+    }
+    /**
+     * Clear all focus tracking.
+     */
+    clear() {
+        this.focused.clear();
+        this.generation = 0;
+    }
+}

package/dist/src/indexer/project-index.js

@@ -66,8 +66,8 @@ export function createProjectIndex(symbols, files, dependencyEdges, plugins, pro
             }
             return [...result.values()];
         },
-        getCodeMap(tokenBudget) {
-            return generateCodeMap(files, tokenBudget, dependencyEdges);
+        getCodeMap(tokenBudget, focusSymbols) {
+            return generateCodeMap(files, tokenBudget, dependencyEdges, focusSymbols);
         },
         reindexFile(filePath, content) {
             const relPath = path.isAbsolute(filePath)

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

@@ -0,0 +1,233 @@
+import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
+import { loadAgentConfig } from "../agent/config.js";
+import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "../indexer/cache.js";
+import { buildProjectIndex } from "../indexer/project-index.js";
+import { createToolRegistry } from "../tools/registry.js";
+import { listSessions, loadSession, loadSessionByLabel, saveSession, } from "../session/session-store.js";
+export class AgentBridge {
+    agent;
+    config;
+    projectIndex;
+    buildAgent;
+    busy = false;
+    abortController = null;
+    broadcast;
+    verbose;
+    listeners = new Set();
+    pinnedSymbols = new Set();
+    constructor(broadcast, verbose) {
+        this.broadcast = broadcast;
+        this.verbose = verbose;
+    }
+    addListener(fn) {
+        this.listeners.add(fn);
+    }
+    removeListener(fn) {
+        this.listeners.delete(fn);
+    }
+    emit(msg) {
+        this.broadcast(msg);
+        for (const fn of this.listeners) {
+            fn(msg);
+        }
+    }
+    async init() {
+        const config = await loadAgentConfig();
+        const modelClient = createModelClient(config);
+        let projectIndex;
+        try {
+            const cacheDir = getWorkspaceCacheDir(config.workspaceRoot);
+            const fileHashes = await computeFileHashes(config.workspaceRoot);
+            const cached = await loadIndex(cacheDir, fileHashes);
+            if (cached) {
+                projectIndex = cached;
+            }
+            else {
+                projectIndex = await buildProjectIndex(config.workspaceRoot);
+                await saveIndex(projectIndex, cacheDir, fileHashes);
+            }
+        }
+        catch {
+            projectIndex = undefined;
+        }
+        const toolRegistry = createToolRegistry(config, projectIndex);
+        this.config = config;
+        this.projectIndex = projectIndex;
+        this.buildAgent = (session) => {
+            return new CodingAgent({
+                config,
+                modelClient,
+                toolRegistry,
+                verbose: this.verbose,
+                ...(session ? { session } : {}),
+                ...(projectIndex !== undefined
+                    ? { getCodeMap: (focusSymbols) => projectIndex.getCodeMap(undefined, focusSymbols) }
+                    : {}),
+                onUiUpdate: (event) => {
+                    this.emit(event);
+                },
+            });
+        };
+        this.agent = this.buildAgent();
+    }
+    isBusy() {
+        return this.busy;
+    }
+    getConfig() {
+        return this.config;
+    }
+    getAgent() {
+        return this.agent;
+    }
+    async runTurn(message) {
+        if (this.busy) {
+            throw new Error("busy");
+        }
+        this.busy = true;
+        this.abortController = new AbortController();
+        try {
+            this.emit({ type: "turn_start" });
+            const result = await this.agent.runTurn(message, {
+                signal: this.abortController.signal,
+            });
+            this.emit({
+                type: "turn_end",
+                text: result.text,
+                usage: result.usage,
+            });
+            return result;
+        }
+        catch (error) {
+            const msg = error instanceof Error && error.name === "AbortError"
+                ? "Cancelled"
+                : error instanceof Error
+                    ? error.message
+                    : "Unknown error";
+            this.emit({ type: "error", message: msg });
+            throw error;
+        }
+        finally {
+            this.busy = false;
+            this.abortController = null;
+        }
+    }
+    cancel() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    // Session operations
+    async saveSess(label) {
+        return saveSession(this.agent.getSession(), label);
+    }
+    async loadSess(label) {
+        const result = (await loadSessionByLabel(label)) ?? (await loadSession(label));
+        if (!result)
+            return null;
+        this.agent = this.buildAgent(result.session);
+        return result;
+    }
+    async listSess() {
+        return listSessions();
+    }
+    // ── Project index queries ──
+    hasIndex() {
+        return this.projectIndex !== undefined;
+    }
+    getSymbols() {
+        if (!this.projectIndex)
+            return [];
+        const symbols = [];
+        for (const sym of this.projectIndex.symbols.values()) {
+            symbols.push({
+                name: sym.name,
+                qualifiedName: sym.qualifiedName,
+                kind: sym.kind,
+                filePath: sym.filePath,
+                startLine: sym.startLine,
+                endLine: sym.endLine,
+                signature: sym.signature,
+                exported: sym.exported,
+            });
+        }
+        return symbols;
+    }
+    getSymbol(name) {
+        if (!this.projectIndex)
+            return undefined;
+        return this.projectIndex.getSymbol(name);
+    }
+    getDependencies(symbolName, depth) {
+        if (!this.projectIndex)
+            return undefined;
+        const cone = this.projectIndex.getDependencyCone(symbolName, depth);
+        if (cone.length === 0)
+            return undefined;
+        return cone.map((sym) => ({
+            name: sym.name,
+            qualifiedName: sym.qualifiedName,
+            kind: sym.kind,
+            filePath: sym.filePath,
+            signature: sym.signature,
+        }));
+    }
+    getReferences(symbolName) {
+        if (!this.projectIndex)
+            return undefined;
+        const sym = this.projectIndex.getSymbol(symbolName);
+        if (!sym)
+            return undefined;
+        // 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 }));
+        return refs;
+    }
+    getCodeMap(tokenBudget) {
+        if (!this.projectIndex)
+            return undefined;
+        const focus = this.pinnedSymbols.size > 0 ? this.pinnedSymbols : undefined;
+        return this.projectIndex.getCodeMap(tokenBudget, focus);
+    }
+    getGraph() {
+        if (!this.projectIndex)
+            return undefined;
+        const nodes = [];
+        for (const sym of this.projectIndex.symbols.values()) {
+            nodes.push({
+                id: sym.qualifiedName,
+                name: sym.name,
+                kind: sym.kind,
+                filePath: sym.filePath,
+                exported: sym.exported,
+            });
+        }
+        const edges = this.projectIndex.dependencyEdges.map((e) => ({
+            from: e.from,
+            to: e.to,
+            kind: e.kind,
+        }));
+        return { nodes, edges };
+    }
+    getPinnedSymbols() {
+        return [...this.pinnedSymbols];
+    }
+    pinSymbol(name) {
+        if (!this.projectIndex)
+            return false;
+        const sym = this.projectIndex.getSymbol(name);
+        if (!sym)
+            return false;
+        this.pinnedSymbols.add(sym.qualifiedName);
+        return true;
+    }
+    unpinSymbol(name) {
+        if (!this.projectIndex)
+            return false;
+        const sym = this.projectIndex.getSymbol(name);
+        if (!sym)
+            return false;
+        this.pinnedSymbols.delete(sym.qualifiedName);
+        return true;
+    }
+}