@heyamiko/amiko-cli 0.4.0 → 0.4.7

package/src/app.tsx

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

@@ -0,0 +1,95 @@
+#!/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";
+
+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";
+}>;
+
+function parseArgs(argv: string[]): ArgOverrides {
+  const overrides: ArgOverrides = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      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() {
+  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);
+
+  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

@@ -0,0 +1,39 @@
+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;
+  }
+}

package/src/components/ModelPicker.tsx

@@ -0,0 +1,107 @@
+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>
+  );
+}