@sean.holung/minicode 0.1.0

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

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { OpenAICompatibleModelClient, createModelClient, } from "../src/model/client.js";
+import { createTestAgentConfig } from "./test-utils.js";
+test("openai-compatible client sends tool schemas and parses tool calls", async () => {
+    let capturedUrl = "";
+    let capturedBody = "";
+    const fetchImpl = async (input, init) => {
+        capturedUrl = String(input);
+        capturedBody = String(init?.body ?? "");
+        return new Response(JSON.stringify({
+            choices: [
+                {
+                    finish_reason: "tool_calls",
+                    message: {
+                        content: "",
+                        tool_calls: [
+                            {
+                                id: "call_1",
+                                type: "function",
+                                function: {
+                                    name: "read_file",
+                                    arguments: "{\"path\":\"src/index.ts\"}",
+                                },
+                            },
+                        ],
+                    },
+                },
+            ],
+            usage: {
+                prompt_tokens: 10,
+                completion_tokens: 5,
+            },
+        }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    const response = await client.chat({
+        model: "qwen2.5-coder-7b-instruct",
+        system: "System instructions",
+        messages: [{ role: "user", content: "Read src/index.ts" }],
+        tools: [
+            {
+                name: "read_file",
+                description: "Read a file",
+                input_schema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string" },
+                    },
+                    required: ["path"],
+                },
+            },
+        ],
+        maxTokens: 256,
+    });
+    assert.equal(capturedUrl, "http://localhost:1234/v1/chat/completions");
+    assert.equal(response.stopReason, "tool_use");
+    assert.equal(response.toolCalls.length, 1);
+    assert.equal(response.toolCalls[0]?.name, "read_file");
+    assert.deepEqual(response.toolCalls[0]?.input, { path: "src/index.ts" });
+    assert.equal(response.usage.inputTokens, 10);
+    assert.equal(response.usage.outputTokens, 5);
+    const parsedBody = JSON.parse(capturedBody);
+    const messages = parsedBody.messages;
+    assert.equal(messages[0]?.role, "system");
+    assert.equal(messages[1]?.role, "user");
+    const tools = parsedBody.tools;
+    assert.equal(tools[0]?.type, "function");
+});
+test("createModelClient returns openai-compatible client", () => {
+    const config = {
+        ...createTestAgentConfig("/tmp"),
+        modelProvider: "openai-compatible",
+        openAiBaseUrl: "http://localhost:1234/v1",
+    };
+    const client = createModelClient(config);
+    assert.ok(client instanceof OpenAICompatibleModelClient);
+});

package/dist/tests/read-symbol.test.js

@@ -0,0 +1,83 @@
+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 { createReadSymbolTool } from "../src/tools/read-symbol.js";
+import { ToolRegistry } from "../src/tools/registry.js";
+import { createTestAgentConfig } from "./test-utils.js";
+test("read_symbol returns correct function body", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createReadSymbolTool(config, projectIndex);
+    const result = await tool.execute({ name: "CodingAgent.runTurn" });
+    assert.ok(result.includes("# CodingAgent.runTurn"));
+    assert.ok(result.includes("src/agent/agent.ts"));
+    assert.ok(result.includes("Lines:"));
+    assert.ok(/\d+\|/.test(result), "should have line numbers");
+    assert.ok(result.includes("runTurn") || result.includes("session"));
+});
+test("read_symbol returns error for unknown symbol name", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createReadSymbolTool(config, projectIndex);
+    const result = await tool.execute({ name: "NonExistentSymbol123" });
+    assert.ok(result.includes("not found"));
+    assert.ok(result.includes("search") || result.includes("read_file"));
+});
+test("read_symbol with includeBody: false returns signature only", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createReadSymbolTool(config, projectIndex);
+    const result = await tool.execute({
+        name: "parseResponse",
+        includeBody: false,
+    });
+    assert.ok(result.includes("# parseResponse"));
+    assert.ok(result.includes("src/model/client.ts"));
+    assert.ok(!result.includes("return {"));
+    assert.ok(result.includes("ModelResponse") || result.includes("=>"));
+});
+test("read_symbol includes leading context and line numbers", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createReadSymbolTool(config, projectIndex);
+    const symbol = projectIndex.getSymbol("loadAgentConfig");
+    assert.ok(symbol, "loadAgentConfig should exist");
+    const result = await tool.execute({ name: "loadAgentConfig" });
+    assert.ok(result.includes("# loadAgentConfig"));
+    assert.ok(result.includes("src/agent/config.ts"));
+    assert.ok(/\d+\|/.test(result), "should have line numbers in output");
+});
+test("read_symbol appears in tool registry schemas when projectIndex provided", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    const registry = ToolRegistry.createDefault(config, projectIndex);
+    const schemas = registry.getToolSchemas();
+    const readSymbol = schemas.find((s) => s.name === "read_symbol");
+    assert.ok(readSymbol, "read_symbol should be in schemas");
+    assert.ok(readSymbol.description.includes("function") || readSymbol.description.includes("class"));
+    const props = readSymbol.input_schema.properties;
+    assert.ok(props && "name" in props);
+});
+test("read_symbol includes Referenced Types section for parseResponse", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createReadSymbolTool(config, projectIndex);
+    const result = await tool.execute({ name: "parseResponse" });
+    assert.ok(result.includes("## Referenced Types"));
+    assert.ok(result.includes("ModelResponse"));
+    assert.ok(result.includes("ToolCall"));
+});
+test("read_symbol is not in tool registry when projectIndex is undefined", () => {
+    const config = createTestAgentConfig("/tmp");
+    const registry = ToolRegistry.createDefault(config);
+    const schemas = registry.getToolSchemas();
+    const readSymbol = schemas.find((s) => s.name === "read_symbol");
+    assert.equal(readSymbol, undefined);
+});

package/dist/tests/search-code-map.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 { createSearchCodeMapTool } from "../src/tools/search-code-map.js";
+test("search_code_map finds symbols by substring", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createSearchCodeMapTool(projectIndex);
+    const result = await tool.execute({ pattern: "ModelResponse" });
+    assert.ok(result.includes("# Symbols matching"));
+    assert.ok(result.includes("ModelResponse"));
+});
+test("search_code_map returns empty when no match", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const projectIndex = await buildProjectIndex(root);
+    const tool = createSearchCodeMapTool(projectIndex);
+    const result = await tool.execute({ pattern: "XyZNoSymbol123" });
+    assert.ok(result.includes("No symbols matching"));
+});
+test("search_code_map 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 searchCodeMap = schemas.find((s) => s.name === "search_code_map");
+    assert.ok(searchCodeMap);
+});

package/dist/tests/session.test.js

@@ -0,0 +1,37 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Session } from "../src/session/session.js";
+test("session stores and returns messages", () => {
+    const session = new Session("test");
+    session.addMessage({ role: "user", content: "hello" });
+    session.addMessage({ role: "assistant", content: "world" });
+    const messages = session.getMessages();
+    assert.equal(messages.length, 2);
+    assert.equal(messages[0]?.role, "user");
+    assert.equal(messages[1]?.role, "assistant");
+});
+test("trim keeps recent messages while reducing token estimate", () => {
+    const session = new Session("test");
+    session.addMessage({ role: "user", content: "a".repeat(200) });
+    session.addMessage({
+        role: "assistant",
+        content: "thinking",
+        toolCalls: [{ id: "1", name: "read_file", input: { path: "x" } }],
+    });
+    session.addMessage({
+        role: "tool",
+        toolCallId: "1",
+        toolName: "read_file",
+        content: "tool-output",
+    });
+    session.addMessage({ role: "assistant", content: "done" });
+    const before = session.getTokenEstimate();
+    session.trim(30, 2);
+    const after = session.getTokenEstimate();
+    const messages = session.getMessages();
+    assert.ok(after <= before);
+    assert.equal(messages.length, 3);
+    assert.equal(messages[0]?.role, "assistant");
+    assert.equal(messages[1]?.role, "tool");
+    assert.equal(messages[2]?.role, "assistant");
+});

package/dist/tests/system-prompt.test.js

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { test } from "node:test";
+import { buildSystemPrompt } from "../src/prompt/system-prompt.js";
+function createMinimalConfig(workspaceRoot) {
+    return {
+        modelProvider: "openai-compatible",
+        model: "test",
+        maxSteps: 10,
+        maxTokens: 1024,
+        maxContextTokens: 16_000,
+        workspaceRoot,
+        commandTimeoutMs: 5000,
+        maxFileSizeBytes: 1_000_000,
+        commandDenylist: [],
+        confirmDestructive: false,
+        keepRecentMessages: 10,
+        loopDetectionWindow: 6,
+        maxToolOutputChars: 15_000,
+        openAiBaseUrl: "http://localhost:1234/v1",
+    };
+}
+const MINIMAL_TOOLS = [
+    {
+        name: "read_file",
+        description: "Read a file",
+        input_schema: { type: "object", properties: { path: { type: "string" } } },
+    },
+];
+const TOOLS_WITH_SEARCH_CODE_MAP = [
+    ...MINIMAL_TOOLS,
+    {
+        name: "search_code_map",
+        description: "Search the code map",
+        input_schema: { type: "object", properties: { pattern: { type: "string" } } },
+    },
+];
+test("buildSystemPrompt omits code map when undefined", () => {
+    const prompt = buildSystemPrompt(createMinimalConfig("/tmp"), MINIMAL_TOOLS);
+    assert.ok(!prompt.includes("[Project Code Map]"));
+    assert.ok(prompt.includes("[Identity]"));
+    assert.ok(prompt.includes("[Tool Descriptions]"));
+});
+test("buildSystemPrompt omits code map when empty", () => {
+    const prompt = buildSystemPrompt(createMinimalConfig("/tmp"), MINIMAL_TOOLS, { text: "", shownCount: 0, totalCount: 0 });
+    assert.ok(!prompt.includes("[Project Code Map]"));
+});
+test("buildSystemPrompt includes code map when provided", () => {
+    const codeMapResult = {
+        text: "# Project Code Map\n\n  src/foo.ts\n    function bar()",
+        shownCount: 1,
+        totalCount: 1,
+    };
+    const prompt = buildSystemPrompt(createMinimalConfig("/tmp"), MINIMAL_TOOLS, codeMapResult);
+    assert.ok(prompt.includes("[Project Code Map]"));
+    assert.ok(prompt.includes("src/foo.ts"));
+    assert.ok(prompt.includes("function bar()"));
+});
+test("buildSystemPrompt includes workspace context", () => {
+    const prompt = buildSystemPrompt(createMinimalConfig("/home/user/project"), MINIMAL_TOOLS);
+    assert.ok(prompt.includes("/home/user/project"));
+});
+test("buildSystemPrompt includes tool list", () => {
+    const prompt = buildSystemPrompt(createMinimalConfig("/tmp"), MINIMAL_TOOLS);
+    assert.ok(prompt.includes("read_file"));
+    assert.ok(prompt.includes("Read a file"));
+});
+test("buildSystemPrompt shows truncated stats and search_code_map hint when truncated", () => {
+    const codeMapResult = {
+        text: "# Project Code Map\n\n  src/foo.ts\n    function bar()",
+        shownCount: 5,
+        totalCount: 100,
+    };
+    const prompt = buildSystemPrompt(createMinimalConfig("/tmp"), TOOLS_WITH_SEARCH_CODE_MAP, codeMapResult);
+    assert.ok(prompt.includes("Showing 5 of 100 symbols"));
+    assert.ok(prompt.includes("search_code_map to find symbols not listed above"));
+});
+test("buildSystemPrompt detects project type from workspace", () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const prompt = buildSystemPrompt(createMinimalConfig(root), MINIMAL_TOOLS);
+    assert.ok(prompt.includes("Node.js") || prompt.includes("TypeScript"), "minicode has package.json");
+});

package/dist/tests/test-utils.js

@@ -0,0 +1,18 @@
+export function createTestAgentConfig(workspaceRoot) {
+    return {
+        modelProvider: "anthropic",
+        model: "test-model",
+        maxSteps: 10,
+        maxTokens: 1024,
+        maxContextTokens: 16_000,
+        workspaceRoot,
+        commandTimeoutMs: 2_000,
+        maxFileSizeBytes: 1_000_000,
+        commandDenylist: [],
+        confirmDestructive: false,
+        keepRecentMessages: 10,
+        loopDetectionWindow: 6,
+        maxToolOutputChars: 15_000,
+        openAiBaseUrl: "http://localhost:1234/v1",
+    };
+}

package/dist/tests/tool-registry.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { ToolRegistry } from "../src/tools/registry.js";
+const echoTool = {
+    name: "echo",
+    description: "Echo input value",
+    inputSchema: {
+        type: "object",
+        properties: {
+            value: { type: "string" },
+        },
+        required: ["value"],
+    },
+    execute: async (input) => `echo:${String(input.value)}`,
+};
+test("tool registry rejects duplicate tool names", () => {
+    assert.throws(() => new ToolRegistry([echoTool, echoTool]), /Duplicate tool registration/);
+});
+test("tool registry returns error for unknown tool", async () => {
+    const registry = new ToolRegistry([echoTool]);
+    const result = await registry.execute("missing", {});
+    assert.equal(result, 'Tool error: Unknown tool "missing".');
+});
+test("tool registry validates input shape", async () => {
+    const registry = new ToolRegistry([echoTool]);
+    const result = await registry.execute("echo", "bad-input");
+    assert.match(result, /Tool input must be a JSON object/);
+});
+test("tool registry returns wrapped tool execution errors", async () => {
+    const explodingTool = {
+        name: "explode",
+        description: "Always fails",
+        inputSchema: { type: "object", properties: {} },
+        execute: async () => {
+            throw new Error("boom");
+        },
+    };
+    const registry = new ToolRegistry([explodingTool]);
+    const result = await registry.execute("explode", {});
+    assert.equal(result, "Tool error (explode): boom");
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@sean.holung/minicode",
+  "version": "0.1.0",
+  "description": "A coding agent for mini models",
+  "type": "module",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "bin": {
+    "minicode": "dist/src/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "node --env-file=.env --import tsx src/index.ts",
+    "dev:ink": "CLI_UI_MODE=ink node --env-file=.env --import tsx src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/src/index.js",
+    "install:global": "npm run build && npm link",
+    "lint": "eslint \"src/**/*.ts\" \"src/**/*.tsx\" \"tests/**/*.ts\" --max-warnings=0",
+    "test": "node --test --import tsx \"tests/**/*.test.ts\"",
+    "verify-index": "node --import tsx test-programs/verify-index/verify.ts"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.76.0",
+    "@inkjs/ui": "^2.0.0",
+    "dotenv": "^17.3.1",
+    "ink": "^6.8.0",
+    "picocolors": "^1.1.1",
+    "react": "^19.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "@types/react": "^19.2.14",
+    "eslint": "^10.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.0"
+  }
+}