@sean.holung/minicode 0.3.2 → 0.3.3

package/dist/tests/model-selection.test.js

@@ -0,0 +1,136 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createServer } from "node:http";
+import { OpenAICompatibleModelClient } from "@minicode/agent-sdk";
+import { createRequestHandler } from "../src/serve/server.js";
+import { AgentBridge } from "../src/serve/agent-bridge.js";
+import { createTestAgentConfig } from "./test-utils.js";
+// ── OpenAI-compatible listModels ──
+test("openai-compatible listModels fetches /models and parses response", async () => {
+    const fetchImpl = async (input) => {
+        assert.ok(String(input).endsWith("/models"));
+        return new Response(JSON.stringify({
+            data: [
+                { id: "model-a", name: "Model A" },
+                { id: "model-b" },
+            ],
+        }), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    const models = await client.listModels();
+    assert.equal(models.length, 2);
+    assert.equal(models[0].id, "model-a");
+    assert.equal(models[0].name, "Model A");
+    assert.equal(models[1].id, "model-b");
+    assert.equal(models[1].name, "model-b"); // falls back to id
+});
+test("openai-compatible listModels returns empty array on error", async () => {
+    const fetchImpl = async () => {
+        return new Response("Server error", { status: 500 });
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    const models = await client.listModels();
+    assert.deepEqual(models, []);
+});
+test("openai-compatible listModels returns empty array on network failure", async () => {
+    const fetchImpl = async () => {
+        throw new Error("Connection refused");
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    const models = await client.listModels();
+    assert.deepEqual(models, []);
+});
+// ── Serve API /api/models and /api/model ──
+class MockBridgeForModels extends AgentBridge {
+    constructor() {
+        super(() => { }, false);
+    }
+    isBusy() {
+        return false;
+    }
+    getConfig() {
+        return createTestAgentConfig("/tmp/test-workspace");
+    }
+    async listModels() {
+        return [
+            { id: "model-z", name: "Zulu" },
+            { id: "model-a", name: "Alpha" },
+            { id: "model-m" },
+        ];
+    }
+    switchModel(modelId) {
+        this.getConfig().model = modelId;
+    }
+    async runTurn(message) {
+        return { text: `Echo: ${message}`, usage: { inputTokens: 1, outputTokens: 1 } };
+    }
+    async listSess() { return []; }
+    hasIndex() { return false; }
+}
+function startTestServer(bridge) {
+    return new Promise((resolve) => {
+        const handler = createRequestHandler(bridge);
+        const server = createServer(handler);
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            const port = typeof addr === "string" ? 0 : addr.port;
+            resolve({ server, port });
+        });
+    });
+}
+test("GET /api/models returns model list and active model", async () => {
+    const bridge = new MockBridgeForModels();
+    const { server, port } = await startTestServer(bridge);
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/models`);
+        assert.equal(res.status, 200);
+        const data = (await res.json());
+        assert.equal(data.models.length, 3);
+        assert.deepEqual(data.models.map((model) => model.id), ["model-a", "model-m", "model-z"]);
+        assert.equal(data.activeModel, "test-model");
+    }
+    finally {
+        server.close();
+    }
+});
+test("POST /api/model switches the active model", async () => {
+    const bridge = new MockBridgeForModels();
+    const { server, port } = await startTestServer(bridge);
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/model`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: "model-y" }),
+        });
+        assert.equal(res.status, 200);
+        const data = (await res.json());
+        assert.equal(data.model, "model-y");
+    }
+    finally {
+        server.close();
+    }
+});
+test("POST /api/model returns 400 when model is missing", async () => {
+    const bridge = new MockBridgeForModels();
+    const { server, port } = await startTestServer(bridge);
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/model`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({}),
+        });
+        assert.equal(res.status, 400);
+    }
+    finally {
+        server.close();
+    }
+});

package/dist/tests/model-utils.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { sortModelsAlphabetically } from "../src/model-utils.js";
+test("sortModelsAlphabetically sorts by display name without mutating input", () => {
+    const models = [
+        { id: "zeta-2", name: "Zeta 2" },
+        { id: "alpha-10", name: "alpha 10" },
+        { id: "alpha-2", name: "Alpha 2" },
+        { id: "beta-id" },
+    ];
+    const sorted = sortModelsAlphabetically(models);
+    assert.deepEqual(sorted.map((model) => model.id), ["alpha-2", "alpha-10", "beta-id", "zeta-2"]);
+    assert.deepEqual(models.map((model) => model.id), ["zeta-2", "alpha-10", "alpha-2", "beta-id"]);
+});
+test("sortModelsAlphabetically uses id as a stable tiebreaker", () => {
+    const models = [
+        { id: "gpt-4.1-b", name: "GPT-4.1" },
+        { id: "gpt-4.1-a", name: "GPT-4.1" },
+    ];
+    const sorted = sortModelsAlphabetically(models);
+    assert.deepEqual(sorted.map((model) => model.id), ["gpt-4.1-a", "gpt-4.1-b"]);
+});

package/dist/tests/reasoning-effort.test.js

@@ -0,0 +1,264 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { OpenAICompatibleModelClient, CodingAgent, ToolRegistry, } from "@minicode/agent-sdk";
+import { createTestAgentConfig } from "./test-utils.js";
+import { loadAgentConfig } from "../src/agent/config.js";
+// ---------------------------------------------------------------------------
+// Config: REASONING_EFFORT env var
+// ---------------------------------------------------------------------------
+test("loadAgentConfig parses REASONING_EFFORT env var", async () => {
+    const prev = process.env.REASONING_EFFORT;
+    try {
+        process.env.REASONING_EFFORT = "high";
+        const config = await loadAgentConfig("/tmp");
+        assert.equal(config.reasoningEffort, "high");
+    }
+    finally {
+        if (prev === undefined) {
+            delete process.env.REASONING_EFFORT;
+        }
+        else {
+            process.env.REASONING_EFFORT = prev;
+        }
+    }
+});
+test("loadAgentConfig ignores invalid REASONING_EFFORT values", async () => {
+    const prev = process.env.REASONING_EFFORT;
+    try {
+        process.env.REASONING_EFFORT = "ultra";
+        const config = await loadAgentConfig("/tmp");
+        assert.equal(config.reasoningEffort, undefined);
+    }
+    finally {
+        if (prev === undefined) {
+            delete process.env.REASONING_EFFORT;
+        }
+        else {
+            process.env.REASONING_EFFORT = prev;
+        }
+    }
+});
+test("loadAgentConfig leaves reasoningEffort undefined when env var is unset", async () => {
+    const prev = process.env.REASONING_EFFORT;
+    try {
+        delete process.env.REASONING_EFFORT;
+        const config = await loadAgentConfig("/tmp");
+        assert.equal(config.reasoningEffort, undefined);
+    }
+    finally {
+        if (prev === undefined) {
+            delete process.env.REASONING_EFFORT;
+        }
+        else {
+            process.env.REASONING_EFFORT = prev;
+        }
+    }
+});
+test("loadAgentConfig normalizes REASONING_EFFORT case", async () => {
+    const prev = process.env.REASONING_EFFORT;
+    try {
+        process.env.REASONING_EFFORT = "MEDIUM";
+        const config = await loadAgentConfig("/tmp");
+        assert.equal(config.reasoningEffort, "medium");
+    }
+    finally {
+        if (prev === undefined) {
+            delete process.env.REASONING_EFFORT;
+        }
+        else {
+            process.env.REASONING_EFFORT = prev;
+        }
+    }
+});
+// ---------------------------------------------------------------------------
+// OpenAI-compatible client: reasoning field in request body
+// ---------------------------------------------------------------------------
+test("openai-compatible client includes reasoning field when reasoningEffort is set", async () => {
+    let capturedBody = "";
+    const fetchImpl = async (_input, init) => {
+        capturedBody = String(init?.body ?? "");
+        return new Response(JSON.stringify({
+            choices: [
+                {
+                    finish_reason: "stop",
+                    message: { content: "Hello", tool_calls: [] },
+                },
+            ],
+            usage: { prompt_tokens: 10, completion_tokens: 5 },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    await client.chat({
+        model: "test-model",
+        system: "System",
+        messages: [{ role: "user", content: "Hi" }],
+        tools: [],
+        maxTokens: 1024,
+        reasoningEffort: "high",
+    });
+    const parsed = JSON.parse(capturedBody);
+    assert.deepEqual(parsed.reasoning, { effort: "high" });
+});
+test("openai-compatible client omits reasoning field when reasoningEffort is not set", async () => {
+    let capturedBody = "";
+    const fetchImpl = async (_input, init) => {
+        capturedBody = String(init?.body ?? "");
+        return new Response(JSON.stringify({
+            choices: [
+                {
+                    finish_reason: "stop",
+                    message: { content: "Hello", tool_calls: [] },
+                },
+            ],
+            usage: { prompt_tokens: 10, completion_tokens: 5 },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    await client.chat({
+        model: "test-model",
+        system: "System",
+        messages: [{ role: "user", content: "Hi" }],
+        tools: [],
+        maxTokens: 1024,
+    });
+    const parsed = JSON.parse(capturedBody);
+    assert.equal(parsed.reasoning, undefined);
+});
+test("openai-compatible client sends all valid effort levels", async () => {
+    const levels = ["xhigh", "high", "medium", "low", "minimal", "none"];
+    for (const level of levels) {
+        let capturedBody = "";
+        const fetchImpl = async (_input, init) => {
+            capturedBody = String(init?.body ?? "");
+            return new Response(JSON.stringify({
+                choices: [
+                    {
+                        finish_reason: "stop",
+                        message: { content: "Ok", tool_calls: [] },
+                    },
+                ],
+                usage: { prompt_tokens: 5, completion_tokens: 2 },
+            }), { status: 200, headers: { "content-type": "application/json" } });
+        };
+        const client = new OpenAICompatibleModelClient({
+            baseUrl: "http://localhost:1234/v1",
+            fetchImpl,
+        });
+        await client.chat({
+            model: "test-model",
+            system: "System",
+            messages: [{ role: "user", content: "Hi" }],
+            tools: [],
+            maxTokens: 1024,
+            reasoningEffort: level,
+        });
+        const parsed = JSON.parse(capturedBody);
+        assert.deepEqual(parsed.reasoning, { effort: level }, `Expected reasoning.effort="${level}"`);
+    }
+});
+// ---------------------------------------------------------------------------
+// CodingAgent: get/set reasoning effort
+// ---------------------------------------------------------------------------
+test("CodingAgent.getReasoningEffort returns config value", () => {
+    const config = {
+        ...createTestAgentConfig("/tmp"),
+        reasoningEffort: "medium",
+    };
+    const mockClient = {
+        async chat() {
+            return {
+                text: "done",
+                toolCalls: [],
+                stopReason: "end_turn",
+                usage: { inputTokens: 0, outputTokens: 0 },
+            };
+        },
+    };
+    const agent = new CodingAgent({
+        config,
+        modelClient: mockClient,
+        toolRegistry: new ToolRegistry([]),
+    });
+    assert.equal(agent.getReasoningEffort(), "medium");
+});
+test("CodingAgent.setReasoningEffort updates reasoning effort", () => {
+    const config = createTestAgentConfig("/tmp");
+    const mockClient = {
+        async chat() {
+            return {
+                text: "done",
+                toolCalls: [],
+                stopReason: "end_turn",
+                usage: { inputTokens: 0, outputTokens: 0 },
+            };
+        },
+    };
+    const agent = new CodingAgent({
+        config,
+        modelClient: mockClient,
+        toolRegistry: new ToolRegistry([]),
+    });
+    assert.equal(agent.getReasoningEffort(), undefined);
+    agent.setReasoningEffort("high");
+    assert.equal(agent.getReasoningEffort(), "high");
+    agent.setReasoningEffort("none");
+    assert.equal(agent.getReasoningEffort(), "none");
+    agent.setReasoningEffort(undefined);
+    assert.equal(agent.getReasoningEffort(), undefined);
+});
+// ---------------------------------------------------------------------------
+// Agent loop passes reasoningEffort to model client
+// ---------------------------------------------------------------------------
+test("agent loop passes reasoningEffort to model client chat call", async () => {
+    let capturedReasoningEffort;
+    const config = {
+        ...createTestAgentConfig("/tmp"),
+        reasoningEffort: "low",
+    };
+    const mockClient = {
+        async chat(params) {
+            capturedReasoningEffort = params.reasoningEffort;
+            return {
+                text: "Response",
+                toolCalls: [],
+                stopReason: "end_turn",
+                usage: { inputTokens: 10, outputTokens: 5 },
+            };
+        },
+    };
+    const agent = new CodingAgent({
+        config,
+        modelClient: mockClient,
+        toolRegistry: new ToolRegistry([]),
+    });
+    await agent.runTurn("Hello");
+    assert.equal(capturedReasoningEffort, "low");
+});
+test("agent loop omits reasoningEffort when not configured", async () => {
+    let capturedParams = {};
+    const config = createTestAgentConfig("/tmp");
+    const mockClient = {
+        async chat(params) {
+            capturedParams = params;
+            return {
+                text: "Response",
+                toolCalls: [],
+                stopReason: "end_turn",
+                usage: { inputTokens: 10, outputTokens: 5 },
+            };
+        },
+    };
+    const agent = new CodingAgent({
+        config,
+        modelClient: mockClient,
+        toolRegistry: new ToolRegistry([]),
+    });
+    await agent.runTurn("Hello");
+    assert.equal(capturedParams.reasoningEffort, undefined);
+});

package/dist/tests/run-benchmarks.test.js

@@ -0,0 +1,161 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { test } from "node:test";
+import { parseArgs, buildConfig, loadTasks } from "../scripts/run-benchmarks.js";
+// ─── parseArgs ────────────────────────────────────────────────────
+test("parseArgs: defaults to variant 'ci' with no flags", () => {
+    const args = parseArgs([]);
+    assert.equal(args.variant, "ci");
+    assert.equal(args.category, undefined);
+    assert.equal(args.task, undefined);
+    assert.equal(args.out, undefined);
+});
+test("parseArgs: parses --variant flag", () => {
+    const args = parseArgs(["--variant", "nightly"]);
+    assert.equal(args.variant, "nightly");
+});
+test("parseArgs: parses --category flag", () => {
+    const args = parseArgs(["--category", "navigation"]);
+    assert.equal(args.category, "navigation");
+});
+test("parseArgs: parses --task flag", () => {
+    const args = parseArgs(["--task", "navigation/find-symbol-definition"]);
+    assert.equal(args.task, "navigation/find-symbol-definition");
+});
+test("parseArgs: parses --out flag", () => {
+    const args = parseArgs(["--out", "report.json"]);
+    assert.equal(args.out, "report.json");
+});
+test("parseArgs: parses all flags together", () => {
+    const args = parseArgs([
+        "--category", "editing",
+        "--variant", "v2",
+        "--out", "/tmp/report.json",
+    ]);
+    assert.equal(args.category, "editing");
+    assert.equal(args.variant, "v2");
+    assert.equal(args.out, "/tmp/report.json");
+});
+test("parseArgs: ignores unknown flags", () => {
+    const args = parseArgs(["--unknown", "value", "--variant", "test"]);
+    assert.equal(args.variant, "test");
+});
+// ─── buildConfig ──────────────────────────────────────────────────
+test("buildConfig: returns defaults when no env vars set", () => {
+    const originalProvider = process.env.MODEL_PROVIDER;
+    const originalModel = process.env.MODEL;
+    delete process.env.MODEL_PROVIDER;
+    delete process.env.MODEL;
+    try {
+        const config = buildConfig();
+        assert.equal(config.modelProvider, "openai-compatible");
+        assert.equal(config.model, "test-model");
+        assert.equal(config.maxSteps, 50);
+        assert.equal(config.maxTokens, 4096);
+        assert.equal(config.maxContextTokens, 32000);
+        assert.equal(config.confirmDestructive, false);
+    }
+    finally {
+        if (originalProvider !== undefined)
+            process.env.MODEL_PROVIDER = originalProvider;
+        if (originalModel !== undefined)
+            process.env.MODEL = originalModel;
+    }
+});
+test("buildConfig: reads MODEL_PROVIDER and MODEL from env", () => {
+    const originalProvider = process.env.MODEL_PROVIDER;
+    const originalModel = process.env.MODEL;
+    process.env.MODEL_PROVIDER = "anthropic";
+    process.env.MODEL = "claude-test";
+    try {
+        const config = buildConfig();
+        assert.equal(config.modelProvider, "anthropic");
+        assert.equal(config.model, "claude-test");
+    }
+    finally {
+        if (originalProvider !== undefined) {
+            process.env.MODEL_PROVIDER = originalProvider;
+        }
+        else {
+            delete process.env.MODEL_PROVIDER;
+        }
+        if (originalModel !== undefined) {
+            process.env.MODEL = originalModel;
+        }
+        else {
+            delete process.env.MODEL;
+        }
+    }
+});
+// ─── loadTasks ────────────────────────────────────────────────────
+let tmpDir;
+async function setupTempTasks() {
+    tmpDir = await mkdtemp(path.join(tmpdir(), "bench-cli-test-"));
+    await mkdir(path.join(tmpDir, "navigation", "find-foo"), { recursive: true });
+    await mkdir(path.join(tmpDir, "editing", "fix-bar"), { recursive: true });
+    await writeFile(path.join(tmpDir, "navigation", "find-foo", "task.json"), JSON.stringify({
+        title: "Find foo",
+        prompt: "Find foo",
+        rubric: { expectedOutputPatterns: ["foo"] },
+    }));
+    await writeFile(path.join(tmpDir, "editing", "fix-bar", "task.json"), JSON.stringify({
+        title: "Fix bar",
+        prompt: "Fix bar",
+        rubric: { expectedOutputPatterns: ["bar"] },
+    }));
+    return tmpDir;
+}
+test("loadTasks: loads all tasks when no filter", async () => {
+    const dir = await setupTempTasks();
+    try {
+        const tasks = await loadTasks(dir, { variant: "ci" });
+        assert.equal(tasks.length, 2);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+});
+test("loadTasks: filters by category", async () => {
+    const dir = await setupTempTasks();
+    try {
+        const tasks = await loadTasks(dir, { variant: "ci", category: "navigation" });
+        assert.equal(tasks.length, 1);
+        assert.ok(tasks[0]);
+        assert.equal(tasks[0].category, "navigation");
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+});
+test("loadTasks: loads single task by id", async () => {
+    const dir = await setupTempTasks();
+    try {
+        const tasks = await loadTasks(dir, { variant: "ci", task: "navigation/find-foo" });
+        assert.equal(tasks.length, 1);
+        assert.ok(tasks[0]);
+        assert.equal(tasks[0].id, "navigation/find-foo");
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+});
+test("loadTasks: throws for unknown task id", async () => {
+    const dir = await setupTempTasks();
+    try {
+        await assert.rejects(() => loadTasks(dir, { variant: "ci", task: "navigation/nonexistent" }), { message: "Task not found: navigation/nonexistent" });
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+});
+test("loadTasks: throws for unknown category", async () => {
+    const dir = await setupTempTasks();
+    try {
+        await assert.rejects(() => loadTasks(dir, { variant: "ci", category: "nonexistent" }), { message: "No tasks found for category: nonexistent" });
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+});

package/dist/tests/search-code-map.test.js

@@ -1,5 +1,7 @@
 import assert from "node:assert/strict";
+import { mkdtemp, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { tmpdir } from "node:os";
 import { test } from "node:test";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createSearchCodeMapTool } from "../src/tools/search-code-map.js";
@@ -28,3 +30,19 @@ test("search_code_map appears in tool registry when projectIndex provided", asyn
     const searchCodeMap = schemas.find((s) => s.name === "search_code_map");
     assert.ok(searchCodeMap);
 });
+test("search_code_map shows colliding symbols with disambiguated display names", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-search-collisions-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export interface Employee {
+  id: string;
+}
+
+export class Employee {
+  constructor(public id: string) {}
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createSearchCodeMapTool(projectIndex);
+    const result = await tool.execute({ pattern: "Employee" });
+    assert.ok(result.includes("Employee (interface)"));
+    assert.ok(result.includes("Employee (class)"));
+});