@sean.holung/minicode 0.1.0

package/dist/tests/agent.test.js

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { test } from "node:test";
+import { CodingAgent } from "../src/agent/agent.js";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+import { ToolRegistry } from "../src/tools/registry.js";
+import { createTestAgentConfig } from "./test-utils.js";
+class SequenceModelClient {
+    responses;
+    constructor(responses) {
+        this.responses = [...responses];
+    }
+    async chat(params) {
+        void params;
+        const next = this.responses.shift();
+        if (!next) {
+            throw new Error("No queued model response.");
+        }
+        return next;
+    }
+}
+class RepeatingModelClient {
+    async chat(params) {
+        void params;
+        return {
+            text: "running tool",
+            toolCalls: [{ id: "tool-1", name: "echo_tool", input: { value: "same" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 1, outputTokens: 1 },
+        };
+    }
+}
+function createEchoTool() {
+    return {
+        name: "echo_tool",
+        description: "Echoes a value",
+        inputSchema: {
+            type: "object",
+            properties: {
+                value: { type: "string" },
+            },
+            required: ["value"],
+        },
+        execute: async (input) => `echo:${String(input.value)}`,
+    };
+}
+test("agent executes tool calls and returns final assistant text", async () => {
+    const responses = [
+        {
+            text: "I will use a tool first.",
+            toolCalls: [{ id: "tool-1", name: "echo_tool", input: { value: "ok" } }],
+            stopReason: "tool_use",
+            usage: { inputTokens: 10, outputTokens: 8 },
+        },
+        {
+            text: "Done. Change applied.",
+            toolCalls: [],
+            stopReason: "end_turn",
+            usage: { inputTokens: 12, outputTokens: 6 },
+        },
+    ];
+    const agent = new CodingAgent({
+        config: createTestAgentConfig("/tmp"),
+        modelClient: new SequenceModelClient(responses),
+        toolRegistry: new ToolRegistry([createEchoTool()]),
+    });
+    const { text } = await agent.runTurn("Make a change");
+    assert.equal(text, "Done. Change applied.");
+    const messages = agent.getSession().getMessages();
+    assert.equal(messages.length, 4);
+    assert.equal(messages[0]?.role, "user");
+    assert.equal(messages[1]?.role, "assistant");
+    assert.equal(messages[2]?.role, "tool");
+    assert.equal(messages[3]?.role, "assistant");
+});
+test("agent stops on repeated identical tool calls", async () => {
+    const agent = new CodingAgent({
+        config: createTestAgentConfig("/tmp"),
+        modelClient: new RepeatingModelClient(),
+        toolRegistry: new ToolRegistry([createEchoTool()]),
+    });
+    const { text } = await agent.runTurn("Do something");
+    assert.match(text, /repeated identical tool calls/);
+});
+test("agent omits code map when projectIndex is not provided", async () => {
+    let capturedSystem = "";
+    const spyClient = {
+        async chat(params) {
+            capturedSystem = params.system;
+            return {
+                text: "Done.",
+                toolCalls: [],
+                stopReason: "end_turn",
+                usage: { inputTokens: 1, outputTokens: 1 },
+            };
+        },
+    };
+    const agent = new CodingAgent({
+        config: createTestAgentConfig("/tmp"),
+        modelClient: spyClient,
+        toolRegistry: new ToolRegistry([createEchoTool()]),
+    });
+    await agent.runTurn("Hello");
+    assert.ok(!capturedSystem.includes("[Project Code Map]"));
+});
+test("agent includes code map in system prompt when projectIndex is provided", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    let capturedSystem = "";
+    const spyClient = {
+        async chat(params) {
+            capturedSystem = params.system;
+            return {
+                text: "Task complete.",
+                toolCalls: [],
+                stopReason: "end_turn",
+                usage: { inputTokens: 1, outputTokens: 1 },
+            };
+        },
+    };
+    const agent = new CodingAgent({
+        config: createTestAgentConfig(root),
+        modelClient: spyClient,
+        toolRegistry: new ToolRegistry([createEchoTool()]),
+        projectIndex,
+    });
+    await agent.runTurn("List the project structure");
+    assert.ok(capturedSystem.includes("[Project Code Map]"));
+    assert.ok(capturedSystem.includes("CodingAgent"));
+});

package/dist/tests/cache.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "../src/indexer/cache.js";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+test("saveIndex and loadIndex round-trip", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-cache-"));
+    const samplePath = path.join(workspaceRoot, "sample.ts");
+    const content = `export function greet(name: string): string {
+  return \`Hello, \${name}\`;
+}
+`;
+    await writeFile(samplePath, content, "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    const fileHashes = await computeFileHashes(workspaceRoot);
+    const cacheDir = getWorkspaceCacheDir(workspaceRoot);
+    await saveIndex(index, cacheDir, fileHashes);
+    const loaded = await loadIndex(cacheDir, fileHashes);
+    assert.ok(loaded, "should load from cache");
+    assert.equal(loaded.getSymbol("greet")?.qualifiedName, "greet");
+    assert.ok(loaded.getCodeMap().text.includes("greet"));
+});
+test("loadIndex returns null when file hashes differ", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-cache2-"));
+    const samplePath = path.join(workspaceRoot, "sample.ts");
+    await writeFile(samplePath, "export function a(): void {}", "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    const fileHashes = await computeFileHashes(workspaceRoot);
+    const cacheDir = getWorkspaceCacheDir(workspaceRoot);
+    await saveIndex(index, cacheDir, fileHashes);
+    await writeFile(samplePath, "export function b(): void {}", "utf8");
+    const newHashes = await computeFileHashes(workspaceRoot);
+    const loaded = await loadIndex(cacheDir, newHashes);
+    assert.equal(loaded, null, "should invalidate cache when file changes");
+});

package/dist/tests/config.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { loadAgentConfig } from "../src/agent/config.js";
+test("loadAgentConfig normalizes openai-compatible provider aliases", async () => {
+    const previousProvider = process.env.MODEL_PROVIDER;
+    const previousBaseUrl = process.env.OPENAI_BASE_URL;
+    const previousModel = process.env.MODEL;
+    try {
+        process.env.MODEL_PROVIDER = "lmstudio";
+        process.env.OPENAI_BASE_URL = "http://127.0.0.1:1234/v1";
+        process.env.MODEL = "qwen2.5-coder-7b-instruct";
+        const config = await loadAgentConfig("/tmp");
+        assert.equal(config.modelProvider, "openai-compatible");
+        assert.equal(config.openAiBaseUrl, "http://127.0.0.1:1234/v1");
+        assert.equal(config.model, "qwen2.5-coder-7b-instruct");
+    }
+    finally {
+        if (previousProvider === undefined) {
+            delete process.env.MODEL_PROVIDER;
+        }
+        else {
+            process.env.MODEL_PROVIDER = previousProvider;
+        }
+        if (previousBaseUrl === undefined) {
+            delete process.env.OPENAI_BASE_URL;
+        }
+        else {
+            process.env.OPENAI_BASE_URL = previousBaseUrl;
+        }
+        if (previousModel === undefined) {
+            delete process.env.MODEL;
+        }
+        else {
+            process.env.MODEL = previousModel;
+        }
+    }
+});

package/dist/tests/dependency-graph.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { test } from "node:test";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+test("buildProjectIndex produces dependency edges", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const index = await buildProjectIndex(root);
+    assert.ok(index.dependencyEdges.length > 0, "should have dependency edges");
+    const parseResponseRefs = index.dependencyEdges.filter((e) => e.from === "parseResponse");
+    assert.ok(parseResponseRefs.some((e) => e.to === "ModelResponse"), "parseResponse should reference ModelResponse");
+    assert.ok(parseResponseRefs.some((e) => e.to === "ToolCall"), "parseResponse should reference ToolCall");
+});
+test("createModelClient has expected dependencies", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const index = await buildProjectIndex(root);
+    const edges = index.dependencyEdges.filter((e) => e.from === "createModelClient");
+    assert.ok(edges.some((e) => e.to === "AgentConfig"), "createModelClient should reference AgentConfig");
+    assert.ok(edges.length >= 1, "createModelClient should have at least one dependency");
+});
+test("AnthropicModelClient implements ModelClient", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const index = await buildProjectIndex(root);
+    const implementsEdge = index.dependencyEdges.find((e) => e.from === "AnthropicModelClient" &&
+        e.to === "ModelClient" &&
+        e.kind === "implements");
+    assert.ok(implementsEdge, "AnthropicModelClient should implement ModelClient");
+});

package/dist/tests/file-tools.test.js

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+import { createEditFileTool } from "../src/tools/edit-file.js";
+import { createReadFileTool } from "../src/tools/read-file.js";
+import { createTestAgentConfig } from "./test-utils.js";
+async function createTempWorkspace() {
+    return mkdtemp(path.join(tmpdir(), "minicode-tests-"));
+}
+test("edit_file replaces exactly one match", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const filePath = path.join(workspaceRoot, "sample.txt");
+    await writeFile(filePath, "hello world", "utf8");
+    const editTool = createEditFileTool(createTestAgentConfig(workspaceRoot));
+    const result = await editTool.execute({
+        path: "sample.txt",
+        old_string: "world",
+        new_string: "there",
+    });
+    assert.match(result, /Updated "sample\.txt" successfully\./);
+    const updated = await readFile(filePath, "utf8");
+    assert.equal(updated, "hello there");
+});
+test("edit_file fails when old_string is not unique", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const filePath = path.join(workspaceRoot, "sample.txt");
+    await writeFile(filePath, "repeat repeat repeat", "utf8");
+    const editTool = createEditFileTool(createTestAgentConfig(workspaceRoot));
+    await assert.rejects(() => editTool.execute({
+        path: "sample.txt",
+        old_string: "repeat",
+        new_string: "once",
+    }), /matched 3 times/);
+    const unchanged = await readFile(filePath, "utf8");
+    assert.equal(unchanged, "repeat repeat repeat");
+});
+test("edit_file triggers reindex when projectIndex provided", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const { mkdir } = await import("node:fs/promises");
+    const filePath = path.join(workspaceRoot, "src", "util.ts");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const initialContent = `export function add(a: number, b: number): number {
+  return a + b;
+}
+`;
+    await writeFile(filePath, initialContent, "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    const before = index.getSymbol("add");
+    assert.ok(before?.signature.includes("a: number, b: number"));
+    const editTool = createEditFileTool(createTestAgentConfig(workspaceRoot), index);
+    await editTool.execute({
+        path: "src/util.ts",
+        old_string: "a: number, b: number",
+        new_string: "a: number, b: number, c?: number",
+    });
+    const after = index.getSymbol("add");
+    assert.ok(after?.signature.includes("c?: number"), "index should reflect edit");
+});
+test("read_file supports negative offset and line limits", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const filePath = path.join(workspaceRoot, "lines.txt");
+    await writeFile(filePath, "a\nb\nc\nd", "utf8");
+    const readTool = createReadFileTool(createTestAgentConfig(workspaceRoot));
+    const output = await readTool.execute({
+        path: "lines.txt",
+        offset: -2,
+        limit: 2,
+    });
+    assert.equal(output, "3|c\n4|d");
+});

package/dist/tests/find-references.test.js

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { test } from "node:test";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+import { createFindReferencesTool } from "../src/tools/find-references.js";
+test("find_references returns symbols that reference ModelResponse", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createFindReferencesTool(projectIndex);
+    const result = await tool.execute({ name: "ModelResponse" });
+    assert.ok(result.includes("# References to ModelResponse"));
+    assert.ok(result.includes("parseResponse"));
+});
+test("find_references returns error for unknown symbol", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createFindReferencesTool(projectIndex);
+    const result = await tool.execute({ name: "NonExistentSymbol" });
+    assert.ok(result.includes("not found"));
+});
+test("find_references appears in tool registry when projectIndex provided", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const { ToolRegistry } = await import("../src/tools/registry.js");
+    const { createTestAgentConfig } = await import("./test-utils.js");
+    const registry = ToolRegistry.createDefault(createTestAgentConfig(root), projectIndex);
+    const schemas = registry.getToolSchemas();
+    const findRefs = schemas.find((s) => s.name === "find_references");
+    assert.ok(findRefs);
+});

package/dist/tests/get-dependencies.test.js

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { test } from "node:test";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+import { createGetDependenciesTool } from "../src/tools/get-dependencies.js";
+test("get_dependencies returns dependency cone for createModelClient", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createGetDependenciesTool(projectIndex);
+    const result = await tool.execute({ name: "createModelClient" });
+    assert.ok(result.includes("# Dependencies of createModelClient"));
+    assert.ok(result.includes("AgentConfig"));
+});
+test("get_dependencies respects depth parameter", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createGetDependenciesTool(projectIndex);
+    const resultDepth1 = await tool.execute({
+        name: "parseResponse",
+        depth: 1,
+    });
+    const resultDepth2 = await tool.execute({
+        name: "parseResponse",
+        depth: 2,
+    });
+    assert.ok(resultDepth1.includes("parseResponse"));
+    assert.ok(resultDepth2.includes("parseResponse"));
+});
+test("get_dependencies returns error for unknown symbol", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createGetDependenciesTool(projectIndex);
+    const result = await tool.execute({ name: "NonExistent" });
+    assert.ok(result.includes("not found"));
+});

package/dist/tests/guardrails.test.js

@@ -0,0 +1,18 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { resolveWorkspacePath, validateCommand, validatePath, } from "../src/safety/guardrails.js";
+test("validatePath allows files within workspace", () => {
+    const workspaceRoot = "/tmp/workspace";
+    assert.equal(validatePath("src/index.ts", workspaceRoot), true);
+});
+test("validatePath rejects escape attempts", () => {
+    const workspaceRoot = "/tmp/workspace";
+    assert.equal(validatePath("../etc/passwd", workspaceRoot), false);
+});
+test("resolveWorkspacePath rejects absolute escape paths", () => {
+    const workspaceRoot = "/tmp/workspace";
+    assert.throws(() => resolveWorkspacePath("/etc/passwd", workspaceRoot), /outside workspace root/);
+});
+test("validateCommand blocks denylisted commands", () => {
+    assert.throws(() => validateCommand("rm -rf /", [/\brm\s+-rf\s+\//i]), /blocked by safety denylist/);
+});

package/dist/tests/indexer.test.js

@@ -0,0 +1,201 @@
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { generateCodeMap } from "../src/indexer/code-map.js";
+import { getPluginForFile, loadPlugins } from "../src/indexer/plugin-loader.js";
+import { buildProjectIndex } from "../src/indexer/project-index.js";
+import { typescriptPlugin } from "../src/indexer/plugins/typescript.js";
+const SAMPLE_TS = `
+export interface Foo {
+  bar: string;
+}
+
+export function hello(name: string): string {
+  return \`Hello, \${name}\`;
+}
+
+export class CodingAgent {
+  constructor(params: { config: unknown }) {}
+
+  async runTurn(input: string): Promise<string> {
+    return input;
+  }
+}
+
+const arrowFn = (x: number) => x + 1;
+`;
+test("TypeScript plugin extracts functions, classes, interfaces", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const names = symbols.map((s) => s.qualifiedName);
+    assert.ok(names.includes("Foo"), "should extract interface Foo");
+    assert.ok(names.includes("hello"), "should extract function hello");
+    assert.ok(names.includes("CodingAgent"), "should extract class CodingAgent");
+    assert.ok(names.includes("CodingAgent.runTurn"), "should extract method runTurn");
+    assert.ok(names.includes("arrowFn"), "should extract arrow function");
+});
+test("TypeScript plugin returns correct line numbers", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const hello = symbols.find((s) => s.name === "hello");
+    assert.ok(hello, "should find hello");
+    assert.ok(hello.startLine >= 6 && hello.startLine <= 10);
+    assert.ok(hello.endLine > hello.startLine);
+});
+test("TypeScript plugin handles arrow functions assigned to const", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const arrow = symbols.find((s) => s.name === "arrowFn");
+    assert.ok(arrow, "should find arrowFn");
+    assert.equal(arrow.kind, "function");
+});
+test("Plugin loader returns the built-in TypeScript plugin", async () => {
+    const plugins = await loadPlugins("/tmp");
+    assert.ok(plugins.length >= 1);
+    assert.ok(plugins.some((p) => p.name === "typescript"));
+});
+test("getPluginForFile routes .ts files to TypeScript plugin", async () => {
+    const plugins = await loadPlugins("/tmp");
+    const plugin = getPluginForFile("src/agent/agent.ts", plugins);
+    assert.ok(plugin);
+    assert.equal(plugin.name, "typescript");
+});
+test("verify-index fixture exercises full indexing pipeline", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const fixtureRoot = path.join(root, "test-programs", "verify-index");
+    const index = await buildProjectIndex(fixtureRoot);
+    assert.ok(index.getSymbol("Processor"), "Processor class");
+    assert.ok(index.getSymbol("Processor.run"), "Processor.run method");
+    assert.ok(index.getSymbol("parse"), "parse function");
+    assert.ok(index.getSymbol("Task"), "Task interface");
+    const taskRefs = index.dependencyEdges.filter((e) => e.to === "Task");
+    assert.ok(taskRefs.length >= 2, "Task should have multiple references");
+    const implementsEdges = index.dependencyEdges.filter((e) => e.kind === "implements" && e.from === "Processor");
+    assert.ok(implementsEdges.length >= 1, "Processor should implement TaskRunner");
+    const codeMap = index.getCodeMap();
+    assert.ok(codeMap.text.includes("Processor"));
+    assert.ok(codeMap.text.includes("parseAndProcess"));
+});
+test("Code map generator produces expected format", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const byFile = new Map([["sample.ts", symbols]]);
+    const result = generateCodeMap(byFile);
+    assert.ok(result.text.includes("# Project Code Map"));
+    assert.ok(result.text.includes("sample.ts"));
+    assert.ok(result.text.includes("CodingAgent"));
+    assert.ok(result.text.includes("runTurn"));
+});
+test("Code map respects token budget", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const byFile = new Map([["sample.ts", symbols]]);
+    const result = generateCodeMap(byFile, 50);
+    assert.ok(result.text.length < 300);
+    assert.ok(result.text.includes("... and") || result.text.length > 0, "should truncate or fit within budget");
+});
+test("buildProjectIndex works on minicode src/", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const index = await buildProjectIndex(root);
+    assert.ok(index.symbols.size > 0);
+    assert.ok(index.files.size > 0);
+    const agentSymbols = index.getSymbolsInFile("src/agent/agent.ts");
+    assert.ok(agentSymbols.length >= 1);
+    assert.ok(agentSymbols.some((s) => s.name === "CodingAgent"));
+    const codeMap = index.getCodeMap();
+    assert.ok(codeMap.text.includes("CodingAgent"));
+    assert.ok(codeMap.text.includes("runTurn"));
+});
+test("getPluginForFile routes .tsx, .js, .jsx to TypeScript plugin", async () => {
+    const plugins = await loadPlugins("/tmp");
+    const tsx = getPluginForFile("src/component.tsx", plugins);
+    const js = getPluginForFile("src/legacy.js", plugins);
+    const jsx = getPluginForFile("src/component.jsx", plugins);
+    assert.ok(tsx);
+    assert.ok(js);
+    assert.ok(jsx);
+    assert.equal(tsx.name, "typescript");
+});
+test("TypeScript plugin extracts constructor", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const ctor = symbols.find((s) => s.qualifiedName === "CodingAgent.constructor");
+    assert.ok(ctor, "should extract constructor");
+    assert.equal(ctor.kind, "method");
+});
+test("TypeScript plugin extracts type alias", () => {
+    const code = `export type UserId = string;`;
+    const symbols = typescriptPlugin.indexFile("types.ts", code);
+    const typeSym = symbols.find((s) => s.name === "UserId");
+    assert.ok(typeSym, "should extract type alias");
+    assert.equal(typeSym.kind, "type");
+});
+test("TypeScript plugin returns empty array for empty file", () => {
+    const symbols = typescriptPlugin.indexFile("empty.ts", "");
+    assert.equal(symbols.length, 0);
+});
+test("TypeScript plugin handles comments-only file", () => {
+    const symbols = typescriptPlugin.indexFile("comments.ts", "// comment only\n/* block */");
+    assert.equal(symbols.length, 0);
+});
+test("TypeScript plugin handles malformed syntax", () => {
+    const symbols = typescriptPlugin.indexFile("bad.ts", "function { broken");
+    assert.ok(Array.isArray(symbols));
+});
+test("ProjectIndex getSymbol finds by qualifiedName and by name", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const index = await buildProjectIndex(root);
+    const byQualified = index.getSymbol("CodingAgent.runTurn");
+    assert.ok(byQualified);
+    assert.equal(byQualified.qualifiedName, "CodingAgent.runTurn");
+    const byName = index.getSymbol("runTurn");
+    assert.ok(byName, "getSymbol should find by name when unique");
+});
+test("ProjectIndex getSymbolsInFile returns empty for non-existent file", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const index = await buildProjectIndex(root);
+    const symbols = index.getSymbolsInFile("src/nonexistent.ts");
+    assert.ok(Array.isArray(symbols));
+    assert.equal(symbols.length, 0);
+});
+test("ProjectIndex getDependencyCone returns target and dependencies", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const index = await buildProjectIndex(root);
+    const cone = index.getDependencyCone("parseResponse", 1);
+    assert.ok(Array.isArray(cone));
+    assert.ok(cone.length >= 1, "should include target symbol");
+    assert.ok(cone.some((s) => s.qualifiedName === "parseResponse"), "should include parseResponse");
+});
+test("Code map handles empty symbols map", () => {
+    const result = generateCodeMap(new Map());
+    assert.ok(result.text.includes("# Project Code Map"));
+    assert.ok(result.text.length < 100);
+});
+test("Code map nests methods under class", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const byFile = new Map([["sample.ts", symbols]]);
+    const result = generateCodeMap(byFile);
+    assert.ok(result.text.includes("class CodingAgent"));
+    assert.ok(result.text.includes("runTurn"));
+    const runTurnLine = result.text.split("\n").find((l) => l.includes("runTurn"));
+    assert.ok(runTurnLine?.startsWith("    "), "method should be indented under class");
+});
+test("reindexFile updates symbols and code map after file change", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-reindex-"));
+    const samplePath = path.join(workspaceRoot, "sample.ts");
+    const initialContent = `export function greet(name: string): string {
+  return \`Hello, \${name}\`;
+}
+`;
+    await writeFile(samplePath, initialContent, "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    const sym = index.getSymbol("greet");
+    assert.ok(sym, "should find greet");
+    assert.ok(sym.signature.includes("name: string"), "initial signature");
+    const updatedContent = `export function greet(name: string, title?: string): string {
+  return title ? \`Hello, \${title} \${name}\` : \`Hello, \${name}\`;
+}
+`;
+    index.reindexFile("sample.ts", updatedContent);
+    const updatedSym = index.getSymbol("greet");
+    assert.ok(updatedSym, "should still find greet");
+    assert.ok(updatedSym.signature.includes("title?: string"), "signature should reflect updated params");
+    const codeMap = index.getCodeMap();
+    assert.ok(codeMap.text.includes("title?: string"), "code map should reflect new signature");
+});