coaiajs 0.1.0

package/dist/mcp/config.d.ts

@@ -0,0 +1,14 @@
+export type FeatureLevel = 'MINIMAL' | 'STANDARD' | 'OBSERVABILITY' | 'FULL';
+export declare class FeatureConfig {
+    private level;
+    private enabledTools;
+    constructor(level?: FeatureLevel);
+    isToolEnabled(toolName: string): boolean;
+    getEnabledTools(): Set<string>;
+    getFeatureLevel(): FeatureLevel;
+    getStats(): {
+        tools: number;
+        level: FeatureLevel;
+    };
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/mcp/config.js

@@ -0,0 +1,185 @@
+// coaiajs/mcp/config.ts — Feature gating
+// Port of coaiapy-mcp/config.py
+// All available tool names across all modules
+const ALL_TOOLS = new Set([
+    // Redis (coaiapy-mcp)
+    'coaia_tash',
+    'coaia_fetch',
+    // Langfuse traces (coaiapy-mcp)
+    'coaia_fuse_trace_create',
+    'coaia_fuse_add_observation',
+    'coaia_fuse_trace_patch_output',
+    'coaia_fuse_trace_get',
+    'coaia_fuse_trace_view',
+    'coaia_fuse_observation_get',
+    'coaia_fuse_traces_list',
+    'coaia_fuse_traces_session_view',
+    // Langfuse comments (coaiapy-mcp)
+    'coaia_fuse_comments_list',
+    'coaia_fuse_comments_get',
+    'coaia_fuse_comments_create',
+    // Langfuse prompts (coaiapy-mcp)
+    'coaia_fuse_prompts_list',
+    'coaia_fuse_prompts_get',
+    // Langfuse datasets (coaiapy-mcp)
+    'coaia_fuse_datasets_list',
+    'coaia_fuse_datasets_get',
+    // Score configs (coaiapy-mcp)
+    'coaia_fuse_score_configs_list',
+    'coaia_fuse_score_configs_get',
+    'coaia_fuse_score_apply',
+    // Media (coaiapy-mcp, FULL only)
+    'coaia_fuse_media_upload',
+    'coaia_fuse_media_get',
+    // Narrative (coaia-narrative, 28 tools)
+    'create_structural_tension_chart',
+    'telescope_action_step',
+    'mark_action_complete',
+    'get_chart_progress',
+    'list_active_charts',
+    'get_chart',
+    'get_action_step',
+    'update_action_progress',
+    'update_current_reality',
+    'manage_action_step',
+    'add_action_step',
+    'remove_action_step',
+    'update_desired_outcome',
+    'perform_mmot_evaluation',
+    'init_llm_guidance',
+    'create_narrative_beat',
+    'telescope_narrative_beat',
+    'list_narrative_beats',
+    'add_observations',
+    'create_entities',
+    'create_relations',
+    'search_nodes',
+    'open_nodes',
+    'read_graph',
+    'delete_entities',
+    'delete_relations',
+    'delete_observations',
+    'merge_entities',
+    // PDE (coaia-pde, 10 tools)
+    'pde_decompose',
+    'pde_parse_response',
+    'pde_get',
+    'pde_list',
+    'pde_export_markdown',
+    'import_pde',
+    'create_stc_from_pde',
+    'pde_sessions_list',
+    'pde_sessions_create',
+    'pde_sessions_update',
+    // Planning (coaia-planning, 6 tools)
+    'parse_plan',
+    'plan_to_stc',
+    'sync_plans',
+    'trace_plan',
+    'pde_to_plan',
+    'list_plans',
+]);
+const MINIMAL_TOOLS = new Set([
+    'coaia_tash',
+    'coaia_fetch',
+    'coaia_fuse_trace_create',
+    'coaia_fuse_add_observation',
+    'coaia_fuse_trace_patch_output',
+    'coaia_fuse_trace_get',
+    'coaia_fuse_trace_view',
+    'coaia_fuse_observation_get',
+    'coaia_fuse_traces_list',
+    'coaia_fuse_traces_session_view',
+    'coaia_fuse_comments_list',
+    'coaia_fuse_comments_get',
+    'coaia_fuse_comments_create',
+    'coaia_fuse_prompts_list',
+    'coaia_fuse_prompts_get',
+    'coaia_fuse_datasets_list',
+    'coaia_fuse_datasets_get',
+    'coaia_fuse_score_configs_list',
+    'coaia_fuse_score_configs_get',
+    'coaia_fuse_score_apply',
+]);
+const STANDARD_TOOLS = new Set([
+    ...MINIMAL_TOOLS,
+    // Narrative STC tools
+    'create_structural_tension_chart',
+    'telescope_action_step',
+    'mark_action_complete',
+    'get_chart_progress',
+    'list_active_charts',
+    'get_chart',
+    'get_action_step',
+    'update_action_progress',
+    'update_current_reality',
+    'manage_action_step',
+    'add_action_step',
+    'remove_action_step',
+    'update_desired_outcome',
+    'perform_mmot_evaluation',
+    'init_llm_guidance',
+    'create_narrative_beat',
+    'telescope_narrative_beat',
+    'list_narrative_beats',
+    // KG tools
+    'add_observations',
+    'create_entities',
+    'create_relations',
+    'search_nodes',
+    'open_nodes',
+    'read_graph',
+    'delete_entities',
+    'delete_relations',
+    'delete_observations',
+    'merge_entities',
+    // PDE tools
+    'pde_decompose',
+    'pde_parse_response',
+    'pde_get',
+    'pde_list',
+    'pde_export_markdown',
+    'import_pde',
+    'create_stc_from_pde',
+    'pde_sessions_list',
+    'pde_sessions_create',
+    'pde_sessions_update',
+    // Planning tools
+    'parse_plan',
+    'plan_to_stc',
+    'sync_plans',
+    'trace_plan',
+    'pde_to_plan',
+    'list_plans',
+]);
+const FEATURE_SETS = {
+    MINIMAL: MINIMAL_TOOLS,
+    STANDARD: STANDARD_TOOLS,
+    OBSERVABILITY: STANDARD_TOOLS,
+    FULL: ALL_TOOLS,
+};
+export class FeatureConfig {
+    level;
+    enabledTools;
+    constructor(level) {
+        const envLevel = (level ?? process.env['COAIAJS_FEATURES'] ?? 'STANDARD').toUpperCase();
+        this.level = envLevel in FEATURE_SETS ? envLevel : 'STANDARD';
+        this.enabledTools = FEATURE_SETS[this.level];
+    }
+    isToolEnabled(toolName) {
+        return this.enabledTools.has(toolName);
+    }
+    getEnabledTools() {
+        return new Set(this.enabledTools);
+    }
+    getFeatureLevel() {
+        return this.level;
+    }
+    getStats() {
+        return {
+            tools: this.enabledTools.size,
+            level: this.level,
+        };
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+// coaiajs/mcp/server.ts — Unified MCP server
+// Consolidates all tools: coaiapy-mcp (20) + narrative (28) + PDE (10) + planning (6) = 64+ tools
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { FeatureConfig } from './config.js';
+import { getCoaiapyToolDefinitions } from './tools/index.js';
+// Langfuse imports
+import { addTrace, patchTraceOutput, listTraces, getTrace, formatTracesTable, formatTraceTree, } from '../src/langfuse/traces.js';
+import { addObservation, getObservation, formatObservationDisplay } from '../src/langfuse/observations.js';
+import { listPrompts, getPrompt, formatPromptsTable, formatPromptDisplay } from '../src/langfuse/prompts.js';
+import { listDatasets, getDataset, formatDatasetsTable } from '../src/langfuse/datasets.js';
+import { listScoreConfigs, getScoreConfig, applyScoreConfig, formatScoreConfigsTable, } from '../src/langfuse/scores.js';
+import { listComments, getComment, createComment } from '../src/langfuse/comments.js';
+import { uploadAndAttachMedia, getMedia, formatMediaDisplay } from '../src/langfuse/media.js';
+// ─── Server Info ────────────────────────────────────────────────────
+const SERVER_NAME = 'coaiajs-mcp';
+const SERVER_VERSION = '0.1.0';
+// ─── Parse CLI args ─────────────────────────────────────────────────
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--memory-path' && args[i + 1]) {
+            result.memoryPath = args[++i];
+        }
+        else if (args[i] === '--plans-dir' && args[i + 1]) {
+            result.plansDir = args[++i];
+        }
+        else if (args[i] === '--features' && args[i + 1]) {
+            result.featureLevel = args[++i];
+        }
+    }
+    return result;
+}
+function textResult(text, isError = false) {
+    return { content: [{ type: 'text', text }], isError };
+}
+async function handleCoaiapyTool(name, args) {
+    try {
+        switch (name) {
+            // ── Redis ──
+            case 'coaia_tash': {
+                // Redis stash — defer to redis module if available, placeholder for now
+                return textResult(JSON.stringify({
+                    success: false,
+                    error: 'Redis module not yet wired. Use coaiapy-mcp for Redis operations.',
+                }));
+            }
+            case 'coaia_fetch': {
+                return textResult(JSON.stringify({
+                    success: false,
+                    error: 'Redis module not yet wired. Use coaiapy-mcp for Redis operations.',
+                }));
+            }
+            // ── Traces ──
+            case 'coaia_fuse_trace_create': {
+                const result = await addTrace({
+                    traceId: args.trace_id,
+                    userId: args.user_id,
+                    sessionId: args.session_id,
+                    name: args.name,
+                    metadata: args.metadata,
+                    inputData: args.input_data,
+                    outputData: args.output_data,
+                });
+                return textResult(result);
+            }
+            case 'coaia_fuse_add_observation': {
+                const result = await addObservation({
+                    observationId: args.observation_id,
+                    traceId: args.trace_id,
+                    name: args.name,
+                    type: args.observation_type,
+                    parentId: args.parent_id,
+                    metadata: args.metadata,
+                    inputData: args.input_data,
+                    outputData: args.output_data,
+                    startTime: args.start_time,
+                    endTime: args.end_time,
+                });
+                return textResult(result);
+            }
+            case 'coaia_fuse_trace_patch_output': {
+                const result = await patchTraceOutput(args.trace_id, args.output_data);
+                return textResult(result);
+            }
+            case 'coaia_fuse_trace_get':
+            case 'coaia_fuse_trace_view': {
+                const traceJson = await getTrace(args.trace_id);
+                if (args.json_output) {
+                    return textResult(traceJson);
+                }
+                const formatted = formatTraceTree(traceJson);
+                return textResult(formatted);
+            }
+            case 'coaia_fuse_observation_get': {
+                const obsJson = await getObservation(args.observation_id);
+                if (args.json_output) {
+                    return textResult(obsJson);
+                }
+                return textResult(formatObservationDisplay(obsJson));
+            }
+            case 'coaia_fuse_traces_list': {
+                const result = await listTraces({
+                    sessionId: args.session_id,
+                    userId: args.user_id,
+                    name: args.name,
+                    tags: args.tags,
+                    fromTimestamp: args.from_timestamp,
+                    toTimestamp: args.to_timestamp,
+                    orderBy: args.order_by,
+                    page: args.page,
+                    limit: args.limit,
+                });
+                return textResult(formatTracesTable(result));
+            }
+            case 'coaia_fuse_traces_session_view': {
+                const result = await listTraces({
+                    sessionId: args.session_id,
+                });
+                if (args.json_output)
+                    return textResult(result);
+                return textResult(formatTracesTable(result));
+            }
+            // ── Prompts ──
+            case 'coaia_fuse_prompts_list': {
+                const result = await listPrompts();
+                return textResult(formatPromptsTable(result));
+            }
+            case 'coaia_fuse_prompts_get': {
+                const result = await getPrompt(args.name, args.label);
+                return textResult(formatPromptDisplay(result));
+            }
+            // ── Datasets ──
+            case 'coaia_fuse_datasets_list': {
+                const result = await listDatasets();
+                return textResult(formatDatasetsTable(result));
+            }
+            case 'coaia_fuse_datasets_get': {
+                const result = await getDataset(args.name);
+                return textResult(result);
+            }
+            // ── Score Configs ──
+            case 'coaia_fuse_score_configs_list': {
+                const result = await listScoreConfigs();
+                return textResult(formatScoreConfigsTable(result));
+            }
+            case 'coaia_fuse_score_configs_get': {
+                const result = await getScoreConfig(args.name_or_id);
+                return textResult(result);
+            }
+            case 'coaia_fuse_score_apply': {
+                const result = await applyScoreConfig(args.config_name_or_id, args.target_type, args.target_id, args.value, args.observation_id, args.comment);
+                return textResult(result);
+            }
+            // ── Comments ──
+            case 'coaia_fuse_comments_list': {
+                const result = await listComments({
+                    objectType: args.object_type,
+                    objectId: args.object_id,
+                    authorUserId: args.author_user_id,
+                    page: args.page,
+                    limit: args.limit,
+                });
+                return textResult(result);
+            }
+            case 'coaia_fuse_comments_get': {
+                const result = await getComment(args.comment_id);
+                return textResult(result);
+            }
+            case 'coaia_fuse_comments_create': {
+                const result = await createComment({
+                    text: args.text,
+                    objectType: args.object_type,
+                    objectId: args.object_id,
+                    authorUserId: args.author_user_id,
+                });
+                return textResult(result);
+            }
+            // ── Media ──
+            case 'coaia_fuse_media_upload': {
+                const result = await uploadAndAttachMedia({
+                    filePath: args.file_path,
+                    traceId: args.trace_id,
+                    field: args.field,
+                    observationId: args.observation_id,
+                    contentType: args.content_type,
+                });
+                return textResult(result);
+            }
+            case 'coaia_fuse_media_get': {
+                const result = await getMedia(args.media_id);
+                return textResult(formatMediaDisplay(result));
+            }
+            default:
+                return textResult(`Unknown tool: ${name}`, true);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return textResult(JSON.stringify({ error: msg }), true);
+    }
+}
+// ─── Narrative/PDE/Planning tool stubs ──────────────────────────────
+// These modules will be wired by other direction agents (SOUTH/EAST/WEST).
+// For now we register placeholder definitions so the server schema is complete.
+function getNarrativeToolDefinitions(featureConfig) {
+    const narrativeToolNames = [
+        'create_structural_tension_chart', 'telescope_action_step', 'mark_action_complete',
+        'get_chart_progress', 'list_active_charts', 'get_chart', 'get_action_step',
+        'update_action_progress', 'update_current_reality', 'manage_action_step',
+        'add_action_step', 'remove_action_step', 'update_desired_outcome',
+        'perform_mmot_evaluation', 'init_llm_guidance',
+        'create_narrative_beat', 'telescope_narrative_beat', 'list_narrative_beats',
+        'add_observations', 'create_entities', 'create_relations', 'search_nodes',
+        'open_nodes', 'read_graph', 'delete_entities', 'delete_relations',
+        'delete_observations', 'merge_entities',
+    ];
+    return narrativeToolNames
+        .filter((name) => featureConfig.isToolEnabled(name))
+        .map((name) => ({
+        name,
+        description: `[Narrative] ${name.replace(/_/g, ' ')} — pending wiring from narrative module`,
+        inputSchema: { type: 'object', properties: {} },
+    }));
+}
+function getPdeToolDefinitions(featureConfig) {
+    const pdeToolNames = [
+        'pde_decompose', 'pde_parse_response', 'pde_get', 'pde_list',
+        'pde_export_markdown', 'import_pde', 'create_stc_from_pde',
+        'pde_sessions_list', 'pde_sessions_create', 'pde_sessions_update',
+    ];
+    return pdeToolNames
+        .filter((name) => featureConfig.isToolEnabled(name))
+        .map((name) => ({
+        name,
+        description: `[PDE] ${name.replace(/_/g, ' ')} — pending wiring from PDE module`,
+        inputSchema: { type: 'object', properties: {} },
+    }));
+}
+function getPlanningToolDefinitions(featureConfig) {
+    const planToolNames = [
+        'parse_plan', 'plan_to_stc', 'sync_plans', 'trace_plan', 'pde_to_plan', 'list_plans',
+    ];
+    return planToolNames
+        .filter((name) => featureConfig.isToolEnabled(name))
+        .map((name) => ({
+        name,
+        description: `[Planning] ${name.replace(/_/g, ' ')} — pending wiring from planning module`,
+        inputSchema: { type: 'object', properties: {} },
+    }));
+}
+// ─── Server Creation ────────────────────────────────────────────────
+function createServer() {
+    const cliArgs = parseArgs();
+    const featureConfig = new FeatureConfig(cliArgs.featureLevel);
+    const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
+    // Collect all tool definitions
+    const allToolDefs = [
+        ...getCoaiapyToolDefinitions(featureConfig),
+        ...getNarrativeToolDefinitions(featureConfig),
+        ...getPdeToolDefinitions(featureConfig),
+        ...getPlanningToolDefinitions(featureConfig),
+    ];
+    // ── list_tools handler ──
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: allToolDefs.map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            })),
+        };
+    });
+    // ── call_tool handler ──
+    server.setRequestHandler(CallToolRequestSchema, async (request, _extra) => {
+        const { name, arguments: args } = request.params;
+        const toolArgs = (args ?? {});
+        // Route to coaiapy handler if it's a coaia_* tool
+        if (name.startsWith('coaia_')) {
+            return handleCoaiapyTool(name, toolArgs);
+        }
+        // Route to narrative/PDE/planning stubs
+        const stubModules = ['create_structural_tension_chart', 'telescope_action_step',
+            'mark_action_complete', 'get_chart_progress', 'list_active_charts', 'get_chart',
+            'get_action_step', 'update_action_progress', 'update_current_reality',
+            'manage_action_step', 'add_action_step', 'remove_action_step',
+            'update_desired_outcome', 'perform_mmot_evaluation', 'init_llm_guidance',
+            'create_narrative_beat', 'telescope_narrative_beat', 'list_narrative_beats',
+            'add_observations', 'create_entities', 'create_relations', 'search_nodes',
+            'open_nodes', 'read_graph', 'delete_entities', 'delete_relations',
+            'delete_observations', 'merge_entities',
+            'pde_decompose', 'pde_parse_response', 'pde_get', 'pde_list',
+            'pde_export_markdown', 'import_pde', 'create_stc_from_pde',
+            'pde_sessions_list', 'pde_sessions_create', 'pde_sessions_update',
+            'parse_plan', 'plan_to_stc', 'sync_plans', 'trace_plan', 'pde_to_plan', 'list_plans',
+        ];
+        if (stubModules.includes(name)) {
+            return textResult(JSON.stringify({
+                status: 'pending',
+                message: `Tool '${name}' is registered but not yet wired. Module integration pending.`,
+                args: toolArgs,
+            }));
+        }
+        return textResult(`Unknown tool: ${name}`, true);
+    });
+    return server;
+}
+// ─── Main ───────────────────────────────────────────────────────────
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    const featureConfig = new FeatureConfig();
+    const stats = featureConfig.getStats();
+    console.error(`${SERVER_NAME} v${SERVER_VERSION} started (${stats.level}: ${stats.tools} tools)`);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=server.js.map

package/dist/mcp/tools/coaiapy-tools.d.ts

@@ -0,0 +1,8 @@
+import type { FeatureConfig } from '../config.js';
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export declare function getCoaiapyToolDefinitions(featureConfig: FeatureConfig): ToolDefinition[];
+//# sourceMappingURL=coaiapy-tools.d.ts.map