mia-code 0.2.0 → 0.3.0

package/src/mcp/utils.ts

@@ -3,10 +3,13 @@
  */
 
 import { spawn } from "child_process";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
+// Using low-level Server for direct JSON schema control (McpServer requires Zod)
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
 
 export interface MCPTool {
   name: string;
@@ -23,6 +26,7 @@ export interface MCPTool {
 }
 
 export interface MCPToolResult {
+  [key: string]: unknown;
   content: Array<{
     type: "text";
     text: string;
@@ -33,7 +37,6 @@ export interface MCPToolResult {
 export interface MCPServerConfig {
   name: string;
   version: string;
-  cliPath: string;
   tools: MCPTool[];
 }
 
@@ -105,17 +108,47 @@ export function buildArgs(
   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;
 }
+
+/**
+ * Bootstrap an MCP server with JSON-RPC over stdio transport.
+ * Uses low-level Server API for direct JSON schema passthrough.
+ */
+export async function bootstrapMCPServer(
+  config: MCPServerConfig,
+  handleTool: (name: string, args: Record<string, any>) => Promise<MCPToolResult>
+): Promise<void> {
+  const server = new Server(
+    { name: config.name, version: config.version },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: config.tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema,
+    })),
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
+    const { name, arguments: args } = request.params;
+    return handleTool(name, args ?? {});
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/sessionStore.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { MiaCodeSessionMeta, ChatMessage } from "./types.js";
+import { MiaCodeSessionMeta, ChatMessage, Engine } from "./types.js";
 
 const SESSIONS_FILE = path.join(os.homedir(), ".mia-code-sessions.json");
 const HISTORY_DIR = path.join(os.homedir(), ".mia-code-history");
@@ -11,6 +11,11 @@ interface SessionIndex {
   byId: Record<string, MiaCodeSessionMeta>;
 }
 
+/** Build the engine-qualified key for byProjectRoot lookup. */
+function projectKey(projectRoot: string, engine?: Engine): string {
+  return engine ? `${engine}:${projectRoot}` : projectRoot;
+}
+
 function loadIndex(): SessionIndex {
   if (!fs.existsSync(SESSIONS_FILE)) {
     return { byProjectRoot: {}, byId: {} };
@@ -34,7 +39,16 @@ function saveIndex(index: SessionIndex): void {
 export function rememberSession(meta: MiaCodeSessionMeta): void {
   const idx = loadIndex();
   if (meta.projectRoot) {
-    idx.byProjectRoot[meta.projectRoot] = meta;
+    // Store under engine-qualified key so each engine has its own "last session"
+    idx.byProjectRoot[projectKey(meta.projectRoot, meta.engine)] = meta;
+
+    // Clean up stale legacy (unqualified) entry if it points to this same session,
+    // preventing a different engine from claiming it via fallback.
+    const legacyKey = meta.projectRoot;  // bare, no engine prefix
+    const legacy = idx.byProjectRoot[legacyKey];
+    if (legacy && legacy.id === meta.id && meta.engine) {
+      delete idx.byProjectRoot[legacyKey];
+    }
   }
   idx.byId[meta.id] = meta;
   saveIndex(idx);
@@ -46,7 +60,7 @@ export function markSessionInitialized(id: string): void {
   if (session) {
     session.initialized = true;
     if (session.projectRoot) {
-      idx.byProjectRoot[session.projectRoot] = session;
+      idx.byProjectRoot[projectKey(session.projectRoot, session.engine)] = session;
     }
     saveIndex(idx);
   }
@@ -57,8 +71,34 @@ export function isSessionInitialized(id: string): boolean {
   return idx.byId[id]?.initialized ?? false;
 }
 
-export function getLastSessionForProject(projectRoot: string): MiaCodeSessionMeta | null {
+/**
+ * Get the last session for a project, optionally filtered by engine.
+ * When engine is provided, only returns a session owned by that engine.
+ * Falls back to legacy unqualified key if no engine-specific entry exists
+ * (for backward compatibility with pre-engine sessions).
+ */
+export function getLastSessionForProject(projectRoot: string, engine?: Engine): MiaCodeSessionMeta | null {
   const idx = loadIndex();
+
+  // Try engine-qualified key first
+  if (engine) {
+    const qualified = idx.byProjectRoot[projectKey(projectRoot, engine)];
+    if (qualified) return qualified;
+
+    // Fallback: check unqualified key for legacy sessions that match engine
+    const legacy = idx.byProjectRoot[projectRoot];
+    if (legacy && (legacy.engine === engine || !legacy.engine)) {
+      // Migrate: promote to engine-qualified key and remove stale legacy entry
+      // so no other engine can claim it via the same fallback path.
+      idx.byProjectRoot[projectKey(projectRoot, engine)] = { ...legacy, engine };
+      delete idx.byProjectRoot[projectRoot];
+      saveIndex(idx);
+      return { ...legacy, engine };
+    }
+    return null;
+  }
+
+  // No engine filter — return whatever is there (unqualified key)
   return idx.byProjectRoot[projectRoot] ?? null;
 }
 

package/src/types.ts

@@ -18,8 +18,9 @@ export interface MiaCodeSessionMeta {
   id: string;
   startedAt: string;
   model: string;
+  engine?: Engine;         // Which engine owns this session
   projectRoot: string | null;
-  initialized?: boolean;  // Has engine acknowledged this session?
+  initialized?: boolean;   // Has engine acknowledged this session?
 }
 
 export interface ChatMessage {

package/widget/mia-ceremony/README.md

@@ -0,0 +1,36 @@
+# 🌅 Mia Ceremony — Four Movements Footer
+
+Tracks ceremony phase in Pi's footer status bar. Transitions automatically based on tool usage.
+
+## Install
+
+```bash
+# Quick test (works best with mia-tools loaded too)
+pi -e /a/src/mia-code/widget/mia-ceremony/index.ts
+
+# Permanent
+ln -s /a/src/mia-code/widget/mia-ceremony/index.ts ~/.pi/agent/extensions/mia-ceremony.ts
+```
+
+## Phases
+
+| Phase | When | Trigger |
+|-------|------|---------|
+| 🌅 EAST — Gathering | Understanding, decomposing | Session start, PDE decompose |
+| 🔥 SOUTH — Building | Implementing, growing | STC chart create |
+| 🌊 WEST — Validating | Testing, reflecting | STC steps completed |
+| ❄️ NORTH — Completing | Deploying, documenting | STC review |
+
+## Commands
+
+- `/ceremony` — Show current phase
+- `/ceremony south` — Manually set phase
+
+## Load All Three Together
+
+```bash
+pi \
+  -e /a/src/mia-code/widget/miette-echo/index.ts \
+  -e /a/src/mia-code/widget/mia-tools/index.ts \
+  -e /a/src/mia-code/widget/mia-ceremony/index.ts
+```

package/widget/mia-ceremony/index.ts

@@ -0,0 +1,143 @@
+/**
+ * 🌅 Mia Ceremony — Four Movements Session Lifecycle
+ *
+ * Tracks ceremony phase in the footer status bar:
+ *   🌅 EAST — Gathering (understanding, decomposing)
+ *   🔥 SOUTH — Building (implementing, growing)
+ *   🌊 WEST — Validating (testing, reflecting)
+ *   ❄️ NORTH — Completing (deploying, documenting)
+ *
+ * Phase transitions happen automatically based on tool usage:
+ *   - PDE decompose → EAST
+ *   - STC chart create → SOUTH
+ *   - STC step complete → progresses toward WEST/NORTH
+ *   - STC review → NORTH
+ *
+ * Manual: /ceremony [east|south|west|north] to set phase
+ *
+ * Install: ln -s /a/src/mia-code/widget/mia-ceremony/index.ts ~/.pi/agent/extensions/mia-ceremony.ts
+ * Or test: pi -e /a/src/mia-code/widget/mia-ceremony/index.ts
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+type Direction = "east" | "south" | "west" | "north";
+
+interface CeremonyState {
+	phase: Direction;
+	turnCount: number;
+	pdeUsed: boolean;
+	chartCreated: boolean;
+	stepsCompleted: number;
+	reviewDone: boolean;
+}
+
+const PHASES: Record<Direction, { emoji: string; name: string; verb: string }> = {
+	east: { emoji: "🌅", name: "EAST", verb: "Gathering" },
+	south: { emoji: "🔥", name: "SOUTH", verb: "Building" },
+	west: { emoji: "🌊", name: "WEST", verb: "Validating" },
+	north: { emoji: "❄️", name: "NORTH", verb: "Completing" },
+};
+
+function phaseLabel(dir: Direction): string {
+	const p = PHASES[dir];
+	return `${p.emoji} ${p.name} — ${p.verb}`;
+}
+
+export default function miaCeremony(pi: ExtensionAPI) {
+	const state: CeremonyState = {
+		phase: "east",
+		turnCount: 0,
+		pdeUsed: false,
+		chartCreated: false,
+		stepsCompleted: 0,
+		reviewDone: false,
+	};
+
+	function updateStatus(ctx: ExtensionContext) {
+		if (!ctx.hasUI) return;
+		ctx.ui.setStatus("ceremony", phaseLabel(state.phase));
+	}
+
+	function inferPhase(): Direction {
+		// Review done → NORTH
+		if (state.reviewDone) return "north";
+		// Steps being completed → WEST (validation/reflection)
+		if (state.stepsCompleted >= 2) return "west";
+		// Chart created, working → SOUTH
+		if (state.chartCreated) return "south";
+		// PDE used or early turns → EAST
+		return "east";
+	}
+
+	// --- Session lifecycle ---
+
+	pi.on("session_start", (_event, ctx) => {
+		updateStatus(ctx);
+	});
+
+	pi.on("session_switch", (_event, ctx) => {
+		updateStatus(ctx);
+	});
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		if (ctx.hasUI) ctx.ui.setStatus("ceremony", undefined);
+	});
+
+	// --- Track turns ---
+
+	pi.on("turn_end", (_event, ctx) => {
+		state.turnCount++;
+		updateStatus(ctx);
+	});
+
+	// --- Track tool usage for automatic phase transitions ---
+
+	pi.on("tool_execution_end", (event, ctx) => {
+		const name = event.toolName;
+
+		if (name === "pde_decompose") {
+			state.pdeUsed = true;
+			// PDE means we're gathering/understanding
+			if (state.phase === "east") {
+				// Stay east — this IS east
+			}
+		}
+
+		if (name === "stc_create") {
+			state.chartCreated = true;
+			// Chart creation means we have a plan → SOUTH
+			state.phase = inferPhase();
+		}
+
+		if (name === "stc_complete_step") {
+			state.stepsCompleted++;
+			state.phase = inferPhase();
+		}
+
+		if (name === "stc_review") {
+			state.reviewDone = true;
+			state.phase = inferPhase();
+		}
+
+		updateStatus(ctx);
+	});
+
+	// --- Manual command ---
+
+	pi.registerCommand("ceremony", {
+		description: "Set ceremony phase: /ceremony [east|south|west|north]",
+		handler: async (args, ctx) => {
+			const dir = args.trim().toLowerCase() as Direction;
+			if (dir && PHASES[dir]) {
+				state.phase = dir;
+				updateStatus(ctx);
+				ctx.ui.notify(`Ceremony phase set to ${phaseLabel(dir)}`, "info");
+			} else if (!dir) {
+				ctx.ui.notify(`Current phase: ${phaseLabel(state.phase)}`, "info");
+			} else {
+				ctx.ui.notify("Usage: /ceremony [east|south|west|north]", "info");
+			}
+		},
+	});
+}

package/widget/mia-interceptor/README.md

@@ -0,0 +1,39 @@
+# 🌅 Mia Interceptor — Proactive PDE Sensing
+
+Gently asks before complex prompts reach the agent.
+
+```
+🌅 This prompt touches 4 areas + implicit intents — want to decompose first?
+```
+
+## Install
+
+```bash
+# Quick test
+pi -e /a/src/mia-code/widget/mia-interceptor/index.ts
+
+# Permanent
+ln -s /a/src/mia-code/widget/mia-interceptor/index.ts ~/.pi/agent/extensions/mia-interceptor.ts
+```
+
+## How It Works
+
+1. Hooks `on("input")` — sees every prompt before the agent
+2. Counts distinct action areas (creating, testing, deploying, etc.)
+3. Checks for implicit intent markers ("I assume", "somehow", "make sure")
+4. If complexity ≥ 3 areas → asks the question
+5. If yes → runs PDE, shows result in chat, then lets the original prompt proceed
+6. If no → continues normally
+7. Cooldown: won't ask again for 5 turns
+
+## Behavior
+
+- **Never blocks** — always a yes/no question, never automatic
+- **Short prompts ignored** — under 30 chars, no question
+- **Slash commands ignored** — `/pde`, `/stc` etc pass through
+- **Cooldown** — won't nag, waits 5 turns between asks
+- **PDE + continue** — decomposition shows as context, then your prompt still goes to the agent
+
+## Future: Sensing Layer
+
+This interceptor is designed to eventually feed miawa storytelling too — sensing milestone moments, phase transitions, and narrative-worthy beats from the flow of input.

package/widget/mia-interceptor/index.ts

@@ -0,0 +1,221 @@
+/**
+ * 🌅 Mia Interceptor — Proactive PDE Prompt Sensing
+ *
+ * Listens to every input. When a prompt looks complex (multiple verbs,
+ * conjunctions, implicit intents), gently asks:
+ *
+ *   🌅 This prompt touches 3 areas — want to decompose first? (y/n)
+ *
+ * If yes → runs pde_decompose, shows result, then lets user proceed.
+ * If no → continues normally.
+ *
+ * Light touch. Never blocks flow. Just asks once.
+ *
+ * Install: ln -s /a/src/mia-code/widget/mia-interceptor/index.ts ~/.pi/agent/extensions/mia-interceptor.ts
+ * Or test: pi -e /a/src/mia-code/widget/mia-interceptor/index.ts
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+const MIACO_BIN = join("/a/src/mia-code/miaco/dist/index.js");
+
+// ============================================================================
+// Complexity Heuristics
+// ============================================================================
+
+/** Action verbs that signal distinct intents */
+const ACTION_VERBS = [
+	"create", "build", "make", "write", "generate", "design", "implement",
+	"update", "modify", "change", "refactor", "fix", "edit", "alter",
+	"analyze", "review", "check", "inspect", "study", "examine", "investigate",
+	"deploy", "publish", "release", "ship", "install", "setup", "configure",
+	"test", "validate", "verify", "debug",
+	"delete", "remove", "clean", "drop",
+	"move", "migrate", "port", "transfer",
+	"document", "explain", "describe",
+	"connect", "integrate", "link", "bridge",
+	"observe", "envision", "plan", "decompose",
+];
+
+/** Words that join separate intents */
+const CONJUNCTIONS = ["and", "also", "then", "after that", "plus", "additionally", "as well", "while"];
+
+/** Hedging language that signals implicit intents */
+const IMPLICIT_MARKERS = [
+	"somehow", "probably", "maybe", "I assume", "you will", "I expect",
+	"which means", "so that", "in order to", "make sure",
+];
+
+interface ComplexityAssessment {
+	score: number;
+	areas: string[];
+	hasImplicit: boolean;
+	reason: string;
+}
+
+function assessComplexity(text: string): ComplexityAssessment {
+	const lower = text.toLowerCase();
+	const words = lower.split(/\s+/);
+
+	// Count distinct action verbs
+	const foundVerbs = new Set<string>();
+	for (const verb of ACTION_VERBS) {
+		// Match whole words or verb at start of word (e.g., "creating")
+		const re = new RegExp(`\\b${verb}(e?s|ed|ing)?\\b`, "i");
+		if (re.test(lower)) {
+			foundVerbs.add(verb);
+		}
+	}
+
+	// Count conjunctions joining clauses
+	let conjunctionCount = 0;
+	for (const conj of CONJUNCTIONS) {
+		const re = new RegExp(`\\b${conj}\\b`, "gi");
+		const matches = lower.match(re);
+		if (matches) conjunctionCount += matches.length;
+	}
+
+	// Check for implicit intent markers
+	let implicitCount = 0;
+	for (const marker of IMPLICIT_MARKERS) {
+		if (lower.includes(marker)) implicitCount++;
+	}
+
+	// Compute areas (groups of related verbs)
+	const areas: string[] = [];
+	const verbGroups: Record<string, string[]> = {
+		"creating": ["create", "build", "make", "write", "generate", "design", "implement"],
+		"modifying": ["update", "modify", "change", "refactor", "fix", "edit", "alter"],
+		"analyzing": ["analyze", "review", "check", "inspect", "study", "examine", "investigate"],
+		"deploying": ["deploy", "publish", "release", "ship", "install", "setup", "configure"],
+		"testing": ["test", "validate", "verify", "debug"],
+		"removing": ["delete", "remove", "clean", "drop"],
+		"moving": ["move", "migrate", "port", "transfer"],
+		"documenting": ["document", "explain", "describe"],
+		"integrating": ["connect", "integrate", "link", "bridge"],
+		"planning": ["observe", "envision", "plan", "decompose"],
+	};
+
+	for (const [area, verbs] of Object.entries(verbGroups)) {
+		if (verbs.some((v) => foundVerbs.has(v))) {
+			areas.push(area);
+		}
+	}
+
+	// Score: primarily driven by distinct areas
+	const score = areas.length + (conjunctionCount > 0 ? 0.5 : 0) + (implicitCount > 0 ? 0.5 : 0);
+
+	// Build reason
+	const parts: string[] = [];
+	if (areas.length > 1) parts.push(`${areas.length} areas (${areas.join(", ")})`);
+	if (implicitCount > 0) parts.push(`${implicitCount} implicit intent(s)`);
+	if (conjunctionCount > 1) parts.push(`${conjunctionCount} conjunctions`);
+
+	return {
+		score,
+		areas,
+		hasImplicit: implicitCount > 0,
+		reason: parts.join(", ") || "single intent",
+	};
+}
+
+// ============================================================================
+// Extension
+// ============================================================================
+
+/** Threshold: prompt needs at least this many areas to trigger */
+const COMPLEXITY_THRESHOLD = 3;
+
+/** Don't ask again within this many turns */
+const COOLDOWN_TURNS = 5;
+
+export default function miaInterceptor(pi: ExtensionAPI) {
+	let turnsSinceLastAsk = COOLDOWN_TURNS; // Start ready
+
+	pi.on("turn_end", () => {
+		turnsSinceLastAsk++;
+	});
+
+	pi.on("input", async (event, ctx) => {
+		if (!ctx.hasUI) return { action: "continue" as const };
+
+		const text = event.text.trim();
+
+		// Skip slash commands, short prompts, or cooldown
+		if (text.startsWith("/") || text.length < 30 || turnsSinceLastAsk < COOLDOWN_TURNS) {
+			return { action: "continue" as const };
+		}
+
+		const assessment = assessComplexity(text);
+
+		if (assessment.score >= COMPLEXITY_THRESHOLD) {
+			const areaCount = assessment.areas.length;
+			const implicit = assessment.hasImplicit ? " + implicit intents" : "";
+			const message = `🌅 This prompt touches ${areaCount} areas${implicit} — want to decompose first?`;
+
+			const decompose = await ctx.ui.confirm("Prompt Decomposition", message);
+			turnsSinceLastAsk = 0;
+
+			if (decompose) {
+				ctx.ui.setStatus("pde", "🌅 decomposing...");
+
+				// Run PDE
+				const result = await runMiaco(
+					["decompose", "run", "-e", "claude", "-p", text, "--json"],
+					ctx.cwd,
+				);
+
+				ctx.ui.setStatus("pde", undefined);
+
+				if (result.code === 0) {
+					const parsed = parseJson(result.stdout);
+					if (parsed?.markdownPath && existsSync(parsed.markdownPath)) {
+						const md = readFileSync(parsed.markdownPath, "utf-8");
+						pi.sendMessage({
+							customType: "pde-result",
+							content: md,
+							display: true,
+							details: parsed,
+						});
+					}
+				}
+
+				// Let the original prompt continue to the agent with PDE context
+				return { action: "continue" as const };
+			}
+		}
+
+		return { action: "continue" as const };
+	});
+}
+
+// ============================================================================
+// Helpers (duplicated from mia-tools to keep extensions independent)
+// ============================================================================
+
+function runMiaco(args: string[], cwd: string): Promise<{ stdout: string; stderr: string; code: number }> {
+	return new Promise((resolve) => {
+		const child = spawn("node", [MIACO_BIN, ...args], {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+			env: process.env,
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (d: Buffer) => (stdout += d.toString()));
+		child.stderr.on("data", (d: Buffer) => (stderr += d.toString()));
+		child.on("close", (code) => resolve({ stdout, stderr, code: code ?? 1 }));
+		child.on("error", (err) => resolve({ stdout: "", stderr: err.message, code: 1 }));
+	});
+}
+
+function parseJson(stdout: string): any {
+	try {
+		return JSON.parse(stdout.trim());
+	} catch {
+		return null;
+	}
+}

package/widget/mia-tools/README.md

@@ -0,0 +1,37 @@
+# 🔧 Mia Tools — PDE + STC as Pi Extension
+
+Registers miaco's **Prompt Decomposition Engine** and **Structural Tension Charts** as LLM-callable tools and slash commands within Pi.
+
+## Install
+
+```bash
+# Quick test
+pi -e /a/src/mia-code/widget/mia-tools/index.ts
+
+# Permanent
+ln -s /a/src/mia-code/widget/mia-tools/index.ts ~/.pi/agent/extensions/mia-tools.ts
+```
+
+**Requires:** miaco built (`cd /a/src/mia-code/miaco && npm run build`)
+
+## LLM-Callable Tools
+
+| Tool | Description |
+|------|-------------|
+| `pde_decompose` | Decompose complex prompt into structured intents + Four Directions |
+| `stc_create` | Create structural tension chart (outcome vs reality) |
+| `stc_add_step` | Add action step to a chart |
+| `stc_complete_step` | Mark step complete |
+| `stc_review` | Creator Moment of Truth — review chart progress |
+| `stc_list` | List active charts |
+
+## Slash Commands
+
+- `/pde <prompt>` — Decompose a prompt, show result in chat
+- `/pde` — List recent decompositions
+- `/stc` — List active charts
+- `/stc create` — Interactive chart creation (prompts for outcome + reality)
+
+## How It Works
+
+Tools delegate to `miaco` CLI via `child_process.spawn` with `--json` output parsing. Custom `renderResult` provides visual summaries in the TUI.