mia-code 0.2.0

package/dist/commands.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 declare const SLASH_COMMANDS: SlashCommand[];
+/**
+ * Get all command names including aliases (without the leading /)
+ */
+export declare function getAllCommandNames(): string[];
+/**
+ * Find commands that match a partial input (for tab completion)
+ * @param partial The partial command (without leading /)
+ * @returns Array of matching command names
+ */
+export declare function findMatchingCommands(partial: string): string[];
+/**
+ * Get the longest common prefix of matching commands
+ * @param matches Array of matching command names
+ * @returns The longest common prefix
+ */
+export declare function getLongestCommonPrefix(matches: string[]): string;
+/**
+ * Get command by name or alias
+ */
+export declare function getCommand(name: string): SlashCommand | undefined;
+/**
+ * Format command for display in tab completion hints
+ */
+export declare function formatCommandHint(cmd: SlashCommand): string;

package/dist/commands.js

@@ -0,0 +1,108 @@
+/**
+ * Command registry for mia-code CLI
+ * Provides metadata for slash commands including descriptions and argument specs
+ */
+/**
+ * Registry of all available slash commands
+ */
+export const SLASH_COMMANDS = [
+    {
+        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() {
+    const names = [];
+    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) {
+    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) {
+    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) {
+    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) {
+    const aliasStr = cmd.aliases.length > 0
+        ? ` (aliases: ${cmd.aliases.map(a => "/" + a).join(", ")})`
+        : "";
+    return `/${cmd.name}${aliasStr} - ${cmd.description}`;
+}

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+import { MiaCodeConfig, Engine } from "./types.js";
+/** Available models per engine */
+export declare const ENGINE_MODELS: Record<Engine, string[]>;
+/** All supported engines */
+export declare const ENGINES: Engine[];
+export declare function loadConfig(): MiaCodeConfig;
+export declare function saveConfig(partial: Partial<MiaCodeConfig>): void;
+export declare function getConfigPath(): string;

package/dist/config.js

@@ -0,0 +1,57 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+const CONFIG_FILE = path.join(os.homedir(), ".mia-code.json");
+/** Available models per engine */
+export const ENGINE_MODELS = {
+    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 = ["gemini", "claude", "copilot"];
+const defaultConfig = {
+    engine: process.env.MIA_CODE_ENGINE || "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() {
+    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) {
+    const merged = { ...loadConfig(), ...partial };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), "utf8");
+}
+export function getConfigPath() {
+    return CONFIG_FILE;
+}

package/dist/formatting.d.ts

@@ -0,0 +1,12 @@
+import { GeminiJsonEvent } from "./types.js";
+export interface RenderOptions {
+    showRawToolEvents?: boolean;
+    showTimestamps?: boolean;
+    compact?: boolean;
+}
+export declare function renderEventsToText(events: GeminiJsonEvent[], opts?: RenderOptions): string;
+export declare function formatSpinner(message: string): string;
+export declare function formatError(message: string): string;
+export declare function formatSuccess(message: string): string;
+export declare function formatHeader(projectRoot: string, sessionId?: string, engine?: string): string;
+export declare function formatHelpText(): string;

package/dist/formatting.js

@@ -0,0 +1,133 @@
+import chalk from "chalk";
+export function renderEventsToText(events, opts = {}) {
+    const { showRawToolEvents = false, showTimestamps = false, compact = false } = opts;
+    const out = [];
+    // Consolidate consecutive assistant messages
+    let assistantTextBuffer = [];
+    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.name || ""}`));
+                break;
+            }
+            case "tool_result": {
+                flushAssistantBuffer();
+                if (!showRawToolEvents)
+                    break;
+                out.push(chalk.magenta(`✓ tool_result: ${evt.tool?.name || evt.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, compact) {
+    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) {
+    return chalk.dim(`⏳ ${message}`);
+}
+export function formatError(message) {
+    return chalk.red(`❌ ${message}`);
+}
+export function formatSuccess(message) {
+    return chalk.green(`✓ ${message}`);
+}
+export function formatHeader(projectRoot, sessionId, engine) {
+    const lines = [];
+    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() {
+    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/dist/geminiHeadless.d.ts

@@ -0,0 +1,25 @@
+import { 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 declare function runGeminiHeadless(opts: GeminiHeadlessOptions): Promise<GeminiHeadlessResult>;
+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 declare function streamGemini(opts: GeminiStreamOptions): ChildProcess;

package/dist/geminiHeadless.js

@@ -0,0 +1,246 @@
+import { spawn } from "child_process";
+export function runGeminiHeadless(opts) {
+    const { prompt, config, sessionId, projectRoot, additionalDirs, onEvent } = opts;
+    const binary = config.engine === "claude" ? config.claudeBinary
+        : config.engine === "copilot" ? config.copilotBinary
+            : config.geminiBinary;
+    const args = [];
+    // 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 = [];
+        let discoveredSessionId;
+        // 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) => {
+            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);
+                        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 = { 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) => {
+            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);
+                    // Claude --print with --output-format json returns {type: "result", result: "text"}
+                    if (obj.type === "result" && obj.result) {
+                        // Convert to standard message format
+                        const resultEvt = {
+                            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 = { 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 function streamGemini(opts) {
+    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 = [];
+    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;
+    child.stdout?.on("data", (chunk) => {
+        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);
+                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;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};