mia-code 0.2.0

package/dist/mcp/miatel-server.js

@@ -0,0 +1,123 @@
+/**
+ * MCP Server for miatel - Story World CLI
+ *
+ * Exposes beat/arc/theme 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, "../../miatel/dist/index.js");
+export const miatelTools = [
+    {
+        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, args) {
+    try {
+        let cliArgs;
+        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) {
+        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/dist/mcp/miawa-server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP Server for miawa - Ceremony World CLI
+ *
+ * Exposes ceremony/wound/eva tools as MCP tools
+ */
+import { MCPTool, MCPToolResult } from "./utils.js";
+export declare const miawaTools: MCPTool[];
+export declare function handleMiawaTool(name: string, args: Record<string, any>): Promise<MCPToolResult>;
+export declare const miawaServerConfig: {
+    name: string;
+    version: string;
+    description: string;
+    tools: MCPTool[];
+    handleTool: typeof handleMiawaTool;
+};

package/dist/mcp/miawa-server.js

@@ -0,0 +1,125 @@
+/**
+ * MCP Server for miawa - Ceremony World CLI
+ *
+ * Exposes ceremony/wound/eva 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, "../../miawa/dist/index.js");
+export const miawaTools = [
+    {
+        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, args) {
+    try {
+        let cliArgs;
+        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) {
+        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/dist/mcp/utils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MCP Server base utilities for mia-code sub-CLIs
+ */
+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 declare function runCLI(cliPath: string, args: string[]): Promise<string>;
+/**
+ * Parse JSON output from CLI, handling errors gracefully
+ */
+export declare function parseJSONOutput(output: string): any;
+/**
+ * Create MCP tool result from parsed data
+ */
+export declare function createToolResult(data: any, isError?: boolean): MCPToolResult;
+/**
+ * Get session ID from args or environment
+ */
+export declare function getSessionId(args: {
+    session?: string;
+}): string | undefined;
+/**
+ * Build CLI arguments from tool input
+ */
+export declare function buildArgs(command: string[], args: Record<string, any>, mapping: Record<string, string>): string[];

package/dist/mcp/utils.js

@@ -0,0 +1,76 @@
+/**
+ * MCP Server base utilities for mia-code sub-CLIs
+ */
+import { spawn } from "child_process";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Run a CLI command and return parsed JSON output
+ */
+export function runCLI(cliPath, args) {
+    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) {
+    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, isError = false) {
+    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) {
+    return args.session || process.env.MIA_SESSION_ID;
+}
+/**
+ * Build CLI arguments from tool input
+ */
+export function buildArgs(command, args, mapping) {
+    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;
+}

package/dist/multiline-input.d.ts

@@ -0,0 +1,98 @@
+/**
+ * MultilineInput - Multiline input handler for terminal CLIs
+ *
+ * Supports:
+ * - Ctrl+J to add new lines without submitting
+ * - Enter to submit the complete input
+ * - Pasting multiline content
+ * - Arrow key navigation
+ * - Interactive dropdown completion for / commands and @ file paths
+ * - TTY detection with readline fallback
+ */
+import { EventEmitter } from "events";
+export interface TabCompletion {
+    matches: string[];
+    /** Display labels (shown in dropdown). Falls back to matches if not provided. */
+    labels?: string[];
+    prefix: string;
+    /** Position in the input line where the completable token starts */
+    tokenStart: number;
+    /** Character to prepend to each match for display (e.g. "/" or "@") */
+    triggerChar: string;
+    /** If true, append "/" to directories instead of " " */
+    isFilePath?: boolean;
+}
+export interface MultilineInputOptions {
+    prompt: string;
+    continuationPrompt?: string;
+    maxLines?: number;
+    onSubmit: (input: string) => Promise<void>;
+    onClose?: () => void;
+    onTabComplete?: (input: string) => TabCompletion | null;
+}
+/**
+ * Check if environment supports raw mode multiline input
+ */
+export declare function supportsMultilineInput(): boolean;
+export declare class MultilineInput extends EventEmitter {
+    private prompt;
+    private continuationPrompt;
+    private maxLines;
+    private onSubmit;
+    private onClose?;
+    private onTabComplete?;
+    private lines;
+    private currentLine;
+    private cursorPos;
+    private isRunning;
+    private isPaused;
+    private isProcessing;
+    private dropdown;
+    private static readonly MAX_DROPDOWN_ITEMS;
+    private static stripAnsi;
+    private visibleLength;
+    private getColumns;
+    private getRows;
+    private wrappedRows;
+    constructor(options: MultilineInputOptions);
+    start(): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    private showPrompt;
+    private redraw;
+    /**
+     * Calculate how many rows down from the cursor to the start of the dropdown
+     */
+    private rowsFromCursorToDropdown;
+    /**
+     * Reposition cursor back to the input editing position (absolute)
+     */
+    private repositionCursor;
+    private eraseDropdownRows;
+    private renderDropdown;
+    private clearDropdown;
+    /**
+     * Query the completion handler and update dropdown state
+     */
+    private updateDropdown;
+    /**
+     * Accept the currently selected dropdown item
+     */
+    private acceptDropdownSelection;
+    private handleData;
+    /**
+     * Check if the current input context should trigger a live dropdown.
+     * "/" commands: always live (few items, instant feedback).
+     * "@" files: only update if dropdown is already open (Tab to initiate).
+     */
+    private maybeShowDropdown;
+    /**
+     * Check if text ends with an active @path context (no space after @)
+     */
+    private isInAtContext;
+    private handlePaste;
+    private handleEscapeSequence;
+    private redrawAll;
+}