@heyamiko/amiko-cli 0.4.1 → 0.4.8

package/dist/prompt.js

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,26 @@
+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

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

package/dist/workspace.js

@@ -0,0 +1,42 @@
+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/package.json

@@ -1,39 +1,28 @@
 {
   "name": "@heyamiko/amiko-cli",
-  "version": "0.4.1",
-  "description": "Amiko CLI — manage agents, wallets, credits, and marketplace on the MPP payment rail",
+  "version": "0.4.8",
   "type": "module",
   "bin": {
-    "amiko": "./dist/index.js"
+    "amiko": "dist/cli.js"
   },
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --format esm",
-    "dev": "bun run src/index.ts",
-    "typecheck": "bun x tsc --noEmit",
-    "test": "bun test"
+    "dev": "tsx src/cli.tsx",
+    "build": "tsc -p tsconfig.json"
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "keywords": [
-    "amiko",
-    "mpp",
-    "ai-agents",
-    "marketplace",
-    "cli"
-  ],
-  "license": "MIT",
   "dependencies": {
-    "@crossmint/wallets-sdk": "^1.0.5",
-    "@solana/mpp": "^0.2.0",
-    "chalk": "^5.3.0",
-    "commander": "^12.1.0",
-    "ora": "^8.1.0"
+    "@mariozechner/pi-agent-core": "*",
+    "@mariozechner/pi-ai": "*",
+    "ink": "^4.4.1",
+    "ink-select-input": "^5.0.0",
+    "@sinclair/typebox": "^0.34.41",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "@types/bun": "latest",
-    "@types/node": "^22.0.0",
-    "typescript": "^5.6.0"
+    "@types/node": "^20.10.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
   }
 }

package/src/agent/piAgent.ts

@@ -0,0 +1,266 @@
+import { Agent } from "@mariozechner/pi-agent-core";
+import { getEnvApiKey, getModel, getModels, getProviders } from "@mariozechner/pi-ai";
+import type { KnownProvider } from "@mariozechner/pi-ai";
+import { Agent as AmikoAgent, AgentInput, AppConfig } from "../types.js";
+import { createBashTool, createReadTool } from "./tools.js";
+
+type Queue = {
+  push: (value: string) => void;
+  end: () => void;
+  iterate: () => AsyncGenerator<string>;
+};
+
+function createQueue(): Queue {
+  const queue: Array<string | null> = [];
+  let pending: ((value: string | null) => void) | null = null;
+
+  return {
+    push(value: string) {
+      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<string | null>((resolve) => {
+          pending = resolve;
+        });
+        if (value === null) return;
+        yield value;
+      }
+    }
+  };
+}
+
+function resolveModel(config: AppConfig) {
+  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: Record<string, string[]> = {
+  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: string): string | null {
+  const models = getModels(provider as KnownProvider);
+  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 as KnownProvider));
+  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: AppConfig): Promise<AmikoAgent> {
+  const modelInfo = resolveModel(config) || pickAutoModel();
+  const model = modelInfo ? (getModel as any)(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: any = {
+    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: Array<(event: any) => void> = [];
+  agent.subscribe((event) => {
+    for (const listener of eventListeners) {
+      listener(event);
+    }
+  });
+
+  return {
+    async *streamReply(input: AgentInput) {
+      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 as any).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 as Error).message || "unknown"}\n`);
+      } finally {
+        unsubscribe();
+        endOnce();
+      }
+
+      yield* queue.iterate();
+    },
+    setModel(provider: string, modelId: string) {
+      const resolved = (getModel as any)(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: string): AmikoAgent {
+  return {
+    async *streamReply(input: AgentInput) {
+      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/src/agent/tools.ts

@@ -0,0 +1,153 @@
+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";
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { TextContent } from "@mariozechner/pi-ai";
+
+const MAX_OUTPUT_BYTES = 200_000;
+
+function textContent(text: string): TextContent {
+  return { type: "text", text };
+}
+
+function resolvePath(root: string, targetPath: string): string {
+  if (path.isAbsolute(targetPath)) return targetPath;
+  return path.resolve(root, targetPath);
+}
+
+function expandTilde(value: string): string {
+  if (!value) return value;
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2));
+  return value;
+}
+
+function resolveShell(): string | undefined {
+  const candidates = [process.env.SHELL, "/bin/zsh", "/bin/bash", "/bin/sh"].filter(Boolean) as string[];
+  for (const candidate of candidates) {
+    try {
+      if (fsSync.existsSync(candidate)) return candidate;
+    } catch {
+      // ignore
+    }
+  }
+  return undefined;
+}
+
+export function createReadTool(options: { root: string }): AgentTool {
+  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: any) {
+      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 as Error).message || "read failed";
+        return {
+          content: [textContent(`Error reading ${filePath}: ${message}`)],
+          details: { path: filePath, error: message }
+        };
+      }
+    }
+  };
+}
+
+export function createBashTool(options: { cwd: string }): AgentTool {
+  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: any, 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: Buffer, target: "stdout" | "stderr") => {
+          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 as 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 }
+          });
+        });
+      });
+    }
+  };
+}