coaiajs 0.3.0 → 0.3.2

package/src/pde/mcp-tools.ts

@@ -1,201 +0,0 @@
-/**
- * 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

@@ -1,248 +0,0 @@
-/**
- * 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();