@sean.holung/minicode 0.1.1 → 0.2.1

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { ToolRegistry } from "../src/tools/registry.js";
+import { ToolRegistry } from "@minicode/agent-sdk";
 const echoTool = {
     name: "echo",
     description: "Echo input value",

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@sean.holung/minicode",
-  "version": "0.1.1",
+  "version": "0.2.1",
+  "workspaces": [
+    "packages/*"
+  ],
   "description": "A coding agent for mini models",
   "type": "module",
   "engines": {
@@ -17,16 +20,18 @@
   "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",
+    "build": "npm run build --workspace=packages/agent-sdk && tsc -p tsconfig.json && chmod +x dist/src/index.js",
     "start": "node dist/src/index.js",
     "install:global": "npm run build && npm link",
     "lint": "eslint \"src/**/*.ts\" \"src/**/*.tsx\" \"tests/**/*.ts\" --max-warnings=0",
+    "pretest": "npm run build --workspace=packages/agent-sdk",
     "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",
+    "@minicode/agent-sdk": "*",
     "dotenv": "^17.3.1",
     "ink": "^6.8.0",
     "picocolors": "^1.1.1",

package/dist/src/agent/agent.js

@@ -1,209 +0,0 @@
-import { buildSystemPrompt } from "../prompt/system-prompt.js";
-import { ensureStepWithinLimit } from "../safety/guardrails.js";
-import { Session } from "../session/session.js";
-function stableSerialize(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
-    }
-    if (value && typeof value === "object") {
-        const entries = Object.entries(value)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableSerialize(entryValue)}`);
-        return `{${entries.join(",")}}`;
-    }
-    return JSON.stringify(value);
-}
-function signatureForToolCall(toolCall) {
-    return `${toolCall.name}:${stableSerialize(toolCall.input)}`;
-}
-function formatToolCallForProgress(toolCall, maxArgsLen = 100) {
-    const argsStr = JSON.stringify(toolCall.input);
-    const truncated = argsStr.length > maxArgsLen
-        ? argsStr.slice(0, maxArgsLen) + "..."
-        : argsStr;
-    return `${toolCall.name}(${truncated})`;
-}
-const VERBOSE_SEP = "─".repeat(60);
-const PROGRESS_THINKING_MAX = 200;
-export class CodingAgent {
-    session;
-    config;
-    modelClient;
-    toolRegistry;
-    projectIndex;
-    verbose;
-    onProgress;
-    onUiUpdate;
-    constructor(params) {
-        this.config = params.config;
-        this.modelClient = params.modelClient;
-        this.toolRegistry = params.toolRegistry;
-        this.session = params.session ?? new Session();
-        this.projectIndex = params.projectIndex;
-        this.verbose = params.verbose ?? false;
-        this.onProgress = params.onProgress;
-        this.onUiUpdate = params.onUiUpdate;
-    }
-    getSession() {
-        return this.session;
-    }
-    async runTurn(userMessage, options) {
-        this.session.addMessage({
-            role: "user",
-            content: userMessage,
-        });
-        const toolSchemas = this.toolRegistry.getToolSchemas();
-        const codeMapResult = this.projectIndex?.getCodeMap();
-        const systemPrompt = buildSystemPrompt(this.config, toolSchemas, codeMapResult);
-        const recentToolCallFingerprints = [];
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        for (let step = 0; step < this.config.maxSteps; step += 1) {
-            ensureStepWithinLimit(step, this.config.maxSteps);
-            if (this.onUiUpdate) {
-                this.onUiUpdate({ type: "step", step });
-            }
-            this.session.trim(this.config.maxContextTokens, this.config.keepRecentMessages);
-            const messages = this.session.getMessages();
-            if (this.verbose) {
-                console.error(`\n${VERBOSE_SEP}`);
-                console.error(`[verbose] Request (step ${step})`);
-                console.error(`${VERBOSE_SEP}`);
-                console.error("\n[System Prompt]\n", systemPrompt);
-                console.error("\n[Messages]\n", JSON.stringify(messages, null, 2));
-                console.error(VERBOSE_SEP);
-            }
-            const response = await this.modelClient.chat({
-                model: this.config.model,
-                system: systemPrompt,
-                messages,
-                tools: toolSchemas,
-                maxTokens: this.config.maxTokens,
-                ...(this.onUiUpdate
-                    ? {
-                        onStream: (chunk) => {
-                            this.onUiUpdate({ type: "streaming_chunk", content: chunk });
-                        },
-                    }
-                    : {}),
-                ...(options?.signal && { signal: options.signal }),
-            });
-            totalInputTokens += response.usage.inputTokens;
-            totalOutputTokens += response.usage.outputTokens;
-            if (this.verbose) {
-                console.error(`\n${VERBOSE_SEP}`);
-                console.error("[verbose] Response");
-                console.error(`${VERBOSE_SEP}`);
-                console.error("Text:", response.text);
-                console.error("Tool calls:", response.toolCalls.length);
-                if (response.toolCalls.length > 0) {
-                    console.error("Tools:", response.toolCalls.map((t) => `${t.name}(${JSON.stringify(t.input)})`).join(", "));
-                }
-                console.error("Usage:", response.usage);
-                console.error(VERBOSE_SEP);
-            }
-            if (response.toolCalls.length === 0) {
-                const finalText = response.text.length > 0
-                    ? response.text
-                    : "The model returned no response or tool calls. If you asked for code changes or other work, try rephrasing your request or using a model with stronger tool-use support.";
-                this.session.addMessage({
-                    role: "assistant",
-                    content: finalText,
-                });
-                const streamed = this.config.modelProvider === "openai-compatible" && !!this.onUiUpdate;
-                return {
-                    text: finalText,
-                    usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
-                    streamed,
-                };
-            }
-            if (response.text.length > 0) {
-                const truncated = response.text.length > PROGRESS_THINKING_MAX
-                    ? response.text.slice(0, PROGRESS_THINKING_MAX) + "..."
-                    : response.text;
-                if (this.onProgress) {
-                    this.onProgress(`thinking: ${truncated}`);
-                }
-                if (this.onUiUpdate) {
-                    this.onUiUpdate({ type: "thinking", content: truncated });
-                }
-            }
-            this.session.addMessage({
-                role: "assistant",
-                content: response.text,
-                toolCalls: response.toolCalls,
-            });
-            for (const toolCall of response.toolCalls) {
-                const fingerprint = signatureForToolCall(toolCall);
-                recentToolCallFingerprints.push(fingerprint);
-                if (recentToolCallFingerprints.length >
-                    this.config.loopDetectionWindow) {
-                    recentToolCallFingerprints.shift();
-                }
-                const repeatedCalls = recentToolCallFingerprints.filter((value) => value === fingerprint).length;
-                if (repeatedCalls >= 3) {
-                    const loopMessage = "Stopped due to repeated identical tool calls. Please refine the prompt or provide additional constraints.";
-                    this.session.addMessage({
-                        role: "assistant",
-                        content: loopMessage,
-                    });
-                    return {
-                        text: loopMessage,
-                        usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
-                        streamed: false,
-                    };
-                }
-                if (this.onProgress) {
-                    this.onProgress(`tool_call: ${formatToolCallForProgress(toolCall)}`);
-                }
-                if (this.onUiUpdate) {
-                    this.onUiUpdate({
-                        type: "tool_call_start",
-                        name: toolCall.name,
-                        input: toolCall.input,
-                    });
-                }
-                if (this.verbose) {
-                    console.error(`\n${VERBOSE_SEP}`);
-                    console.error(`[verbose] Tool: ${toolCall.name}`);
-                    console.error("Arguments:", JSON.stringify(toolCall.input, null, 2));
-                }
-                const toolStartMs = Date.now();
-                let toolResult = await this.toolRegistry.execute(toolCall.name, toolCall.input);
-                const maxChars = this.config.maxToolOutputChars;
-                if (maxChars > 0 && toolResult.length > maxChars) {
-                    toolResult = `${toolResult.slice(0, maxChars)}\n\n[... truncated, ${toolResult.length - maxChars} more chars ...]`;
-                }
-                if (this.onUiUpdate) {
-                    this.onUiUpdate({
-                        type: "tool_call_end",
-                        name: toolCall.name,
-                        input: toolCall.input,
-                        result: toolResult,
-                        elapsedMs: Date.now() - toolStartMs,
-                    });
-                }
-                if (this.verbose) {
-                    console.error("Output:", toolResult);
-                    console.error(VERBOSE_SEP);
-                }
-                this.session.addMessage({
-                    role: "tool",
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    content: toolResult,
-                });
-            }
-        }
-        const stepLimitMessage = "Reached the maximum number of steps for this turn. I stopped to avoid an infinite loop.";
-        this.session.addMessage({
-            role: "assistant",
-            content: stepLimitMessage,
-        });
-        return {
-            text: stepLimitMessage,
-            usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
-            streamed: false,
-        };
-    }
-}

package/dist/src/agent/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/model/client.js

@@ -1,374 +0,0 @@
-import process from "node:process";
-import { setTimeout as sleep } from "node:timers/promises";
-import Anthropic from "@anthropic-ai/sdk";
-function toAnthropicMessages(messages) {
-    const converted = [];
-    for (const message of messages) {
-        if (message.role === "user") {
-            converted.push({
-                role: "user",
-                content: message.content,
-            });
-            continue;
-        }
-        if (message.role === "assistant") {
-            const content = [];
-            if (message.content.trim().length > 0) {
-                content.push({
-                    type: "text",
-                    text: message.content,
-                });
-            }
-            for (const toolCall of message.toolCalls ?? []) {
-                content.push({
-                    type: "tool_use",
-                    id: toolCall.id,
-                    name: toolCall.name,
-                    input: toolCall.input,
-                });
-            }
-            converted.push({
-                role: "assistant",
-                content: content.length > 0 ? content : "",
-            });
-            continue;
-        }
-        converted.push({
-            role: "user",
-            content: [
-                {
-                    type: "tool_result",
-                    tool_use_id: message.toolCallId,
-                    content: message.content,
-                },
-            ],
-        });
-    }
-    return converted;
-}
-function parseResponse(response) {
-    const textParts = [];
-    const toolCalls = [];
-    for (const block of response.content) {
-        if (block.type === "text") {
-            textParts.push(block.text);
-            continue;
-        }
-        if (block.type === "tool_use") {
-            toolCalls.push({
-                id: block.id,
-                name: block.name,
-                input: block.input,
-            });
-        }
-    }
-    return {
-        text: textParts.join("\n").trim(),
-        toolCalls,
-        stopReason: response.stop_reason === "tool_use"
-            ? "tool_use"
-            : response.stop_reason === "max_tokens"
-                ? "max_tokens"
-                : "end_turn",
-        usage: {
-            inputTokens: response.usage.input_tokens,
-            outputTokens: response.usage.output_tokens,
-        },
-    };
-}
-function isAbortError(error) {
-    return error instanceof Error && error.name === "AbortError";
-}
-async function withRetry(fn, attempts = 3) {
-    let lastError;
-    for (let attempt = 1; attempt <= attempts; attempt += 1) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            if (isAbortError(error)) {
-                throw error;
-            }
-            if (attempt === attempts) {
-                break;
-            }
-            const delayMs = 500 * 2 ** (attempt - 1);
-            await sleep(delayMs);
-        }
-    }
-    throw lastError;
-}
-function toOpenAICompatibleMessages(system, messages) {
-    const converted = [
-        {
-            role: "system",
-            content: system,
-        },
-    ];
-    for (const message of messages) {
-        if (message.role === "user") {
-            converted.push({
-                role: "user",
-                content: message.content,
-            });
-            continue;
-        }
-        if (message.role === "assistant") {
-            const toolCalls = message.toolCalls?.map((toolCall) => ({
-                id: toolCall.id,
-                type: "function",
-                function: {
-                    name: toolCall.name,
-                    arguments: JSON.stringify(toolCall.input),
-                },
-            }));
-            converted.push({
-                role: "assistant",
-                content: message.content.length > 0 ? message.content : null,
-                ...(toolCalls ? { tool_calls: toolCalls } : {}),
-            });
-            continue;
-        }
-        converted.push({
-            role: "tool",
-            tool_call_id: message.toolCallId,
-            content: message.content,
-        });
-    }
-    return converted;
-}
-function toOpenAICompatibleTools(tools) {
-    return tools.map((tool) => ({
-        type: "function",
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.input_schema,
-        },
-    }));
-}
-function parseOpenAICompatibleToolArguments(rawArguments) {
-    try {
-        const parsed = JSON.parse(rawArguments);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-            return parsed;
-        }
-    }
-    catch {
-        // Fall back to empty object when model emits malformed function arguments.
-    }
-    return {};
-}
-function parseOpenAICompatibleResponse(response) {
-    const firstChoice = response.choices?.[0];
-    const message = firstChoice?.message;
-    if (!message) {
-        throw new Error("OpenAI-compatible response missing choices[0].message.");
-    }
-    const toolCalls = message.tool_calls?.map((toolCall, index) => ({
-        id: toolCall.id || `tool-call-${index + 1}`,
-        name: toolCall.function.name,
-        input: parseOpenAICompatibleToolArguments(toolCall.function.arguments),
-    })) ?? [];
-    const finishReason = firstChoice?.finish_reason ?? null;
-    const stopReason = finishReason === "tool_calls" || finishReason === "function_call"
-        ? "tool_use"
-        : finishReason === "length"
-            ? "max_tokens"
-            : toolCalls.length > 0
-                ? "tool_use"
-                : "end_turn";
-    return {
-        text: (message.content ?? "").trim(),
-        toolCalls,
-        stopReason,
-        usage: {
-            inputTokens: response.usage?.prompt_tokens ?? 0,
-            outputTokens: response.usage?.completion_tokens ?? 0,
-        },
-    };
-}
-function normalizeBaseUrl(baseUrl) {
-    const trimmed = baseUrl.trim().replace(/\/+$/, "");
-    if (trimmed.length === 0) {
-        throw new Error("OPENAI_BASE_URL cannot be empty.");
-    }
-    return trimmed;
-}
-export class AnthropicModelClient {
-    client;
-    constructor(apiKey = process.env.ANTHROPIC_API_KEY) {
-        if (!apiKey) {
-            throw new Error("Missing ANTHROPIC_API_KEY. Copy .env.example to .env and set a key.");
-        }
-        this.client = new Anthropic({ apiKey });
-    }
-    async chat(params) {
-        const response = await withRetry(() => this.client.messages.create({
-            model: params.model,
-            max_tokens: params.maxTokens,
-            system: params.system,
-            messages: toAnthropicMessages(params.messages),
-            tools: params.tools,
-            stream: false,
-        }));
-        return parseResponse(response);
-    }
-}
-async function parseOpenAIStream(reader, onStream) {
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let content = "";
-    const toolCallsAcc = [];
-    const usage = { prompt_tokens: 0, completion_tokens: 0 };
-    let finishReason = null;
-    const processLines = (lines) => {
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed.startsWith("data: "))
-                continue;
-            const data = trimmed.slice(6).trim();
-            if (data === "[DONE]")
-                continue;
-            try {
-                const chunk = JSON.parse(data);
-                const choice = chunk.choices?.[0];
-                if (!choice)
-                    continue;
-                const delta = choice.delta;
-                if (delta?.content) {
-                    content += delta.content;
-                    onStream?.(delta.content);
-                }
-                if (delta?.tool_calls) {
-                    for (const tc of delta.tool_calls) {
-                        const idx = tc.index ?? 0;
-                        if (!toolCallsAcc[idx]) {
-                            toolCallsAcc[idx] = { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: tc.function?.arguments ?? "" };
-                        }
-                        else {
-                            if (tc.id)
-                                toolCallsAcc[idx].id = tc.id;
-                            if (tc.function?.name)
-                                toolCallsAcc[idx].name = tc.function.name;
-                            if (tc.function?.arguments)
-                                toolCallsAcc[idx].arguments += tc.function.arguments;
-                        }
-                    }
-                }
-                if (choice.finish_reason)
-                    finishReason = choice.finish_reason;
-                if (chunk.usage) {
-                    usage.prompt_tokens = chunk.usage.prompt_tokens ?? 0;
-                    usage.completion_tokens = chunk.usage.completion_tokens ?? 0;
-                }
-            }
-            catch {
-                // skip malformed chunks
-            }
-        }
-    };
-    while (true) {
-        const { done, value } = await reader.read();
-        if (value) {
-            buffer += decoder.decode(value, { stream: true });
-        }
-        const lines = buffer.split(/\r?\n/);
-        buffer = lines.pop() ?? "";
-        processLines(lines);
-        if (done) {
-            if (buffer.trim())
-                processLines([buffer]);
-            break;
-        }
-    }
-    const toolCalls = toolCallsAcc
-        .filter((tc) => tc.id || tc.name)
-        .map((tc, i) => ({
-        id: tc.id || `tool-call-${i + 1}`,
-        name: tc.name,
-        input: parseOpenAICompatibleToolArguments(tc.arguments),
-    }));
-    const stopReason = finishReason === "tool_calls" || finishReason === "function_call"
-        ? "tool_use"
-        : finishReason === "length"
-            ? "max_tokens"
-            : toolCalls.length > 0
-                ? "tool_use"
-                : "end_turn";
-    return {
-        text: content.trim(),
-        toolCalls,
-        stopReason,
-        usage: { inputTokens: usage.prompt_tokens, outputTokens: usage.completion_tokens },
-    };
-}
-export class OpenAICompatibleModelClient {
-    baseUrl;
-    apiKey;
-    fetchImpl;
-    constructor(params) {
-        this.baseUrl = normalizeBaseUrl(params?.baseUrl ?? process.env.OPENAI_BASE_URL ?? "http://localhost:1234/v1");
-        const isOpenRouter = this.baseUrl.includes("openrouter");
-        this.apiKey =
-            params?.apiKey ??
-                (isOpenRouter
-                    ? process.env.OPENROUTER_API_KEY ?? process.env.OPENAI_API_KEY
-                    : process.env.OPENAI_API_KEY);
-        this.fetchImpl = params?.fetchImpl ?? fetch;
-    }
-    async chat(params) {
-        const headers = {
-            "Content-Type": "application/json",
-        };
-        const apiKey = this.apiKey?.trim();
-        if (apiKey && apiKey.length > 0) {
-            if (this.baseUrl.includes("openrouter") &&
-                apiKey.startsWith("sk-proj-")) {
-                throw new Error("OpenRouter requires an OpenRouter API key (sk-or-v1-...), not an OpenAI key (sk-proj-...). Get one at https://openrouter.ai/keys");
-            }
-            headers.Authorization = `Bearer ${apiKey}`;
-        }
-        else if (this.baseUrl.includes("openrouter")) {
-            throw new Error("Missing OpenRouter API key. Set OPENAI_API_KEY or OPENROUTER_API_KEY in .env. Get one at https://openrouter.ai/keys");
-        }
-        const useStream = params.onStream !== undefined;
-        const response = await withRetry(async () => {
-            const httpResponse = await this.fetchImpl(`${this.baseUrl}/chat/completions`, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({
-                    model: params.model,
-                    messages: toOpenAICompatibleMessages(params.system, params.messages),
-                    tools: toOpenAICompatibleTools(params.tools),
-                    tool_choice: "auto",
-                    max_tokens: params.maxTokens,
-                    stream: useStream,
-                }),
-                ...(params.signal && { signal: params.signal }),
-            });
-            if (!httpResponse.ok) {
-                const bodyText = await httpResponse.text();
-                throw new Error(`OpenAI-compatible request failed (${httpResponse.status}): ${bodyText}`);
-            }
-            if (useStream && httpResponse.body) {
-                return parseOpenAIStream(httpResponse.body.getReader(), params.onStream);
-            }
-            const payload = (await httpResponse.json());
-            return parseOpenAICompatibleResponse(payload);
-        });
-        return response;
-    }
-}
-export function createModelClient(config) {
-    if (config.modelProvider === "openai-compatible") {
-        return new OpenAICompatibleModelClient({
-            baseUrl: config.openAiBaseUrl,
-            ...(config.openAiApiKey !== undefined
-                ? { apiKey: config.openAiApiKey }
-                : {}),
-        });
-    }
-    return new AnthropicModelClient();
-}