@heyamiko/amiko-cli 0.4.11 → 0.5.0

package/dist/__tests__/cli-non-tty.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { execFile } from "node:child_process";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const CLI_PATH = join(__dirname, "..", "..", "dist", "cli.js");
-function runCli(args = [], stdin) {
-    return new Promise((resolve) => {
-        const child = execFile("node", [CLI_PATH, ...args], {
-            timeout: 10000,
-            env: { ...process.env, HOME: "/tmp/amiko-cli-test" },
-        }, (error, stdout, stderr) => {
-            resolve({
-                stdout: stdout || "",
-                stderr: stderr || "",
-                code: error?.code === "ETIMEDOUT" ? 0 : error?.status ?? 0,
-            });
-        });
-        if (stdin !== undefined) {
-            child.stdin?.write(stdin);
-        }
-        child.stdin?.end();
-    });
-}
-describe("amiko-cli non-TTY behavior", () => {
-    it("does not crash with RangeError in piped mode", async () => {
-        const result = await runCli();
-        const combined = result.stdout + result.stderr;
-        expect(combined).not.toContain("RangeError");
-        expect(combined).not.toContain("Invalid count value");
-    });
-    it("enters headless mode when stdin is not a TTY", async () => {
-        const result = await runCli([], "/help\n");
-        const combined = result.stdout + result.stderr;
-        expect(combined).toContain("headless");
-        expect(combined).toContain("Commands:");
-    });
-    it("--headless flag is recognized", async () => {
-        const result = await runCli(["--headless"], "/help\n");
-        const combined = result.stdout + result.stderr;
-        expect(combined).toContain("headless");
-        expect(combined).toContain("Commands:");
-    });
-    it("headless /help lists available commands", async () => {
-        const result = await runCli([], "/help\n");
-        expect(result.stdout).toContain("/exit");
-        expect(result.stdout).toContain("/memory");
-        expect(result.stdout).toContain("/model");
-        expect(result.stdout).toContain("/search");
-    });
-});
-describe("String.repeat patch", () => {
-    it("clamps negative values to empty string", () => {
-        const origRepeat = String.prototype.repeat;
-        String.prototype.repeat = function (count) {
-            return origRepeat.call(this, Math.max(0, Math.floor(count)));
-        };
-        try {
-            expect("─".repeat(-2)).toBe("");
-            expect("─".repeat(-1)).toBe("");
-            expect("─".repeat(0)).toBe("");
-            expect("─".repeat(1)).toBe("─");
-            expect("─".repeat(3)).toBe("───");
-            expect("x".repeat(2.9)).toBe("xx");
-        }
-        finally {
-            String.prototype.repeat = origRepeat;
-        }
-    });
-    it("original String.repeat throws on negative values", () => {
-        expect(() => "x".repeat(-2)).toThrow(RangeError);
-        expect(() => "x".repeat(-1)).toThrow(RangeError);
-    });
-});

package/dist/agent/piAgent.js

@@ -1,239 +0,0 @@
-import { Agent } from "@mariozechner/pi-agent-core";
-import { getEnvApiKey, getModel, getModels, getProviders } from "@mariozechner/pi-ai";
-import { createBashTool, createReadTool } from "./tools.js";
-function createQueue() {
-    const queue = [];
-    let pending = null;
-    return {
-        push(value) {
-            if (pending) {
-                const resolve = pending;
-                pending = null;
-                resolve(value);
-                return;
-            }
-            queue.push(value);
-        },
-        end() {
-            if (pending) {
-                const resolve = pending;
-                pending = null;
-                resolve(null);
-                return;
-            }
-            queue.push(null);
-        },
-        async *iterate() {
-            while (true) {
-                if (queue.length > 0) {
-                    const value = queue.shift();
-                    if (value === null)
-                        return;
-                    yield value;
-                    continue;
-                }
-                const value = await new Promise((resolve) => {
-                    pending = resolve;
-                });
-                if (value === null)
-                    return;
-                yield value;
-            }
-        }
-    };
-}
-function resolveModel(config) {
-    if (config.model) {
-        const [provider, ...rest] = config.model.split("/");
-        const modelId = rest.join("/");
-        if (provider && modelId) {
-            return { provider, modelId };
-        }
-    }
-    if (config.modelProvider && config.modelId) {
-        return { provider: config.modelProvider, modelId: config.modelId };
-    }
-    return null;
-}
-const PROVIDER_PRIORITY = [
-    "openai",
-    "anthropic",
-    "openrouter",
-    "google",
-    "groq",
-    "mistral",
-    "xai",
-    "cerebras",
-    "openai-codex",
-    "azure-openai-responses",
-    "amazon-bedrock",
-    "google-vertex",
-    "google-gemini-cli",
-    "vercel-ai-gateway",
-    "zai",
-    "minimax",
-    "minimax-cn",
-    "opencode",
-    "github-copilot"
-];
-const DEFAULT_MODEL_BY_PROVIDER = {
-    openai: ["gpt-4.1", "gpt-4.1-mini", "gpt-4o-mini", "gpt-4o"],
-    anthropic: ["claude-3-5-sonnet-latest", "claude-3-5-sonnet-20241022", "claude-3-5-sonnet-20240620"],
-    openrouter: ["openai/gpt-4.1", "openai/gpt-4.1-mini", "anthropic/claude-3.5-sonnet"],
-    google: ["gemini-2.5-flash-lite-preview-06-17", "gemini-2.5-pro-preview-06-17", "gemini-1.5-pro"],
-    groq: ["llama-3.1-70b-versatile", "llama-3.1-8b-instant"],
-    mistral: ["mistral-large-latest", "mistral-small-latest"],
-    xai: ["grok-2-latest", "grok-2"],
-    cerebras: ["llama3.1-70b", "llama3.1-8b"],
-    "openai-codex": ["gpt-5.1-codex-max", "gpt-5.2-codex", "gpt-5.2"]
-};
-function pickDefaultModelId(provider) {
-    const models = getModels(provider);
-    if (models.length === 0)
-        return null;
-    const preferred = DEFAULT_MODEL_BY_PROVIDER[provider] || [];
-    for (const id of preferred) {
-        if (models.some((m) => m.id === id))
-            return id;
-    }
-    return models.map((m) => m.id).sort()[0] || null;
-}
-function pickAutoModel() {
-    const providers = getProviders();
-    const providersWithKeys = providers.filter((provider) => Boolean(getEnvApiKey(provider)));
-    if (providersWithKeys.length === 0)
-        return null;
-    const ordered = PROVIDER_PRIORITY.filter((p) => providersWithKeys.includes(p));
-    const provider = ordered[0] || providersWithKeys.sort()[0];
-    if (!provider)
-        return null;
-    const modelId = pickDefaultModelId(provider);
-    if (!modelId)
-        return null;
-    return { provider, modelId };
-}
-export async function createPiAgent(config) {
-    const modelInfo = resolveModel(config) || pickAutoModel();
-    const model = modelInfo ? getModel(modelInfo.provider, modelInfo.modelId) : undefined;
-    if (modelInfo) {
-        if (!model) {
-            return fallbackAgent(`Unknown model ${modelInfo.provider}/${modelInfo.modelId}.`);
-        }
-        const apiKey = getEnvApiKey(modelInfo.provider);
-        if (!apiKey) {
-            return fallbackAgent(`No API key found for ${modelInfo.provider}. Set the provider env var or run /login ${modelInfo.provider}.`);
-        }
-    }
-    const initialState = {
-        thinkingLevel: config.thinkingLevel ?? "off",
-        systemPrompt: "",
-        tools: [createReadTool({ root: process.cwd() }), createBashTool({ cwd: process.cwd() })],
-        messages: []
-    };
-    if (model)
-        initialState.model = model;
-    const agent = new Agent({
-        initialState,
-        getApiKey: (provider) => getEnvApiKey(provider)
-    });
-    const eventListeners = [];
-    agent.subscribe((event) => {
-        for (const listener of eventListeners) {
-            listener(event);
-        }
-    });
-    return {
-        async *streamReply(input) {
-            const queue = createQueue();
-            let ended = false;
-            const endOnce = () => {
-                if (ended)
-                    return;
-                ended = true;
-                queue.end();
-            };
-            agent.setSystemPrompt(input.prompt);
-            let toolErrors = 0;
-            const maxToolErrors = 3;
-            const provider = agent.state?.model?.provider;
-            if (provider && !getEnvApiKey(provider)) {
-                queue.push(`\n[amiko] No API key configured for ${provider}.\n` +
-                    `Set the provider env var and retry, e.g. OPENAI_API_KEY or ANTHROPIC_API_KEY.\n` +
-                    `Then run /model <provider>/<modelId>.\n`);
-                endOnce();
-                yield* queue.iterate();
-                return;
-            }
-            const unsubscribe = agent.subscribe((event) => {
-                if (event?.type === "message_update") {
-                    const msg = event.assistantMessageEvent;
-                    if (msg?.type === "text_delta") {
-                        const delta = typeof msg.delta === "string" ? msg.delta : msg.textDelta;
-                        if (typeof delta === "string")
-                            queue.push(delta);
-                    }
-                }
-                if (event?.type === "tool_execution_end" && event.isError) {
-                    toolErrors += 1;
-                    if (toolErrors >= maxToolErrors) {
-                        queue.push("\n[amiko] Tool execution failed too many times. Aborting this response.\n");
-                        agent.abort();
-                        endOnce();
-                    }
-                }
-                if (event?.type === "agent_end") {
-                    endOnce();
-                }
-            });
-            try {
-                await agent.prompt(input.userMessage);
-            }
-            catch (error) {
-                queue.push(`\n[amiko] Agent error: ${error.message || "unknown"}\n`);
-            }
-            finally {
-                unsubscribe();
-                endOnce();
-            }
-            yield* queue.iterate();
-        },
-        setModel(provider, modelId) {
-            const resolved = getModel(provider, modelId);
-            if (!resolved) {
-                return { ok: false, message: `Unknown model ${provider}/${modelId}.` };
-            }
-            const apiKey = getEnvApiKey(provider);
-            if (!apiKey) {
-                return {
-                    ok: false,
-                    message: `No API key found for ${provider}. Set the provider env var or run /login ${provider}.`
-                };
-            }
-            agent.setModel(resolved);
-            return { ok: true, message: `Using model ${provider}/${modelId}.` };
-        },
-        getCurrentModel() {
-            const current = agent.state?.model;
-            if (!current)
-                return null;
-            return `${current.provider}/${current.id}`;
-        },
-        onEvent(handler) {
-            eventListeners.push(handler);
-        }
-    };
-}
-function fallbackAgent(reason) {
-    return {
-        async *streamReply(input) {
-            const message = [
-                "[amiko] Agent backend unavailable.",
-                `Reason: ${reason}`,
-                "Configure AMIKO_MODEL or AMIKO_MODEL_PROVIDER/AMIKO_MODEL_ID and API keys.",
-                "Echoing your input:",
-                input.userMessage
-            ].join("\n");
-            yield message;
-        }
-    };
-}

package/dist/agent/tools.js

@@ -1,149 +0,0 @@
-import fs from "node:fs/promises";
-import fsSync from "node:fs";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import os from "node:os";
-import { Type } from "@sinclair/typebox";
-const MAX_OUTPUT_BYTES = 200_000;
-function textContent(text) {
-    return { type: "text", text };
-}
-function resolvePath(root, targetPath) {
-    if (path.isAbsolute(targetPath))
-        return targetPath;
-    return path.resolve(root, targetPath);
-}
-function expandTilde(value) {
-    if (!value)
-        return value;
-    if (value === "~")
-        return os.homedir();
-    if (value.startsWith("~/"))
-        return path.join(os.homedir(), value.slice(2));
-    return value;
-}
-function resolveShell() {
-    const candidates = [process.env.SHELL, "/bin/zsh", "/bin/bash", "/bin/sh"].filter(Boolean);
-    for (const candidate of candidates) {
-        try {
-            if (fsSync.existsSync(candidate))
-                return candidate;
-        }
-        catch {
-            // ignore
-        }
-    }
-    return undefined;
-}
-export function createReadTool(options) {
-    return {
-        name: "read",
-        label: "read",
-        description: "Read a file from disk",
-        parameters: Type.Object({
-            path: Type.String({ description: "Path to the file" }),
-            maxBytes: Type.Optional(Type.Number({ description: "Max bytes to read" }))
-        }),
-        async execute(_toolCallId, params) {
-            const filePath = resolvePath(options.root, expandTilde(params.path));
-            const maxBytes = params.maxBytes ?? MAX_OUTPUT_BYTES;
-            try {
-                const data = await fs.readFile(filePath);
-                const sliced = data.subarray(0, Math.max(0, maxBytes));
-                const text = sliced.toString("utf8");
-                const suffix = data.length > sliced.length ? `\n[truncated ${data.length - sliced.length} bytes]` : "";
-                return { content: [textContent(text + suffix)], details: { path: filePath, bytes: sliced.length } };
-            }
-            catch (error) {
-                const message = error.message || "read failed";
-                return {
-                    content: [textContent(`Error reading ${filePath}: ${message}`)],
-                    details: { path: filePath, error: message }
-                };
-            }
-        }
-    };
-}
-export function createBashTool(options) {
-    return {
-        name: "bash",
-        label: "bash",
-        description: "Execute a shell command",
-        parameters: Type.Object({
-            command: Type.String({ description: "Shell command to execute" }),
-            cwd: Type.Optional(Type.String({ description: "Working directory" })),
-            timeoutMs: Type.Optional(Type.Number({ description: "Timeout in milliseconds" }))
-        }),
-        execute(_toolCallId, params, signal) {
-            const cwd = params.cwd ? resolvePath(options.cwd, expandTilde(params.cwd)) : options.cwd;
-            const timeoutMs = params.timeoutMs ?? 30_000;
-            const shell = resolveShell();
-            return new Promise((resolve) => {
-                if (!shell) {
-                    resolve({
-                        content: [textContent("Error running command: no shell available in environment")],
-                        details: { cwd, code: null, timedOut: false, error: "no shell available" }
-                    });
-                    return;
-                }
-                const command = expandTilde(params.command);
-                const child = spawn(command, { cwd, shell });
-                let stdout = "";
-                let stderr = "";
-                let timedOut = false;
-                const onData = (chunk, target) => {
-                    const text = chunk.toString("utf8");
-                    if (target === "stdout")
-                        stdout += text;
-                    else
-                        stderr += text;
-                    if (stdout.length + stderr.length > MAX_OUTPUT_BYTES) {
-                        stdout = stdout.slice(0, MAX_OUTPUT_BYTES);
-                        stderr = stderr.slice(0, MAX_OUTPUT_BYTES - stdout.length);
-                    }
-                };
-                child.stdout?.on("data", (chunk) => onData(chunk, "stdout"));
-                child.stderr?.on("data", (chunk) => onData(chunk, "stderr"));
-                child.on("error", (error) => {
-                    clearTimeout(timer);
-                    if (signal)
-                        signal.removeEventListener("abort", abortHandler);
-                    const message = error.message || "spawn error";
-                    resolve({
-                        content: [textContent(`Error running command: ${message}`)],
-                        details: { cwd, code: null, timedOut: false, error: message }
-                    });
-                });
-                const timer = setTimeout(() => {
-                    timedOut = true;
-                    child.kill("SIGKILL");
-                }, timeoutMs);
-                const abortHandler = () => {
-                    child.kill("SIGKILL");
-                };
-                if (signal) {
-                    if (signal.aborted)
-                        abortHandler();
-                    signal.addEventListener("abort", abortHandler, { once: true });
-                }
-                child.on("close", (code) => {
-                    clearTimeout(timer);
-                    if (signal)
-                        signal.removeEventListener("abort", abortHandler);
-                    const output = stdout.trimEnd();
-                    const errorOut = stderr.trimEnd();
-                    const lines = [
-                        `cwd: ${cwd}`,
-                        `exit: ${timedOut ? "timeout" : code}`,
-                        output ? `stdout:\n${output}` : "stdout: (empty)",
-                        errorOut ? `stderr:\n${errorOut}` : "stderr: (empty)"
-                    ];
-                    resolve({
-                        content: [textContent(lines.join("\n"))],
-                        details: { cwd, code, timedOut }
-                    });
-                });
-            });
-        }
-    };
-}