mia-code 0.2.0

package/src/index.ts

@@ -0,0 +1,194 @@
+#!/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 { Engine } from "./types.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: Record<string, unknown> = {};
+      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: string): Promise<string> => {
+        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/src/mcp/config-generator.ts

@@ -0,0 +1,141 @@
+/**
+ * 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));
+
+export interface MCPConfigOptions {
+  enableMiatel?: boolean;
+  enableMiawa?: boolean;
+  enableMiaco?: boolean;
+  outputFormat?: "claude" | "generic";
+}
+
+/**
+ * Generate MCP configuration for Claude Desktop / Claude Code
+ */
+export function generateClaudeConfig(options: MCPConfigOptions = {}): object {
+  const servers: Record<string, object> = {};
+  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: MCPConfigOptions = {}): object[] {
+  const tools: object[] = [];
+
+  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: MCPConfigOptions = {}): object {
+  const servers: object[] = [];
+
+  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: any) => 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: MCPConfigOptions = {
+    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] as "claude" | "generic"
+      : "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/src/mcp/index.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 function getAllTools() {
+  const { miacoTools } = require("./miaco-server.js");
+  const { miatelTools } = require("./miatel-server.js");
+  const { miawaTools } = require("./miawa-server.js");
+  
+  return [
+    ...miacoTools.map((t: any) => ({ ...t, server: "miaco" })),
+    ...miatelTools.map((t: any) => ({ ...t, server: "miatel" })),
+    ...miawaTools.map((t: any) => ({ ...t, server: "miawa" }))
+  ];
+}
+
+/**
+ * Handle a tool call by routing to the appropriate server
+ */
+export async function handleTool(name: string, args: Record<string, any>) {
+  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" as const, text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
+    isError: true
+  };
+}

package/src/mcp/miaco-server.ts

@@ -0,0 +1,199 @@
+/**
+ * MCP Server for miaco - Engineering World CLI
+ * 
+ * Exposes chart/schema/validate tools as MCP tools
+ */
+
+import { runCLI, parseJSONOutput, createToolResult, buildArgs, MCPTool, MCPToolResult } 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: MCPTool[] = [
+  {
+    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: string, args: Record<string, any>): Promise<MCPToolResult> {
+  try {
+    let cliArgs: string[];
+    
+    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: any) {
+    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
+};