@heyamiko/amiko-cli 0.4.11 → 0.5.0

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,222 +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,
-) {
-  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}`);
-      }
-    });
-  }
-
-  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;
-    }
-
-    console.log(`[user] ${trimmed}`);
-    await appendSession(sessionPath, "user", trimmed);
-
-    const workspaceData = await readWorkspaceFiles(workspace);
-
-    let hits: MemoryHit[] = [];
-    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: MemoryHit[] = [];
-      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 as 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: 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";
-};

package/src/workspace.ts

@@ -1,58 +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";
-
-export type WorkspaceFiles = {
-  root: string;
-  identityPath: string;
-  personalityPath: string;
-  memoryPath: string;
-  sessionsDir: string;
-};
-
-async function ensureDir(dirPath: string) {
-  await fs.mkdir(dirPath, { recursive: true });
-}
-
-async function ensureFile(filePath: string, content: string) {
-  try {
-    await fs.access(filePath);
-  } catch {
-    await fs.writeFile(filePath, content, "utf8");
-  }
-}
-
-export async function initWorkspace(root: string): Promise<WorkspaceFiles> {
-  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: WorkspaceFiles) {
-  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/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "dist",
-    "rootDir": "src",
-    "jsx": "react-jsx",
-    "strict": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "types": ["node"]
-  },
-  "include": ["src"]
-}