coaiajs 0.1.0

package/dist/src/pde/mcp-handlers.js

@@ -0,0 +1,300 @@
+/**
+ * PDE MCP tool dispatch — handles each tool by calling stcMapper + sessionManager
+ * Ported from coaia-pde/src/mcp-server.ts handler logic
+ */
+import { stcMapper } from './stc-mapper.js';
+import { sessionManager } from './session-manager.js';
+export async function handlePdeTool(name, args) {
+    try {
+        switch (name) {
+            case 'import_pde_decomposition': {
+                const pdeId = args.pde_id;
+                const workdir = args.workdir;
+                const stored = await sessionManager.loadPdeDecomposition(pdeId, workdir);
+                if (!stored) {
+                    throw new Error(`PDE decomposition ${pdeId} not found in .pde/ directory`);
+                }
+                const { entities, relations, chartId } = stcMapper.mapDecompositionToChart(stored.result, stored.prompt, { pdeId: stored.id });
+                const session = await sessionManager.initSession(stored.prompt, chartId, stored.id);
+                for (const entity of entities) {
+                    await sessionManager.appendEntity(session.sessionId, entity);
+                }
+                for (const relation of relations) {
+                    await sessionManager.appendRelation(session.sessionId, relation);
+                }
+                const desiredOutcome = entities.find(e => e.entityType === 'desired_outcome')?.observations[0];
+                const currentReality = entities.find(e => e.entityType === 'current_reality')?.observations;
+                const actionSteps = entities
+                    .filter(e => e.entityType === 'action_step')
+                    .map(e => ({ name: e.name, description: e.observations[0] }));
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                sessionId: session.sessionId,
+                                chartId,
+                                pdeDecompositionId: stored.id,
+                                filePath: await sessionManager.getSessionFilePath(session.sessionId),
+                                chart: { desiredOutcome, currentReality, actionSteps },
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'create_stc_from_pde': {
+                const resultJson = args.decomposition_result;
+                const originalPrompt = args.original_prompt;
+                const { entities, relations, chartId } = stcMapper.mapDecompositionToChart(resultJson, originalPrompt);
+                const session = await sessionManager.initSession(originalPrompt, chartId);
+                for (const entity of entities) {
+                    await sessionManager.appendEntity(session.sessionId, entity);
+                }
+                for (const relation of relations) {
+                    await sessionManager.appendRelation(session.sessionId, relation);
+                }
+                const desiredOutcome = entities.find(e => e.entityType === 'desired_outcome')?.observations[0];
+                const currentReality = entities.find(e => e.entityType === 'current_reality')?.observations;
+                const actionSteps = entities
+                    .filter(e => e.entityType === 'action_step')
+                    .map(e => ({ name: e.name, description: e.observations[0] }));
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                sessionId: session.sessionId,
+                                chartId,
+                                filePath: await sessionManager.getSessionFilePath(session.sessionId),
+                                chart: { desiredOutcome, currentReality, actionSteps },
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'list_pde_decompositions': {
+                const workdir = args.workdir;
+                const decompositions = await sessionManager.listPdeDecompositions(workdir);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                count: decompositions.length,
+                                decompositions: decompositions.map(d => ({
+                                    id: d.id,
+                                    timestamp: d.timestamp,
+                                    prompt: d.prompt.substring(0, 100) + (d.prompt.length > 100 ? '...' : '')
+                                }))
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'get_session': {
+                const sessionId = args.session_id;
+                const { session, entities } = await sessionManager.loadSession(sessionId);
+                const chart = entities.find(e => e.entityType === 'structural_tension_chart');
+                const desiredOutcome = entities.find(e => e.entityType === 'desired_outcome');
+                const currentReality = entities.find(e => e.entityType === 'current_reality');
+                const actionSteps = entities.filter(e => e.entityType === 'action_step');
+                const completedCount = actionSteps.filter(a => a.metadata?.completionStatus).length;
+                const progress = actionSteps.length > 0 ? completedCount / actionSteps.length : 0;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                session,
+                                chart: {
+                                    chartId: chart?.metadata?.chartId,
+                                    desiredOutcome: desiredOutcome?.observations[0],
+                                    currentReality: currentReality?.observations,
+                                    dueDate: chart?.metadata?.dueDate,
+                                    progress: Math.round(progress * 100) + '%',
+                                    completedActions: completedCount,
+                                    totalActions: actionSteps.length
+                                },
+                                actionSteps: actionSteps.map(a => ({
+                                    name: a.name,
+                                    description: a.observations[0],
+                                    completed: a.metadata?.completionStatus || false,
+                                    dueDate: a.metadata?.dueDate,
+                                    progress: a.observations.slice(1)
+                                }))
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'list_sessions': {
+                const status = args.status;
+                let sessions = await sessionManager.listSessions();
+                if (status && status !== 'all') {
+                    sessions = sessions.filter(s => s.status === status);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                count: sessions.length,
+                                sessions: sessions.map(s => ({
+                                    sessionId: s.sessionId,
+                                    status: s.status,
+                                    createdAt: s.createdAt,
+                                    pdeDecompositionId: s.pdeDecompositionId,
+                                    prompt: s.originalPrompt.substring(0, 100) + (s.originalPrompt.length > 100 ? '...' : '')
+                                }))
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'update_action_progress': {
+                const sessionId = args.session_id;
+                const actionName = args.action_name;
+                const observation = args.observation;
+                const updateCR = args.update_current_reality;
+                const { entities } = await sessionManager.loadSession(sessionId);
+                const action = entities.find(e => e.name === actionName);
+                if (!action) {
+                    throw new Error(`Action step ${actionName} not found`);
+                }
+                action.observations.push(observation);
+                await sessionManager.updateEntity(sessionId, actionName, { observations: action.observations });
+                if (updateCR) {
+                    const chartId = action.metadata?.chartId;
+                    const realityName = `${chartId}_current_reality`;
+                    const reality = entities.find(e => e.name === realityName);
+                    if (reality) {
+                        reality.observations.push(`Progress: ${observation}`);
+                        await sessionManager.updateEntity(sessionId, realityName, { observations: reality.observations });
+                    }
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, actionName, observation })
+                        }]
+                };
+            }
+            case 'mark_action_complete': {
+                const sessionId = args.session_id;
+                const actionName = args.action_name;
+                const completionNote = args.completion_note;
+                const { entities } = await sessionManager.loadSession(sessionId);
+                const action = entities.find(e => e.name === actionName);
+                if (!action) {
+                    throw new Error(`Action step ${actionName} not found`);
+                }
+                if (!action.metadata)
+                    action.metadata = {};
+                action.metadata.completionStatus = true;
+                action.metadata.updatedAt = new Date().toISOString();
+                if (completionNote) {
+                    action.observations.push(`Completed: ${completionNote}`);
+                }
+                await sessionManager.updateEntity(sessionId, actionName, {
+                    observations: action.observations,
+                    metadata: action.metadata
+                });
+                const chartId = action.metadata?.chartId;
+                const realityName = `${chartId}_current_reality`;
+                const reality = entities.find(e => e.name === realityName);
+                if (reality) {
+                    reality.observations.push(`Completed: ${action.observations[0]}`);
+                    await sessionManager.updateEntity(sessionId, realityName, { observations: reality.observations });
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, actionName, completed: true })
+                        }]
+                };
+            }
+            case 'add_action_step': {
+                const sessionId = args.session_id;
+                const description = args.action_description;
+                const currentReality = args.current_reality;
+                const { session, entities } = await sessionManager.loadSession(sessionId);
+                const chart = entities.find(e => e.entityType === 'structural_tension_chart');
+                const chartId = chart?.metadata?.chartId || session.masterChartId;
+                const existingActions = entities.filter(e => e.entityType === 'action_step');
+                const actionNum = existingActions.length + 1;
+                const actionName = `${chartId}_action_${actionNum}`;
+                const now = new Date().toISOString();
+                const newAction = {
+                    name: actionName,
+                    entityType: 'action_step',
+                    observations: currentReality ? [description, `Current: ${currentReality}`] : [description],
+                    metadata: {
+                        chartId,
+                        completionStatus: false,
+                        level: 1,
+                        parentChart: chartId,
+                        createdAt: now,
+                        updatedAt: now,
+                    }
+                };
+                await sessionManager.appendEntity(sessionId, newAction);
+                await sessionManager.appendRelation(sessionId, {
+                    from: `${chartId}_chart`,
+                    to: actionName,
+                    relationType: 'has_action_step',
+                    metadata: { createdAt: now }
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, actionName, description })
+                        }]
+                };
+            }
+            case 'update_current_reality': {
+                const sessionId = args.session_id;
+                const observations = args.observations;
+                const { session, entities } = await sessionManager.loadSession(sessionId);
+                const chartId = session.masterChartId;
+                const realityName = `${chartId}_current_reality`;
+                const reality = entities.find(e => e.name === realityName);
+                if (!reality) {
+                    throw new Error(`Current reality not found for chart ${chartId}`);
+                }
+                reality.observations.push(...observations);
+                await sessionManager.updateEntity(sessionId, realityName, { observations: reality.observations });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, added: observations.length, totalObservations: reality.observations.length })
+                        }]
+                };
+            }
+            case 'complete_session': {
+                const sessionId = args.session_id;
+                const finalNote = args.final_note;
+                await sessionManager.updateSession(sessionId, { status: 'completed' });
+                if (finalNote) {
+                    const { session, entities } = await sessionManager.loadSession(sessionId);
+                    const realityName = `${session.masterChartId}_current_reality`;
+                    const reality = entities.find(e => e.name === realityName);
+                    if (reality) {
+                        reality.observations.push(`Final: ${finalNote}`);
+                        await sessionManager.updateEntity(sessionId, realityName, { observations: reality.observations });
+                    }
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, sessionId, status: 'completed' })
+                        }]
+                };
+            }
+            default:
+                throw new Error(`Unknown PDE tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error: ${message}`,
+                }],
+            isError: true
+        };
+    }
+}
+//# sourceMappingURL=mcp-handlers.js.map

package/dist/src/pde/mcp-tools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare const PDE_MCP_TOOLS: McpToolDef[];
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/src/pde/mcp-tools.js

@@ -0,0 +1,191 @@
+/**
+ * MCP tool definitions for PDE module (10 tools)
+ * Ported from coaia-pde/src/mcp-server.ts tool schemas
+ */
+export const PDE_MCP_TOOLS = [
+    {
+        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']
+        }
+    },
+];
+//# sourceMappingURL=mcp-tools.js.map

package/dist/src/pde/session-manager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Session Manager — JSONL persistence for PDE sessions in .coaia/pde/<UUID>.jsonl
+ * Ported from coaia-pde/src/session-manager.ts
+ */
+import type { Entity, Relation, PdeSession, StoredDecomposition } from '../types.js';
+export declare class SessionManager {
+    private baseDir;
+    constructor(baseDir?: string);
+    private getSessionPath;
+    ensureBaseDir(): Promise<void>;
+    initSession(originalPrompt: string, masterChartId: string, pdeDecompositionId?: string): Promise<PdeSession>;
+    loadSession(sessionId: string): Promise<{
+        session: PdeSession;
+        entities: Entity[];
+        relations: Relation[];
+    }>;
+    appendEntity(sessionId: string, entity: Entity): Promise<void>;
+    appendRelation(sessionId: string, relation: Relation): Promise<void>;
+    updateSession(sessionId: string, updates: Partial<PdeSession>): Promise<void>;
+    updateEntity(sessionId: string, entityName: string, updates: Partial<Entity>): Promise<void>;
+    listSessions(): Promise<PdeSession[]>;
+    deleteSession(sessionId: string): Promise<void>;
+    getSessionFilePath(sessionId: string): Promise<string>;
+    listPdeDecompositions(workdir?: string): Promise<Array<{
+        id: string;
+        timestamp: string;
+        prompt: string;
+    }>>;
+    loadPdeDecomposition(id: string, workdir?: string): Promise<StoredDecomposition | null>;
+}
+export declare const sessionManager: SessionManager;
+//# sourceMappingURL=session-manager.d.ts.map