coaiajs 0.1.0

package/src/pde/mcp-tools.ts

@@ -0,0 +1,201 @@
+/**
+ * MCP tool definitions for PDE module (10 tools)
+ * Ported from coaia-pde/src/mcp-server.ts tool schemas
+ */
+
+export interface McpToolDef {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+export const PDE_MCP_TOOLS: McpToolDef[] = [
+  {
+    name: 'import_pde_decomposition',
+    description: 'Import a .pde/*.json StoredDecomposition and create an STC session from it. Reads the decomposition result, maps it to Structural Tension Chart entities, and persists as .coaia/pde/<UUID>.jsonl.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pde_id: {
+          type: 'string',
+          description: 'ID of the PDE decomposition in .pde/ folder'
+        },
+        workdir: {
+          type: 'string',
+          description: 'Working directory containing .pde/ folder (default: cwd)'
+        }
+      },
+      required: ['pde_id']
+    }
+  },
+  {
+    name: 'create_stc_from_pde',
+    description: 'One-shot: provide a DecompositionResult JSON directly and create a Structural Tension Chart session. Use when you already have the decomposition in memory.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        decomposition_result: {
+          type: 'object',
+          description: 'DecompositionResult JSON object from mcp-pde'
+        },
+        original_prompt: {
+          type: 'string',
+          description: 'The original prompt that was decomposed'
+        }
+      },
+      required: ['decomposition_result', 'original_prompt']
+    }
+  },
+  {
+    name: 'list_pde_decompositions',
+    description: 'List available .pde/*.json decomposition files that can be imported into STC sessions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        workdir: {
+          type: 'string',
+          description: 'Working directory containing .pde/ folder (default: cwd)'
+        }
+      }
+    }
+  },
+  {
+    name: 'get_session',
+    description: 'Get the current state of a PDE session including the Structural Tension Chart, action steps, and progress.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session_id: {
+          type: 'string',
+          description: 'The session UUID'
+        }
+      },
+      required: ['session_id']
+    }
+  },
+  {
+    name: 'list_sessions',
+    description: 'List all PDE sessions in the current directory.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['active', 'completed', 'abandoned', 'all'],
+          description: 'Filter by session status'
+        }
+      }
+    }
+  },
+  {
+    name: 'update_action_progress',
+    description: 'Update progress on an action step with a factual observation.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session_id: {
+          type: 'string',
+          description: 'The session UUID'
+        },
+        action_name: {
+          type: 'string',
+          description: 'The action step entity name (e.g., chart_abc123_action_1)'
+        },
+        observation: {
+          type: 'string',
+          description: 'Factual progress observation (what was done, not what will be done)'
+        },
+        update_current_reality: {
+          type: 'boolean',
+          description: 'Whether to also add this observation to the chart current reality'
+        }
+      },
+      required: ['session_id', 'action_name', 'observation']
+    }
+  },
+  {
+    name: 'mark_action_complete',
+    description: 'Mark an action step as complete. The completion flows into current reality.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session_id: {
+          type: 'string',
+          description: 'The session UUID'
+        },
+        action_name: {
+          type: 'string',
+          description: 'The action step entity name'
+        },
+        completion_note: {
+          type: 'string',
+          description: 'Optional note about what was accomplished'
+        }
+      },
+      required: ['session_id', 'action_name']
+    }
+  },
+  {
+    name: 'add_action_step',
+    description: 'Add a new strategic action step to the chart. Each action step is a secondary choice supporting the primary goal.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session_id: {
+          type: 'string',
+          description: 'The session UUID'
+        },
+        action_description: {
+          type: 'string',
+          description: 'Description of the strategic action'
+        },
+        current_reality: {
+          type: 'string',
+          description: 'Current reality for this specific action step'
+        }
+      },
+      required: ['session_id', 'action_description']
+    }
+  },
+  {
+    name: 'update_current_reality',
+    description: 'Add observations to the current reality of the chart.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session_id: {
+          type: 'string',
+          description: 'The session UUID'
+        },
+        observations: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Factual observations to add to current reality'
+        }
+      },
+      required: ['session_id', 'observations']
+    }
+  },
+  {
+    name: 'complete_session',
+    description: 'Mark the session as completed when the desired outcome is achieved.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        session_id: {
+          type: 'string',
+          description: 'The session UUID'
+        },
+        final_note: {
+          type: 'string',
+          description: 'Final observation about the completed outcome'
+        }
+      },
+      required: ['session_id']
+    }
+  },
+];

package/src/pde/session-manager.ts

@@ -0,0 +1,248 @@
+/**
+ * Session Manager — JSONL persistence for PDE sessions in .coaia/pde/<UUID>.jsonl
+ * Ported from coaia-pde/src/session-manager.ts
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import type { Entity, Relation, PdeSession, StoredDecomposition } from '../types.js';
+
+function serializeEntity(entity: Entity): string {
+  return JSON.stringify({ type: 'entity', ...entity });
+}
+
+function serializeRelation(relation: Relation): string {
+  return JSON.stringify({ type: 'relation', ...relation });
+}
+
+export class SessionManager {
+  private baseDir: string;
+
+  constructor(baseDir?: string) {
+    this.baseDir = baseDir || path.join(process.cwd(), '.coaia', 'pde');
+  }
+
+  private getSessionPath(sessionId: string): string {
+    return path.join(this.baseDir, `${sessionId}.jsonl`);
+  }
+
+  async ensureBaseDir(): Promise<void> {
+    await fs.mkdir(this.baseDir, { recursive: true });
+  }
+
+  async initSession(
+    originalPrompt: string,
+    masterChartId: string,
+    pdeDecompositionId?: string
+  ): Promise<PdeSession> {
+    await this.ensureBaseDir();
+
+    const sessionId = uuidv4();
+    const now = new Date().toISOString();
+
+    const session: PdeSession = {
+      type: 'pde_session',
+      sessionId,
+      originalPrompt,
+      masterChartId,
+      pdeDecompositionId,
+      createdAt: now,
+      updatedAt: now,
+      status: 'active'
+    };
+
+    const sessionPath = this.getSessionPath(sessionId);
+    await fs.writeFile(sessionPath, JSON.stringify(session) + '\n');
+
+    return session;
+  }
+
+  async loadSession(sessionId: string): Promise<{
+    session: PdeSession;
+    entities: Entity[];
+    relations: Relation[];
+  }> {
+    const sessionPath = this.getSessionPath(sessionId);
+    const data = await fs.readFile(sessionPath, 'utf-8');
+    const lines = data.split('\n').filter(line => line.trim());
+
+    let session: PdeSession | null = null;
+    const entities: Entity[] = [];
+    const relations: Relation[] = [];
+
+    for (const line of lines) {
+      const item = JSON.parse(line);
+      if (item.type === 'pde_session') {
+        session = item as PdeSession;
+      } else if (item.type === 'entity') {
+        const { type: _discriminator, ...entity } = item;
+        entities.push(entity as Entity);
+      } else if (item.type === 'relation') {
+        const { type: _discriminator, ...relation } = item;
+        relations.push(relation as Relation);
+      }
+    }
+
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found or corrupted`);
+    }
+
+    return { session, entities, relations };
+  }
+
+  async appendEntity(sessionId: string, entity: Entity): Promise<void> {
+    const sessionPath = this.getSessionPath(sessionId);
+    await fs.appendFile(sessionPath, serializeEntity(entity) + '\n');
+  }
+
+  async appendRelation(sessionId: string, relation: Relation): Promise<void> {
+    const sessionPath = this.getSessionPath(sessionId);
+    await fs.appendFile(sessionPath, serializeRelation(relation) + '\n');
+  }
+
+  async updateSession(sessionId: string, updates: Partial<PdeSession>): Promise<void> {
+    const { session, entities, relations } = await this.loadSession(sessionId);
+    const updatedSession = { ...session, ...updates, updatedAt: new Date().toISOString() };
+
+    const sessionPath = this.getSessionPath(sessionId);
+    const lines = [
+      JSON.stringify(updatedSession),
+      ...entities.map(e => serializeEntity(e)),
+      ...relations.map(r => serializeRelation(r))
+    ];
+    await fs.writeFile(sessionPath, lines.join('\n') + '\n');
+  }
+
+  async updateEntity(sessionId: string, entityName: string, updates: Partial<Entity>): Promise<void> {
+    const { session, entities, relations } = await this.loadSession(sessionId);
+
+    const entityIndex = entities.findIndex(e => e.name === entityName);
+    if (entityIndex === -1) {
+      throw new Error(`Entity ${entityName} not found in session ${sessionId}`);
+    }
+
+    entities[entityIndex] = { ...entities[entityIndex], ...updates };
+    if (entities[entityIndex].metadata) {
+      entities[entityIndex].metadata!.updatedAt = new Date().toISOString();
+    }
+
+    const sessionPath = this.getSessionPath(sessionId);
+    const lines = [
+      JSON.stringify(session),
+      ...entities.map(e => serializeEntity(e)),
+      ...relations.map(r => serializeRelation(r))
+    ];
+    await fs.writeFile(sessionPath, lines.join('\n') + '\n');
+  }
+
+  async listSessions(): Promise<PdeSession[]> {
+    try {
+      await this.ensureBaseDir();
+      const files = await fs.readdir(this.baseDir);
+      const sessions: PdeSession[] = [];
+
+      for (const file of files) {
+        if (file.endsWith('.jsonl')) {
+          try {
+            const sessionId = file.replace('.jsonl', '');
+            const { session } = await this.loadSession(sessionId);
+            sessions.push(session);
+          } catch {
+            // Skip corrupted files
+          }
+        }
+      }
+
+      return sessions.sort((a, b) =>
+        new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+    } catch {
+      return [];
+    }
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    const sessionPath = this.getSessionPath(sessionId);
+    await fs.unlink(sessionPath);
+  }
+
+  async getSessionFilePath(sessionId: string): Promise<string> {
+    return this.getSessionPath(sessionId);
+  }
+
+  // =========================================================================
+  // PDE Decomposition File Access (.pde/ directory)
+  // =========================================================================
+
+  async listPdeDecompositions(workdir?: string): Promise<Array<{
+    id: string;
+    timestamp: string;
+    prompt: string;
+  }>> {
+    const pdeDir = path.join(workdir || process.cwd(), '.pde');
+    try {
+      const entries = await fs.readdir(pdeDir);
+      const results: Array<{ id: string; timestamp: string; prompt: string }> = [];
+
+      for (const entry of entries) {
+        if (!entry.endsWith('.json')) continue;
+        try {
+          const filePath = path.join(pdeDir, entry);
+          const data = await fs.readFile(filePath, 'utf-8');
+          const stored = JSON.parse(data) as StoredDecomposition;
+          if (stored.id && stored.result) {
+            results.push({
+              id: stored.id,
+              timestamp: stored.timestamp,
+              prompt: stored.prompt,
+            });
+          }
+        } catch {
+          // Skip invalid files
+        }
+      }
+
+      return results.sort((a, b) =>
+        new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+      );
+    } catch {
+      return [];
+    }
+  }
+
+  async loadPdeDecomposition(id: string, workdir?: string): Promise<StoredDecomposition | null> {
+    const pdeDir = path.join(workdir || process.cwd(), '.pde');
+
+    // Try direct {id}.json file first
+    const directPath = path.join(pdeDir, `${id}.json`);
+    try {
+      const data = await fs.readFile(directPath, 'utf-8');
+      return JSON.parse(data) as StoredDecomposition;
+    } catch {
+      // Not found as direct file — scan for matching id
+    }
+
+    // Scan directory for a .json file whose parsed id matches
+    try {
+      const entries = await fs.readdir(pdeDir);
+      for (const entry of entries) {
+        if (!entry.endsWith('.json')) continue;
+        try {
+          const filePath = path.join(pdeDir, entry);
+          const data = await fs.readFile(filePath, 'utf-8');
+          const parsed = JSON.parse(data) as StoredDecomposition;
+          if (parsed.id === id) return parsed;
+        } catch {
+          // Skip invalid
+        }
+      }
+    } catch {
+      // Directory not found
+    }
+
+    return null;
+  }
+}
+
+export const sessionManager = new SessionManager();