mia-code 0.2.0

package/src/commands.ts

@@ -0,0 +1,127 @@
+/**
+ * Command registry for mia-code CLI
+ * Provides metadata for slash commands including descriptions and argument specs
+ */
+
+export interface CommandArg {
+  name: string;
+  description: string;
+  required: boolean;
+}
+
+export interface SlashCommand {
+  name: string;
+  aliases: string[];
+  description: string;
+  args: CommandArg[];
+}
+
+/**
+ * Registry of all available slash commands
+ */
+export const SLASH_COMMANDS: SlashCommand[] = [
+  {
+    name: "exit",
+    aliases: ["quit", "q"],
+    description: "Exit the CLI",
+    args: []
+  },
+  {
+    name: "help",
+    aliases: ["h", "?"],
+    description: "Show this help message",
+    args: []
+  },
+  {
+    name: "session",
+    aliases: [],
+    description: "Show current session info",
+    args: []
+  },
+  {
+    name: "sessions",
+    aliases: [],
+    description: "List all saved sessions",
+    args: []
+  },
+  {
+    name: "clear",
+    aliases: [],
+    description: "Clear sessions for current project",
+    args: []
+  },
+  {
+    name: "config",
+    aliases: [],
+    description: "Configure engine & model (interactive)",
+    args: []
+  },
+  {
+    name: "add-dir",
+    aliases: [],
+    description: "Add directory for tool access",
+    args: [{ name: "path", description: "Directory path to add", required: true }]
+  }
+];
+
+/**
+ * Get all command names including aliases (without the leading /)
+ */
+export function getAllCommandNames(): string[] {
+  const names: string[] = [];
+  for (const cmd of SLASH_COMMANDS) {
+    names.push(cmd.name);
+    names.push(...cmd.aliases);
+  }
+  return names;
+}
+
+/**
+ * Find commands that match a partial input (for tab completion)
+ * @param partial The partial command (without leading /)
+ * @returns Array of matching command names
+ */
+export function findMatchingCommands(partial: string): string[] {
+  const lowerPartial = partial.toLowerCase();
+  const allNames = getAllCommandNames();
+  return allNames.filter(name => name.toLowerCase().startsWith(lowerPartial));
+}
+
+/**
+ * Get the longest common prefix of matching commands
+ * @param matches Array of matching command names
+ * @returns The longest common prefix
+ */
+export function getLongestCommonPrefix(matches: string[]): string {
+  if (matches.length === 0) return "";
+  if (matches.length === 1) return matches[0];
+  
+  let prefix = matches[0];
+  for (let i = 1; i < matches.length; i++) {
+    while (!matches[i].toLowerCase().startsWith(prefix.toLowerCase())) {
+      prefix = prefix.slice(0, -1);
+      if (prefix === "") return "";
+    }
+  }
+  return prefix;
+}
+
+/**
+ * Get command by name or alias
+ */
+export function getCommand(name: string): SlashCommand | undefined {
+  const lowerName = name.toLowerCase();
+  return SLASH_COMMANDS.find(cmd => 
+    cmd.name === lowerName || cmd.aliases.includes(lowerName)
+  );
+}
+
+/**
+ * Format command for display in tab completion hints
+ */
+export function formatCommandHint(cmd: SlashCommand): string {
+  const aliasStr = cmd.aliases.length > 0 
+    ? ` (aliases: ${cmd.aliases.map(a => "/" + a).join(", ")})`
+    : "";
+  return `/${cmd.name}${aliasStr} - ${cmd.description}`;
+}

package/src/config.ts

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { MiaCodeConfig, Engine } from "./types.js";
+
+const CONFIG_FILE = path.join(os.homedir(), ".mia-code.json");
+
+/** Available models per engine */
+export const ENGINE_MODELS: Record<Engine, string[]> = {
+  claude: ["sonnet", "haiku", "opus"],
+  copilot: ["claude-sonnet-4.6", "claude-opus-4.6", "claude-haiku-4.5", "gpt-5-mini", "gpt-4.1"],
+  gemini: ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-3.0-pro", "gemini-3.0-flash"],
+};
+
+/** All supported engines */
+export const ENGINES: Engine[] = ["gemini", "claude", "copilot"];
+
+const defaultConfig: MiaCodeConfig = {
+  engine: (process.env.MIA_CODE_ENGINE as "gemini" | "claude" | "copilot") || "gemini",
+  geminiBinary: process.env.MIA_CODE_GEMINI_BIN || "gemini",
+  claudeBinary: process.env.MIA_CODE_CLAUDE_BIN || "claude",
+  copilotBinary: process.env.MIA_CODE_COPILOT_BIN || "copilot",
+  model: process.env.MIA_CODE_MODEL || "",  // Will be set based on engine if empty
+  headlessOutputFormat: "stream-json",
+  defaultMode: "code",
+  defaultProjectRoot: null,
+  yoloMode: false
+};
+
+export function loadConfig(): MiaCodeConfig {
+  try {
+    let merged = { ...defaultConfig };
+    
+    if (fs.existsSync(CONFIG_FILE)) {
+      const raw = fs.readFileSync(CONFIG_FILE, "utf8");
+      const parsed = JSON.parse(raw);
+      merged = { ...merged, ...parsed };
+    }
+    
+    // Set default model based on engine if not specified
+    if (!merged.model) {
+      merged.model = merged.engine === "claude" ? "sonnet"
+        : merged.engine === "copilot" ? "gpt-4.1"
+        : "gemini-2.5-pro";
+    }
+    
+    return merged;
+  } catch {
+    // Silent fallback
+    const fallback = { ...defaultConfig };
+    if (!fallback.model) {
+      fallback.model = fallback.engine === "claude" ? "sonnet"
+        : fallback.engine === "copilot" ? "gpt-4.1"
+        : "gemini-2.5-pro";
+    }
+    return fallback;
+  }
+}
+
+export function saveConfig(partial: Partial<MiaCodeConfig>): void {
+  const merged = { ...loadConfig(), ...partial };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), "utf8");
+}
+
+export function getConfigPath(): string {
+  return CONFIG_FILE;
+}

package/src/formatting.ts

@@ -0,0 +1,157 @@
+import chalk from "chalk";
+import { GeminiJsonEvent } from "./types.js";
+
+export interface RenderOptions {
+  showRawToolEvents?: boolean;
+  showTimestamps?: boolean;
+  compact?: boolean;
+}
+
+export function renderEventsToText(
+  events: GeminiJsonEvent[],
+  opts: RenderOptions = {}
+): string {
+  const { showRawToolEvents = false, showTimestamps = false, compact = false } = opts;
+  const out: string[] = [];
+  
+  // Consolidate consecutive assistant messages
+  let assistantTextBuffer: string[] = [];
+  
+  const flushAssistantBuffer = () => {
+    if (assistantTextBuffer.length > 0) {
+      const fullText = assistantTextBuffer.join("").trim();
+      if (fullText) {
+        out.push(formatAssistantText(fullText, compact));
+      }
+      assistantTextBuffer = [];
+    }
+  };
+
+  for (const evt of events) {
+    switch (evt.type) {
+      case "init": {
+        flushAssistantBuffer();
+        const sid = evt.session_id ? ` (${evt.session_id.slice(0, 8)}...)` : "";
+        const ts = showTimestamps && evt.timestamp ? ` [${evt.timestamp}]` : "";
+        out.push(chalk.dim(`🧠🌸 session init${sid}${ts}`));
+        break;
+      }
+      case "message": {
+        if (evt.role === "assistant") {
+          const content = evt.text || evt.content || "";
+          if (content) {
+            assistantTextBuffer.push(content);
+          }
+        } else if (evt.role === "user") {
+          flushAssistantBuffer();
+          out.push(chalk.cyan.bold(`you:`));
+          out.push(chalk.cyan(evt.text || evt.content || ""));
+        }
+        break;
+      }
+      case "tool_use": {
+        flushAssistantBuffer();
+        if (!showRawToolEvents) break;
+        out.push(chalk.magenta(`🔧 tool_use: ${evt.tool?.name || (evt as any).name || ""}`));
+        break;
+      }
+      case "tool_result": {
+        flushAssistantBuffer();
+        if (!showRawToolEvents) break;
+        out.push(chalk.magenta(`✓ tool_result: ${evt.tool?.name || (evt as any).name || ""}`));
+        break;
+      }
+      case "error": {
+        flushAssistantBuffer();
+        out.push(
+          chalk.red(`❌ error: ${evt.error?.code ?? ""} - ${evt.error?.message ?? ""}`)
+        );
+        break;
+      }
+      case "result": {
+        flushAssistantBuffer();
+        if (!compact) {
+          out.push(chalk.dim("🧠🌸 session complete"));
+        }
+        break;
+      }
+      case "raw_text": {
+        if (evt.text) {
+          assistantTextBuffer.push(evt.text);
+        }
+        break;
+      }
+      default:
+        // Handle unknown event types with text content
+        const text = evt.text || evt.content;
+        if (text) {
+          assistantTextBuffer.push(String(text));
+        }
+        break;
+    }
+  }
+  
+  // Flush any remaining assistant text
+  flushAssistantBuffer();
+
+  return out.join("\n");
+}
+
+function formatAssistantText(text: string, compact: boolean): string {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+
+  // Check if text already has 🧠🌸 miawa: prefix (agent self-formats)
+  const hasPrefix = trimmed.startsWith("🧠🌸 miawa:");
+  
+  if (compact) {
+    return trimmed;
+  }
+
+  // If agent already formatted, use it as-is
+  if (hasPrefix) {
+    return trimmed;
+  }
+
+  // Otherwise, add our prefix
+  return [chalk.green.bold("🧠🌸 miawa:"), "", trimmed].join("\n");
+}
+
+export function formatSpinner(message: string): string {
+  return chalk.dim(`⏳ ${message}`);
+}
+
+export function formatError(message: string): string {
+  return chalk.red(`❌ ${message}`);
+}
+
+export function formatSuccess(message: string): string {
+  return chalk.green(`✓ ${message}`);
+}
+
+export function formatHeader(projectRoot: string, sessionId?: string, engine?: string): string {
+  const lines: string[] = [];
+  const engineName = engine === "claude" ? "Claude" : engine === "copilot" ? "Copilot" : "Gemini";
+  lines.push(chalk.bold(`🧠🌸 mia-code — ${engineName}-backed terminal agent`));
+  lines.push(chalk.dim(`project: ${projectRoot}`));
+  if (sessionId) {
+    lines.push(chalk.dim(`session: ${sessionId.slice(0, 12)}...`));
+  }
+  return lines.join("\n");
+}
+
+export function formatHelpText(): string {
+  return chalk.dim(`
+Commands:
+  /exit, /quit     Exit the CLI
+  /session         Show current session info
+  /sessions        List all sessions
+  /clear           Clear session for current project
+  /config          Configure engine & model (interactive)
+  /add-dir <path>  Add directory for tool access
+  /help            Show this help
+
+Note: By default, output is interpreted through the Miawa Unifier.
+      Use --raw flag to see uninterpreted agent output.
+`);
+}

package/src/geminiHeadless.ts

@@ -0,0 +1,300 @@
+import { spawn, ChildProcess } from "child_process";
+import { MiaCodeConfig, GeminiJsonEvent } from "./types.js";
+
+export interface GeminiHeadlessOptions {
+  prompt: string;
+  config: MiaCodeConfig;
+  sessionId?: string;
+  projectRoot?: string | null;
+  additionalDirs?: string[];
+  onEvent?: (event: GeminiJsonEvent) => void;
+}
+
+export interface GeminiHeadlessResult {
+  sessionId?: string;
+  events: GeminiJsonEvent[];
+}
+
+export function runGeminiHeadless(
+  opts: GeminiHeadlessOptions
+): Promise<GeminiHeadlessResult> {
+  const { prompt, config, sessionId, projectRoot, additionalDirs, onEvent } = opts;
+
+  const binary = config.engine === "claude" ? config.claudeBinary
+    : config.engine === "copilot" ? config.copilotBinary
+    : config.geminiBinary;
+  const args: string[] = [];
+
+  // Positional prompt for non-interactive mode
+  args.push(prompt);
+
+  // Engine-specific flags
+  let actualOutputFormat = config.headlessOutputFormat;
+
+  if (config.engine === "claude") {
+    // Claude uses --print for non-interactive mode
+    args.push("--print");
+    // Claude --print with stream-json requires --verbose, use json instead
+    actualOutputFormat = config.headlessOutputFormat === "stream-json" ? "json" : config.headlessOutputFormat;
+    args.push("--output-format", actualOutputFormat);
+  } else if (config.engine === "copilot") {
+    // Copilot-cli uses --print for non-interactive mode
+    args.push("--print");
+    actualOutputFormat = "json";
+    args.push("--output-format", actualOutputFormat);
+  } else {
+    // Gemini uses --output-format directly
+    args.push("--output-format", config.headlessOutputFormat);
+  }
+
+  // Model
+  if (config.model) {
+    args.push("--model", config.model);
+  }
+
+  // YOLO mode for auto-approval
+  if (config.yoloMode) {
+    if (config.engine === "claude" || config.engine === "copilot") {
+      args.push("--dangerously-skip-permissions");
+    } else {
+      args.push("--yolo");
+    }
+  }
+
+  // Session resume
+  if (sessionId) {
+    args.push("--resume", sessionId);
+  }
+
+  // Additional directories
+  if (additionalDirs) {
+    for (const dir of additionalDirs) {
+      args.push("--add-dir", dir);
+    }
+  }
+
+  const child = spawn(binary, args, {
+    cwd: projectRoot || process.cwd(),
+    // Claude/copilot --print mode needs stdin closed, Gemini needs it open
+    stdio: (config.engine === "claude" || config.engine === "copilot") ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
+    env: { ...process.env, FORCE_COLOR: "1" }
+  });
+
+  return new Promise((resolve, reject) => {
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    const events: GeminiJsonEvent[] = [];
+    let discoveredSessionId: string | undefined;
+
+    // Claude/copilot with json format returns single JSON object, not JSONL
+    const isClaudeJsonMode = (config.engine === "claude" || config.engine === "copilot") && actualOutputFormat === "json";
+
+    child.stdout?.on("data", (chunk: Buffer) => {
+      const text = chunk.toString("utf8");
+      stdoutBuf += text;
+
+      // Only parse line-by-line for stream-json format (Gemini or Claude with stream-json)
+      if (!isClaudeJsonMode) {
+        // Parse JSONL (stream-json format)
+        const lines = stdoutBuf.split("\n");
+        stdoutBuf = lines.pop() ?? "";  // Keep last incomplete line in buffer
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const evt = JSON.parse(trimmed) as GeminiJsonEvent;
+            if (evt.session_id && !discoveredSessionId) {
+              discoveredSessionId = evt.session_id;
+            }
+            events.push(evt);
+            if (onEvent) {
+              onEvent(evt);
+            }
+          } catch {
+            // Non-JSON line, could be raw text output
+            const textEvt: GeminiJsonEvent = { type: "raw_text", text: trimmed };
+            events.push(textEvt);
+            if (onEvent) {
+              onEvent(textEvt);
+            }
+          }
+        }
+      }
+      // For Claude json mode, just accumulate - don't split or parse yet
+    });
+
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderrBuf += chunk.toString("utf8");
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+
+    child.on("close", (code) => {
+      // Handle remaining buffer
+      const trimmed = stdoutBuf.trim();
+      
+      if (trimmed) {
+        try {
+          const obj = JSON.parse(trimmed) as any;
+          
+          // Claude --print with --output-format json returns {type: "result", result: "text"}
+          if (obj.type === "result" && obj.result) {
+            // Convert to standard message format
+            const resultEvt: GeminiJsonEvent = {
+              type: "message",
+              role: "assistant",
+              text: obj.result,
+              session_id: obj.session_id
+            };
+            events.push(resultEvt);
+            
+            // Also add a completion event
+            events.push({ type: "result", session_id: obj.session_id });
+            
+            if (obj.session_id && !discoveredSessionId) {
+              discoveredSessionId = obj.session_id;
+            }
+            if (onEvent) {
+              onEvent(resultEvt);
+            }
+          } else if (Array.isArray(obj)) {
+            for (const evt of obj) {
+              events.push(evt);
+              if (evt.session_id && !discoveredSessionId) {
+                discoveredSessionId = evt.session_id;
+              }
+              if (onEvent) {
+                onEvent(evt);
+              }
+            }
+          } else {
+            // Generic event
+            events.push(obj);
+            if (obj.session_id && !discoveredSessionId) {
+              discoveredSessionId = obj.session_id;
+            }
+            if (onEvent) {
+              onEvent(obj);
+            }
+          }
+        } catch {
+          // Raw text output
+          if (trimmed) {
+            const textEvt: GeminiJsonEvent = { type: "raw_text", text: trimmed };
+            events.push(textEvt);
+            if (onEvent) {
+              onEvent(textEvt);
+            }
+          }
+        }
+      }
+
+      // Handle specific exit codes
+      if (code === 42) {
+        // Gemini-specific: Invalid session identifier
+        reject(new Error(`Invalid session identifier "${sessionId}"`));
+        return;
+      }
+
+      if (code !== 0 && !events.length) {
+        reject(new Error(`${config.engine} exited with code ${code}\n${stderrBuf}`));
+        return;
+      }
+
+      resolve({
+        sessionId: discoveredSessionId || sessionId,
+        events
+      });
+    });
+  });
+}
+
+export interface GeminiStreamOptions {
+  prompt: string;
+  config: MiaCodeConfig;
+  sessionId?: string;
+  projectRoot?: string | null;
+  onData: (text: string) => void;
+  onEvent?: (event: GeminiJsonEvent) => void;
+  onComplete?: (sessionId?: string) => void;
+}
+
+export function streamGemini(opts: GeminiStreamOptions): ChildProcess {
+  const { prompt, config, sessionId, projectRoot, onData, onEvent, onComplete } = opts;
+
+  const binary = config.engine === "claude" ? config.claudeBinary
+    : config.engine === "copilot" ? config.copilotBinary
+    : config.geminiBinary;
+  const args: string[] = [];
+  args.push(prompt);
+
+  if (config.engine === "claude" || config.engine === "copilot") {
+    args.push("--print");
+  }
+  args.push("--output-format", "stream-json");
+
+  if (config.model) {
+    args.push("--model", config.model);
+  }
+
+  if (config.yoloMode) {
+    if (config.engine === "claude" || config.engine === "copilot") {
+      args.push("--dangerously-skip-permissions");
+    } else {
+      args.push("--yolo");
+    }
+  }
+
+  if (sessionId) {
+    args.push("--resume", sessionId);
+  }
+
+  const child = spawn(binary, args, {
+    cwd: projectRoot || process.cwd(),
+    stdio: (config.engine === "claude" || config.engine === "copilot") ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
+    env: { ...process.env, FORCE_COLOR: "1" }
+  });
+
+  let stdoutBuf = "";
+  let discoveredSessionId: string | undefined;
+
+  child.stdout?.on("data", (chunk: Buffer) => {
+    const text = chunk.toString("utf8");
+    stdoutBuf += text;
+
+    const lines = stdoutBuf.split("\n");
+    stdoutBuf = lines.pop() ?? "";
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const evt = JSON.parse(trimmed) as GeminiJsonEvent;
+        if (evt.session_id && !discoveredSessionId) {
+          discoveredSessionId = evt.session_id;
+        }
+        if (onEvent) {
+          onEvent(evt);
+        }
+        // Extract text content for display
+        const textContent = evt.text || evt.content || (evt.type === "raw_text" ? evt.text : null);
+        if (textContent) {
+          onData(textContent);
+        }
+      } catch {
+        onData(trimmed);
+      }
+    }
+  });
+
+  child.on("close", () => {
+    if (onComplete) {
+      onComplete(discoveredSessionId);
+    }
+  });
+
+  return child;
+}