@sean.holung/minicode 0.3.1 → 0.3.3

package/dist/tests/config-slash-command.test.js

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { access, mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, test } from "node:test";
+import { getGlobalConfigPath, setPersistedConfigValue, unsetPersistedConfigValue, } from "../src/agent/editable-config.js";
+import { handleConfigSlashCommand } from "../src/cli/config-slash-command.js";
+import { createTestAgentConfig } from "./test-utils.js";
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+test("setPersistedConfigValue writes mapped keys and unset removes empty config files", async () => {
+    const home = await mkdtemp(path.join(os.tmpdir(), "minicode-config-"));
+    tempDirs.push(home);
+    const setResult = await setPersistedConfigValue({
+        minicodeHome: home,
+        key: "commandTimeoutMs",
+        rawValue: "45000",
+    });
+    assert.equal(setResult.path, path.join(home, "agent.config.json"));
+    const file = JSON.parse(await readFile(setResult.path, "utf8"));
+    assert.equal(file.commandTimeout, 45000);
+    await unsetPersistedConfigValue({
+        minicodeHome: home,
+        key: "commandTimeoutMs",
+    });
+    await assert.rejects(access(setResult.path));
+});
+test("handleConfigSlashCommand persists config and reports env overrides", async () => {
+    const home = await mkdtemp(path.join(os.tmpdir(), "minicode-config-"));
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "minicode-config-ws-"));
+    tempDirs.push(home, workspace);
+    const config = createTestAgentConfig(workspace);
+    const previous = process.env.MAX_STEPS;
+    try {
+        process.env.MAX_STEPS = "120";
+        const result = await handleConfigSlashCommand("/config set maxSteps 64", {
+            config,
+            minicodeHome: home,
+        });
+        assert.equal(result.handled, true);
+        assert.match(result.message ?? "", /Saved config: maxSteps = 64/);
+        assert.match(result.message ?? "", /MAX_STEPS is currently set/);
+        const persisted = JSON.parse(await readFile(path.join(home, "agent.config.json"), "utf8"));
+        assert.equal(persisted.maxSteps, 64);
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env.MAX_STEPS;
+        }
+        else {
+            process.env.MAX_STEPS = previous;
+        }
+    }
+});
+test("handleConfigSlashCommand reports config layers with /config get", async () => {
+    const home = await mkdtemp(path.join(os.tmpdir(), "minicode-config-"));
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "minicode-config-ws-"));
+    tempDirs.push(home, workspace);
+    const config = {
+        ...createTestAgentConfig(workspace),
+        modelProvider: "openai-compatible",
+    };
+    const previous = process.env.MODEL_PROVIDER;
+    try {
+        process.env.MODEL_PROVIDER = "openai-compatible";
+        await setPersistedConfigValue({
+            minicodeHome: home,
+            key: "modelProvider",
+            rawValue: "openai-compatible",
+        });
+        const getResult = await handleConfigSlashCommand("/config get modelProvider", {
+            config,
+            minicodeHome: home,
+        });
+        assert.equal(getResult.handled, true);
+        assert.match(getResult.message ?? "", /effective: openai-compatible/);
+        assert.match(getResult.message ?? "", /config file: openai-compatible/);
+        assert.match(getResult.message ?? "", /env override \(MODEL_PROVIDER\): openai-compatible/);
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env.MODEL_PROVIDER;
+        }
+        else {
+            process.env.MODEL_PROVIDER = previous;
+        }
+    }
+});
+test("handleConfigSlashCommand rejects non-editable keys and keeps secrets env-only", async () => {
+    const home = await mkdtemp(path.join(os.tmpdir(), "minicode-config-"));
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "minicode-config-ws-"));
+    tempDirs.push(home, workspace);
+    const result = await handleConfigSlashCommand("/config set openAiApiKey secret", {
+        config: createTestAgentConfig(workspace),
+        minicodeHome: home,
+    });
+    assert.equal(result.handled, true);
+    assert.match(result.message ?? "", /Unknown editable config key "openAiApiKey"/);
+    assert.match(result.message ?? "", /Secrets like API keys stay env-only for now/);
+});
+test("getGlobalConfigPath resolves to minicode home", () => {
+    const home = "/tmp/example-home";
+    assert.equal(getGlobalConfigPath(home), path.join(home, "agent.config.json"));
+});

package/dist/tests/config.test.js

@@ -1,6 +1,13 @@
 import assert from "node:assert/strict";
-import { test } from "node:test";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, test } from "node:test";
 import { loadAgentConfig } from "../src/agent/config.js";
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
 test("loadAgentConfig normalizes openai-compatible provider aliases", async () => {
     const previousProvider = process.env.MODEL_PROVIDER;
     const previousBaseUrl = process.env.OPENAI_BASE_URL;
@@ -35,3 +42,37 @@ test("loadAgentConfig normalizes openai-compatible provider aliases", async () =
         }
     }
 });
+test("loadAgentConfig uses global config and env vars with correct precedence", async () => {
+    const base = await mkdtemp(path.join(os.tmpdir(), "minicode-config-test-"));
+    tempDirs.push(base);
+    const minicodeHome = path.join(base, "home");
+    await mkdir(minicodeHome, { recursive: true });
+    await writeFile(path.join(minicodeHome, "agent.config.json"), JSON.stringify({ model: "global-model", maxSteps: 33 }, null, 2) + "\n", "utf8");
+    await writeFile(path.join(minicodeHome, ".env"), "MODEL=home-env-model\n", "utf8");
+    const previousMaxSteps = process.env.MAX_STEPS;
+    const previousModel = process.env.MODEL;
+    try {
+        // Shell env vars should override everything
+        process.env.MAX_STEPS = "120";
+        delete process.env.MODEL;
+        const config = await loadAgentConfig("/tmp", { minicodeHome });
+        // MODEL from ~/.minicode/.env (no shell override)
+        assert.equal(config.model, "home-env-model");
+        // MAX_STEPS from shell env (overrides config file value of 33)
+        assert.equal(config.maxSteps, 120);
+    }
+    finally {
+        if (previousMaxSteps === undefined) {
+            delete process.env.MAX_STEPS;
+        }
+        else {
+            process.env.MAX_STEPS = previousMaxSteps;
+        }
+        if (previousModel === undefined) {
+            delete process.env.MODEL;
+        }
+        else {
+            process.env.MODEL = previousModel;
+        }
+    }
+});

package/dist/tests/context-indicator.test.js

@@ -0,0 +1,220 @@
+import assert from "node:assert/strict";
+import { test, afterEach } from "node:test";
+import { createServer } from "node:http";
+import { createRequestHandler } from "../src/serve/server.js";
+import { AgentBridge } from "../src/serve/agent-bridge.js";
+import { CodingAgent, ToolRegistry, } from "@minicode/agent-sdk";
+import { UiStore } from "../src/ui/state/ui-store.js";
+import { createTestAgentConfig } from "./test-utils.js";
+// ── Mock model client ──
+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;
+    }
+}
+// ── MockBridge for serve tests ──
+class MockBridge extends AgentBridge {
+    _busy = false;
+    _contextTokens = 1200;
+    _maxContextTokens = 16000;
+    constructor() {
+        super(() => { }, false);
+    }
+    isReady() {
+        return true;
+    }
+    isBusy() {
+        return this._busy;
+    }
+    getConfig() {
+        return createTestAgentConfig("/tmp/test-workspace");
+    }
+    getAgent() {
+        const ctx = { contextTokens: this._contextTokens, maxContextTokens: this._maxContextTokens };
+        return {
+            getContextStatus: () => ctx,
+        };
+    }
+    async runTurn(message) {
+        this._busy = true;
+        this.emit({ type: "streaming_chunk", content: `Echo: ${message}` });
+        this._busy = false;
+        return { text: `Echo: ${message}`, usage: { inputTokens: 10, outputTokens: 5 } };
+    }
+    async listSess() { return []; }
+    async saveSess() { return { id: "s", label: "l", createdAt: "", savedAt: "", messageCount: 0 }; }
+    async loadSess() { return null; }
+    hasIndex() { return false; }
+    emit(msg) {
+        for (const fn of this.listeners) {
+            fn(msg);
+        }
+    }
+    setContextState(tokens, max) {
+        this._contextTokens = tokens;
+        this._maxContextTokens = max;
+    }
+}
+// ── Test harness ──
+let activeServer;
+function startTestServer(bridge) {
+    const handler = createRequestHandler(bridge);
+    const server = createServer(handler);
+    activeServer = server;
+    return new Promise((resolve) => {
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (typeof addr === "object" && addr) {
+                resolve(`http://127.0.0.1:${addr.port}`);
+            }
+        });
+    });
+}
+function stopTestServer() {
+    return new Promise((resolve) => {
+        if (activeServer) {
+            activeServer.close(() => resolve());
+            activeServer = undefined;
+        }
+        else {
+            resolve();
+        }
+    });
+}
+afterEach(async () => {
+    await stopTestServer();
+});
+// ── REST API: /api/context ──
+test("GET /api/context returns context token status", async () => {
+    const bridge = new MockBridge();
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/context`);
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.equal(body.contextTokens, 1200);
+    assert.equal(body.maxContextTokens, 16000);
+});
+test("GET /api/context reflects updated context state", async () => {
+    const bridge = new MockBridge();
+    bridge.setContextState(8000, 16000);
+    const base = await startTestServer(bridge);
+    const res = await fetch(`${base}/api/context`);
+    const body = (await res.json());
+    assert.equal(body.contextTokens, 8000);
+    assert.equal(body.maxContextTokens, 16000);
+});
+// ── Agent emits context_status UiUpdate ──
+test("agent emits context_status UiUpdate during turn", async () => {
+    const config = createTestAgentConfig("/tmp/test-workspace");
+    const modelClient = new SequenceModelClient([
+        {
+            text: "done",
+            toolCalls: [],
+            stopReason: "end_turn",
+            usage: { inputTokens: 10, outputTokens: 5 },
+        },
+    ]);
+    const toolRegistry = new ToolRegistry([]);
+    const events = [];
+    const agent = new CodingAgent({
+        config,
+        modelClient,
+        toolRegistry,
+        onUiUpdate: (event) => events.push(event),
+    });
+    await agent.runTurn("hello");
+    const contextEvents = events.filter((e) => e.type === "context_status");
+    assert.ok(contextEvents.length >= 1, "should emit at least one context_status event");
+    const ev = contextEvents[0];
+    assert.equal(ev.type, "context_status");
+    assert.equal(typeof ev.contextTokens, "number");
+    assert.equal(ev.maxContextTokens, config.maxContextTokens);
+});
+test("agent context_status tokens increase as messages are added", async () => {
+    const config = createTestAgentConfig("/tmp/test-workspace");
+    const modelClient = new SequenceModelClient([
+        {
+            text: "first",
+            toolCalls: [],
+            stopReason: "end_turn",
+            usage: { inputTokens: 10, outputTokens: 5 },
+        },
+        {
+            text: "second",
+            toolCalls: [],
+            stopReason: "end_turn",
+            usage: { inputTokens: 10, outputTokens: 5 },
+        },
+    ]);
+    const toolRegistry = new ToolRegistry([]);
+    const contextTokensPerTurn = [];
+    const agent = new CodingAgent({
+        config,
+        modelClient,
+        toolRegistry,
+        onUiUpdate: (event) => {
+            if (event.type === "context_status") {
+                contextTokensPerTurn.push(event.contextTokens);
+            }
+        },
+    });
+    await agent.runTurn("hello");
+    await agent.runTurn("world");
+    assert.equal(contextTokensPerTurn.length, 2);
+    assert.ok(contextTokensPerTurn[1] > contextTokensPerTurn[0], `context should grow: ${contextTokensPerTurn[0]} → ${contextTokensPerTurn[1]}`);
+});
+// ── CodingAgent.getContextStatus() ──
+test("agent getContextStatus returns current token estimate and max", async () => {
+    const config = createTestAgentConfig("/tmp/test-workspace");
+    const modelClient = new SequenceModelClient([
+        {
+            text: "done",
+            toolCalls: [],
+            stopReason: "end_turn",
+            usage: { inputTokens: 10, outputTokens: 5 },
+        },
+    ]);
+    const toolRegistry = new ToolRegistry([]);
+    const agent = new CodingAgent({ config, modelClient, toolRegistry });
+    // Before any turn, context should be empty
+    const before = agent.getContextStatus();
+    assert.equal(before.contextTokens, 0);
+    assert.equal(before.maxContextTokens, config.maxContextTokens);
+    await agent.runTurn("test message");
+    // After a turn, context should have some tokens
+    const after = agent.getContextStatus();
+    assert.ok(after.contextTokens > 0, "context should have tokens after a turn");
+    assert.equal(after.maxContextTokens, config.maxContextTokens);
+});
+// ── UiStore context status ──
+test("UiStore tracks context status via setContextStatus", () => {
+    const store = new UiStore();
+    assert.equal(store.getState().contextTokens, 0);
+    assert.equal(store.getState().maxContextTokens, 0);
+    store.setContextStatus(5000, 40000);
+    assert.equal(store.getState().contextTokens, 5000);
+    assert.equal(store.getState().maxContextTokens, 40000);
+});
+test("UiStore context status updates trigger listeners", () => {
+    const store = new UiStore();
+    let notified = false;
+    store.subscribe(() => { notified = true; });
+    store.setContextStatus(1000, 16000);
+    assert.ok(notified, "listener should have been called");
+    assert.equal(store.getState().contextTokens, 1000);
+});
+test("UiStore reset clears context status", () => {
+    const store = new UiStore();
+    store.setContextStatus(5000, 40000);
+    store.reset();
+    assert.equal(store.getState().contextTokens, 0);
+    assert.equal(store.getState().maxContextTokens, 0);
+});

package/dist/tests/editable-config.test.js

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, test } from "node:test";
+import { applyPersistedConfigUpdates, buildStructuredConfigPayload, getGlobalConfigPath, } from "../src/agent/editable-config.js";
+import { createTestAgentConfig } from "./test-utils.js";
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+async function withUnsetEnvVars(names, callback) {
+    const previous = new Map();
+    for (const name of names) {
+        previous.set(name, process.env[name]);
+        delete process.env[name];
+    }
+    try {
+        await callback();
+    }
+    finally {
+        for (const [name, value] of previous) {
+            if (value === undefined) {
+                delete process.env[name];
+            }
+            else {
+                process.env[name] = value;
+            }
+        }
+    }
+}
+test("buildStructuredConfigPayload reports effective values and env overrides", async () => {
+    await withUnsetEnvVars(["MAX_STEPS", "MODEL", "ENABLE_DYNAMIC_PROMPT"], async () => {
+        const home = await mkdtemp(path.join(os.tmpdir(), "minicode-editable-config-"));
+        const workspace = await mkdtemp(path.join(os.tmpdir(), "minicode-editable-ws-"));
+        tempDirs.push(home, workspace);
+        await applyPersistedConfigUpdates({
+            minicodeHome: home,
+            updates: {
+                maxSteps: 77,
+                model: "global-model",
+            },
+        });
+        process.env.MAX_STEPS = "120";
+        const payload = await buildStructuredConfigPayload({
+            ...createTestAgentConfig(workspace),
+            maxSteps: 120,
+            model: "global-model",
+        }, home);
+        assert.equal(payload.configPath, path.join(home, "agent.config.json"));
+        const maxSteps = payload.entries.find((entry) => entry.key === "maxSteps");
+        assert.equal(maxSteps?.effectiveValue, 120);
+        assert.equal(maxSteps?.persistedValue, 77);
+        assert.equal(maxSteps?.envValue, "120");
+        assert.equal(maxSteps?.envSource, "process");
+        assert.equal(maxSteps?.envSourcePath, null);
+        assert.equal(maxSteps?.overriddenByEnv, true);
+        const model = payload.entries.find((entry) => entry.key === "model");
+        assert.equal(model?.effectiveValue, "global-model");
+        assert.equal(model?.persistedValue, "global-model");
+        assert.equal(model?.overriddenByEnv, false);
+    });
+});
+test("buildStructuredConfigPayload reports home dotenv env source", async () => {
+    await withUnsetEnvVars(["MAX_STEPS"], async () => {
+        const home = await mkdtemp(path.join(os.tmpdir(), "minicode-editable-config-"));
+        const workspace = await mkdtemp(path.join(os.tmpdir(), "minicode-editable-ws-"));
+        tempDirs.push(home, workspace);
+        await mkdir(home, { recursive: true });
+        await writeFile(path.join(home, ".env"), "MAX_STEPS=88\n", "utf8");
+        const payload = await buildStructuredConfigPayload({
+            ...createTestAgentConfig(workspace),
+            maxSteps: 88,
+        }, home);
+        const maxSteps = payload.entries.find((entry) => entry.key === "maxSteps");
+        assert.equal(maxSteps?.envValue, "88");
+        assert.equal(maxSteps?.envSource, "home-dotenv");
+        assert.equal(maxSteps?.envSourcePath, path.join(home, ".env"));
+        assert.equal(maxSteps?.overriddenByEnv, true);
+    });
+});
+test("applyPersistedConfigUpdates writes global config and removes files when everything is unset", async () => {
+    const home = await mkdtemp(path.join(os.tmpdir(), "minicode-editable-config-"));
+    tempDirs.push(home);
+    const result = await applyPersistedConfigUpdates({
+        minicodeHome: home,
+        updates: {
+            keepRecentMessages: 18,
+            enableFileReadDedup: false,
+        },
+    });
+    assert.equal(result.path, getGlobalConfigPath(home));
+    assert.deepEqual(result.saved, [
+        { key: "keepRecentMessages", value: 18 },
+        { key: "enableFileReadDedup", value: false },
+    ]);
+    const configPath = path.join(home, "agent.config.json");
+    const persisted = JSON.parse(await readFile(configPath, "utf8"));
+    assert.equal(persisted.keepRecentMessages, 18);
+    assert.equal(persisted.enableFileReadDedup, false);
+    await applyPersistedConfigUpdates({
+        minicodeHome: home,
+        updates: {
+            keepRecentMessages: null,
+            enableFileReadDedup: null,
+        },
+    });
+    await assert.rejects(access(configPath));
+});

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

@@ -0,0 +1,183 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { test } from "node:test";
+import { createProjectIndex } from "../src/indexer/project-index.js";
+import { createFindPathTool } from "../src/tools/find-path.js";
+function makeSymbol(name, kind = "function") {
+    return {
+        name,
+        qualifiedName: name,
+        kind,
+        filePath: "test.ts",
+        startLine: 1,
+        endLine: 5,
+        signature: `function ${name}()`,
+        exported: true,
+        dependencies: [],
+    };
+}
+function buildTestIndex(symbols, edges) {
+    const symMap = new Map();
+    const fileMap = new Map();
+    for (const sym of symbols) {
+        symMap.set(sym.qualifiedName, sym);
+        const existing = fileMap.get(sym.filePath) ?? [];
+        existing.push(sym);
+        fileMap.set(sym.filePath, existing);
+    }
+    return createProjectIndex(symMap, fileMap, edges, [], new Map(), "/tmp/test");
+}
+test("findPath returns path between two connected symbols", () => {
+    const symbols = [makeSymbol("a"), makeSymbol("b"), makeSymbol("c")];
+    const edges = [
+        { from: "a", to: "b", kind: "calls" },
+        { from: "b", to: "c", kind: "calls" },
+    ];
+    const index = buildTestIndex(symbols, edges);
+    const result = index.findPath("a", "c");
+    assert.equal(result.length, 3);
+    assert.equal(result[0].qualifiedName, "a");
+    assert.equal(result[1].qualifiedName, "b");
+    assert.equal(result[2].qualifiedName, "c");
+});
+test("findPath returns empty array when no path exists", () => {
+    const symbols = [makeSymbol("a"), makeSymbol("b")];
+    const edges = [];
+    const index = buildTestIndex(symbols, edges);
+    const result = index.findPath("a", "b");
+    assert.equal(result.length, 0);
+});
+test("findPath returns direct path for adjacent symbols", () => {
+    const symbols = [makeSymbol("a"), makeSymbol("b")];
+    const edges = [{ from: "a", to: "b", kind: "calls" }];
+    const index = buildTestIndex(symbols, edges);
+    const result = index.findPath("a", "b");
+    assert.equal(result.length, 2);
+    assert.equal(result[0].qualifiedName, "a");
+    assert.equal(result[1].qualifiedName, "b");
+});
+test("findPath finds path via reverse edges", () => {
+    const symbols = [makeSymbol("a"), makeSymbol("b"), makeSymbol("c")];
+    // Only edge is b->a and b->c, so path from a to c goes a<-b->c
+    const edges = [
+        { from: "b", to: "a", kind: "calls" },
+        { from: "b", to: "c", kind: "calls" },
+    ];
+    const index = buildTestIndex(symbols, edges);
+    const result = index.findPath("a", "c");
+    assert.equal(result.length, 3);
+    assert.equal(result[0].qualifiedName, "a");
+    assert.equal(result[1].qualifiedName, "b");
+    assert.equal(result[2].qualifiedName, "c");
+});
+test("findPath respects maxDepth", () => {
+    const symbols = [makeSymbol("a"), makeSymbol("b"), makeSymbol("c"), makeSymbol("d")];
+    const edges = [
+        { from: "a", to: "b", kind: "calls" },
+        { from: "b", to: "c", kind: "calls" },
+        { from: "c", to: "d", kind: "calls" },
+    ];
+    const index = buildTestIndex(symbols, edges);
+    // maxDepth 1 should not find a path from a to d (3 hops away)
+    const result = index.findPath("a", "d", 1);
+    assert.equal(result.length, 0);
+    // maxDepth 3 should find it
+    const result2 = index.findPath("a", "d", 3);
+    assert.equal(result2.length, 4);
+});
+test("findPath returns empty for unknown symbols", () => {
+    const symbols = [makeSymbol("a")];
+    const index = buildTestIndex(symbols, []);
+    assert.equal(index.findPath("a", "nonexistent").length, 0);
+    assert.equal(index.findPath("nonexistent", "a").length, 0);
+});
+test("findPathToEntryPoint traces back to entry points", () => {
+    const symbols = [makeSymbol("entry"), makeSymbol("middle"), makeSymbol("leaf")];
+    const edges = [
+        { from: "entry", to: "middle", kind: "calls" },
+        { from: "middle", to: "leaf", kind: "calls" },
+    ];
+    const index = buildTestIndex(symbols, edges);
+    const paths = index.findPathToEntryPoint("leaf");
+    assert.ok(paths.length > 0);
+    // The path should go from entry -> middle -> leaf
+    const firstPath = paths[0];
+    assert.equal(firstPath[0].qualifiedName, "entry");
+    assert.equal(firstPath[firstPath.length - 1].qualifiedName, "leaf");
+});
+test("findPathToEntryPoint returns empty for entry point symbols", () => {
+    const symbols = [makeSymbol("entry"), makeSymbol("other")];
+    const edges = [
+        { from: "entry", to: "other", kind: "calls" },
+    ];
+    const index = buildTestIndex(symbols, edges);
+    // "entry" has no inbound edges, so it IS an entry point
+    const paths = index.findPathToEntryPoint("entry");
+    // Should return empty or self-referential since it's already an entry point
+    assert.equal(paths.length, 0);
+});
+test("findPathToEntryPoint returns empty for unknown symbols", () => {
+    const index = buildTestIndex([], []);
+    const paths = index.findPathToEntryPoint("nonexistent");
+    assert.equal(paths.length, 0);
+});
+test("find_path tool returns path between two symbols", async () => {
+    const symbols = [makeSymbol("a"), makeSymbol("b"), makeSymbol("c")];
+    const edges = [
+        { from: "a", to: "b", kind: "calls" },
+        { from: "b", to: "c", kind: "calls" },
+    ];
+    const index = buildTestIndex(symbols, edges);
+    const tool = createFindPathTool(index);
+    const result = await tool.execute({ from: "a", to: "c" });
+    assert.ok(result.includes("# Path from a to c"));
+    assert.ok(result.includes("3 symbols"));
+    assert.ok(result.includes("[function] a"));
+    assert.ok(result.includes("[function] b"));
+    assert.ok(result.includes("[function] c"));
+});
+test("find_path tool traces to entry points when 'to' is omitted", async () => {
+    const symbols = [makeSymbol("entry"), makeSymbol("middle"), makeSymbol("leaf")];
+    const edges = [
+        { from: "entry", to: "middle", kind: "calls" },
+        { from: "middle", to: "leaf", kind: "calls" },
+    ];
+    const index = buildTestIndex(symbols, edges);
+    const tool = createFindPathTool(index);
+    const result = await tool.execute({ from: "leaf" });
+    assert.ok(result.includes("Entry point paths for leaf"));
+    assert.ok(result.includes("[function] entry"));
+});
+test("find_path tool returns error for unknown symbol", async () => {
+    const index = buildTestIndex([], []);
+    const tool = createFindPathTool(index);
+    const result = await tool.execute({ from: "nonexistent" });
+    assert.ok(result.includes("not found"));
+});
+test("find_path tool returns error when target symbol not found", async () => {
+    const symbols = [makeSymbol("a")];
+    const index = buildTestIndex(symbols, []);
+    const tool = createFindPathTool(index);
+    const result = await tool.execute({ from: "a", to: "nonexistent" });
+    assert.ok(result.includes("not found"));
+});
+test("find_path tool reports no path when symbols are disconnected", async () => {
+    const symbols = [makeSymbol("a"), makeSymbol("b")];
+    const index = buildTestIndex(symbols, []);
+    const tool = createFindPathTool(index);
+    const result = await tool.execute({ from: "a", to: "b" });
+    assert.ok(result.includes("No path found"));
+});
+test("find_path tool works with real project index", async () => {
+    const { buildProjectIndex } = await import("../src/indexer/project-index.js");
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createFindPathTool(projectIndex);
+    // Find path between two known symbols
+    const result = await tool.execute({
+        from: "createModelClient",
+        to: "AgentConfig",
+    });
+    assert.ok(result.includes("# Path from createModelClient to AgentConfig"));
+    assert.ok(result.includes("symbols"));
+});