@heyamiko/amiko-cli 0.4.11 → 0.5.0

package/dist/headless.js

@@ -1,218 +0,0 @@
-import { createInterface } from "node:readline";
-import { parseCommand } from "./commands.js";
-import { buildPrompt } from "./prompt.js";
-import { appendSession } from "./session.js";
-import { readWorkspaceFiles } from "./workspace.js";
-import { createPiAgent } from "./agent/piAgent.js";
-import { qmdSearch, qmdGet, qmdCollectionAdd, qmdEmbed } from "./memory/qmd.js";
-import { saveConfigFile } from "./configFile.js";
-import { getModels, getProviders } from "@mariozechner/pi-ai";
-export async function runHeadless(config, workspace, sessionPath) {
-    const agent = await createPiAgent(config);
-    let currentModel = config.model
-        ?? (config.modelProvider && config.modelId ? `${config.modelProvider}/${config.modelId}` : "auto");
-    if (currentModel === "auto") {
-        const value = agent.getCurrentModel?.();
-        if (value)
-            currentModel = value;
-    }
-    if (agent.onEvent) {
-        agent.onEvent((event) => {
-            if (event?.type === "tool_execution_start") {
-                const lines = [`[tool] ${event.toolName} start`];
-                if (event.args?.command)
-                    lines.push(`  command: ${event.args.command}`);
-                console.log(lines.join("\n"));
-            }
-            if (event?.type === "tool_execution_end") {
-                const resultText = event.result?.content
-                    ? event.result.content.map((c) => (c.text ? c.text : "")).join("\n")
-                    : "";
-                const summary = resultText.trim() || "(no output)";
-                console.log(`[tool] ${event.toolName} done\n${summary}`);
-            }
-        });
-    }
-    console.log(`amiko-cli (headless) | model: ${currentModel} | workspace: ${workspace.root}`);
-    console.log("Type a message or /command. Press Ctrl+D to exit.");
-    const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: "> ",
-        terminal: false,
-    });
-    rl.prompt();
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            rl.prompt();
-            continue;
-        }
-        const command = parseCommand(trimmed);
-        if (command) {
-            await handleCommand(command.name, command.args, {
-                config, workspace, sessionPath, agent, currentModel,
-                setModel: (m) => { currentModel = m; },
-            });
-            rl.prompt();
-            continue;
-        }
-        console.log(`[user] ${trimmed}`);
-        await appendSession(sessionPath, "user", trimmed);
-        const workspaceData = await readWorkspaceFiles(workspace);
-        let hits = [];
-        if (config.qmdEnabled) {
-            hits = await qmdSearch({
-                qmdBin: config.qmdBin,
-                query: trimmed,
-                limit: config.qmdLimit,
-                collection: config.qmdCollection,
-            });
-        }
-        if (config.qmdFull && hits.length > 0) {
-            const expanded = [];
-            for (const hit of hits) {
-                const docId = hit.path || hit.id;
-                if (!docId) {
-                    expanded.push(hit);
-                    continue;
-                }
-                const text = await qmdGet({ qmdBin: config.qmdBin, docId, full: true });
-                expanded.push({ ...hit, snippet: text || hit.snippet });
-            }
-            hits = expanded;
-        }
-        const prompt = buildPrompt({
-            identity: workspaceData.identity,
-            personality: workspaceData.personality,
-            memory: workspaceData.memory,
-            hits,
-        });
-        let assistantText = "";
-        try {
-            for await (const chunk of agent.streamReply({ prompt, userMessage: trimmed })) {
-                process.stdout.write(chunk);
-                assistantText += chunk;
-            }
-        }
-        catch (error) {
-            const message = error.message || "unknown error";
-            assistantText += `\n[error] ${message}\n`;
-            console.error(`[error] ${message}`);
-        }
-        if (!assistantText.endsWith("\n"))
-            process.stdout.write("\n");
-        if (assistantText) {
-            await appendSession(sessionPath, "assistant", assistantText);
-        }
-        rl.prompt();
-    }
-    process.exit(0);
-}
-async function handleCommand(name, args, ctx) {
-    switch (name) {
-        case "exit":
-            process.exit(0);
-        case "help":
-            console.log("Commands: /help /exit /search <query> /memory /session /plan /identity /personality /index [collection] /model [provider[/id]]");
-            return;
-        case "memory": {
-            const data = await readWorkspaceFiles(ctx.workspace);
-            console.log(`MEMORY.md:\n\n${data.memory.trim() || "(empty)"}`);
-            return;
-        }
-        case "session":
-            console.log(`Session file: ${ctx.sessionPath}`);
-            return;
-        case "plan":
-            console.log("Plan file: PLAN.md");
-            return;
-        case "identity": {
-            const data = await readWorkspaceFiles(ctx.workspace);
-            console.log(`IDENTITY.md:\n\n${data.identity.trim() || "(empty)"}`);
-            return;
-        }
-        case "personality": {
-            const data = await readWorkspaceFiles(ctx.workspace);
-            console.log(`PERSONALITY.md:\n\n${data.personality.trim() || "(empty)"}`);
-            return;
-        }
-        case "index": {
-            if (!ctx.config.qmdEnabled) {
-                console.log("QMD is disabled.");
-                return;
-            }
-            const collName = args || ctx.config.qmdCollection || "amiko";
-            const added = await qmdCollectionAdd({ qmdBin: ctx.config.qmdBin, name: collName, path: ctx.workspace.root });
-            if (!added) {
-                console.log("Failed to add QMD collection.");
-                return;
-            }
-            const embedded = await qmdEmbed({ qmdBin: ctx.config.qmdBin, collection: collName });
-            console.log(embedded ? `Indexed QMD collection "${collName}".` : `Collection "${collName}" added, but embedding failed.`);
-            return;
-        }
-        case "search": {
-            if (!args) {
-                console.log("Usage: /search <query>");
-                return;
-            }
-            if (!ctx.config.qmdEnabled) {
-                console.log("QMD is disabled.");
-                return;
-            }
-            const hits = await qmdSearch({ qmdBin: ctx.config.qmdBin, query: args, limit: ctx.config.qmdLimit, collection: ctx.config.qmdCollection });
-            if (hits.length === 0) {
-                console.log("No memory hits.");
-                return;
-            }
-            const formatted = hits.map((hit, i) => {
-                const label = hit.title || hit.path || hit.id;
-                const score = hit.score ? ` (${hit.score.toFixed(2)})` : "";
-                return `${i + 1}. ${label}${score}`;
-            }).join("\n");
-            console.log(formatted);
-            return;
-        }
-        case "model": {
-            if (!args) {
-                const providers = getProviders().sort();
-                console.log(`Current model: ${ctx.currentModel}\nProviders:\n${providers.map((p, i) => `  ${i + 1}. ${p}`).join("\n")}`);
-                return;
-            }
-            const slashParts = args.includes("/") ? args.split("/") : [];
-            let provider = args.split(" ")[0];
-            let modelId = args.split(" ")[1];
-            if (slashParts.length >= 2) {
-                provider = slashParts[0]?.trim();
-                modelId = slashParts.slice(1).join("/").trim();
-            }
-            if (provider && !modelId) {
-                const models = getModels(provider);
-                if (models.length === 0) {
-                    console.log(`Unknown provider: ${provider}`);
-                    return;
-                }
-                console.log(`Models for ${provider}:\n${models.map((m) => m.id).sort().join("\n")}`);
-                return;
-            }
-            if (!provider || !modelId) {
-                console.log("Usage: /model <provider>/<modelId>");
-                return;
-            }
-            if (!ctx.agent.setModel) {
-                console.log("Agent does not support model switching.");
-                return;
-            }
-            const result = ctx.agent.setModel(provider, modelId);
-            console.log(result.message);
-            if (result.ok) {
-                ctx.setModel(`${provider}/${modelId}`);
-                await saveConfigFile(ctx.workspace.root, { model: `${provider}/${modelId}`, modelProvider: provider, modelId });
-            }
-            return;
-        }
-        default:
-            console.log(`Unknown command: ${name}`);
-    }
-}

package/dist/memory/qmd.js

@@ -1,87 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-function parseJsonLines(text) {
-    const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
-    const results = [];
-    for (const line of lines) {
-        try {
-            results.push(JSON.parse(line));
-        }
-        catch {
-            // ignore
-        }
-    }
-    return results;
-}
-export async function qmdSearch(options) {
-    const { qmdBin, query, limit, collection } = options;
-    try {
-        const args = ["query", "--json", "-n", String(limit)];
-        if (collection) {
-            args.push("-c", collection);
-        }
-        args.push(query);
-        const { stdout } = await execFileAsync(qmdBin, [
-            ...args
-        ]);
-        try {
-            const parsed = JSON.parse(stdout);
-            if (Array.isArray(parsed)) {
-                return parsed.map(normalizeHit);
-            }
-        }
-        catch {
-            // fall through to JSONL parsing
-        }
-        return parseJsonLines(stdout).map(normalizeHit);
-    }
-    catch {
-        return [];
-    }
-}
-export async function qmdGet(options) {
-    const { qmdBin, docId, full } = options;
-    try {
-        const args = ["get", docId];
-        if (full)
-            args.push("--full");
-        const { stdout } = await execFileAsync(qmdBin, args);
-        return stdout.trim();
-    }
-    catch {
-        return null;
-    }
-}
-export async function qmdCollectionAdd(options) {
-    const { qmdBin, name, path } = options;
-    try {
-        await execFileAsync(qmdBin, ["collection", "add", path, "--name", name]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function qmdEmbed(options) {
-    const { qmdBin, collection } = options;
-    try {
-        const args = ["embed"];
-        if (collection)
-            args.push("-c", collection);
-        await execFileAsync(qmdBin, args);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function normalizeHit(hit) {
-    return {
-        id: String(hit.id ?? hit.docId ?? hit.path ?? "unknown"),
-        score: typeof hit.score === "number" ? hit.score : undefined,
-        title: hit.title ?? hit.name,
-        snippet: hit.snippet ?? hit.text,
-        path: hit.path
-    };
-}

package/dist/prompt.js

@@ -1,43 +0,0 @@
-import os from "node:os";
-export function buildPrompt(options) {
-    const { identity, personality, memory, hits } = options;
-    const hitText = hits
-        .map((hit, index) => {
-        const title = hit.title || hit.path || hit.id;
-        const snippet = hit.snippet || "";
-        return `(${index + 1}) ${title}\n${snippet}`.trim();
-    })
-        .filter(Boolean)
-        .join("\n\n");
-    const systemInfo = [
-        `platform: ${process.platform}`,
-        `arch: ${process.arch}`,
-        `cwd: ${process.cwd()}`,
-        `home: ${os.homedir()}`
-    ].join("\n");
-    const toolSpec = [
-        "Available tools:",
-        "- read: { path: string, maxBytes?: number }",
-        "- bash: { command: string, cwd?: string, timeoutMs?: number }",
-        "",
-        "Tool call rules:",
-        "1) Always include the tool name.",
-        "2) Always include required fields (read.path, bash.command).",
-        "3) Do not call tools with empty arguments.",
-        "4) Use bash for shell commands; do not invent other tool names.",
-    ].join("\n");
-    const sections = [
-        "# Identity\n" + identity.trim(),
-        "# Personality\n" + personality.trim(),
-        "# System Info\n" + systemInfo,
-        "# Tooling Policy\n" +
-            "You can use tools (read, bash) to answer questions. Prefer tools over asking the user to run commands. " +
-            "Only ask for clarification if needed to choose a safe tool or path.",
-        "# Tool Schemas\n" + toolSpec,
-        "# Long-term Memory\n" + memory.trim()
-    ];
-    if (hitText.length > 0) {
-        sections.push("# Retrieved Memory\n" + hitText);
-    }
-    return sections.join("\n\n").trim();
-}

package/dist/session.js

@@ -1,26 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-function formatDate(date) {
-    const yyyy = date.getFullYear();
-    const mm = String(date.getMonth() + 1).padStart(2, "0");
-    const dd = String(date.getDate()).padStart(2, "0");
-    return `${yyyy}-${mm}-${dd}`;
-}
-export async function createSessionFile(sessionsDir, sessionId) {
-    const date = formatDate(new Date());
-    const fileName = `${date}-${sessionId}.md`;
-    const sessionPath = path.join(sessionsDir, fileName);
-    try {
-        await fs.access(sessionPath);
-    }
-    catch {
-        const header = `# Session ${fileName}\n\n`;
-        await fs.writeFile(sessionPath, header, "utf8");
-    }
-    return { id: sessionId, path: sessionPath };
-}
-export async function appendSession(sessionPath, role, content) {
-    const timestamp = new Date().toISOString();
-    const block = `## ${role} @ ${timestamp}\n\n${content}\n\n`;
-    await fs.appendFile(sessionPath, block, "utf8");
-}

package/dist/types.js

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

package/dist/workspace.js

@@ -1,42 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-const DEFAULT_IDENTITY = "# Identity\n\nYou are Amiko, a helpful CLI agent.\n";
-const DEFAULT_PERSONALITY = "# Personality\n\n- Clear, concise, friendly.\n- Ask for clarification when unsure.\n";
-const DEFAULT_MEMORY = "# Memory\n\n";
-async function ensureDir(dirPath) {
-    await fs.mkdir(dirPath, { recursive: true });
-}
-async function ensureFile(filePath, content) {
-    try {
-        await fs.access(filePath);
-    }
-    catch {
-        await fs.writeFile(filePath, content, "utf8");
-    }
-}
-export async function initWorkspace(root) {
-    const identityPath = path.join(root, "IDENTITY.md");
-    const personalityPath = path.join(root, "PERSONALITY.md");
-    const memoryPath = path.join(root, "MEMORY.md");
-    const sessionsDir = path.join(root, "sessions");
-    await ensureDir(root);
-    await ensureDir(sessionsDir);
-    await ensureFile(identityPath, DEFAULT_IDENTITY);
-    await ensureFile(personalityPath, DEFAULT_PERSONALITY);
-    await ensureFile(memoryPath, DEFAULT_MEMORY);
-    return {
-        root,
-        identityPath,
-        personalityPath,
-        memoryPath,
-        sessionsDir
-    };
-}
-export async function readWorkspaceFiles(files) {
-    const [identity, personality, memory] = await Promise.all([
-        fs.readFile(files.identityPath, "utf8"),
-        fs.readFile(files.personalityPath, "utf8"),
-        fs.readFile(files.memoryPath, "utf8")
-    ]);
-    return { identity, personality, memory };
-}

package/src/__tests__/cli-non-tty.test.ts

@@ -1,86 +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: string[] = [], stdin?: string): Promise<{ stdout: string; stderr: string; code: number | null }> {
-  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 as any)?.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: number) {
-      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);
-  });
-});