@heyamiko/amiko-cli 0.4.12 → 0.5.1

package/src/app.tsx

@@ -1,448 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useState } from "react";
-import { Box, Static, Text, useApp, useInput, useStdout } from "ink";
-import { getEnvApiKey, getModels, getProviders, type KnownProvider } from "@mariozechner/pi-ai";
-import { AppConfig, Message, MemoryHit } from "./types.js";
-import { parseCommand } from "./commands.js";
-import { qmdCollectionAdd, qmdEmbed, qmdGet, qmdSearch } from "./memory/qmd.js";
-import { buildPrompt } from "./prompt.js";
-import { appendSession } from "./session.js";
-import { readWorkspaceFiles, WorkspaceFiles } from "./workspace.js";
-import { createPiAgent } from "./agent/piAgent.js";
-import { ModelPicker } from "./components/ModelPicker.js";
-import { saveConfigFile } from "./configFile.js";
-
-export type AppProps = {
-  config: AppConfig;
-  workspace: WorkspaceFiles;
-  sessionPath: string;
-};
-
-type StyledMessage = {
-  role: Message["role"];
-  content: string;
-};
-
-type StaticItem =
-  | { type: "banner" }
-  | { type: "message"; message: StyledMessage };
-
-export function App({ config, workspace, sessionPath }: AppProps) {
-  const { exit } = useApp();
-  const { stdout } = useStdout();
-  const [input, setInput] = useState("");
-  const [messages, setMessages] = useState<StyledMessage[]>([]);
-  const [streamingAssistant, setStreamingAssistant] = useState("");
-  const [status, setStatus] = useState<string>("ready");
-  const [agentReady, setAgentReady] = useState(false);
-  const [currentModel, setCurrentModel] = useState<string>(() => {
-    if (config.model) return config.model;
-    if (config.modelProvider && config.modelId) return `${config.modelProvider}/${config.modelId}`;
-    return "auto";
-  });
-  const [showModelPicker, setShowModelPicker] = useState(false);
-  const toolMessageIds = useMemo(() => new Set<string>(), []);
-
-  const agentPromise = useMemo(() => createPiAgent(config), [
-    config.model,
-    config.modelProvider,
-    config.modelId,
-    config.thinkingLevel
-  ]);
-
-  useEffect(() => {
-    let mounted = true;
-    agentPromise.then((agent) => {
-      if (!mounted) return;
-      setAgentReady(true);
-      if (currentModel === "auto") {
-        const value = agent.getCurrentModel?.();
-        if (value) setCurrentModel(value);
-      }
-      if (agent.onEvent) {
-        agent.onEvent((event) => {
-          if (event?.type === "tool_execution_start") {
-            const key = `${event.toolCallId ?? ""}:${event.toolName ?? ""}:${JSON.stringify(event.args || {})}`;
-            if (toolMessageIds.has(key)) return;
-            toolMessageIds.add(key);
-
-            const lines = [`[${event.toolName}] start`];
-            if (event.args?.command) lines.push(`command: ${event.args.command}`);
-            if (event.args?.cwd) lines.push(`cwd: ${event.args.cwd}`);
-            if (event.args?.timeoutMs) lines.push(`timeoutMs: ${event.args.timeoutMs}`);
-            pushMessage("tool", lines.join("\n"));
-            return;
-          }
-          if (event?.type === "tool_execution_end") {
-            const key = `${event.toolCallId ?? ""}:${event.toolName ?? ""}:${JSON.stringify(event.args || {})}`;
-            if (toolMessageIds.has(key + ":end")) return;
-            toolMessageIds.add(key + ":end");
-
-            const resultText = event.result?.content
-              ? event.result.content.map((c: any) => (c.text ? c.text : "")).join("\\n")
-              : "";
-            const trimmed = resultText.trim();
-            const summary = trimmed.length > 0 ? trimmed : "(no output)";
-            pushMessage("tool", `[${event.toolName}] done\n${summary}`);
-          }
-        });
-      }
-    });
-    return () => {
-      mounted = false;
-    };
-  }, [agentPromise, currentModel]);
-
-  const pushMessage = useCallback((role: Message["role"], content: string) => {
-    setMessages((prev) => [...prev, { role, content }]);
-  }, []);
-
-  const handleSubmit = useCallback(async () => {
-    const trimmed = input.trim();
-    if (!trimmed) return;
-
-    setInput("");
-
-    const command = parseCommand(trimmed);
-    if (command) {
-      await handleCommand(command.name, command.args);
-      return;
-    }
-
-    pushMessage("user", trimmed);
-    await appendSession(sessionPath, "user", trimmed);
-
-    setStatus("thinking");
-    setStreamingAssistant("");
-
-    const [workspaceData, agent] = await Promise.all([
-      readWorkspaceFiles(workspace),
-      agentPromise
-    ]);
-
-    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 })) {
-        assistantText += chunk;
-        setStreamingAssistant((prev) => prev + chunk);
-      }
-    } catch (error) {
-      const message = (error as Error).message || "unknown error";
-      assistantText += `\n[amiko] ${message}\n`;
-      setStreamingAssistant((prev) => prev + `\n[amiko] ${message}\n`);
-    }
-
-    if (assistantText) {
-      await appendSession(sessionPath, "assistant", assistantText);
-      pushMessage("assistant", assistantText);
-    }
-    setStreamingAssistant("");
-
-    setStatus("ready");
-  }, [
-    input,
-    agentPromise,
-    config.qmdBin,
-    config.qmdEnabled,
-    config.qmdLimit,
-    config.qmdFull,
-    config.qmdCollection,
-    pushMessage,
-    sessionPath,
-    workspace
-  ]);
-
-  const handleCommand = useCallback(
-    async (name: string, args: string) => {
-      switch (name) {
-        case "exit":
-          exit();
-          return;
-        case "help":
-          pushMessage(
-            "assistant",
-            "Commands: /help /exit /search <query> /memory /session /plan /identity /personality /index [collection] /model [provider[/id]]"
-          );
-          return;
-        case "memory": {
-          const data = await readWorkspaceFiles(workspace);
-          pushMessage("assistant", `MEMORY.md:\n\n${data.memory.trim() || "(empty)"}`);
-          return;
-        }
-        case "session":
-          pushMessage("assistant", `Session file: ${sessionPath}`);
-          return;
-        case "plan":
-          pushMessage("assistant", "Plan file: PLAN.md");
-          return;
-        case "identity": {
-          const data = await readWorkspaceFiles(workspace);
-          pushMessage("assistant", `IDENTITY.md:\n\n${data.identity.trim() || "(empty)"}`);
-          return;
-        }
-        case "personality": {
-          const data = await readWorkspaceFiles(workspace);
-          pushMessage("assistant", `PERSONALITY.md:\n\n${data.personality.trim() || "(empty)"}`);
-          return;
-        }
-        case "index": {
-          if (!config.qmdEnabled) {
-            pushMessage("assistant", "QMD is disabled.");
-            return;
-          }
-          const name = args || config.qmdCollection || "amiko";
-          const added = await qmdCollectionAdd({
-            qmdBin: config.qmdBin,
-            name,
-            path: workspace.root
-          });
-          if (!added) {
-            pushMessage("assistant", "Failed to add QMD collection.");
-            return;
-          }
-          const embedded = await qmdEmbed({ qmdBin: config.qmdBin, collection: name });
-          pushMessage(
-            "assistant",
-            embedded ? `Indexed QMD collection "${name}".` : `Collection "${name}" added, but embedding failed.`
-          );
-          return;
-        }
-        case "search": {
-          if (!args) {
-            pushMessage("assistant", "Usage: /search <query>");
-            return;
-          }
-          if (!config.qmdEnabled) {
-            pushMessage("assistant", "QMD is disabled.");
-            return;
-          }
-          const hits = await qmdSearch({
-            qmdBin: config.qmdBin,
-            query: args,
-            limit: config.qmdLimit,
-            collection: config.qmdCollection
-          });
-          if (hits.length === 0) {
-            pushMessage("assistant", "No memory hits.");
-            return;
-          }
-          const formatted = hits
-            .map((hit, index) => {
-              const label = hit.title || hit.path || hit.id;
-              const score = hit.score ? ` (${hit.score.toFixed(2)})` : "";
-              return `${index + 1}. ${label}${score}`;
-            })
-            .join("\n");
-          pushMessage("assistant", formatted);
-          return;
-        }
-        case "model": {
-          const agent = await agentPromise;
-          if (!args) {
-            setShowModelPicker(true);
-            return;
-          }
-
-          const parts = args.split(" ").filter(Boolean);
-          const slashParts = args.includes("/") ? args.split("/") : [];
-          let provider = parts[0];
-          let modelId = parts[1];
-
-          const providerIndex = Number(provider);
-          const providers = getProviders().sort();
-          if (Number.isInteger(providerIndex) && providerIndex > 0 && providerIndex <= providers.length) {
-            provider = providers[providerIndex - 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) {
-              pushMessage("assistant", `Unknown provider: ${provider}`);
-              return;
-            }
-            const modelList = models.map((m) => m.id).sort();
-            pushMessage("assistant", `Models for ${provider}:\n${modelList.join("\n")}`);
-            return;
-          }
-
-          if (!provider || !modelId) {
-            pushMessage("assistant", "Usage: /model <provider> [modelId] or /model <provider>/<modelId>");
-            return;
-          }
-
-          if (!agent.setModel) {
-            pushMessage("assistant", "Agent does not support model switching.");
-            return;
-          }
-
-          const result = agent.setModel(provider, modelId);
-          pushMessage("assistant", result.message);
-          if (result.ok) {
-            setCurrentModel(`${provider}/${modelId}`);
-            await saveConfigFile(workspace.root, {
-              model: `${provider}/${modelId}`,
-              modelProvider: provider,
-              modelId
-            });
-          }
-          return;
-        }
-        default:
-          pushMessage("assistant", `Unknown command: ${name}`);
-      }
-    },
-    [
-      agentPromise,
-      config.qmdBin,
-      config.qmdLimit,
-      config.qmdCollection,
-      exit,
-      pushMessage,
-      sessionPath,
-      workspace,
-      currentModel,
-      config.qmdEnabled
-    ]
-  );
-
-  useInput((value, key) => {
-    if (key.return) {
-      void handleSubmit();
-      return;
-    }
-    if (key.backspace || key.delete) {
-      setInput((prev) => prev.slice(0, -1));
-      return;
-    }
-    if (key.ctrl && value === "c") {
-      exit();
-      return;
-    }
-    setInput((prev) => prev + value);
-  });
-
-  const terminalWidth = stdout?.columns ?? 80;
-  const shortWorkspace = terminalWidth < 90 ? workspace.root.split("/").slice(-2).join("/") : workspace.root;
-  const shortModel =
-    terminalWidth < 90 && currentModel.includes("/")
-      ? currentModel.split("/").slice(-2).join("/")
-      : currentModel;
-
-  const maxVisibleMessages = Math.max(4, (stdout?.rows ?? 24) - 12);
-  const visibleMessages =
-    messages.length > maxVisibleMessages ? messages.slice(messages.length - maxVisibleMessages) : messages;
-
-  const staticItems: StaticItem[] = [
-    { type: "banner" },
-    ...visibleMessages.map((message): StaticItem => ({ type: "message", message }))
-  ];
-
-  return (
-    <Box flexDirection="column" padding={1}>
-      <Box flexDirection="column" marginBottom={1}>
-        <Static items={staticItems}>
-          {(item, index) => {
-            if (item.type === "banner") {
-              return (
-                <Box key={`banner-${index}`} borderStyle="round" borderColor="cyan" paddingX={1} marginBottom={1} flexDirection="column">
-                  <Box>
-                    <Text>amiko-cli</Text>
-                    <Text color="gray">  {shortWorkspace}</Text>
-                  </Box>
-                  <Box>
-                    <Text color="blue">model: {shortModel}</Text>
-                    <Text>  </Text>
-                    <Text color={agentReady ? "green" : "yellow"}>agent: {agentReady ? "ready" : "loading"}</Text>
-                    <Text>  </Text>
-                    <Text color="magenta">status: {status}</Text>
-                  </Box>
-                </Box>
-              );
-            }
-            const message = item.message;
-            return (
-              <Box key={`message-${index}`} flexDirection="column" marginBottom={1}>
-                <Text color={message.role === "user" ? "cyan" : message.role === "tool" ? "yellow" : "green"}>
-                  [{message.role}]
-                </Text>
-                <Text>{message.content}</Text>
-              </Box>
-            );
-          }}
-        </Static>
-        {streamingAssistant ? (
-          <Box flexDirection="column" marginBottom={1}>
-            <Text color="green">[assistant]</Text>
-            <Text>{streamingAssistant}</Text>
-          </Box>
-        ) : null}
-      </Box>
-
-      {showModelPicker ? (
-        <ModelPicker
-          currentModel={currentModel}
-          onCancel={() => setShowModelPicker(false)}
-          onSelect={async (provider, modelId) => {
-            const agent = await agentPromise;
-            if (!agent.setModel) {
-              pushMessage("assistant", "Agent does not support model switching.");
-              setShowModelPicker(false);
-              return;
-            }
-            const result = agent.setModel(provider, modelId);
-            pushMessage("assistant", result.message);
-            if (result.ok) setCurrentModel(`${provider}/${modelId}`);
-            if (result.ok) {
-              await saveConfigFile(workspace.root, {
-                model: `${provider}/${modelId}`,
-                modelProvider: provider,
-                modelId
-              });
-            }
-            setShowModelPicker(false);
-          }}
-        />
-      ) : null}
-
-      <Box>
-        <Text color="yellow">&gt; </Text>
-        <Text>{input}</Text>
-      </Box>
-    </Box>
-  );
-}

package/src/cli.tsx

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-import React from "react";
-import { render } from "ink";
-import { loadConfig } from "./config.js";
-import { initWorkspace } from "./workspace.js";
-import { createSessionFile } from "./session.js";
-import { App } from "./app.js";
-import { loadConfigFile } from "./configFile.js";
-import { runHeadless } from "./headless.js";
-
-type ArgOverrides = Partial<{
-  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";
-  headless?: boolean;
-  message?: string;
-}>;
-
-function parseArgs(argv: string[]): ArgOverrides {
-  const overrides: ArgOverrides = {};
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    switch (arg) {
-      case "--headless":
-        overrides.headless = true;
-        break;
-      case "--message":
-      case "-m":
-        overrides.message = argv[i + 1];
-        i += 1;
-        break;
-      case "--workspace":
-      case "-w":
-        overrides.workspacePath = argv[i + 1];
-        i += 1;
-        break;
-      case "--session":
-        overrides.sessionId = argv[i + 1];
-        i += 1;
-        break;
-      case "--qmd-bin":
-        overrides.qmdBin = argv[i + 1];
-        i += 1;
-        break;
-      case "--qmd-limit":
-        overrides.qmdLimit = Number(argv[i + 1]);
-        i += 1;
-        break;
-      case "--qmd-collection":
-        overrides.qmdCollection = argv[i + 1];
-        i += 1;
-        break;
-      case "--qmd-full":
-        overrides.qmdFull = true;
-        break;
-      case "--no-qmd":
-        overrides.qmdEnabled = false;
-        break;
-      case "--model":
-        overrides.model = argv[i + 1];
-        i += 1;
-        break;
-      case "--model-provider":
-        overrides.modelProvider = argv[i + 1];
-        i += 1;
-        break;
-      case "--model-id":
-        overrides.modelId = argv[i + 1];
-        i += 1;
-        break;
-      case "--thinking":
-        overrides.thinkingLevel = argv[i + 1] as ArgOverrides["thinkingLevel"];
-        i += 1;
-        break;
-      default:
-        break;
-    }
-  }
-  return overrides;
-}
-
-async function main() {
-  // Ink's render-border.js calls box.top.repeat(contentWidth) where
-  // contentWidth = width - 2. When yoga computes a zero-width node (common
-  // in non-TTY / piped environments), contentWidth goes negative and
-  // String.repeat() throws. Patch String.repeat to clamp to 0.
-  const origRepeat = String.prototype.repeat;
-  String.prototype.repeat = function (count: number) {
-    return origRepeat.call(this, Math.max(0, Math.floor(count)));
-  };
-
-  const config = loadConfig();
-  const overrides = parseArgs(process.argv.slice(2));
-  const finalConfig = { ...config, ...overrides };
-  const workspace = await initWorkspace(finalConfig.workspacePath);
-  const persisted = await loadConfigFile(workspace.root);
-  const mergedConfig = { ...finalConfig, ...persisted, ...overrides };
-  const sessionFile = await createSessionFile(workspace.sessionsDir, finalConfig.sessionId);
-
-  // Auto-detect non-TTY, --headless flag, or -m single-shot
-  if (overrides.headless || overrides.message || !process.stdout.isTTY) {
-    await runHeadless(mergedConfig, workspace, sessionFile.path, overrides.message);
-    return;
-  }
-
-  render(<App config={mergedConfig} workspace={workspace} sessionPath={sessionFile.path} />);
-}
-
-main().catch((error) => {
-  // eslint-disable-next-line no-console
-  console.error("amiko-cli failed:", error);
-  process.exit(1);
-});

package/src/commands.ts

@@ -1,39 +0,0 @@
-export type CommandName =
-  | "exit"
-  | "help"
-  | "memory"
-  | "session"
-  | "search"
-  | "plan"
-  | "index"
-  | "identity"
-  | "personality"
-  | "model";
-
-export type ParsedCommand = {
-  name: CommandName;
-  args: string;
-};
-
-export function parseCommand(input: string): ParsedCommand | null {
-  if (!input.startsWith("/")) return null;
-  const [command, ...rest] = input.slice(1).split(" ");
-  const name = command.toLowerCase();
-  const args = rest.join(" ").trim();
-
-  switch (name) {
-    case "exit":
-    case "help":
-    case "memory":
-    case "session":
-    case "search":
-    case "plan":
-    case "index":
-    case "identity":
-    case "personality":
-    case "model":
-      return { name, args };
-    default:
-      return null;
-  }
-}