mia-code 0.2.0

package/dist/cli.js

@@ -0,0 +1,679 @@
+import { createInterface } from "readline";
+import chalk from "chalk";
+import { loadConfig, saveConfig, ENGINE_MODELS, ENGINES } from "./config.js";
+import { runGeminiHeadless } from "./geminiHeadless.js";
+import { rememberSession, getLastSessionForProject, listSessions, clearSessions, markSessionInitialized, isSessionInitialized, saveChatMessage, loadChatHistory } from "./sessionStore.js";
+import { renderEventsToText, formatHeader, formatHelpText, formatError, formatSuccess } from "./formatting.js";
+import { runUnifierSession } from "./unifier.js";
+import { MultilineInput, supportsMultilineInput } from "./multiline-input.js";
+import { findMatchingCommands, getCommand } from "./commands.js";
+import path from "path";
+import fs from "fs";
+/** Prompt a numbered-choice question and return the 0-based index chosen. */
+async function promptChoice(label, options, current) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    console.log(chalk.bold(`\n${label}`));
+    options.forEach((opt, i) => {
+        const marker = opt === current ? chalk.green(" ◀ current") : "";
+        console.log(chalk.dim(`  ${i + 1}. ${opt}${marker}`));
+    });
+    return new Promise((resolve) => {
+        rl.question(chalk.cyan(`  select (1-${options.length}): `), (answer) => {
+            rl.close();
+            const n = parseInt(answer.trim(), 10);
+            if (isNaN(n) || n < 1 || n > options.length) {
+                console.log(chalk.yellow("  cancelled (invalid choice)"));
+                resolve(-1);
+            }
+            else {
+                resolve(n - 1);
+            }
+        });
+    });
+}
+/** Interactive config: pick engine → pick model → save */
+async function runInteractiveConfig(config) {
+    console.log(chalk.dim("\ncurrent configuration:"));
+    console.log(chalk.dim(`  engine: ${config.engine}`));
+    console.log(chalk.dim(`  model:  ${config.model}`));
+    // 1. Pick engine
+    const engineIdx = await promptChoice("Select engine:", ENGINES, config.engine);
+    if (engineIdx < 0)
+        return;
+    const engine = ENGINES[engineIdx];
+    // 2. Pick model for chosen engine
+    const models = ENGINE_MODELS[engine];
+    const modelIdx = await promptChoice(`Select model for ${engine}:`, models, config.model);
+    if (modelIdx < 0)
+        return;
+    const model = models[modelIdx];
+    // 3. Save
+    saveConfig({ engine, model });
+    config.engine = engine;
+    config.model = model;
+    console.log(chalk.green(`\n✓ config updated → engine: ${engine}, model: ${model}`));
+}
+async function pickSession(projectRoot) {
+    const sessions = listSessions().filter(s => s.projectRoot === projectRoot);
+    if (sessions.length === 0) {
+        console.log(chalk.yellow("No saved sessions for this project."));
+        return undefined;
+    }
+    console.log(chalk.bold("\nAvailable sessions:"));
+    sessions.forEach((s, idx) => {
+        console.log(chalk.dim(`  ${idx + 1}. ${s.id.slice(0, 12)}... (${s.startedAt})`));
+    });
+    console.log(chalk.dim(`  0. Start new session`));
+    console.log("");
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(chalk.cyan("Select session (0-" + sessions.length + "): "), (answer) => {
+            rl.close();
+            const choice = parseInt(answer.trim(), 10);
+            if (isNaN(choice) || choice < 0 || choice > sessions.length) {
+                console.log(chalk.yellow("Invalid choice. Starting new session."));
+                resolve(undefined);
+            }
+            else if (choice === 0) {
+                resolve(undefined);
+            }
+            else {
+                resolve(sessions[choice - 1].id);
+            }
+        });
+    });
+}
+export async function runInteractiveCli(options = {}) {
+    const config = loadConfig();
+    const projectRoot = options.projectRoot
+        ? path.resolve(options.projectRoot)
+        : process.cwd();
+    // Override engine if specified
+    if (options.engine !== undefined) {
+        config.engine = options.engine;
+        // Update model to match engine if using default
+        if (!process.env.MIA_CODE_MODEL && !options.resume) {
+            config.model = config.engine === "claude" ? "sonnet" : "gemini-2.5-pro";
+        }
+    }
+    // Override yolo mode if specified
+    if (options.yolo !== undefined) {
+        config.yoloMode = options.yolo;
+    }
+    // Raw mode - skip unifier, show raw events
+    const rawMode = options.raw ?? false;
+    // Mutable list of additional directories (from CLI + runtime /add-dir)
+    const runtimeAddDirs = [...(options.addDirs || [])];
+    // Handle session resume
+    let currentSessionId;
+    if (options.resume === true) {
+        // Interactive session picker
+        currentSessionId = await pickSession(projectRoot);
+    }
+    else if (typeof options.resume === "string") {
+        // Explicit session ID provided
+        currentSessionId = options.resume;
+    }
+    else {
+        // Auto-resume last session for this project
+        currentSessionId = getLastSessionForProject(projectRoot)?.id;
+    }
+    // Print header
+    console.log("");
+    console.log(formatHeader(projectRoot, currentSessionId, config.engine));
+    if (!currentSessionId) {
+        console.log(chalk.dim("new session will be created on first prompt"));
+    }
+    if (supportsMultilineInput()) {
+        console.log(chalk.dim("type /help for commands, Ctrl+J for newline, Enter to submit"));
+    }
+    else {
+        console.log(chalk.dim("type /help for commands, ctrl+c to exit"));
+    }
+    console.log("");
+    // Restore chat history if resuming a session
+    if (currentSessionId) {
+        const history = loadChatHistory(currentSessionId);
+        if (history.length > 0) {
+            console.log(chalk.dim(`── restoring ${history.length} messages ──`));
+            for (const msg of history) {
+                if (msg.role === "user") {
+                    console.log(chalk.cyan.bold("you> ") + chalk.cyan(msg.text.length > 200 ? msg.text.slice(0, 200) + "…" : msg.text));
+                }
+                else {
+                    const preview = msg.text.length > 300 ? msg.text.slice(0, 300) + "…" : msg.text;
+                    console.log(chalk.green.bold("🧠🌸 ") + chalk.dim(preview));
+                }
+            }
+            console.log(chalk.dim(`── end history ──\n`));
+        }
+    }
+    // Process input handles both readline and MultilineInput callbacks
+    const processInput = async (input, resetFn) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            resetFn();
+            return true;
+        }
+        // Handle slash commands
+        if (trimmed.startsWith("/")) {
+            const [cmd] = trimmed.slice(1).split(/\s+/);
+            const lowerCmd = cmd.toLowerCase();
+            switch (lowerCmd) {
+                case "exit":
+                case "quit":
+                case "q":
+                    console.log(chalk.dim("👋 bye."));
+                    return false;
+                case "help":
+                case "h":
+                case "?":
+                    console.log(formatHelpText());
+                    break;
+                case "session":
+                    if (currentSessionId) {
+                        console.log(chalk.dim(`current session: ${currentSessionId}`));
+                        console.log(chalk.dim(`project: ${projectRoot}`));
+                        console.log(chalk.dim(`model: ${config.model}`));
+                    }
+                    else {
+                        console.log(chalk.dim("no active session"));
+                    }
+                    break;
+                case "sessions":
+                    const sessions = listSessions();
+                    if (sessions.length === 0) {
+                        console.log(chalk.dim("no saved sessions"));
+                    }
+                    else {
+                        console.log(chalk.dim(`saved sessions (${sessions.length}):`));
+                        for (const s of sessions.slice(-10)) {
+                            const marker = s.id === currentSessionId ? chalk.green("→ ") : "  ";
+                            console.log(chalk.dim(`${marker}${s.id.slice(0, 12)}... | ${s.projectRoot || "unknown"} | ${s.startedAt}`));
+                        }
+                    }
+                    break;
+                case "clear":
+                    clearSessions();
+                    console.log(formatSuccess("sessions cleared"));
+                    break;
+                case "config":
+                    await runInteractiveConfig(config);
+                    break;
+                case "add-dir": {
+                    const dirArg = trimmed.slice(trimmed.indexOf(cmd) + cmd.length).trim();
+                    if (!dirArg) {
+                        console.log(chalk.dim("usage: /add-dir <directory>"));
+                        if (runtimeAddDirs.length > 0) {
+                            console.log(chalk.dim(`\ncurrent additional dirs:`));
+                            for (const d of runtimeAddDirs) {
+                                console.log(chalk.dim(`  📁 ${d}`));
+                            }
+                        }
+                        break;
+                    }
+                    const resolved = path.resolve(dirArg);
+                    try {
+                        const stat = fs.statSync(resolved);
+                        if (!stat.isDirectory()) {
+                            console.log(formatError(`not a directory: ${resolved}`));
+                            break;
+                        }
+                    }
+                    catch {
+                        console.log(formatError(`directory not found: ${resolved}`));
+                        break;
+                    }
+                    if (!runtimeAddDirs.includes(resolved)) {
+                        runtimeAddDirs.push(resolved);
+                    }
+                    console.log(formatSuccess(`added directory: ${resolved}`));
+                    console.log(chalk.dim(`total additional dirs: ${runtimeAddDirs.length}`));
+                    break;
+                }
+                default:
+                    console.log(formatError(`unknown command: /${cmd}`));
+                    console.log(formatHelpText());
+            }
+            console.log("");
+            resetFn();
+            return true;
+        }
+        // Expand @file references: read file contents and inject into prompt
+        const expandedPrompt = expandFileReferences(trimmed);
+        // Send to engine
+        console.log("");
+        console.log(chalk.dim("⏳ thinking..."));
+        try {
+            // Only pass sessionId if the session is initialized (acknowledged by engine)
+            const sessionToUse = currentSessionId && isSessionInitialized(currentSessionId)
+                ? currentSessionId
+                : undefined;
+            const result = await runGeminiHeadless({
+                prompt: expandedPrompt,
+                config,
+                sessionId: sessionToUse,
+                projectRoot,
+                additionalDirs: runtimeAddDirs.length > 0 ? runtimeAddDirs : undefined
+            });
+            // Clear the "thinking" line
+            process.stdout.write("\x1B[1A\x1B[2K");
+            if (result.sessionId) {
+                if (result.sessionId !== currentSessionId) {
+                    currentSessionId = result.sessionId;
+                    const meta = {
+                        id: currentSessionId,
+                        startedAt: new Date().toISOString(),
+                        model: config.model,
+                        projectRoot,
+                        initialized: true
+                    };
+                    rememberSession(meta);
+                    console.log(chalk.dim(`session: ${currentSessionId.slice(0, 12)}...`));
+                }
+                else if (!isSessionInitialized(currentSessionId)) {
+                    // Mark existing session as initialized now that engine acknowledged it
+                    markSessionInitialized(currentSessionId);
+                }
+            }
+            // Extract assistant text for history
+            let assistantText = "";
+            // Raw mode: show original events
+            if (rawMode) {
+                const rendered = renderEventsToText(result.events);
+                if (rendered) {
+                    console.log(rendered);
+                    assistantText = rendered;
+                }
+            }
+            else {
+                // Unifier mode: run ceremonial interpretation
+                console.log(chalk.dim("⏳ interpreting..."));
+                try {
+                    const ceremonialOutput = await runUnifierSession(result.events, trimmed, config);
+                    process.stdout.write("\x1B[1A\x1B[2K");
+                    if (ceremonialOutput) {
+                        console.log(ceremonialOutput);
+                        assistantText = ceremonialOutput;
+                    }
+                }
+                catch (unifierErr) {
+                    // Fallback to raw output if unifier fails
+                    process.stdout.write("\x1B[1A\x1B[2K");
+                    console.log(chalk.yellow("⚠ unifier failed, showing raw output:"));
+                    const rendered = renderEventsToText(result.events);
+                    if (rendered) {
+                        console.log(rendered);
+                        assistantText = rendered;
+                    }
+                }
+            }
+            // Save chat history
+            if (currentSessionId) {
+                const ts = new Date().toISOString();
+                saveChatMessage(currentSessionId, { role: "user", text: trimmed, timestamp: ts });
+                if (assistantText) {
+                    saveChatMessage(currentSessionId, { role: "assistant", text: assistantText, timestamp: ts });
+                }
+            }
+            console.log("");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // Handle invalid session error gracefully
+            if (message.includes("Invalid session identifier") && currentSessionId) {
+                console.log(chalk.yellow("⚠ Session expired, starting fresh..."));
+                // Mark session as not initialized and retry without session
+                const meta = {
+                    id: currentSessionId,
+                    startedAt: new Date().toISOString(),
+                    model: config.model,
+                    projectRoot,
+                    initialized: false
+                };
+                rememberSession(meta);
+                try {
+                    const result = await runGeminiHeadless({
+                        prompt: trimmed,
+                        config,
+                        sessionId: undefined, // Don't resume
+                        projectRoot,
+                        additionalDirs: runtimeAddDirs.length > 0 ? runtimeAddDirs : undefined
+                    });
+                    process.stdout.write("\x1B[1A\x1B[2K");
+                    if (result.sessionId) {
+                        currentSessionId = result.sessionId;
+                        const newMeta = {
+                            id: currentSessionId,
+                            startedAt: new Date().toISOString(),
+                            model: config.model,
+                            projectRoot,
+                            initialized: true
+                        };
+                        rememberSession(newMeta);
+                        console.log(chalk.dim(`new session: ${currentSessionId.slice(0, 12)}...`));
+                    }
+                    const rendered = renderEventsToText(result.events);
+                    if (rendered) {
+                        console.log(rendered);
+                    }
+                }
+                catch (retryErr) {
+                    const retryMessage = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                    console.log(formatError(`engine error: ${retryMessage}`));
+                }
+            }
+            else {
+                console.log(formatError(`engine error: ${message}`));
+            }
+            console.log("");
+        }
+        resetFn();
+        return true;
+    };
+    // Tab completion handler for /commands and @file paths
+    const handleTabComplete = (input) => {
+        // --- @file/path completion ---
+        // Find the last @ token before or at cursor position
+        const atIdx = input.lastIndexOf("@");
+        if (atIdx >= 0) {
+            const afterAt = input.slice(atIdx + 1);
+            // Only complete if there's no space after @ (still typing the path)
+            if (!afterAt.includes(" ")) {
+                return completeFilePath(input, atIdx, afterAt);
+            }
+        }
+        // --- /command completion (only when input starts with / with no spaces) ---
+        if (input.startsWith("/") && !input.includes(" ")) {
+            const partial = input.slice(1);
+            const matches = findMatchingCommands(partial);
+            if (matches.length === 0)
+                return null;
+            // Build rich labels: "/command  — description"
+            const labels = matches.map(name => {
+                const cmd = getCommand(name);
+                const desc = cmd ? cmd.description : "";
+                return desc ? `/${name}  — ${desc}` : `/${name}`;
+            });
+            return {
+                matches,
+                labels,
+                prefix: partial,
+                tokenStart: 0,
+                triggerChar: "/",
+            };
+        }
+        // --- /add-dir <path> directory completion ---
+        const addDirMatch = input.match(/^\/add-dir\s+(.*)/);
+        if (addDirMatch) {
+            const partial = addDirMatch[1];
+            return completeDirPath(input, input.indexOf(addDirMatch[1]), partial);
+        }
+        return null;
+    };
+    function fileIcon(name) {
+        const ext = name.split(".").pop()?.toLowerCase() || "";
+        const icons = {
+            ts: "🔷", tsx: "🔷", js: "🟡", jsx: "🟡", json: "📋",
+            md: "📝", txt: "📄", sh: "⚙️", yaml: "📋", yml: "📋",
+            py: "🐍", rs: "🦀", go: "🔵", toml: "📋", lock: "🔒",
+            css: "🎨", html: "🌐", svg: "🖼️", png: "🖼️", jpg: "🖼️",
+        };
+        return icons[ext] || "📄";
+    }
+    /**
+     * Complete file/directory paths after @
+     */
+    function completeFilePath(_input, atIdx, partial) {
+        const cwd = process.cwd();
+        // Split into directory part and name prefix
+        const lastSlash = partial.lastIndexOf("/");
+        let dirPath;
+        let namePrefix;
+        if (lastSlash >= 0) {
+            dirPath = partial.slice(0, lastSlash + 1);
+            namePrefix = partial.slice(lastSlash + 1);
+        }
+        else {
+            dirPath = "";
+            namePrefix = partial;
+        }
+        const resolvedDir = path.resolve(cwd, dirPath || ".");
+        let entries;
+        try {
+            entries = fs.readdirSync(resolvedDir, { withFileTypes: true });
+        }
+        catch {
+            return null;
+        }
+        // Filter: skip hidden files, match prefix
+        const lowerPrefix = namePrefix.toLowerCase();
+        const filtered = entries
+            .filter(e => !e.name.startsWith(".") && e.name.toLowerCase().startsWith(lowerPrefix))
+            .sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory())
+                return -1;
+            if (!a.isDirectory() && b.isDirectory())
+                return 1;
+            return a.name.localeCompare(b.name);
+        })
+            .slice(0, 20);
+        const matches = filtered.map(e => dirPath + e.name + (e.isDirectory() ? "/" : ""));
+        // Rich labels with icons
+        const labels = filtered.map(e => {
+            const icon = e.isDirectory() ? "📁" : fileIcon(e.name);
+            return `${icon} @${dirPath}${e.name}${e.isDirectory() ? "/" : ""}`;
+        });
+        if (matches.length === 0)
+            return null;
+        return {
+            matches,
+            labels,
+            prefix: partial,
+            tokenStart: atIdx,
+            triggerChar: "@",
+            isFilePath: true,
+        };
+    }
+    /**
+     * Complete directory paths for /add-dir command
+     */
+    function completeDirPath(_input, tokenStart, partial) {
+        const cwd = process.cwd();
+        const lastSlash = partial.lastIndexOf("/");
+        let dirPath;
+        let namePrefix;
+        if (lastSlash >= 0) {
+            dirPath = partial.slice(0, lastSlash + 1);
+            namePrefix = partial.slice(lastSlash + 1);
+        }
+        else {
+            dirPath = "";
+            namePrefix = partial;
+        }
+        const resolvedDir = path.resolve(cwd, dirPath || ".");
+        let entries;
+        try {
+            entries = fs.readdirSync(resolvedDir, { withFileTypes: true });
+        }
+        catch {
+            return null;
+        }
+        const lowerPrefix = namePrefix.toLowerCase();
+        const filtered = entries
+            .filter(e => e.isDirectory() && !e.name.startsWith(".") && e.name.toLowerCase().startsWith(lowerPrefix))
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .slice(0, 20);
+        const matches = filtered.map(e => dirPath + e.name + "/");
+        const labels = filtered.map(e => `📁 ${dirPath}${e.name}/`);
+        if (matches.length === 0)
+            return null;
+        return {
+            matches,
+            labels,
+            prefix: partial,
+            tokenStart,
+            triggerChar: "",
+            isFilePath: true,
+        };
+    }
+    /**
+     * Expand @file references in user input.
+     * Replaces @path/to/file with the file contents block.
+     */
+    function expandFileReferences(input) {
+        // Match @path (non-whitespace after @), but not email-like patterns
+        const refPattern = /@((?:\.{0,2}\/)?[\w./_-]+[\w._-])/g;
+        let expanded = input;
+        const seen = new Set();
+        let match;
+        while ((match = refPattern.exec(input)) !== null) {
+            const refPath = match[1];
+            if (seen.has(refPath))
+                continue;
+            seen.add(refPath);
+            const resolved = path.resolve(process.cwd(), refPath);
+            try {
+                const stat = fs.statSync(resolved);
+                if (stat.isFile()) {
+                    const content = fs.readFileSync(resolved, "utf-8");
+                    const maxLen = 50_000; // safety cap
+                    const truncated = content.length > maxLen
+                        ? content.slice(0, maxLen) + "\n... [truncated]"
+                        : content;
+                    const block = `\n\n--- @${refPath} ---\n${truncated}\n--- end @${refPath} ---\n`;
+                    expanded = expanded.replace(`@${refPath}`, refPath) + block;
+                    console.log(chalk.dim(`  📎 attached ${refPath} (${stat.size} bytes)`));
+                }
+                else if (stat.isDirectory()) {
+                    // List directory contents
+                    const entries = fs.readdirSync(resolved)
+                        .filter(e => !e.startsWith("."))
+                        .slice(0, 50);
+                    const listing = entries.join("\n");
+                    const block = `\n\n--- @${refPath} (directory listing) ---\n${listing}\n--- end @${refPath} ---\n`;
+                    expanded = expanded.replace(`@${refPath}`, refPath) + block;
+                    console.log(chalk.dim(`  📁 attached ${refPath}/ listing (${entries.length} entries)`));
+                }
+            }
+            catch {
+                // File doesn't exist — leave as-is, might be intentional @mention
+            }
+        }
+        return expanded;
+    }
+    // Use MultilineInput if available, otherwise fall back to readline
+    if (supportsMultilineInput()) {
+        const multilineInput = new MultilineInput({
+            prompt: chalk.yellow("you> "),
+            continuationPrompt: chalk.dim("... "),
+            onSubmit: async (input) => {
+                const shouldContinue = await processInput(input, () => multilineInput.reset());
+                if (!shouldContinue) {
+                    multilineInput.stop();
+                    process.exit(0);
+                }
+            },
+            onClose: () => {
+                console.log(chalk.dim("\n👋 bye."));
+                process.exit(0);
+            },
+            onTabComplete: handleTabComplete
+        });
+        multilineInput.start();
+    }
+    else {
+        // Fallback to readline for non-TTY environments
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: chalk.yellow("you> "),
+            terminal: true
+        });
+        rl.on("line", async (line) => {
+            const shouldContinue = await processInput(line, () => rl.prompt());
+            if (!shouldContinue) {
+                rl.close();
+            }
+        });
+        rl.on("close", () => {
+            console.log(chalk.dim("\n👋 bye."));
+            process.exit(0);
+        });
+        rl.prompt();
+    }
+}
+export async function runSinglePrompt(prompt, options = {}) {
+    const config = loadConfig();
+    const projectRoot = options.projectRoot
+        ? path.resolve(options.projectRoot)
+        : process.cwd();
+    if (options.engine !== undefined) {
+        config.engine = options.engine;
+        // Update model to match engine if using default
+        if (!process.env.MIA_CODE_MODEL) {
+            config.model = config.engine === "claude" ? "sonnet" : "gemini-2.5-pro";
+        }
+    }
+    if (options.yolo !== undefined) {
+        config.yoloMode = options.yolo;
+    }
+    const rawMode = options.raw ?? false;
+    // Handle session resume (single prompt doesn't support interactive picker)
+    let sessionId;
+    if (typeof options.resume === "string") {
+        sessionId = options.resume;
+    }
+    else if (options.resume === true) {
+        // Don't auto-resume for single prompts
+        sessionId = undefined;
+    }
+    else {
+        // options.resume is undefined - don't auto-resume
+        sessionId = undefined;
+    }
+    try {
+        const result = await runGeminiHeadless({
+            prompt,
+            config,
+            sessionId,
+            projectRoot,
+            additionalDirs: options.addDirs
+        });
+        if (result.sessionId) {
+            const meta = {
+                id: result.sessionId,
+                startedAt: new Date().toISOString(),
+                model: config.model,
+                projectRoot
+            };
+            rememberSession(meta);
+        }
+        // Raw mode: show original events
+        if (rawMode) {
+            const rendered = renderEventsToText(result.events);
+            console.log(rendered);
+        }
+        else {
+            // Unifier mode: run ceremonial interpretation
+            try {
+                const ceremonialOutput = await runUnifierSession(result.events, prompt, config);
+                console.log(ceremonialOutput);
+            }
+            catch (unifierErr) {
+                // Fallback to raw output if unifier fails
+                console.error(chalk.yellow("⚠ unifier failed, showing raw output:"));
+                const rendered = renderEventsToText(result.events);
+                console.log(rendered);
+            }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(formatError(message));
+        process.exit(1);
+    }
+}