mia-code 0.2.0 → 0.3.0

package/miawa/src/index.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * miawa - Ceremony World Terminal Agent
+ * 
+ * Part of the mia-code family:
+ * - miaco: Engineering World CLI
+ * - miatel: Story World CLI
+ * - miawa: Ceremony World CLI (this one)
+ * 
+ * Provides ceremonial operations:
+ * - Story beat creation with sacred pause
+ * - Circle joining and witnessing
+ * - Ceremony initiation and closing
+ * - Wound acknowledgment and healing
+ * - Eva companion interactions
+ * - Full Lighthouse API access
+ */
+
+import { Command } from "commander";
+import chalk from "chalk";
+import { beatCommand } from "./commands/beat.js";
+import { circleCommand } from "./commands/circle.js";
+import { ceremonyCommand } from "./commands/ceremony.js";
+import { woundCommand } from "./commands/wound.js";
+import { evaCommand } from "./commands/eva.js";
+
+const program = new Command();
+
+program
+  .name("miawa")
+  .description("🙏 miawa — Ceremony World terminal agent for healing and relational accountability")
+  .version("0.1.0");
+
+// Story beat operations (with ceremony awareness)
+program.addCommand(beatCommand);
+
+// Circle operations
+program.addCommand(circleCommand);
+
+// Ceremony operations
+program.addCommand(ceremonyCommand);
+
+// Wound/healing operations
+program.addCommand(woundCommand);
+
+// Eva companion operations
+program.addCommand(evaCommand);
+
+// Quick status command
+program
+  .command("status")
+  .description("Show current ceremony status")
+  .action(async () => {
+    console.log(chalk.bold("🙏 miawa — Ceremony World Status"));
+    console.log();
+    console.log(chalk.dim("  Active ceremony: none"));
+    console.log(chalk.dim("  Circles joined: 0"));
+    console.log(chalk.dim("  Story beats: 0"));
+    console.log(chalk.dim("  Wounds tracked: 0"));
+    console.log();
+    console.log(chalk.yellow("  Take a breath. The ceremony begins when you are ready."));
+  });
+
+// Help with examples
+program
+  .command("examples")
+  .description("Show usage examples")
+  .action(() => {
+    console.log(chalk.bold("\n🙏 miawa Examples\n"));
+    
+    console.log(chalk.dim("# Create a story beat with reflection"));
+    console.log("  miawa beat create --phase violet --text 'Today I noticed...'\n");
+    
+    console.log(chalk.dim("# Join a story circle"));
+    console.log("  miawa circle join --id <circle-uuid>\n");
+    
+    console.log(chalk.dim("# Initiate a healing ceremony"));
+    console.log("  miawa ceremony init --type healing_circle --title 'Evening Reflection'\n");
+    
+    console.log(chalk.dim("# Acknowledge a wound"));
+    console.log("  miawa wound acknowledge --name 'ancestral grief' --category ancestral\n");
+    
+    console.log(chalk.dim("# Ask Eva to analyze text"));
+    console.log("  miawa eva analyze --text 'My reflection on today...'\n");
+    
+    console.log(chalk.dim("# Witness a shared story"));
+    console.log("  miawa circle witness --story <story-id> --text 'I see you.'\n");
+  });
+
+// K'é acknowledgment
+program
+  .command("ke")
+  .description("Acknowledge kinship relationships")
+  .action(async () => {
+    console.log(chalk.bold("🙏 K'é - Kinship Acknowledgment"));
+    console.log();
+    console.log(chalk.dim("  The Diné concept of K'é recognizes that we are all related."));
+    console.log(chalk.dim("  Before we begin work, we acknowledge:"));
+    console.log();
+    console.log(chalk.dim("    - The land where this work is done"));
+    console.log(chalk.dim("    - The ancestors whose wisdom guides us"));
+    console.log(chalk.dim("    - The community who will benefit"));
+    console.log(chalk.dim("    - The future generations who inherit our choices"));
+    console.log();
+    console.log(chalk.green("  ✓ K'é acknowledged. Proceed with relational awareness."));
+  });
+
+program.parseAsync(process.argv);

package/miawa/src/storage.ts

@@ -0,0 +1,179 @@
+/**
+ * SessionStorage - Persistence layer for miawa CLI
+ * 
+ * Provides JSONL-based storage with session isolation.
+ * Each session gets its own directory with separate files per entity type.
+ */
+
+import { existsSync, mkdirSync, appendFileSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+export interface StorageOptions {
+  sessionId?: string;
+  storageRoot?: string;
+}
+
+export class SessionStorage {
+  private sessionId: string;
+  private sessionDir: string;
+
+  constructor(options: StorageOptions = {}) {
+    this.sessionId = this.resolveSessionId(options.sessionId);
+
+    const root = options.storageRoot || join(process.cwd(), ".mia-code/sessions");
+    this.sessionDir = join(root, this.sessionId);
+
+    // Ensure directory exists
+    mkdirSync(this.sessionDir, { recursive: true });
+  }
+
+  private resolveSessionId(providedId?: string): string {
+    // 1. Explicit flag
+    if (providedId) return providedId;
+
+    // 2. Environment variable
+    if (process.env.MIA_SESSION_ID) return process.env.MIA_SESSION_ID;
+
+    // 3. Current session file
+    try {
+      const currentFile = join(process.cwd(), ".mia-code/current-session");
+      if (existsSync(currentFile)) {
+        return readFileSync(currentFile, "utf8").trim();
+      }
+    } catch {
+      // Ignore
+    }
+
+    // 4. Generate new (simplified UUID)
+    return `session_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+
+  getSessionId(): string {
+    return this.sessionId;
+  }
+
+  getSessionDir(): string {
+    return this.sessionDir;
+  }
+
+  append<T>(file: string, data: T): void {
+    const path = join(this.sessionDir, file);
+    appendFileSync(path, JSON.stringify(data) + "\n", "utf8");
+  }
+
+  readAll<T>(file: string): T[] {
+    const path = join(this.sessionDir, file);
+
+    if (!existsSync(path)) {
+      return [];
+    }
+
+    try {
+      const content = readFileSync(path, "utf8");
+      return content
+        .trim()
+        .split("\n")
+        .filter(line => line.length > 0)
+        .map(line => JSON.parse(line) as T);
+    } catch (err) {
+      console.error(`Error reading ${file}:`, err);
+      return [];
+    }
+  }
+
+  findById<T extends { id: string }>(file: string, id: string): T | null {
+    const items = this.readAll<T>(file);
+    return items.find(item => item.id === id) || null;
+  }
+
+  query<T>(file: string, predicate: (item: T) => boolean): T[] {
+    const items = this.readAll<T>(file);
+    return items.filter(predicate);
+  }
+
+  update<T extends { id: string }>(file: string, id: string, updater: (item: T) => T): boolean {
+    const items = this.readAll<T>(file);
+    const index = items.findIndex(item => item.id === id);
+    
+    if (index === -1) {
+      return false;
+    }
+
+    items[index] = updater(items[index]);
+    
+    // Rewrite entire file
+    const path = join(this.sessionDir, file);
+    const content = items.map(item => JSON.stringify(item)).join("\n") + "\n";
+    writeFileSync(path, content, "utf8");
+    
+    return true;
+  }
+
+  delete<T extends { id: string }>(file: string, id: string): boolean {
+    const items = this.readAll<T>(file);
+    const filtered = items.filter(item => item.id !== id);
+    
+    if (filtered.length === items.length) {
+      return false;
+    }
+
+    const path = join(this.sessionDir, file);
+    const content = filtered.map(item => JSON.stringify(item)).join("\n") + (filtered.length > 0 ? "\n" : "");
+    writeFileSync(path, content, "utf8");
+    
+    return true;
+  }
+}
+
+// Ceremony types
+export type CeremonyType = "group_reflection" | "seasonal" | "healing_circle" | "wisdom_sharing";
+export type Movement = 1 | 2 | 3 | 4;
+
+export interface Ceremony {
+  id: string;
+  type: CeremonyType;
+  title: string;
+  intention: string;
+  movement: Movement;
+  createdAt: number;
+  completedAt?: number;
+}
+
+// Wound types
+export type WoundCategory = "betrayal" | "abandonment" | "shame" | "grief" | "injustice" | "trauma" | "ancestral" | "spiritual";
+export type WoundStage = "acknowledged" | "explored" | "witnessing" | "integrating" | "medicine";
+
+export interface Wound {
+  id: string;
+  name: string;
+  category: WoundCategory;
+  stage: WoundStage;
+  originStory?: string;
+  bulletPoints: string[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+// Ceremonial Beat types
+export type Phase = "yellow" | "violet" | "white-gold" | "emerald";
+
+export interface CeremonialBeat {
+  id: string;
+  phase: Phase;
+  text: string;
+  color?: string;
+  sound?: string;
+  shared: boolean;
+  createdAt: number;
+}
+
+// Circle types
+export interface Circle {
+  id: string;
+  name: string;
+  type: "ongoing" | "seasonal" | "one_time";
+  isPublic: boolean;
+  capacity: number;
+  members: string[];
+  createdAt: number;
+}

package/miawa/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mia-code",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Mia/Miette/Miawa terminal coding agent that wraps Gemini CLI in headless mode.",
   "bin": {
     "mia-code": "dist/index.js",
@@ -15,12 +15,15 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "ava-langchain-inquiry-routing": "^0.1.0",
     "ava-langchain-narrative-tracing": "^0.1.1",
-    "ava-langchain-prompt-decomposition": "^0.1.1",
-    "ava-langchain-relational-intelligence": "^0.1.1",
+    "ava-langchain-prompt-decomposition": "^0.1.4",
+    "ava-langchain-relational-intelligence": "^0.1.2",
     "ava-langgraph-narrative-intelligence": "^0.1.1",
-    "ava-langgraph-prompt-decomposition-engine": "^0.1.0",
+    "ava-langgraph-prompt-decomposition-engine": "^0.1.3",
     "chalk": "^5.3.0",
+    "coaiajs": "^0.1.0",
     "commander": "^12.0.0",
     "echo": "^0.1.9",
     "enquirer": "^2.4.1",
@@ -28,7 +31,6 @@
     "medicine-wheel-narrative-engine": "^0.1.1",
     "medicine-wheel-ontology-core": "^0.1.1",
     "medicine-wheel-relational-query": "^0.1.1",
-    "narrative-tracing": "^0.1.0",
     "ora": "^8.0.0"
   },
   "devDependencies": {

package/references/acp/CLAUDE.md

@@ -0,0 +1,7 @@
+
+
+## some potential pattern to look
+
+* in `clients.md` I observed : """Web Browser with AI SDK (powered by @mcpc/acp-ai-provider)""" which sounds a very interesting ways that we might be capable to interact with the terminal agent, create our own ACP and chat, see interaction into a web page or something
+
+

package/references/acp/agent-plan.md

@@ -0,0 +1,84 @@
+> ## Documentation Index
+> Fetch the complete documentation index at: https://agentclientprotocol.com/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Agent Plan
+
+> How Agents communicate their execution plans
+
+Plans are execution strategies for complex tasks that require multiple steps.
+
+Agents may share plans with Clients through [`session/update`](./prompt-turn#3-agent-reports-output) notifications, providing real-time visibility into their thinking and progress.
+
+## Creating Plans
+
+When the language model creates an execution plan, the Agent **SHOULD** report it to the Client:
+
+```json  theme={null}
+{
+  "jsonrpc": "2.0",
+  "method": "session/update",
+  "params": {
+    "sessionId": "sess_abc123def456",
+    "update": {
+      "sessionUpdate": "plan",
+      "entries": [
+        {
+          "content": "Analyze the existing codebase structure",
+          "priority": "high",
+          "status": "pending"
+        },
+        {
+          "content": "Identify components that need refactoring",
+          "priority": "high",
+          "status": "pending"
+        },
+        {
+          "content": "Create unit tests for critical functions",
+          "priority": "medium",
+          "status": "pending"
+        }
+      ]
+    }
+  }
+}
+```
+
+<ParamField path="entries" type="PlanEntry[]" required>
+  An array of [plan entries](#plan-entries) representing the tasks to be
+  accomplished
+</ParamField>
+
+## Plan Entries
+
+Each plan entry represents a specific task or goal within the overall execution strategy:
+
+<ParamField path="content" type="string" required>
+  A human-readable description of what this task aims to accomplish
+</ParamField>
+
+<ParamField path="priority" type="PlanEntryPriority" required>
+  The relative importance of this task.
+
+  * `high`
+  * `medium`
+  * `low`
+</ParamField>
+
+<ParamField path="status" type="PlanEntryStatus" required>
+  The current [execution status](#status) of this task
+
+  * `pending`
+  * `in_progress`
+  * `completed`
+</ParamField>
+
+## Updating Plans
+
+As the Agent progresses through the plan, it **SHOULD** report updates by sending more `session/update` notifications with the same structure.
+
+The Agent **MUST** send a complete list of all plan entries in each update and their current status. The Client **MUST** replace the current plan completely.
+
+### Dynamic Planning
+
+Plans can evolve during execution. The Agent **MAY** add, remove, or modify plan entries as it discovers new requirements or completes tasks, allowing it to adapt based on what it learns.

package/references/acp/clients.md

@@ -0,0 +1,31 @@
+> ## Documentation Index
+> Fetch the complete documentation index at: https://agentclientprotocol.com/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Clients
+
+> Clients implementing the Agent Client Protocol.
+
+The following clients can be used with an ACP Agent:
+
+* [Agent Studio](https://github.com/sxhxliang/agent-studio)
+* [Agmente](https://agmente.halliharp.com) (iOS)
+* [AionUi](https://github.com/iOfficeAI/AionUi)
+* [aizen](https://aizen.win)
+* [DeepChat](https://github.com/ThinkInAIXYZ/deepchat)
+* DuckDB
+  * through the [sidequery/duckdb-acp](https://github.com/sidequery/duckdb-acp) extension
+* Emacs via [agent-shell.el](https://github.com/xenodium/agent-shell)
+* [JetBrains](https://www.jetbrains.com/help/ai-assistant/acp.html)
+* [marimo notebook](https://github.com/marimo-team/marimo)
+* [neovim](https://neovim.io)
+  * through the [CodeCompanion](https://github.com/olimorris/codecompanion.nvim) plugin
+  * through the [carlos-algms/agentic.nvim](https://github.com/carlos-algms/agentic.nvim) plugin
+  * through the [yetone/avante.nvim](https://github.com/yetone/avante.nvim) plugin
+* [Obsidian](https://obsidian.md)
+  * through the [Agent Client](https://github.com/RAIT-09/obsidian-agent-client) plugin
+* [Sidequery *(coming soon)*](https://sidequery.dev)
+* [Tidewave](https://tidewave.ai/)
+* [Toad](https://www.batrachian.ai/)
+* [Web Browser with AI SDK](https://github.com/mcpc-tech/ai-elements-remix-template) (powered by [@mcpc/acp-ai-provider](https://github.com/mcpc-tech/mcpc/tree/main/packages/acp-ai-provider))
+* [Zed](https://zed.dev/docs/ai/external-agents)

package/references/acp/extensibility.md

@@ -0,0 +1,137 @@
+> ## Documentation Index
+> Fetch the complete documentation index at: https://agentclientprotocol.com/llms.txt
+> Use this file to discover all available pages before exploring further.
+
+# Extensibility
+
+> Adding custom data and capabilities
+
+The Agent Client Protocol provides built-in extension mechanisms that allow implementations to add custom functionality while maintaining compatibility with the core protocol. These mechanisms ensure that Agents and Clients can innovate without breaking interoperability.
+
+## The `_meta` Field
+
+All types in the protocol include a `_meta` field with type `{ [key: string]: unknown }` that implementations can use to attach custom information. This includes requests, responses, notifications, and even nested types like content blocks, tool calls, plan entries, and capability objects.
+
+```json  theme={null}
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "session/prompt",
+  "params": {
+    "sessionId": "sess_abc123def456",
+    "prompt": [
+      {
+        "type": "text",
+        "text": "Hello, world!"
+      }
+    ],
+    "_meta": {
+      "traceparent": "00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01",
+      "zed.dev/debugMode": true
+    }
+  }
+}
+```
+
+Clients may propagate fields to the agent for correlation purposes, such as `requestId`. The following root-level keys in `_meta` **SHOULD** be reserved for [W3C trace context](https://www.w3.org/TR/trace-context/) to guarantee interop with existing MCP implementations and OpenTelemetry tooling:
+
+* `traceparent`
+* `tracestate`
+* `baggage`
+
+Implementations **MUST NOT** add any custom fields at the root of a type that's part of the specification. All possible names are reserved for future protocol versions.
+
+## Extension Methods
+
+The protocol reserves any method name starting with an underscore (`_`) for custom extensions. This allows implementations to add new functionality without the risk of conflicting with future protocol versions.
+
+Extension methods follow standard [JSON-RPC 2.0](https://www.jsonrpc.org/specification) semantics:
+
+* **[Requests](https://www.jsonrpc.org/specification#request_object)** - Include an `id` field and expect a response
+* **[Notifications](https://www.jsonrpc.org/specification#notification)** - Omit the `id` field and are one-way
+
+### Custom Requests
+
+In addition to the requests specified by the protocol, implementations **MAY** expose and call custom JSON-RPC requests as long as their name starts with an underscore (`_`).
+
+```json  theme={null}
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "_zed.dev/workspace/buffers",
+  "params": {
+    "language": "rust"
+  }
+}
+```
+
+Upon receiving a custom request, implementations **MUST** respond accordingly with the provided `id`:
+
+```json  theme={null}
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "buffers": [
+      { "id": 0, "path": "/home/user/project/src/main.rs" },
+      { "id": 1, "path": "/home/user/project/src/editor.rs" }
+    ]
+  }
+}
+```
+
+If the receiving end doesn't recognize the custom method name, it should respond with the standard "Method not found" error:
+
+```json  theme={null}
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "error": {
+    "code": -32601,
+    "message": "Method not found"
+  }
+}
+```
+
+To avoid such cases, extensions **SHOULD** advertise their [custom capabilities](#advertising-custom-capabilities) so that callers can check their availability first and adapt their behavior or interface accordingly.
+
+### Custom Notifications
+
+Custom notifications are regular JSON-RPC notifications that start with an underscore (`_`). Like all notifications, they omit the `id` field:
+
+```json  theme={null}
+{
+  "jsonrpc": "2.0",
+  "method": "_zed.dev/file_opened",
+  "params": {
+    "path": "/home/user/project/src/editor.rs"
+  }
+}
+```
+
+Unlike with custom requests, implementations **SHOULD** ignore unrecognized notifications.
+
+## Advertising Custom Capabilities
+
+Implementations **SHOULD** use the `_meta` field in capability objects to advertise support for extensions and their methods:
+
+```json  theme={null}
+{
+  "jsonrpc": "2.0",
+  "id": 0,
+  "result": {
+    "protocolVersion": 1,
+    "agentCapabilities": {
+      "loadSession": true,
+      "_meta": {
+        "zed.dev": {
+          "workspace": true,
+          "fileNotifications": true
+        }
+      }
+    }
+  }
+}
+```
+
+This allows implementations to negotiate custom features during initialization without breaking compatibility with standard Clients and Agents.