@heyamiko/amiko-cli 0.4.12 → 0.5.1

package/src/components/ModelPicker.tsx

@@ -1,107 +0,0 @@
-import React, { useMemo, useState } from "react";
-import { Box, Text, useInput, useStdout } from "ink";
-import SelectInput from "ink-select-input";
-import { getEnvApiKey, getModels, getProviders, type KnownProvider } from "@mariozechner/pi-ai";
-
-type Item = {
-  label: string;
-  value: string;
-  key?: string;
-};
-
-type ModelPickerProps = {
-  currentModel: string;
-  onSelect: (provider: string, modelId: string) => void;
-  onCancel: () => void;
-};
-
-export function ModelPicker({ currentModel, onSelect, onCancel }: ModelPickerProps) {
-  const [step, setStep] = useState<"provider" | "model">("provider");
-  const [provider, setProvider] = useState<string | null>(null);
-  const { stdout } = useStdout();
-  const maxItems = Math.max(6, Math.min(15, (stdout?.rows ?? 24) - 12));
-
-  const [currentProvider, currentModelId] = useMemo(() => {
-    if (!currentModel || currentModel === "auto") return [null, null] as const;
-    const parts = currentModel.split("/");
-    if (parts.length < 2) return [null, null] as const;
-    return [parts[0], parts.slice(1).join("/")] as const;
-  }, [currentModel]);
-
-  const providerItems = useMemo<Item[]>(() => {
-    const providers = getProviders().sort();
-    return providers.map((p) => {
-      const hasKey = Boolean(getEnvApiKey(p));
-      return {
-        label: `${hasKey ? "[x]" : "[ ]"} ${p}`,
-        value: p
-      };
-    });
-  }, []);
-
-  const providerInitialIndex = useMemo(() => {
-    if (!currentProvider) return 0;
-    const idx = providerItems.findIndex((item) => item.value === currentProvider);
-    return idx >= 0 ? idx : 0;
-  }, [providerItems, currentProvider]);
-
-  const modelItems = useMemo<Item[]>(() => {
-    if (!provider) return [];
-    return getModels(provider as KnownProvider)
-      .map((m) => ({
-        label: m.id,
-        value: m.id
-      }))
-      .sort((a, b) => a.label.localeCompare(b.label));
-  }, [provider]);
-
-  const modelInitialIndex = useMemo(() => {
-    if (!currentModelId) return 0;
-    const idx = modelItems.findIndex((item) => item.value === currentModelId);
-    return idx >= 0 ? idx : 0;
-  }, [modelItems, currentModelId]);
-
-  useInput((_, key) => {
-    if (key.escape) onCancel();
-  });
-
-  return (
-    <Box flexDirection="column" borderStyle="round" borderColor="cyan" padding={1} marginBottom={1}>
-      <Text color="cyan">Model Picker</Text>
-      <Text color="gray">Current: {currentModel}</Text>
-
-      {step === "provider" ? (
-        <Box flexDirection="column" marginTop={1}>
-          <Text>Select provider (Esc to cancel)</Text>
-          <SelectInput
-            items={providerItems}
-            initialIndex={providerInitialIndex}
-            limit={maxItems}
-            onSelect={(item) => {
-              setProvider(item.value);
-              setStep("model");
-            }}
-          />
-        </Box>
-      ) : (
-        <Box flexDirection="column" marginTop={1}>
-          <Text>Select model for {provider}</Text>
-          {modelItems.length === 0 ? (
-            <Text color="red">No models found.</Text>
-          ) : (
-            <SelectInput
-              items={modelItems}
-              initialIndex={modelInitialIndex}
-              limit={maxItems}
-              onSelect={(item) => {
-                if (!provider) return;
-                onSelect(provider, item.value);
-              }}
-            />
-          )}
-          <Text color="gray">Press Esc to cancel</Text>
-        </Box>
-      )}
-    </Box>
-  );
-}

package/src/config.ts

@@ -1,31 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { AppConfig } from "./types.js";
-
-function defaultWorkspacePath() {
-  return path.join(os.homedir(), ".amiko");
-}
-
-function newSessionId() {
-  return randomUUID().split("-")[0];
-}
-
-export function loadConfig(): AppConfig {
-  const workspacePath = process.env.AMIKO_WORKSPACE || defaultWorkspacePath();
-  const sessionId = process.env.AMIKO_SESSION_ID || newSessionId();
-
-  return {
-    workspacePath,
-    sessionId,
-    qmdBin: process.env.AMIKO_QMD_BIN || "qmd",
-    qmdLimit: Number(process.env.AMIKO_QMD_LIMIT || 5),
-    qmdEnabled: process.env.AMIKO_QMD_ENABLED !== "0",
-    qmdCollection: process.env.AMIKO_QMD_COLLECTION || undefined,
-    qmdFull: process.env.AMIKO_QMD_FULL === "1",
-    model: process.env.AMIKO_MODEL || undefined,
-    modelProvider: process.env.AMIKO_MODEL_PROVIDER || undefined,
-    modelId: process.env.AMIKO_MODEL_ID || undefined,
-    thinkingLevel: (process.env.AMIKO_THINKING_LEVEL as any) || undefined
-  };
-}

package/src/configFile.ts

@@ -1,33 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { AppConfig } from "./types.js";
-
-export type PersistedConfig = {
-  model?: string;
-  modelProvider?: string;
-  modelId?: string;
-  thinkingLevel?: AppConfig["thinkingLevel"];
-};
-
-export function getConfigFilePath(workspacePath: string) {
-  const base = workspacePath || path.join(os.homedir(), ".amiko");
-  return path.join(base, "config.json");
-}
-
-export async function loadConfigFile(workspacePath: string): Promise<PersistedConfig> {
-  const filePath = getConfigFilePath(workspacePath);
-  try {
-    const raw = await fs.readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw) as PersistedConfig;
-    return parsed || {};
-  } catch {
-    return {};
-  }
-}
-
-export async function saveConfigFile(workspacePath: string, config: PersistedConfig): Promise<void> {
-  const filePath = getConfigFilePath(workspacePath);
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
-}

package/src/headless.ts

@@ -1,243 +0,0 @@
-import { createInterface } from "node:readline";
-import { AppConfig, Message, MemoryHit } from "./types.js";
-import { parseCommand } from "./commands.js";
-import { buildPrompt } from "./prompt.js";
-import { appendSession } from "./session.js";
-import { readWorkspaceFiles, WorkspaceFiles } 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, type KnownProvider } from "@mariozechner/pi-ai";
-
-export async function runHeadless(
-  config: AppConfig,
-  workspace: WorkspaceFiles,
-  sessionPath: string,
-  singleMessage?: string,
-) {
-  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: any) => (c.text ? c.text : "")).join("\n")
-          : "";
-        const summary = resultText.trim() || "(no output)";
-        console.log(`[tool] ${event.toolName} done\n${summary}`);
-      }
-    });
-  }
-
-  // Single-shot mode: process one message and exit
-  if (singleMessage) {
-    const response = await processMessage(singleMessage, { config, workspace, sessionPath, agent, currentModel });
-    if (response !== undefined) process.stdout.write(response.endsWith("\n") ? response : response + "\n");
-    process.exit(0);
-  }
-
-  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: string) => { currentModel = m; },
-      });
-      rl.prompt();
-      continue;
-    }
-
-    const response = await processMessage(trimmed, { config, workspace, sessionPath, agent, currentModel });
-    if (response) {
-      process.stdout.write(response.endsWith("\n") ? response : response + "\n");
-    }
-
-    rl.prompt();
-  }
-
-  process.exit(0);
-}
-
-async function processMessage(
-  message: string,
-  ctx: {
-    config: AppConfig;
-    workspace: WorkspaceFiles;
-    sessionPath: string;
-    agent: any;
-    currentModel: string;
-  },
-): Promise<string> {
-  await appendSession(ctx.sessionPath, "user", message);
-
-  const workspaceData = await readWorkspaceFiles(ctx.workspace);
-
-  let hits: MemoryHit[] = [];
-  if (ctx.config.qmdEnabled) {
-    hits = await qmdSearch({
-      qmdBin: ctx.config.qmdBin,
-      query: message,
-      limit: ctx.config.qmdLimit,
-      collection: ctx.config.qmdCollection,
-    });
-  }
-
-  if (ctx.config.qmdFull && hits.length > 0) {
-    const expanded: MemoryHit[] = [];
-    for (const hit of hits) {
-      const docId = hit.path || hit.id;
-      if (!docId) { expanded.push(hit); continue; }
-      const text = await qmdGet({ qmdBin: ctx.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 ctx.agent.streamReply({ prompt, userMessage: message })) {
-      assistantText += chunk;
-    }
-  } catch (error) {
-    const msg = (error as Error).message || "unknown error";
-    assistantText += `\n[error] ${msg}\n`;
-  }
-
-  if (assistantText) {
-    await appendSession(ctx.sessionPath, "assistant", assistantText);
-  }
-
-  return assistantText;
-}
-
-async function handleCommand(
-  name: string,
-  args: string,
-  ctx: {
-    config: AppConfig;
-    workspace: WorkspaceFiles;
-    sessionPath: string;
-    agent: any;
-    currentModel: string;
-    setModel: (m: string) => void;
-  },
-) {
-  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 as KnownProvider);
-        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/src/memory/qmd.ts

@@ -1,111 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { MemoryHit } from "../types.js";
-
-const execFileAsync = promisify(execFile);
-
-function parseJsonLines(text: string) {
-  const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
-  const results: any[] = [];
-  for (const line of lines) {
-    try {
-      results.push(JSON.parse(line));
-    } catch {
-      // ignore
-    }
-  }
-  return results;
-}
-
-export async function qmdSearch(options: {
-  qmdBin: string;
-  query: string;
-  limit: number;
-  collection?: string;
-}): Promise<MemoryHit[]> {
-  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: {
-  qmdBin: string;
-  docId: string;
-  full?: boolean;
-}): Promise<string | null> {
-  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: {
-  qmdBin: string;
-  name: string;
-  path: string;
-}): Promise<boolean> {
-  const { qmdBin, name, path } = options;
-
-  try {
-    await execFileAsync(qmdBin, ["collection", "add", path, "--name", name]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function qmdEmbed(options: {
-  qmdBin: string;
-  collection?: string;
-}): Promise<boolean> {
-  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: any): MemoryHit {
-  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/src/prompt.ts

@@ -1,55 +0,0 @@
-import os from "node:os";
-import { MemoryHit } from "./types.js";
-
-export function buildPrompt(options: {
-  identity: string;
-  personality: string;
-  memory: string;
-  hits: MemoryHit[];
-}) {
-  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/src/session.ts

@@ -1,35 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export type SessionFile = {
-  id: string;
-  path: string;
-};
-
-function formatDate(date: 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: string, sessionId: string): Promise<SessionFile> {
-  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: string, role: "user" | "assistant", content: string) {
-  const timestamp = new Date().toISOString();
-  const block = `## ${role} @ ${timestamp}\n\n${content}\n\n`;
-  await fs.appendFile(sessionPath, block, "utf8");
-}

package/src/types.ts

@@ -1,40 +0,0 @@
-export type Role = "user" | "assistant" | "system" | "tool";
-
-export type Message = {
-  role: Role;
-  content: string;
-};
-
-export type MemoryHit = {
-  id: string;
-  score?: number;
-  title?: string;
-  snippet?: string;
-  path?: string;
-};
-
-export type AgentInput = {
-  prompt: string;
-  userMessage: string;
-};
-
-export type Agent = {
-  streamReply: (input: AgentInput) => AsyncGenerator<string>;
-  setModel?: (provider: string, modelId: string) => { ok: boolean; message: string };
-  getCurrentModel?: () => string | null;
-  onEvent?: (handler: (event: any) => void) => void;
-};
-
-export type AppConfig = {
-  workspacePath: string;
-  sessionId: string;
-  qmdBin: string;
-  qmdLimit: number;
-  qmdEnabled: boolean;
-  qmdCollection?: string;
-  qmdFull: boolean;
-  model?: string;
-  modelProvider?: string;
-  modelId?: string;
-  thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
-};