@sean.holung/minicode 0.3.2 → 0.3.3

package/dist/tests/focus-tracker.test.js

@@ -0,0 +1,62 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { FocusTracker } from "@minicode/agent-sdk";
+test("FocusTracker tracks added symbols", () => {
+    const tracker = new FocusTracker();
+    tracker.addSymbol("Foo");
+    tracker.addSymbol("Bar");
+    const focused = tracker.getFocusedSymbols();
+    assert.equal(focused.size, 2);
+    assert.ok(focused.has("Foo"));
+    assert.ok(focused.has("Bar"));
+});
+test("FocusTracker evicts oldest symbol when exceeding limit", () => {
+    const tracker = new FocusTracker();
+    // Add 31 symbols (limit is 30)
+    for (let i = 0; i < 31; i++) {
+        tracker.addSymbol(`sym_${i}`);
+    }
+    const focused = tracker.getFocusedSymbols();
+    assert.equal(focused.size, 30);
+    // The first symbol should have been evicted
+    assert.ok(!focused.has("sym_0"), "oldest symbol should be evicted");
+    assert.ok(focused.has("sym_30"), "newest symbol should remain");
+});
+test("FocusTracker refreshes existing symbol generation on re-add", () => {
+    const tracker = new FocusTracker();
+    // Add initial symbols
+    tracker.addSymbol("first");
+    for (let i = 0; i < 29; i++) {
+        tracker.addSymbol(`filler_${i}`);
+    }
+    // Re-add "first" to refresh its generation
+    tracker.addSymbol("first");
+    // Add one more to trigger eviction — "first" should survive since it was refreshed
+    tracker.addSymbol("extra");
+    const focused = tracker.getFocusedSymbols();
+    assert.ok(focused.has("first"), "re-added symbol should survive eviction");
+    assert.equal(focused.size, 30);
+});
+test("FocusTracker.hasFocus returns correct status", () => {
+    const tracker = new FocusTracker();
+    tracker.addSymbol("Foo");
+    assert.ok(tracker.hasFocus("Foo"));
+    assert.ok(!tracker.hasFocus("Bar"));
+});
+test("FocusTracker.clear resets all state", () => {
+    const tracker = new FocusTracker();
+    tracker.addSymbol("Foo");
+    tracker.addSymbol("Bar");
+    tracker.clear();
+    assert.equal(tracker.getFocusedSymbols().size, 0);
+    assert.ok(!tracker.hasFocus("Foo"));
+});
+test("FocusTracker.addSymbols adds multiple symbols at once", () => {
+    const tracker = new FocusTracker();
+    tracker.addSymbols(["A", "B", "C"]);
+    const focused = tracker.getFocusedSymbols();
+    assert.equal(focused.size, 3);
+    assert.ok(focused.has("A"));
+    assert.ok(focused.has("B"));
+    assert.ok(focused.has("C"));
+});

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

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const distWeb = join(import.meta.dirname, '..', 'dist', 'src', 'web');
+test('built CSS contains graph-onboarding styles', () => {
+    const css = readFileSync(join(distWeb, 'style.css'), 'utf-8');
+    assert.ok(css.includes('.graph-onboarding'), 'CSS should contain .graph-onboarding class');
+    assert.ok(css.includes('.graph-onboarding-icon'), 'CSS should contain .graph-onboarding-icon class');
+    assert.ok(css.includes('.graph-onboarding-title'), 'CSS should contain .graph-onboarding-title class');
+    assert.ok(css.includes('.graph-onboarding-subtitle'), 'CSS should contain .graph-onboarding-subtitle class');
+    assert.ok(css.includes('pointer-events: none'), 'onboarding overlay should not block interactions');
+    assert.ok(css.includes('width: 380px;'), 'symbol detail panel should have a wider default width');
+});
+test('built JS contains onboarding hint logic', () => {
+    const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
+    assert.ok(js.includes('graph-onboarding'), 'JS should create onboarding hint element');
+    assert.ok(js.includes('showOnboardingHint'), 'JS should define showOnboardingHint function');
+    assert.ok(js.includes('removeOnboardingHint'), 'JS should define removeOnboardingHint function');
+});
+test('built HTML contains #cy graph container', () => {
+    const html = readFileSync(join(distWeb, 'index.html'), 'utf-8');
+    assert.ok(html.includes('id="cy"'), 'HTML should contain the #cy graph container');
+    assert.ok(html.includes('id="graph-pane"'), 'HTML should contain the #graph-pane wrapper');
+});
+test('onboarding hint includes user-facing guidance text in built JS', () => {
+    const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
+    assert.ok(js.includes('Code dependency graph'), 'onboarding title should mention the code dependency graph');
+    assert.ok(js.includes('Search for a symbol'), 'onboarding subtitle should guide users to search');
+});
+test('onboarding hint is re-shown on clear in built JS', () => {
+    const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
+    // The clear handler should call showOnboardingHint after removing elements
+    assert.ok(js.includes('graph-clear'), 'JS should reference the clear button');
+    // Verify that showOnboardingHint appears more than once (init + clear handler)
+    const matches = js.match(/showOnboardingHint/g);
+    assert.ok(matches && matches.length >= 2, 'showOnboardingHint should be called at init and on clear');
+});
+test('onboarding hint is removed when nodes are added in built JS', () => {
+    const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
+    // removeOnboardingHint should be called inside addNodeToGraph
+    assert.ok(js.includes('removeOnboardingHint'), 'JS should call removeOnboardingHint when adding nodes');
+});
+test('built JS keeps agent activity reveals narrower than manual expansion', () => {
+    const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
+    assert.ok(js.includes('renderNodeNeighborhoodAndLayout'), 'JS should define a configurable graph-rendering helper');
+    assert.ok(js.includes('maxDegrees: 0'), 'agent activity should reveal only the active symbol instead of expanding neighbors');
+    assert.ok(js.includes('maxDegrees: 1'), 'intentional graph exploration should still render first-degree neighbors');
+});
+test('built JS auto-opens symbol details for agent activity and graph search selection', () => {
+    const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
+    assert.ok(js.includes('focusSymbolInGraph'), 'JS should define a shared focus helper for graph-driven symbol selection');
+    assert.ok(js.includes('openDetail: true'), 'JS should request the detail panel when focusing symbols from agent activity or search');
+    assert.ok(js.includes('await showDetail(node, detailEl)'), 'JS should populate the symbol detail panel when focus requests it');
+});

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

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { buildStylesheet, KIND_COLORS } from '../src/shared/graph-styles.js';
+describe('buildStylesheet', () => {
+    const styles = buildStylesheet();
+    it('returns an array of style entries', () => {
+        assert.ok(Array.isArray(styles));
+        assert.ok(styles.length > 0);
+    });
+    it('includes base node style', () => {
+        const base = styles.find((s) => s.selector === 'node');
+        assert.ok(base, 'base node style should exist');
+        assert.equal(base.style['shape'], 'roundrectangle');
+        assert.equal(base.style['label'], 'data(label)');
+    });
+    it('includes base edge style', () => {
+        const edge = styles.find((s) => s.selector === 'edge');
+        assert.ok(edge, 'base edge style should exist');
+        assert.equal(edge.style['curve-style'], 'bezier');
+    });
+    it('includes a style for each kind color', () => {
+        for (const kind of Object.keys(KIND_COLORS)) {
+            const entry = styles.find((s) => s.selector === `node.${kind}`);
+            assert.ok(entry, `style for node.${kind} should exist`);
+            assert.equal(entry.style['border-color'], KIND_COLORS[kind].border);
+            assert.equal(entry.style['background-color'], KIND_COLORS[kind].bg);
+        }
+    });
+    it('includes hover-target style with pointer affordance cues', () => {
+        const hover = styles.find((s) => s.selector === 'node.hover-target');
+        assert.ok(hover, 'hover-target style should exist');
+        // Increased size signals interactivity
+        assert.equal(hover.style['width'], 24, 'hover-target should enlarge node width');
+        assert.equal(hover.style['height'], 24, 'hover-target should enlarge node height');
+        // Thicker border for visual highlight
+        assert.equal(hover.style['border-width'], 3, 'hover-target should have thicker border');
+        // Overlay provides subtle glow
+        assert.ok(hover.style['overlay-opacity'] > 0, 'hover-target should have a visible overlay');
+        // Higher z-index to pop above neighbors
+        assert.ok(hover.style['z-index'] >= 20, 'hover-target should have high z-index');
+    });
+    it('includes highlighted style for neighborhood nodes', () => {
+        const highlighted = styles.find((s) => s.selector === 'node.highlighted');
+        assert.ok(highlighted, 'highlighted style should exist');
+        assert.ok(highlighted.style['border-width'] > 1.5, 'highlighted should increase border width');
+    });
+    it('includes structural analysis styles for flagged graph elements', () => {
+        const flaggedNode = styles.find((s) => s.selector === 'node.analysis-flagged');
+        assert.ok(flaggedNode, 'analysis-flagged node style should exist');
+        assert.equal(flaggedNode.style['border-style'], 'double');
+        const selectedNode = styles.find((s) => s.selector === 'node.analysis-selected');
+        assert.ok(selectedNode, 'analysis-selected node style should exist');
+        assert.ok(selectedNode.style['border-width'] >= 4, 'analysis-selected node should emphasize border width');
+        const selectedEdge = styles.find((s) => s.selector === 'edge.analysis-selected');
+        assert.ok(selectedEdge, 'analysis-selected edge style should exist');
+        assert.ok(selectedEdge.style['width'] >= 3, 'analysis-selected edge should increase edge width');
+    });
+    it('includes faded style for non-neighborhood elements', () => {
+        const fadedNode = styles.find((s) => s.selector === 'node.faded');
+        assert.ok(fadedNode, 'faded node style should exist');
+        assert.ok(fadedNode.style['opacity'] < 1, 'faded nodes should reduce opacity');
+        const fadedEdge = styles.find((s) => s.selector === 'edge.faded');
+        assert.ok(fadedEdge, 'faded edge style should exist');
+    });
+});

package/dist/tests/indexer.test.js

@@ -7,6 +7,7 @@ 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";
+import { normalizeIndexedSymbols } from "../src/indexer/symbol-names.js";
 const SAMPLE_TS = `
 export interface Foo {
   bar: string;
@@ -199,6 +200,39 @@ test("reindexFile updates symbols and code map after file change", async () => {
     const codeMap = index.getCodeMap();
     assert.ok(codeMap.text.includes("title?: string"), "code map should reflect new signature");
 });
+test("buildProjectIndex preserves colliding top-level symbols with distinct display names", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-colliding-symbols-"));
+    const samplePath = path.join(workspaceRoot, "sample.ts");
+    const content = `export interface Employee {
+  id: string;
+}
+
+export class Employee {
+  constructor(public id: string) {}
+}
+`;
+    await writeFile(samplePath, content, "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    const fileSymbols = index.getSymbolsInFile("sample.ts");
+    assert.equal(fileSymbols.length, 3, "should preserve interface, class, and constructor");
+    const employeeSymbols = fileSymbols.filter((symbol) => symbol.name === "Employee");
+    assert.equal(employeeSymbols.length, 2, "should keep both colliding Employee symbols");
+    assert.notEqual(employeeSymbols[0].qualifiedName, employeeSymbols[1].qualifiedName, "colliding symbols should have unique internal qualified names");
+    assert.ok(employeeSymbols.some((symbol) => symbol.displayName === "Employee (interface)"));
+    assert.ok(employeeSymbols.some((symbol) => symbol.displayName === "Employee (class)"));
+    const employeeClass = index.getSymbol("Employee (class)");
+    const employeeInterface = index.getSymbol("Employee (interface)");
+    assert.ok(employeeClass, "should resolve colliding class by display name");
+    assert.ok(employeeInterface, "should resolve colliding interface by display name");
+    assert.equal(employeeClass.kind, "class");
+    assert.equal(employeeInterface.kind, "interface");
+    const codeMap = index.getCodeMap();
+    assert.ok(codeMap.text.includes("interface Employee (interface)"));
+    assert.ok(codeMap.text.includes("class Employee (class)"));
+    const resolved = index.getSymbol("Employee");
+    assert.ok(resolved, "bare lookup should still resolve one of the colliding symbols");
+    assert.ok(resolved.displayName === "Employee (class)" || resolved.displayName === "Employee (interface)", "resolved symbol should use a disambiguated display name");
+});
 test("TypeScript plugin indexes class expressions assigned to variables", () => {
     const code = `const MyClass = class MyClass {
   constructor(name) {
@@ -261,3 +295,106 @@ function setup() {
     const newCallEdge = edges.find((e) => e.from === "setup" && e.to === "Logger" && e.kind === "calls");
     assert.ok(newCallEdge, "new Logger() should produce a calls edge from setup to Logger");
 });
+test("AST cache avoids double-parsing: resolveDependencies reuses cached ASTs from indexFile", () => {
+    const code = `
+export interface Task {
+  id: string;
+  name: string;
+}
+
+export function createTask(id: string, name: string): Task {
+  return { id, name };
+}
+
+export class TaskManager {
+  run(task: Task) {
+    return createTask(task.id, task.name);
+  }
+}
+`;
+    // indexFile populates the internal AST cache
+    const symbols = typescriptPlugin.indexFile("cached.ts", code);
+    assert.ok(symbols.length > 0, "should extract symbols");
+    // resolveDependencies should reuse the cached AST (no re-parse)
+    const projectFiles = new Map([["cached.ts", code]]);
+    const edges = typescriptPlugin.resolveDependencies(symbols, projectFiles);
+    // Verify edges are still correctly produced (cache didn't break resolution)
+    const callEdge = edges.find((e) => e.from === "TaskManager.run" && e.to === "createTask" && e.kind === "calls");
+    assert.ok(callEdge, "should find calls edge from TaskManager.run to createTask");
+    const refEdge = edges.find((e) => e.from === "createTask" && e.to === "Task" && e.kind === "references");
+    assert.ok(refEdge, "should find references edge from createTask to Task");
+});
+test("AST cache is cleared after resolveDependencies completes", () => {
+    const code = `export function foo(): void {}`;
+    // First pass: indexFile caches the AST
+    typescriptPlugin.indexFile("clear-test.ts", code);
+    // resolveDependencies should clear the cache when done
+    typescriptPlugin.resolveDependencies(typescriptPlugin.indexFile("clear-test.ts", code), new Map([["clear-test.ts", code]]));
+    // Second pass with different content on same path — should parse fresh, not stale cache
+    const newCode = `export function bar(): string { return "bar"; }`;
+    const symbols = typescriptPlugin.indexFile("clear-test.ts", newCode);
+    const names = symbols.map((s) => s.qualifiedName);
+    assert.ok(names.includes("bar"), "should extract bar from fresh parse");
+    assert.ok(!names.includes("foo"), "should not have stale foo from cache");
+});
+test("resolveDependencies works without prior indexFile (cache miss)", () => {
+    const code = `
+function alpha() { beta(); }
+function beta() {}
+`;
+    // Call resolveDependencies without indexFile first — should still work via fallback parse
+    const symbols = [
+        { name: "alpha", qualifiedName: "alpha", kind: "function", filePath: "no-cache.ts", startLine: 2, endLine: 2, signature: "function alpha()", exported: false, dependencies: [] },
+        { name: "beta", qualifiedName: "beta", kind: "function", filePath: "no-cache.ts", startLine: 3, endLine: 3, signature: "function beta()", exported: false, dependencies: [] },
+    ];
+    const projectFiles = new Map([["no-cache.ts", code]]);
+    const edges = typescriptPlugin.resolveDependencies(symbols, projectFiles);
+    const callEdge = edges.find((e) => e.from === "alpha" && e.to === "beta" && e.kind === "calls");
+    assert.ok(callEdge, "should resolve dependencies even without cached AST");
+});
+test("resolveDependencies prefers same-file symbols over same-named helpers in other files", () => {
+    const projectIndexCode = `
+async function collectSourceFiles(dir: string): Promise<void> {
+  await collectSourceFiles(dir + "/nested");
+}
+
+export async function buildProjectIndex(): Promise<void> {
+  await collectSourceFiles("src");
+}
+`;
+    const cacheCode = `
+async function collectSourceFiles(dir: string): Promise<void> {
+  await collectSourceFiles(dir + "/cached");
+}
+
+export async function computeFileHashes(): Promise<void> {
+  await collectSourceFiles("src");
+}
+`;
+    const byFile = new Map([
+        ["src/indexer/project-index.ts", typescriptPlugin.indexFile("src/indexer/project-index.ts", projectIndexCode)],
+        ["src/indexer/cache.ts", typescriptPlugin.indexFile("src/indexer/cache.ts", cacheCode)],
+    ]);
+    const symbols = [...normalizeIndexedSymbols(byFile).values()];
+    const projectFiles = new Map([
+        ["src/indexer/project-index.ts", projectIndexCode],
+        ["src/indexer/cache.ts", cacheCode],
+    ]);
+    const edges = typescriptPlugin.resolveDependencies(symbols, projectFiles);
+    const projectHelper = symbols.find((symbol) => symbol.name === "collectSourceFiles" && symbol.filePath === "src/indexer/project-index.ts");
+    const cacheHelper = symbols.find((symbol) => symbol.name === "collectSourceFiles" && symbol.filePath === "src/indexer/cache.ts");
+    assert.ok(projectHelper, "project-index helper should be uniquely preserved after normalization");
+    assert.ok(cacheHelper, "cache helper should be uniquely preserved after normalization");
+    const projectSelfEdge = edges.find((edge) => edge.from === projectHelper?.qualifiedName
+        && edge.to === projectHelper?.qualifiedName
+        && edge.kind === "calls");
+    const cacheSelfEdge = edges.find((edge) => edge.from === cacheHelper?.qualifiedName
+        && edge.to === cacheHelper?.qualifiedName
+        && edge.kind === "calls");
+    const crossFileEdge = edges.find((edge) => edge.from === projectHelper?.qualifiedName
+        && edge.to === cacheHelper?.qualifiedName
+        && edge.kind === "calls");
+    assert.ok(projectSelfEdge, "project-index helper should resolve recursive calls to itself");
+    assert.ok(cacheSelfEdge, "cache helper should resolve recursive calls to itself");
+    assert.ok(!crossFileEdge, "same-named helpers in other files should not be linked by default");
+});

package/dist/tests/mcp-and-plugin.test.js

@@ -0,0 +1,186 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createServer } from "node:http";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { parseCliArgs, validateCliArgs } from "../src/cli/args.js";
+// ── CLI args: plugin install ──
+test("parseCliArgs parses 'plugin install' subcommand", () => {
+    const parsed = parseCliArgs(["node", "src/index.ts", "plugin", "install"]);
+    assert.equal(parsed.pluginInstall, true);
+    assert.equal(parsed.serve, false);
+    assert.equal(parsed.oneshot, false);
+});
+test("parseCliArgs does not set pluginInstall for bare 'plugin'", () => {
+    const parsed = parseCliArgs(["node", "src/index.ts", "plugin"]);
+    assert.equal(parsed.pluginInstall, false);
+    assert.equal(parsed.task, "plugin");
+});
+test("validateCliArgs rejects plugin install with serve", () => {
+    assert.throws(() => validateCliArgs({
+        verbose: false, oneshot: false, json: false, serve: true,
+        port: 4567, task: "", pluginInstall: true,
+    }), /mutually exclusive/);
+});
+test("validateCliArgs rejects plugin install with oneshot", () => {
+    assert.throws(() => validateCliArgs({
+        verbose: false, oneshot: true, json: false, serve: false,
+        port: 4567, task: "test", pluginInstall: true,
+    }), /mutually exclusive/);
+});
+// ── MCP endpoint: malformed JSON ──
+test("MCP POST with malformed JSON returns 400 with JSON-RPC error", async () => {
+    // Import after top-level to avoid issues with module loading
+    const { createRequestHandler } = await import("../src/serve/server.js");
+    const { AgentBridge } = await import("../src/serve/agent-bridge.js");
+    // Create a minimal mock bridge
+    class MinimalBridge extends AgentBridge {
+        constructor() { super(() => { }, false); }
+        getConfig() {
+            return {
+                modelProvider: "openai-compatible",
+                model: "test",
+                maxSteps: 10,
+                maxTokens: 1024,
+                maxContextTokens: 4000,
+                workspaceRoot: "/tmp/mcp-test",
+                commandTimeoutMs: 5000,
+                maxFileSizeBytes: 100000,
+                commandDenylist: [],
+                confirmDestructive: false,
+                keepRecentMessages: 6,
+                loopDetectionWindow: 4,
+                maxToolOutputChars: 2000,
+                openAiBaseUrl: "http://localhost:1234/v1",
+            };
+        }
+    }
+    const bridge = new MinimalBridge();
+    const handler = createRequestHandler(bridge, () => { });
+    const server = createServer(handler);
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const addr = server.address();
+    try {
+        const res = await fetch(`http://127.0.0.1:${addr.port}/mcp`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: "this is not json{{{",
+        });
+        assert.equal(res.status, 400);
+        const body = await res.json();
+        assert.equal(body.jsonrpc, "2.0");
+        assert.equal(body.error.code, -32700);
+        assert.ok(body.error.message.includes("Parse error"));
+    }
+    finally {
+        server.close();
+    }
+});
+// ── MCP endpoint: missing session ID ──
+test("MCP POST without session ID and non-init request returns 400", async () => {
+    const { createRequestHandler } = await import("../src/serve/server.js");
+    const { AgentBridge } = await import("../src/serve/agent-bridge.js");
+    class MinimalBridge extends AgentBridge {
+        constructor() { super(() => { }, false); }
+        getConfig() {
+            return {
+                modelProvider: "openai-compatible",
+                model: "test",
+                maxSteps: 10,
+                maxTokens: 1024,
+                maxContextTokens: 4000,
+                workspaceRoot: "/tmp/mcp-test",
+                commandTimeoutMs: 5000,
+                maxFileSizeBytes: 100000,
+                commandDenylist: [],
+                confirmDestructive: false,
+                keepRecentMessages: 6,
+                loopDetectionWindow: 4,
+                maxToolOutputChars: 2000,
+                openAiBaseUrl: "http://localhost:1234/v1",
+            };
+        }
+    }
+    const bridge = new MinimalBridge();
+    const handler = createRequestHandler(bridge, () => { });
+    const server = createServer(handler);
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const addr = server.address();
+    try {
+        const res = await fetch(`http://127.0.0.1:${addr.port}/mcp`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", method: "tools/list", id: 1 }),
+        });
+        assert.equal(res.status, 400);
+        const body = await res.json();
+        assert.ok(body.error.includes("session"));
+    }
+    finally {
+        server.close();
+    }
+});
+// ── MCP endpoint: method not allowed ──
+test("MCP PATCH returns 405", async () => {
+    const { createRequestHandler } = await import("../src/serve/server.js");
+    const { AgentBridge } = await import("../src/serve/agent-bridge.js");
+    class MinimalBridge extends AgentBridge {
+        constructor() { super(() => { }, false); }
+        getConfig() {
+            return {
+                modelProvider: "openai-compatible",
+                model: "test",
+                maxSteps: 10,
+                maxTokens: 1024,
+                maxContextTokens: 4000,
+                workspaceRoot: "/tmp/mcp-test",
+                commandTimeoutMs: 5000,
+                maxFileSizeBytes: 100000,
+                commandDenylist: [],
+                confirmDestructive: false,
+                keepRecentMessages: 6,
+                loopDetectionWindow: 4,
+                maxToolOutputChars: 2000,
+                openAiBaseUrl: "http://localhost:1234/v1",
+            };
+        }
+    }
+    const bridge = new MinimalBridge();
+    const handler = createRequestHandler(bridge, () => { });
+    const server = createServer(handler);
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const addr = server.address();
+    try {
+        const res = await fetch(`http://127.0.0.1:${addr.port}/mcp`, {
+            method: "PATCH",
+        });
+        assert.equal(res.status, 405);
+    }
+    finally {
+        server.close();
+    }
+});
+// ── Plugin installer: resolves source dir ──
+test("plugin source directory contains plugin.json", async () => {
+    // Verify the plugin directory exists in the repo
+    const pluginJson = path.resolve(process.cwd(), "plugin/.claude-plugin/plugin.json");
+    assert.ok(existsSync(pluginJson), `Plugin manifest should exist at ${pluginJson}`);
+});
+test("plugin manifest has required fields", async () => {
+    const pluginJson = path.resolve(process.cwd(), "plugin/.claude-plugin/plugin.json");
+    const { readFile } = await import("node:fs/promises");
+    const content = JSON.parse(await readFile(pluginJson, "utf-8"));
+    assert.ok(content.name, "Plugin must have a name");
+    assert.equal(content.name, "minicode");
+    assert.ok(content.version, "Plugin must have a version");
+    assert.ok(content.description, "Plugin must have a description");
+});
+test("plugin .mcp.json references minicode MCP endpoint", async () => {
+    const mcpJson = path.resolve(process.cwd(), "plugin/.mcp.json");
+    assert.ok(existsSync(mcpJson), `.mcp.json should exist`);
+    const { readFile } = await import("node:fs/promises");
+    const content = JSON.parse(await readFile(mcpJson, "utf-8"));
+    assert.ok(content.mcpServers.minicode, "Should have a minicode server entry");
+    assert.equal(content.mcpServers.minicode.type, "http");
+    assert.ok(content.mcpServers.minicode.url.includes("/mcp"), "URL should point to /mcp");
+});

package/dist/tests/model-client-openai.test.js

@@ -73,6 +73,35 @@ test("openai-compatible client sends tool schemas and parses tool calls", async
     const tools = parsedBody.tools;
     assert.equal(tools[0]?.type, "function");
 });
+test("openai-compatible client sends correct app URL in HTTP-Referer header", async () => {
+    let capturedHeaders = {};
+    const fetchImpl = async (_input, init) => {
+        const rawHeaders = init?.headers;
+        capturedHeaders = rawHeaders ?? {};
+        return new Response(JSON.stringify({
+            choices: [
+                {
+                    finish_reason: "stop",
+                    message: { content: "hello", tool_calls: [] },
+                },
+            ],
+            usage: { prompt_tokens: 5, completion_tokens: 3 },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    await client.chat({
+        model: "test-model",
+        system: "sys",
+        messages: [{ role: "user", content: "hi" }],
+        tools: [],
+        maxTokens: 64,
+    });
+    assert.equal(capturedHeaders["HTTP-Referer"], "https://minicode.seanholung.com", "HTTP-Referer should point to minicode.seanholung.com");
+    assert.equal(capturedHeaders["X-Title"], "minicode");
+});
 test("createModelClient returns openai-compatible client", () => {
     const config = {
         ...createTestAgentConfig("/tmp"),