coaiajs 0.1.0

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

@@ -0,0 +1,310 @@
+/**
+ * Planning MCP tool dispatch — handles each tool by calling plan-parser functions
+ * Ported from coaia-planning/src/index.ts handler logic
+ */
+import { promises as fs, readFileSync, existsSync } from 'fs';
+import path from 'path';
+import { parsePlan, parsePlanContent, planToSTC, exportToJSONL, decompositionResultToPlan, } from './plan-parser.js';
+// Cache for parsed plans
+const planCache = new Map();
+function getCachedOrParse(planPath) {
+    if (planCache.has(planPath)) {
+        return Promise.resolve(planCache.get(planPath));
+    }
+    return parsePlan(planPath).then(parsed => {
+        planCache.set(planPath, parsed);
+        return parsed;
+    });
+}
+function loadExistingCharts(chartsPath) {
+    try {
+        if (!existsSync(chartsPath))
+            return [];
+        const content = readFileSync(chartsPath, 'utf-8');
+        return content
+            .split('\n')
+            .filter((line) => line.trim())
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+function detectPlanChanges(parsed, existingCharts) {
+    const changes = [];
+    const existingActions = existingCharts
+        .filter(c => c.entityType === 'action_step')
+        .map(c => c.observations[0]);
+    for (const step of parsed.actionSteps) {
+        if (!existingActions.includes(step.content)) {
+            changes.push({
+                type: 'new_action',
+                description: step.content,
+                details: `New action step detected: ${step.content}`,
+            });
+        }
+    }
+    return changes;
+}
+function chartsToPlan(charts) {
+    let md = '';
+    const chartEntity = charts.find(c => c.entityType === 'structural_tension_chart');
+    if (chartEntity) {
+        const title = chartEntity.name.replace(/_chart$/, '').replace(/_/g, ' ');
+        md += `# ${title}\n\n`;
+    }
+    const desiredOutcome = charts.find(c => c.entityType === 'desired_outcome');
+    if (desiredOutcome) {
+        md += `## Desired Outcome\n\n${desiredOutcome.observations[0]}\n\n`;
+    }
+    const currentReality = charts.find(c => c.entityType === 'current_reality');
+    if (currentReality) {
+        md += `## Current Reality\n\n${currentReality.observations[0]}\n\n`;
+    }
+    const actionSteps = charts
+        .filter(c => c.entityType === 'action_step')
+        .sort((a, b) => (a.metadata?.order || 0) - (b.metadata?.order || 0));
+    if (actionSteps.length > 0) {
+        md += `## Action Steps\n\n`;
+        for (const step of actionSteps) {
+            const completed = step.metadata?.completionStatus ? '[x]' : '[ ]';
+            md += `- ${completed} ${step.observations[0]}\n`;
+        }
+    }
+    return md;
+}
+export async function handlePlanningTool(name, args) {
+    try {
+        switch (name) {
+            case 'parse_plan_structural': {
+                let parsed;
+                if (args.planPath) {
+                    const planPath = args.planPath;
+                    parsed = await parsePlan(planPath);
+                    planCache.set(planPath, parsed);
+                }
+                else if (args.planContent) {
+                    parsed = parsePlanContent(args.planContent);
+                }
+                else {
+                    throw new Error('Either planPath or planContent must be provided');
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                structuralAnalysis: {
+                                    title: parsed.title,
+                                    filePath: parsed.filePath,
+                                    desiredOutcome: parsed.desiredOutcome ? {
+                                        content: parsed.desiredOutcome.content,
+                                        confidence: parsed.desiredOutcome.confidence,
+                                    } : null,
+                                    currentReality: parsed.currentReality ? {
+                                        content: parsed.currentReality.content,
+                                        confidence: parsed.currentReality.confidence,
+                                    } : null,
+                                    actionSteps: parsed.actionSteps.map(s => ({
+                                        content: s.content,
+                                        confidence: s.confidence,
+                                        canTelescope: !!s.telescopesInto,
+                                    })),
+                                    observations: parsed.observations,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case 'plan_to_stc': {
+                const planPath = args.planPath;
+                const outputPath = args.outputPath ||
+                    path.join(process.cwd(), `${path.basename(planPath, '.md')}.stc.jsonl`);
+                const parsed = await getCachedOrParse(planPath);
+                // Override current reality if provided
+                if (args.currentReality && parsed.currentReality) {
+                    parsed.currentReality.content = args.currentReality;
+                }
+                else if (args.currentReality) {
+                    parsed.currentReality = {
+                        type: 'current_reality',
+                        content: args.currentReality,
+                        confidence: 1.0,
+                        sourceLines: { start: 0, end: 0 },
+                    };
+                }
+                const stc = planToSTC(parsed);
+                const jsonl = exportToJSONL(stc);
+                await fs.writeFile(outputPath, jsonl + '\n');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                chartCreated: {
+                                    title: parsed.title,
+                                    entitiesCount: stc.entities.length,
+                                    relationsCount: stc.relations.length,
+                                    outputPath,
+                                    hasDesiredOutcome: !!parsed.desiredOutcome,
+                                    hasCurrentReality: !!parsed.currentReality,
+                                    actionStepsCount: parsed.actionSteps.length,
+                                    telescopedCount: parsed.actionSteps.filter(s => s.telescopesInto).length,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case 'sync_plan_to_chart': {
+                const planPath = args.planPath;
+                const chartsPath = args.chartsPath;
+                const dryRun = args.dryRun || false;
+                const parsed = await getCachedOrParse(planPath);
+                const existingCharts = loadExistingCharts(chartsPath);
+                const changes = detectPlanChanges(parsed, existingCharts);
+                if (dryRun) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ dryRun: true, changes }, null, 2),
+                            }],
+                    };
+                }
+                // Apply changes: regenerate STC and write
+                const stc = planToSTC(parsed);
+                const jsonl = exportToJSONL(stc);
+                await fs.writeFile(chartsPath, jsonl + '\n');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, changesApplied: changes }, null, 2),
+                        }],
+                };
+            }
+            case 'sync_chart_to_plan': {
+                const chartsPath = args.chartsPath;
+                const planPath = args.planPath;
+                const dryRun = args.dryRun || false;
+                const charts = loadExistingCharts(chartsPath);
+                const planContent = chartsToPlan(charts);
+                if (dryRun) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ dryRun: true, proposedPlanContent: planContent }, null, 2),
+                            }],
+                    };
+                }
+                await fs.writeFile(planPath, planContent);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ success: true, planUpdated: planPath }, null, 2),
+                        }],
+                };
+            }
+            case 'create_plan_trace': {
+                const planPath = args.planPath;
+                const chartsPath = args.chartsPath;
+                const sessionId = args.sessionId;
+                const metadata = args.metadata || {};
+                const parsed = await getCachedOrParse(planPath);
+                const charts = loadExistingCharts(chartsPath);
+                const traceData = {
+                    trace_id: `plan-${Date.now()}`,
+                    name: `📋 Plan→STC: ${parsed.title}`,
+                    session_id: sessionId,
+                    input_data: {
+                        plan_title: parsed.title,
+                        plan_path: planPath,
+                        desired_outcome: parsed.desiredOutcome?.content,
+                        current_reality: parsed.currentReality?.content,
+                        action_steps: parsed.actionSteps.map(s => s.content),
+                    },
+                    output_data: {
+                        charts_created: charts.length,
+                        charts_path: chartsPath,
+                    },
+                    metadata: {
+                        ...metadata,
+                        transformation_timestamp: new Date().toISOString(),
+                        tool: 'coaia-planning',
+                    },
+                };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                traceData,
+                                note: 'Use Langfuse MCP to create trace with this data',
+                            }, null, 2),
+                        }],
+                };
+            }
+            case 'pde_to_plan': {
+                const workdir = args.workdir || process.cwd();
+                let decomposition;
+                let originalPrompt = args.original_prompt;
+                if (args.pde_id) {
+                    const pdeId = args.pde_id;
+                    const pdePath = path.join(workdir, '.pde', `${pdeId}.json`);
+                    let data;
+                    try {
+                        data = await fs.readFile(pdePath, 'utf-8');
+                    }
+                    catch {
+                        throw new Error(`PDE decomposition not found: ${pdePath}`);
+                    }
+                    const stored = JSON.parse(data);
+                    decomposition = stored.result;
+                    originalPrompt = originalPrompt || stored.prompt;
+                }
+                else if (args.decomposition_result) {
+                    decomposition = args.decomposition_result;
+                }
+                else {
+                    throw new Error('Either pde_id or decomposition_result must be provided');
+                }
+                const stc = decompositionResultToPlan(decomposition, originalPrompt);
+                const jsonl = exportToJSONL(stc);
+                if (args.outputPath) {
+                    const outPath = path.isAbsolute(args.outputPath)
+                        ? args.outputPath
+                        : path.resolve(args.outputPath);
+                    await fs.writeFile(outPath, jsonl + '\n');
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                chartCreated: {
+                                    entitiesCount: stc.entities.length,
+                                    relationsCount: stc.relations.length,
+                                    primaryIntent: `${decomposition.primary.action}: ${decomposition.primary.target}`,
+                                    actionStepsCount: decomposition.actionStack.length,
+                                    ambiguitiesCount: decomposition.ambiguities.length,
+                                    outputPath: args.outputPath || null,
+                                },
+                                jsonl,
+                            }, null, 2),
+                        }],
+                };
+            }
+            default:
+                throw new Error(`Unknown planning tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error: ${errorMessage}`,
+                }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=mcp-handlers.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * MCP tool definitions for Planning module (6 tools)
+ * Ported from coaia-planning/src/tools/index.ts
+ */
+export interface McpToolDef {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export declare const PLANNING_MCP_TOOLS: McpToolDef[];
+//# sourceMappingURL=mcp-tools.d.ts.map

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

@@ -0,0 +1,145 @@
+/**
+ * MCP tool definitions for Planning module (6 tools)
+ * Ported from coaia-planning/src/tools/index.ts
+ */
+export const PLANNING_MCP_TOOLS = [
+    {
+        name: 'parse_plan_structural',
+        description: 'Parse a Claude plan as structural tension chart. Extracts desired outcome, current reality, and action steps (which telescope into sub-charts). Returns confidence scores.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                planPath: {
+                    type: 'string',
+                    description: 'Path to the Claude plan markdown file',
+                },
+                planContent: {
+                    type: 'string',
+                    description: 'Alternative: raw markdown content (if path not provided)',
+                },
+            },
+        },
+    },
+    {
+        name: 'plan_to_stc',
+        description: 'Convert plan to structural tension chart (JSONL). Action steps become telescoped STCs with their own desired outcome/current reality.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                planPath: {
+                    type: 'string',
+                    description: 'Path to the Claude plan markdown file',
+                },
+                currentReality: {
+                    type: 'string',
+                    description: 'Override: provide current reality if not detected in plan',
+                },
+                outputPath: {
+                    type: 'string',
+                    description: 'Path to write the STC JSONL (default: <planname>.stc.jsonl)',
+                },
+            },
+            required: ['planPath'],
+        },
+    },
+    {
+        name: 'sync_plan_to_chart',
+        description: 'Plan → Chart sync. When plan changes, update the structural tension chart.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                planPath: {
+                    type: 'string',
+                    description: 'Path to the Claude plan markdown file',
+                },
+                chartsPath: {
+                    type: 'string',
+                    description: 'Path to the charts JSONL file',
+                },
+                dryRun: {
+                    type: 'boolean',
+                    description: 'If true, show changes without applying',
+                },
+            },
+            required: ['planPath', 'chartsPath'],
+        },
+    },
+    {
+        name: 'sync_chart_to_plan',
+        description: 'Chart → Plan sync. When agents modify chart (observations, completions), regenerate plan markdown.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                chartsPath: {
+                    type: 'string',
+                    description: 'Path to the charts JSONL file',
+                },
+                planPath: {
+                    type: 'string',
+                    description: 'Path to write the updated plan markdown',
+                },
+                dryRun: {
+                    type: 'boolean',
+                    description: 'If true, show proposed plan without writing',
+                },
+            },
+            required: ['chartsPath', 'planPath'],
+        },
+    },
+    {
+        name: 'create_plan_trace',
+        description: 'Generate Langfuse trace data for plan→STC transformation.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                planPath: {
+                    type: 'string',
+                    description: 'Path to the source plan',
+                },
+                chartsPath: {
+                    type: 'string',
+                    description: 'Path to generated charts',
+                },
+                sessionId: {
+                    type: 'string',
+                    description: 'Optional Langfuse session ID',
+                },
+                metadata: {
+                    type: 'object',
+                    description: 'Additional trace metadata',
+                },
+            },
+            required: ['planPath', 'chartsPath'],
+        },
+    },
+    {
+        name: 'pde_to_plan',
+        description: 'Convert a PDE DecompositionResult to a structural tension chart (JSONL). Takes pre-decomposed PDE output and produces coaia-narrative compatible entities and relations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pde_id: {
+                    type: 'string',
+                    description: 'ID of a stored PDE decomposition in .pde/ folder',
+                },
+                decomposition_result: {
+                    type: 'object',
+                    description: 'Alternative: provide DecompositionResult JSON directly',
+                },
+                original_prompt: {
+                    type: 'string',
+                    description: 'The original prompt (required if providing decomposition_result)',
+                },
+                outputPath: {
+                    type: 'string',
+                    description: 'Path to write the STC JSONL output',
+                },
+                workdir: {
+                    type: 'string',
+                    description: 'Working directory containing .pde/ folder (default: cwd)',
+                },
+            },
+        },
+    },
+];
+//# sourceMappingURL=mcp-tools.js.map

package/dist/src/planning/plan-parser.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Plan Parser — Transforms markdown plans into structural tension charts
+ * Ported from coaia-planning/src/plan-parser.ts
+ */
+import type { Entity, Relation, StructuralTensionPlan, DecompositionResult } from '../types.js';
+/**
+ * Parse a plan file as a structural tension chart
+ */
+export declare function parsePlan(planPath: string): Promise<StructuralTensionPlan>;
+/**
+ * Parse plan content directly
+ */
+export declare function parsePlanContent(content: string, filePath?: string, telescopeLevel?: number): StructuralTensionPlan;
+/**
+ * Convert structural tension plan to Entity[]/Relation[] (JSONL-compatible)
+ */
+export declare function planToSTC(plan: StructuralTensionPlan, chartIdPrefix?: string): {
+    entities: Entity[];
+    relations: Relation[];
+};
+/**
+ * Export Entity[]/Relation[] to JSONL format
+ */
+export declare function exportToJSONL(stc: {
+    entities: Entity[];
+    relations: Relation[];
+}): string;
+/**
+ * PDE bridge: Convert DecompositionResult into Entity[]/Relation[]
+ */
+export declare function decompositionResultToPlan(decomposition: DecompositionResult, originalPrompt?: string): {
+    entities: Entity[];
+    relations: Relation[];
+};
+//# sourceMappingURL=plan-parser.d.ts.map