mia-code 0.2.0

package/src/mcp/miatel-server.ts

@@ -0,0 +1,138 @@
+/**
+ * MCP Server for miatel - Story World CLI
+ * 
+ * Exposes beat/arc/theme 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, "../../miatel/dist/index.js");
+
+export const miatelTools: MCPTool[] = [
+  {
+    name: "miatel_beat_create",
+    description: "Create a story beat in the narrative intelligence system",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Story beat content" },
+        character: { type: "string", description: "Character ID" },
+        tone: { 
+          type: "string", 
+          description: "Emotional tone",
+          enum: ["joy", "fear", "anticipation", "surprise", "sadness", "anger", "disgust", "trust", "neutral"]
+        },
+        phase: {
+          type: "string",
+          description: "Narrative phase",
+          enum: ["setup", "confrontation", "resolution", "unspecified"]
+        },
+        session: { type: "string", description: "Session ID" }
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "miatel_beat_list",
+    description: "List story beats in current session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "string", description: "Maximum number of results" },
+        character: { type: "string", description: "Filter by character ID" },
+        session: { type: "string", description: "Session ID" }
+      }
+    }
+  },
+  {
+    name: "miatel_beat_analyze",
+    description: "Analyze a specific story beat",
+    inputSchema: {
+      type: "object",
+      properties: {
+        beatId: { type: "string", description: "Beat ID to analyze" },
+        universe: {
+          type: "string",
+          description: "Universe lens for analysis",
+          enum: ["engineer", "ceremony", "story_engine", "all"]
+        },
+        session: { type: "string", description: "Session ID" }
+      },
+      required: ["beatId"]
+    }
+  },
+  {
+    name: "miatel_beat_enrich",
+    description: "Apply emotional enrichment to a beat",
+    inputSchema: {
+      type: "object",
+      properties: {
+        beatId: { type: "string", description: "Beat ID to enrich" },
+        technique: {
+          type: "string",
+          description: "Enrichment technique",
+          enum: ["sensory", "stakes", "dialogue", "auto-detect"]
+        },
+        session: { type: "string", description: "Session ID" }
+      },
+      required: ["beatId"]
+    }
+  }
+];
+
+export async function handleMiatelTool(name: string, args: Record<string, any>): Promise<MCPToolResult> {
+  try {
+    let cliArgs: string[];
+    
+    switch (name) {
+      case "miatel_beat_create":
+        cliArgs = buildArgs(
+          ["beat", "create"],
+          args,
+          { text: "-t", character: "--character", tone: "--tone", phase: "--phase" }
+        );
+        break;
+        
+      case "miatel_beat_list":
+        cliArgs = buildArgs(
+          ["beat", "list"],
+          args,
+          { limit: "-n", character: "--character" }
+        );
+        break;
+        
+      case "miatel_beat_analyze":
+        cliArgs = ["beat", "analyze", args.beatId];
+        if (args.universe) cliArgs.push("--universe", args.universe);
+        if (args.session) cliArgs.push("--session", args.session);
+        break;
+        
+      case "miatel_beat_enrich":
+        cliArgs = ["beat", "enrich", args.beatId];
+        if (args.technique) cliArgs.push("--technique", args.technique);
+        if (args.session) cliArgs.push("--session", args.session);
+        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 miatelServerConfig = {
+  name: "miatel",
+  version: "0.1.0",
+  description: "Story World MCP Server - Beats, arcs, themes, narrative analysis",
+  tools: miatelTools,
+  handleTool: handleMiatelTool
+};

package/src/mcp/miawa-server.ts

@@ -0,0 +1,158 @@
+/**
+ * MCP Server for miawa - Ceremony World CLI
+ * 
+ * Exposes ceremony/wound/eva 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, "../../miawa/dist/index.js");
+
+export const miawaTools: MCPTool[] = [
+  {
+    name: "miawa_ceremony_init",
+    description: "Initiate a new ceremony session with intention",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Ceremony title" },
+        type: {
+          type: "string",
+          description: "Type of ceremony",
+          enum: ["group_reflection", "seasonal", "healing_circle", "wisdom_sharing"]
+        },
+        intention: { type: "string", description: "Ceremony intention" },
+        session: { type: "string", description: "Session ID" }
+      },
+      required: ["title", "type"]
+    }
+  },
+  {
+    name: "miawa_ceremony_list",
+    description: "List ceremonies in current session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session: { type: "string", description: "Session ID" }
+      }
+    }
+  },
+  {
+    name: "miawa_ceremony_advance",
+    description: "Advance ceremony to next movement (1-4)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ceremony: { type: "string", description: "Ceremony ID" },
+        session: { type: "string", description: "Session ID" }
+      },
+      required: ["ceremony"]
+    }
+  },
+  {
+    name: "miawa_ceremony_close",
+    description: "Close ceremony with wisdom archiving",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ceremony: { type: "string", description: "Ceremony ID (uses active if not provided)" },
+        session: { type: "string", description: "Session ID" }
+      }
+    }
+  },
+  {
+    name: "miawa_ceremony_wisdom",
+    description: "Retrieve wisdom from completed ceremonies",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ceremony: { type: "string", description: "Specific ceremony ID" },
+        session: { type: "string", description: "Session ID" }
+      }
+    }
+  },
+  {
+    name: "miawa_ceremony_stage",
+    description: "Check current ceremony stage and Four Movements",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ceremony: { type: "string", description: "Ceremony ID" },
+        session: { type: "string", description: "Session ID" }
+      }
+    }
+  }
+];
+
+export async function handleMiawaTool(name: string, args: Record<string, any>): Promise<MCPToolResult> {
+  try {
+    let cliArgs: string[];
+    
+    switch (name) {
+      case "miawa_ceremony_init":
+        cliArgs = buildArgs(
+          ["ceremony", "init"],
+          args,
+          { title: "-t", type: "--type", intention: "-i" }
+        );
+        break;
+        
+      case "miawa_ceremony_list":
+        cliArgs = buildArgs(["ceremony", "list"], args, {});
+        break;
+        
+      case "miawa_ceremony_advance":
+        cliArgs = buildArgs(
+          ["ceremony", "advance"],
+          args,
+          { ceremony: "--ceremony" }
+        );
+        break;
+        
+      case "miawa_ceremony_close":
+        cliArgs = buildArgs(
+          ["ceremony", "close"],
+          args,
+          { ceremony: "--ceremony" }
+        );
+        break;
+        
+      case "miawa_ceremony_wisdom":
+        cliArgs = buildArgs(
+          ["ceremony", "wisdom"],
+          args,
+          { ceremony: "--ceremony" }
+        );
+        break;
+        
+      case "miawa_ceremony_stage":
+        cliArgs = buildArgs(
+          ["ceremony", "stage"],
+          args,
+          { ceremony: "--ceremony" }
+        );
+        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 miawaServerConfig = {
+  name: "miawa",
+  version: "0.1.0",
+  description: "Ceremony World MCP Server - Ceremonies, wounds, circles, Eva integration",
+  tools: miawaTools,
+  handleTool: handleMiawaTool
+};

package/src/mcp/utils.ts

@@ -0,0 +1,121 @@
+/**
+ * MCP Server base utilities for mia-code sub-CLIs
+ */
+
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: "object";
+    properties: Record<string, {
+      type: string;
+      description: string;
+      enum?: string[];
+    }>;
+    required?: string[];
+  };
+}
+
+export interface MCPToolResult {
+  content: Array<{
+    type: "text";
+    text: string;
+  }>;
+  isError?: boolean;
+}
+
+export interface MCPServerConfig {
+  name: string;
+  version: string;
+  cliPath: string;
+  tools: MCPTool[];
+}
+
+/**
+ * Run a CLI command and return parsed JSON output
+ */
+export function runCLI(cliPath: string, args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", [cliPath, ...args, "--json"], {
+      cwd: process.cwd(),
+      env: { ...process.env, FORCE_COLOR: "0" }
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout?.on("data", (chunk) => stdout += chunk.toString());
+    child.stderr?.on("data", (chunk) => stderr += chunk.toString());
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`CLI exited with code ${code}: ${stderr}`));
+      }
+    });
+
+    child.on("error", reject);
+  });
+}
+
+/**
+ * Parse JSON output from CLI, handling errors gracefully
+ */
+export function parseJSONOutput(output: string): any {
+  try {
+    return JSON.parse(output);
+  } catch {
+    return { success: false, error: "Failed to parse CLI output", raw: output };
+  }
+}
+
+/**
+ * Create MCP tool result from parsed data
+ */
+export function createToolResult(data: any, isError = false): MCPToolResult {
+  return {
+    content: [{
+      type: "text",
+      text: typeof data === "string" ? data : JSON.stringify(data, null, 2)
+    }],
+    isError
+  };
+}
+
+/**
+ * Get session ID from args or environment
+ */
+export function getSessionId(args: { session?: string }): string | undefined {
+  return args.session || process.env.MIA_SESSION_ID;
+}
+
+/**
+ * Build CLI arguments from tool input
+ */
+export function buildArgs(
+  command: string[],
+  args: Record<string, any>,
+  mapping: Record<string, string>
+): string[] {
+  const result = [...command];
+  
+  for (const [key, flag] of Object.entries(mapping)) {
+    const value = args[key];
+    if (value !== undefined && value !== null && value !== "") {
+      result.push(flag, String(value));
+    }
+  }
+  
+  if (args.session) {
+    result.push("--session", args.session);
+  }
+  
+  return result;
+}