mia-code 0.2.0

package/dist/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createInterface } from "readline";
+import { runInteractiveCli, runSinglePrompt } from "./cli.js";
+import { getConfigPath, loadConfig, saveConfig, ENGINE_MODELS, ENGINES } from "./config.js";
+import { listSessions, clearSessions } from "./sessionStore.js";
+import { generateClaudeConfig, generateToolManifest, generateServerInfo } from "./mcp/index.js";
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+const program = new Command();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+program
+    .name("mia-code")
+    .description("Mia/Miette/Miawa terminal coding agent wrapping Gemini CLI headless mode.")
+    .version(pkg.version);
+program
+    .command("chat", { isDefault: true })
+    .description("Start interactive terminal session (default)")
+    .option("-p, --project <path>", "Project root directory (default: cwd)")
+    .option("-r, --resume [sessionId]", "Resume a session (interactive picker if no ID provided)")
+    .option("-y, --yolo", "Enable YOLO mode (auto-approve all actions)")
+    .option("--raw", "Skip unifier, show raw agent output")
+    .option("--claude", "Use Claude engine instead of Gemini")
+    .option("--copilot", "Use Copilot engine")
+    .option("--gemini", "Use Gemini engine (default)")
+    .option("--add-dir <dirs...>", "Additional directories to allow tool access to")
+    .action(async (opts) => {
+    await runInteractiveCli({
+        projectRoot: opts.project,
+        resume: opts.resume,
+        yolo: opts.yolo,
+        raw: opts.raw,
+        engine: opts.claude ? "claude" : opts.copilot ? "copilot" : opts.gemini ? "gemini" : undefined,
+        addDirs: opts.addDir
+    });
+});
+program
+    .command("prompt <text>")
+    .description("Run a single prompt and exit")
+    .option("-p, --project <path>", "Project root directory")
+    .option("-r, --resume <sessionId>", "Resume a specific session")
+    .option("-y, --yolo", "Enable YOLO mode")
+    .option("--raw", "Skip unifier, show raw agent output")
+    .option("--claude", "Use Claude engine instead of Gemini")
+    .option("--copilot", "Use Copilot engine")
+    .option("--gemini", "Use Gemini engine (default)")
+    .option("--add-dir <dirs...>", "Additional directories to allow tool access to")
+    .action(async (text, opts) => {
+    await runSinglePrompt(text, {
+        projectRoot: opts.project,
+        resume: opts.resume,
+        yolo: opts.yolo,
+        raw: opts.raw,
+        engine: opts.claude ? "claude" : opts.copilot ? "copilot" : opts.gemini ? "gemini" : undefined,
+        addDirs: opts.addDir
+    });
+});
+program
+    .command("config")
+    .description("View or update mia-code configuration")
+    .option("--set-engine <engine>", "Set default engine (gemini or claude)")
+    .option("--set-gemini-bin <path>", "Set path to gemini binary")
+    .option("--set-claude-bin <path>", "Set path to claude binary")
+    .option("--set-model <model>", "Set default model")
+    .option("--set-yolo <bool>", "Set default YOLO mode (true/false)")
+    .action(async (opts) => {
+    if (opts.setEngine || opts.setGeminiBin || opts.setClaudeBin || opts.setModel || opts.setYolo !== undefined) {
+        const partial = {};
+        if (opts.setEngine)
+            partial.engine = opts.setEngine;
+        if (opts.setGeminiBin)
+            partial.geminiBinary = opts.setGeminiBin;
+        if (opts.setClaudeBin)
+            partial.claudeBinary = opts.setClaudeBin;
+        if (opts.setModel)
+            partial.model = opts.setModel;
+        if (opts.setYolo !== undefined)
+            partial.yoloMode = opts.setYolo === "true";
+        saveConfig(partial);
+        console.log(chalk.green("✓ config updated"));
+        console.log(chalk.dim(`config file: ${getConfigPath()}`));
+        console.log(JSON.stringify(loadConfig(), null, 2));
+    }
+    else if (process.stdin.isTTY) {
+        // Interactive mode: pick engine → pick model
+        const config = loadConfig();
+        console.log(chalk.dim(`config file: ${getConfigPath()}`));
+        console.log(chalk.dim(`current: engine=${config.engine}, model=${config.model}\n`));
+        const ask = (question) => {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            return new Promise(resolve => {
+                rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+            });
+        };
+        // Pick engine
+        console.log(chalk.bold("Select engine:"));
+        ENGINES.forEach((e, i) => {
+            const marker = e === config.engine ? chalk.green(" ◀ current") : "";
+            console.log(chalk.dim(`  ${i + 1}. ${e}${marker}`));
+        });
+        const engineAnswer = await ask(chalk.cyan(`  select (1-${ENGINES.length}): `));
+        const engineIdx = parseInt(engineAnswer, 10) - 1;
+        if (isNaN(engineIdx) || engineIdx < 0 || engineIdx >= ENGINES.length) {
+            console.log(chalk.yellow("cancelled"));
+            return;
+        }
+        const engine = ENGINES[engineIdx];
+        // Pick model
+        const models = ENGINE_MODELS[engine];
+        console.log(chalk.bold(`\nSelect model for ${engine}:`));
+        models.forEach((m, i) => {
+            const marker = m === config.model ? chalk.green(" ◀ current") : "";
+            console.log(chalk.dim(`  ${i + 1}. ${m}${marker}`));
+        });
+        const modelAnswer = await ask(chalk.cyan(`  select (1-${models.length}): `));
+        const modelIdx = parseInt(modelAnswer, 10) - 1;
+        if (isNaN(modelIdx) || modelIdx < 0 || modelIdx >= models.length) {
+            console.log(chalk.yellow("cancelled"));
+            return;
+        }
+        const model = models[modelIdx];
+        saveConfig({ engine, model });
+        console.log(chalk.green(`\n✓ config updated → engine: ${engine}, model: ${model}`));
+    }
+    else {
+        console.log(chalk.dim(`config file: ${getConfigPath()}`));
+        console.log(JSON.stringify(loadConfig(), null, 2));
+    }
+});
+program
+    .command("sessions")
+    .description("List saved sessions")
+    .option("--clear", "Clear all saved sessions")
+    .action((opts) => {
+    if (opts.clear) {
+        clearSessions();
+        console.log(chalk.green("✓ sessions cleared"));
+        return;
+    }
+    const sessions = listSessions();
+    if (sessions.length === 0) {
+        console.log(chalk.dim("no saved sessions"));
+        return;
+    }
+    console.log(chalk.dim(`saved sessions (${sessions.length}):`));
+    for (const s of sessions) {
+        console.log(chalk.dim(`  ${s.id.slice(0, 12)}... | ${s.projectRoot || "unknown"} | ${s.startedAt}`));
+    }
+});
+program
+    .command("where-config")
+    .description("Show path to mia-code config file")
+    .action(() => {
+    console.log(getConfigPath());
+});
+program
+    .command("mcp-config")
+    .description("Generate MCP configuration for external engines")
+    .option("--miatel", "Include miatel (Story World) server")
+    .option("--miawa", "Include miawa (Ceremony World) server")
+    .option("--miaco", "Include miaco (Engineering World) server")
+    .option("--tools", "Output tool manifest instead of config")
+    .option("--info", "Output detailed server info")
+    .action((opts) => {
+    // If no specific server selected, enable all
+    const enableAll = !opts.miatel && !opts.miawa && !opts.miaco;
+    const options = {
+        enableMiatel: enableAll || opts.miatel,
+        enableMiawa: enableAll || opts.miawa,
+        enableMiaco: enableAll || opts.miaco
+    };
+    if (opts.tools) {
+        console.log(JSON.stringify(generateToolManifest(options), null, 2));
+    }
+    else if (opts.info) {
+        console.log(JSON.stringify(generateServerInfo(options), null, 2));
+    }
+    else {
+        console.log(JSON.stringify(generateClaudeConfig(options), null, 2));
+    }
+});
+program.parseAsync(process.argv);

package/dist/mcp/config-generator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MCP Config Generator
+ *
+ * Generates MCP configuration JSON for external engines (Claude Code, etc.)
+ */
+export interface MCPConfigOptions {
+    enableMiatel?: boolean;
+    enableMiawa?: boolean;
+    enableMiaco?: boolean;
+    outputFormat?: "claude" | "generic";
+}
+/**
+ * Generate MCP configuration for Claude Desktop / Claude Code
+ */
+export declare function generateClaudeConfig(options?: MCPConfigOptions): object;
+/**
+ * Generate tool manifest for all enabled servers
+ */
+export declare function generateToolManifest(options?: MCPConfigOptions): object[];
+/**
+ * Generate full MCP server info
+ */
+export declare function generateServerInfo(options?: MCPConfigOptions): object;

package/dist/mcp/config-generator.js

@@ -0,0 +1,116 @@
+/**
+ * MCP Config Generator
+ *
+ * Generates MCP configuration JSON for external engines (Claude Code, etc.)
+ */
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { miacoServerConfig, miacoTools } from "./miaco-server.js";
+import { miatelServerConfig, miatelTools } from "./miatel-server.js";
+import { miawaServerConfig, miawaTools } from "./miawa-server.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Generate MCP configuration for Claude Desktop / Claude Code
+ */
+export function generateClaudeConfig(options = {}) {
+    const servers = {};
+    const basePath = resolve(__dirname, "..");
+    if (options.enableMiatel !== false) {
+        servers["miatel"] = {
+            command: "node",
+            args: [resolve(basePath, "mcp/miatel-server.js")],
+            env: {}
+        };
+    }
+    if (options.enableMiawa !== false) {
+        servers["miawa"] = {
+            command: "node",
+            args: [resolve(basePath, "mcp/miawa-server.js")],
+            env: {}
+        };
+    }
+    if (options.enableMiaco !== false) {
+        servers["miaco"] = {
+            command: "node",
+            args: [resolve(basePath, "mcp/miaco-server.js")],
+            env: {}
+        };
+    }
+    return {
+        mcpServers: servers
+    };
+}
+/**
+ * Generate tool manifest for all enabled servers
+ */
+export function generateToolManifest(options = {}) {
+    const tools = [];
+    if (options.enableMiatel !== false) {
+        tools.push(...miatelTools.map(t => ({
+            ...t,
+            server: "miatel"
+        })));
+    }
+    if (options.enableMiawa !== false) {
+        tools.push(...miawaTools.map(t => ({
+            ...t,
+            server: "miawa"
+        })));
+    }
+    if (options.enableMiaco !== false) {
+        tools.push(...miacoTools.map(t => ({
+            ...t,
+            server: "miaco"
+        })));
+    }
+    return tools;
+}
+/**
+ * Generate full MCP server info
+ */
+export function generateServerInfo(options = {}) {
+    const servers = [];
+    if (options.enableMiatel !== false) {
+        servers.push({
+            ...miatelServerConfig,
+            tools: miatelTools
+        });
+    }
+    if (options.enableMiawa !== false) {
+        servers.push({
+            ...miawaServerConfig,
+            tools: miawaTools
+        });
+    }
+    if (options.enableMiaco !== false) {
+        servers.push({
+            ...miacoServerConfig,
+            tools: miacoTools
+        });
+    }
+    return {
+        servers,
+        totalTools: servers.reduce((acc, s) => acc + s.tools.length, 0)
+    };
+}
+// CLI usage: node config-generator.js [--miatel] [--miawa] [--miaco] [--format claude|generic]
+if (process.argv[1]?.endsWith("config-generator.js")) {
+    const args = process.argv.slice(2);
+    const options = {
+        enableMiatel: args.includes("--miatel") || !args.some(a => a.startsWith("--mia")),
+        enableMiawa: args.includes("--miawa") || !args.some(a => a.startsWith("--mia")),
+        enableMiaco: args.includes("--miaco") || !args.some(a => a.startsWith("--mia")),
+        outputFormat: args.includes("--format")
+            ? args[args.indexOf("--format") + 1]
+            : "claude"
+    };
+    if (args.includes("--tools")) {
+        console.log(JSON.stringify(generateToolManifest(options), null, 2));
+    }
+    else if (args.includes("--info")) {
+        console.log(JSON.stringify(generateServerInfo(options), null, 2));
+    }
+    else {
+        console.log(JSON.stringify(generateClaudeConfig(options), null, 2));
+    }
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MCP Server Registry for mia-code
+ *
+ * Exports all MCP servers and utilities
+ */
+export { miacoTools, handleMiacoTool, miacoServerConfig } from "./miaco-server.js";
+export { miatelTools, handleMiatelTool, miatelServerConfig } from "./miatel-server.js";
+export { miawaTools, handleMiawaTool, miawaServerConfig } from "./miawa-server.js";
+export { generateClaudeConfig, generateToolManifest, generateServerInfo } from "./config-generator.js";
+export type { MCPTool, MCPToolResult } from "./utils.js";
+/**
+ * All available MCP tools across all servers
+ */
+export declare function getAllTools(): any[];
+/**
+ * Handle a tool call by routing to the appropriate server
+ */
+export declare function handleTool(name: string, args: Record<string, any>): Promise<import("./utils.js").MCPToolResult>;

package/dist/mcp/index.js

@@ -0,0 +1,43 @@
+/**
+ * MCP Server Registry for mia-code
+ *
+ * Exports all MCP servers and utilities
+ */
+export { miacoTools, handleMiacoTool, miacoServerConfig } from "./miaco-server.js";
+export { miatelTools, handleMiatelTool, miatelServerConfig } from "./miatel-server.js";
+export { miawaTools, handleMiawaTool, miawaServerConfig } from "./miawa-server.js";
+export { generateClaudeConfig, generateToolManifest, generateServerInfo } from "./config-generator.js";
+/**
+ * All available MCP tools across all servers
+ */
+export function getAllTools() {
+    const { miacoTools } = require("./miaco-server.js");
+    const { miatelTools } = require("./miatel-server.js");
+    const { miawaTools } = require("./miawa-server.js");
+    return [
+        ...miacoTools.map((t) => ({ ...t, server: "miaco" })),
+        ...miatelTools.map((t) => ({ ...t, server: "miatel" })),
+        ...miawaTools.map((t) => ({ ...t, server: "miawa" }))
+    ];
+}
+/**
+ * Handle a tool call by routing to the appropriate server
+ */
+export async function handleTool(name, args) {
+    if (name.startsWith("miaco_")) {
+        const { handleMiacoTool } = await import("./miaco-server.js");
+        return handleMiacoTool(name, args);
+    }
+    if (name.startsWith("miatel_")) {
+        const { handleMiatelTool } = await import("./miatel-server.js");
+        return handleMiatelTool(name, args);
+    }
+    if (name.startsWith("miawa_")) {
+        const { handleMiawaTool } = await import("./miawa-server.js");
+        return handleMiawaTool(name, args);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
+        isError: true
+    };
+}

package/dist/mcp/miaco-server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP Server for miaco - Engineering World CLI
+ *
+ * Exposes chart/schema/validate tools as MCP tools
+ */
+import { MCPTool, MCPToolResult } from "./utils.js";
+export declare const miacoTools: MCPTool[];
+export declare function handleMiacoTool(name: string, args: Record<string, any>): Promise<MCPToolResult>;
+export declare const miacoServerConfig: {
+    name: string;
+    version: string;
+    description: string;
+    tools: MCPTool[];
+    handleTool: typeof handleMiacoTool;
+};

package/dist/mcp/miaco-server.js

@@ -0,0 +1,161 @@
+/**
+ * MCP Server for miaco - Engineering World CLI
+ *
+ * Exposes chart/schema/validate tools as MCP tools
+ */
+import { runCLI, parseJSONOutput, createToolResult, buildArgs } from "./utils.js";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_PATH = join(__dirname, "../../miaco/dist/index.js");
+export const miacoTools = [
+    {
+        name: "miaco_chart_create",
+        description: "Create a structural tension chart with desired outcome and current reality",
+        inputSchema: {
+            type: "object",
+            properties: {
+                outcome: { type: "string", description: "Desired outcome (what you want to CREATE, not fix)" },
+                reality: { type: "string", description: "Current reality (factual assessment, not readiness)" },
+                due: { type: "string", description: "Due date (ISO format)" },
+                session: { type: "string", description: "Session ID" }
+            },
+            required: ["outcome", "reality"]
+        }
+    },
+    {
+        name: "miaco_chart_list",
+        description: "List active structural tension charts",
+        inputSchema: {
+            type: "object",
+            properties: {
+                session: { type: "string", description: "Session ID" }
+            }
+        }
+    },
+    {
+        name: "miaco_chart_add_step",
+        description: "Add an action step to an existing chart",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chart: { type: "string", description: "Chart ID" },
+                title: { type: "string", description: "Action step title" },
+                reality: { type: "string", description: "Current reality for this step" },
+                session: { type: "string", description: "Session ID" }
+            },
+            required: ["chart", "title", "reality"]
+        }
+    },
+    {
+        name: "miaco_chart_complete",
+        description: "Mark an action step as complete",
+        inputSchema: {
+            type: "object",
+            properties: {
+                step: { type: "string", description: "Action step name or ID" },
+                session: { type: "string", description: "Session ID" }
+            },
+            required: ["step"]
+        }
+    },
+    {
+        name: "miaco_chart_review",
+        description: "Review chart progress using Creator Moment of Truth",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chart: { type: "string", description: "Chart ID to review" },
+                session: { type: "string", description: "Session ID" }
+            },
+            required: ["chart"]
+        }
+    },
+    // PDE — Multi-engine Prompt Decomposition
+    {
+        name: "miaco_decompose",
+        description: "Decompose a prompt into structured Four Directions analysis using any engine (gemini, claude, copilot)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "The prompt to decompose" },
+                engine: { type: "string", description: "Engine: gemini | claude | copilot", enum: ["gemini", "claude", "copilot"] },
+                model: { type: "string", description: "Model override (e.g. gpt-5-mini, sonnet, gemini-2.5-flash)" },
+                workdir: { type: "string", description: "Working directory for .pde/ storage (default: cwd)" }
+            },
+            required: ["prompt"]
+        }
+    },
+    {
+        name: "miaco_decompose_list",
+        description: "List stored decompositions from .pde/ folder",
+        inputSchema: {
+            type: "object",
+            properties: {
+                workdir: { type: "string", description: "Working directory" },
+                limit: { type: "string", description: "Max results (default: 10)" }
+            }
+        }
+    },
+    {
+        name: "miaco_decompose_get",
+        description: "Retrieve a stored decomposition by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Decomposition UUID" },
+                workdir: { type: "string", description: "Working directory" }
+            },
+            required: ["id"]
+        }
+    }
+];
+export async function handleMiacoTool(name, args) {
+    try {
+        let cliArgs;
+        switch (name) {
+            case "miaco_chart_create":
+                cliArgs = buildArgs(["chart", "create"], args, { outcome: "--outcome", reality: "--reality", due: "--due" });
+                break;
+            case "miaco_chart_list":
+                cliArgs = buildArgs(["chart", "list"], args, {});
+                break;
+            case "miaco_chart_add_step":
+                cliArgs = buildArgs(["chart", "add-step"], args, { chart: "--chart", title: "--title", reality: "--reality" });
+                break;
+            case "miaco_chart_complete":
+                cliArgs = buildArgs(["chart", "complete"], args, { step: "--step" });
+                break;
+            case "miaco_chart_review":
+                cliArgs = buildArgs(["chart", "review"], args, { chart: "--chart" });
+                break;
+            // PDE tools — use CLI with --json flag
+            case "miaco_decompose":
+                cliArgs = buildArgs(["decompose", "run"], args, { prompt: "--prompt", engine: "--engine", model: "--model", workdir: "--workdir" });
+                break;
+            case "miaco_decompose_list":
+                cliArgs = buildArgs(["decompose", "list"], args, { workdir: "--workdir", limit: "--limit" });
+                break;
+            case "miaco_decompose_get":
+                cliArgs = ["decompose", "get", args.id || ""];
+                if (args.workdir)
+                    cliArgs.push("--workdir", args.workdir);
+                break;
+            default:
+                return createToolResult({ error: `Unknown tool: ${name}` }, true);
+        }
+        const output = await runCLI(CLI_PATH, cliArgs);
+        const result = parseJSONOutput(output);
+        return createToolResult(result);
+    }
+    catch (err) {
+        return createToolResult({ error: err.message }, true);
+    }
+}
+export const miacoServerConfig = {
+    name: "miaco",
+    version: "0.1.0",
+    description: "Engineering World MCP Server - Structural tension charts, schemas, validation",
+    tools: miacoTools,
+    handleTool: handleMiacoTool
+};

package/dist/mcp/miatel-server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP Server for miatel - Story World CLI
+ *
+ * Exposes beat/arc/theme tools as MCP tools
+ */
+import { MCPTool, MCPToolResult } from "./utils.js";
+export declare const miatelTools: MCPTool[];
+export declare function handleMiatelTool(name: string, args: Record<string, any>): Promise<MCPToolResult>;
+export declare const miatelServerConfig: {
+    name: string;
+    version: string;
+    description: string;
+    tools: MCPTool[];
+    handleTool: typeof handleMiatelTool;
+};