monomind 2.7.3 → 2.7.5

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/causal-infer.js

@@ -1,333 +0,0 @@
-/**
- * Causal Graph Analysis Tool - pr_causal_infer
- *
- * Analyzes causal graph structure to assess identifiability.
- * Identifies confounders, finds backdoor paths, and determines
- * whether a causal effect can be identified from the graph.
- * Does NOT estimate causal effect magnitude (that requires data).
- */
-import { CausalInputSchema, successResult, errorResult, } from './types.js';
-// Default logger
-const defaultLogger = {
-    debug: (msg, meta) => console.debug(`[pr_causal_infer] ${msg}`, meta),
-    info: (msg, meta) => console.info(`[pr_causal_infer] ${msg}`, meta),
-    warn: (msg, meta) => console.warn(`[pr_causal_infer] ${msg}`, meta),
-    error: (msg, meta) => console.error(`[pr_causal_infer] ${msg}`, meta),
-};
-function buildGraphStructure(graph) {
-    const nodes = new Map();
-    // Initialize nodes
-    for (const nodeId of graph.nodes) {
-        nodes.set(nodeId, {
-            id: nodeId,
-            parents: new Set(),
-            children: new Set(),
-        });
-    }
-    // Add edges
-    for (const [from, to] of graph.edges) {
-        const fromNode = nodes.get(from);
-        const toNode = nodes.get(to);
-        if (fromNode && toNode) {
-            fromNode.children.add(to);
-            toNode.parents.add(from);
-        }
-    }
-    return nodes;
-}
-/**
- * Find all ancestors of a node (including the node itself)
- */
-function findAncestors(nodeId, graph) {
-    const ancestors = new Set();
-    const queue = [nodeId];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (ancestors.has(current))
-            continue;
-        ancestors.add(current);
-        const node = graph.get(current);
-        if (node) {
-            for (const parent of node.parents) {
-                queue.push(parent);
-            }
-        }
-    }
-    return ancestors;
-}
-/**
- * Find all descendants of a node (including the node itself)
- */
-function findDescendants(nodeId, graph) {
-    const descendants = new Set();
-    const queue = [nodeId];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (descendants.has(current))
-            continue;
-        descendants.add(current);
-        const node = graph.get(current);
-        if (node) {
-            for (const child of node.children) {
-                queue.push(child);
-            }
-        }
-    }
-    return descendants;
-}
-/**
- * Identify confounders (common causes of treatment and outcome)
- */
-function identifyConfounders(treatment, outcome, graph) {
-    const treatmentAncestors = findAncestors(treatment, graph);
-    const outcomeAncestors = findAncestors(outcome, graph);
-    // Confounders are ancestors of both treatment and outcome
-    // that are not the treatment itself
-    const confounders = [];
-    for (const ancestor of treatmentAncestors) {
-        if (ancestor !== treatment && ancestor !== outcome && outcomeAncestors.has(ancestor)) {
-            confounders.push(ancestor);
-        }
-    }
-    return confounders;
-}
-/**
- * Find backdoor paths from treatment to outcome
- * A backdoor path is a path that goes into the treatment node
- */
-function findBackdoorPaths(treatment, outcome, graph, maxPaths = 10) {
-    const backdoorPaths = [];
-    const treatmentNode = graph.get(treatment);
-    if (!treatmentNode)
-        return [];
-    // Start from each parent of treatment (backdoor)
-    for (const parent of treatmentNode.parents) {
-        const paths = findAllPaths(parent, outcome, graph, new Set([treatment]), maxPaths - backdoorPaths.length);
-        for (const path of paths) {
-            backdoorPaths.push([treatment, ...path]);
-            if (backdoorPaths.length >= maxPaths)
-                break;
-        }
-        if (backdoorPaths.length >= maxPaths)
-            break;
-    }
-    return backdoorPaths;
-}
-/**
- * Find all paths from source to target (BFS with path tracking)
- */
-function findAllPaths(source, target, graph, exclude, maxPaths) {
-    const paths = [];
-    const queue = [{ node: source, path: [source] }];
-    while (queue.length > 0 && paths.length < maxPaths) {
-        const { node, path } = queue.shift();
-        if (node === target) {
-            paths.push(path);
-            continue;
-        }
-        const currentNode = graph.get(node);
-        if (!currentNode)
-            continue;
-        // Consider both parents and children for undirected path finding
-        const neighbors = new Set([...currentNode.parents, ...currentNode.children]);
-        for (const neighbor of neighbors) {
-            if (!path.includes(neighbor) && !exclude.has(neighbor)) {
-                queue.push({
-                    node: neighbor,
-                    path: [...path, neighbor],
-                });
-            }
-        }
-    }
-    return paths;
-}
-/**
- * Check if intervention is valid (treatment must exist and have outgoing edges)
- */
-function validateIntervention(treatment, outcome, graph) {
-    const treatmentNode = graph.get(treatment);
-    const outcomeNode = graph.get(outcome);
-    if (!treatmentNode || !outcomeNode) {
-        return false;
-    }
-    // Check if there's any path from treatment to outcome
-    const descendants = findDescendants(treatment, graph);
-    return descendants.has(outcome);
-}
-/**
- * Assess identifiability of the causal effect based on graph structure.
- * Does NOT estimate the causal effect magnitude -- that requires
- * observational or experimental data which this tool does not have.
- * Returns an identifiability score reflecting how cleanly the effect
- * can be estimated if data were available (fewer confounders and
- * unblocked backdoor paths = higher identifiability).
- */
-function assessIdentifiability(confounders, backdoorPaths) {
-    // Identifiability decreases with confounders and unblocked backdoor paths
-    const confounderPenalty = Math.min(confounders.length * 0.1, 0.3);
-    const pathPenalty = Math.min(backdoorPaths.length * 0.05, 0.2);
-    const identifiability = Math.max(0.1, 1 - confounderPenalty - pathPenalty);
-    return { identifiability };
-}
-/**
- * Get interpretation of causal graph analysis results
- */
-function getInterpretation(interventionValid, confounders, backdoorPaths, identifiability) {
-    if (!interventionValid) {
-        return 'Intervention is not valid - no causal path exists from treatment to outcome';
-    }
-    if (confounders.length === 0 && backdoorPaths.length === 0) {
-        return 'Clean causal identification - no confounding detected. Effect is identifiable with data.';
-    }
-    if (identifiability > 0.8) {
-        return 'Strong identifiability - confounders can be adjusted for with observational data';
-    }
-    if (identifiability > 0.5) {
-        return `Moderate identifiability - ${confounders.length} confounder(s) require adjustment`;
-    }
-    return `Weak identifiability - multiple confounders (${confounders.length}) and backdoor paths (${backdoorPaths.length}) detected`;
-}
-/**
- * Handler for pr_causal_infer tool
- */
-async function handler(input, context) {
-    const logger = context?.logger ?? defaultLogger;
-    const startTime = performance.now();
-    try {
-        // Validate input
-        const validationResult = CausalInputSchema.safeParse(input);
-        if (!validationResult.success) {
-            logger.error('Input validation failed', { error: validationResult.error.message });
-            return errorResult(`Invalid input: ${validationResult.error.message}`);
-        }
-        const { graph, intervention, outcome } = validationResult.data;
-        logger.debug('Processing causal inference', {
-            nodes: graph.nodes.length,
-            edges: graph.edges.length,
-            intervention,
-            outcome,
-        });
-        // Validate nodes exist
-        if (!graph.nodes.includes(intervention)) {
-            return errorResult(`Intervention variable "${intervention}" not found in graph nodes`);
-        }
-        if (!graph.nodes.includes(outcome)) {
-            return errorResult(`Outcome variable "${outcome}" not found in graph nodes`);
-        }
-        const maxBackdoorPaths = context?.config?.causal?.maxBackdoorPaths ?? 10;
-        let identifiability;
-        let confounders;
-        let backdoorPaths;
-        let interventionValid;
-        // Try to use WASM bridge if available
-        if (context?.bridge?.initialized) {
-            try {
-                logger.debug('Using WASM bridge for causal inference');
-                const result = await context.bridge.inferCausal(graph, intervention, outcome);
-                confounders = result.confounders;
-                backdoorPaths = result.backdoorPaths;
-                interventionValid = result.interventionValid;
-                identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
-            }
-            catch (wasmError) {
-                logger.warn('WASM bridge failed, falling back to JS implementation', {
-                    error: wasmError instanceof Error ? wasmError.message : String(wasmError),
-                });
-                // Use JavaScript implementation
-                const graphStructure = buildGraphStructure(graph);
-                interventionValid = validateIntervention(intervention, outcome, graphStructure);
-                confounders = identifyConfounders(intervention, outcome, graphStructure);
-                backdoorPaths = findBackdoorPaths(intervention, outcome, graphStructure, maxBackdoorPaths);
-                identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
-            }
-        }
-        else {
-            // Pure JavaScript fallback
-            logger.debug('Using JavaScript fallback for causal inference');
-            const graphStructure = buildGraphStructure(graph);
-            interventionValid = validateIntervention(intervention, outcome, graphStructure);
-            confounders = identifyConfounders(intervention, outcome, graphStructure);
-            backdoorPaths = findBackdoorPaths(intervention, outcome, graphStructure, maxBackdoorPaths);
-            identifiability = assessIdentifiability(confounders, backdoorPaths).identifiability;
-        }
-        const output = {
-            identifiability,
-            backdoorPaths: backdoorPaths.map(p => p.join(' -> ')),
-            details: {
-                confounders,
-                interventionValid,
-                interpretation: getInterpretation(interventionValid, confounders, backdoorPaths, identifiability),
-                nodeCount: graph.nodes.length,
-                edgeCount: graph.edges.length,
-            },
-        };
-        const duration = performance.now() - startTime;
-        logger.info('Causal graph analysis completed', {
-            identifiability: identifiability.toFixed(4),
-            confounders: confounders.length,
-            backdoorPaths: backdoorPaths.length,
-            interventionValid,
-            durationMs: duration.toFixed(2),
-        });
-        return successResult(output);
-    }
-    catch (error) {
-        const duration = performance.now() - startTime;
-        logger.error('Causal inference failed', {
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: duration.toFixed(2),
-        });
-        return errorResult(error instanceof Error ? error : new Error(String(error)));
-    }
-}
-/**
- * pr_causal_infer MCP Tool Definition
- */
-export const causalInferTool = {
-    name: 'pr_causal_infer',
-    description: 'Analyze causal graph structure for identifiability. Identifies confounders, finds backdoor paths, and assesses whether a causal effect can be identified. Does not estimate effect magnitude (requires observational data).',
-    category: 'causal',
-    version: '0.1.3',
-    tags: ['causal', 'do-calculus', 'confounders', 'backdoor-paths', 'ai-interpretability'],
-    cacheable: true,
-    cacheTTL: 60000,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            graph: {
-                type: 'object',
-                properties: {
-                    nodes: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'List of variable names',
-                    },
-                    edges: {
-                        type: 'array',
-                        items: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            minItems: 2,
-                            maxItems: 2,
-                        },
-                        description: 'Directed edges as [from, to] pairs',
-                    },
-                },
-                required: ['nodes', 'edges'],
-                description: 'Causal graph with nodes and directed edges',
-            },
-            intervention: {
-                type: 'string',
-                description: 'Treatment/intervention variable',
-            },
-            outcome: {
-                type: 'string',
-                description: 'Outcome variable to measure effect on',
-            },
-        },
-        required: ['graph', 'intervention', 'outcome'],
-    },
-    handler,
-};
-export default causalInferTool;
-//# sourceMappingURL=causal-infer.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/coherence-check.d.ts

@@ -1,15 +0,0 @@
-/**
- * Coherence Check Tool - pr_coherence_check
- *
- * Checks coherence of vectors using Sheaf Laplacian energy.
- * Energy 0 = fully coherent, Energy 1 = contradictory
- *
- * Uses CohomologyEngine from prime-radiant-advanced-wasm
- */
-import type { MCPTool } from './types.js';
-/**
- * pr_coherence_check MCP Tool Definition
- */
-export declare const coherenceCheckTool: MCPTool;
-export default coherenceCheckTool;
-//# sourceMappingURL=coherence-check.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/coherence-check.js

@@ -1,188 +0,0 @@
-/**
- * Coherence Check Tool - pr_coherence_check
- *
- * Checks coherence of vectors using Sheaf Laplacian energy.
- * Energy 0 = fully coherent, Energy 1 = contradictory
- *
- * Uses CohomologyEngine from prime-radiant-advanced-wasm
- */
-import { cosineSimilarity } from '../../utils/cosine-similarity.js';
-import { CoherenceInputSchema, successResult, errorResult, } from './types.js';
-// Default logger for when context doesn't provide one
-const defaultLogger = {
-    debug: (msg, meta) => console.debug(`[pr_coherence_check] ${msg}`, meta),
-    info: (msg, meta) => console.info(`[pr_coherence_check] ${msg}`, meta),
-    warn: (msg, meta) => console.warn(`[pr_coherence_check] ${msg}`, meta),
-    error: (msg, meta) => console.error(`[pr_coherence_check] ${msg}`, meta),
-};
-/**
- * Compute Sheaf Laplacian energy for coherence detection
- *
- * The Sheaf Laplacian measures how well local data sections can be
- * glued together into a global section. High energy indicates contradictions.
- *
- * For vectors v1, v2, ..., vn:
- * 1. Construct a sheaf over the complete graph
- * 2. Compute the Laplacian matrix L = D - A (where A captures similarities)
- * 3. Energy = sum of disagreements across edges
- */
-function computeSheafLaplacianEnergy(vectors) {
-    if (vectors.length < 2)
-        return 0;
-    const n = vectors.length;
-    let totalEnergy = 0;
-    let edgeCount = 0;
-    // Compute pairwise disagreement (1 - cosine_similarity)
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            const vi = vectors[i];
-            const vj = vectors[j];
-            const similarity = cosineSimilarity(vi, vj);
-            const disagreement = 1 - Math.max(0, similarity); // Clamp negative similarities
-            totalEnergy += disagreement;
-            edgeCount++;
-        }
-    }
-    // Normalize by number of edges
-    return edgeCount > 0 ? totalEnergy / edgeCount : 0;
-}
-/**
- * Detect contradictions in the vector set
- */
-function detectContradictions(vectors, threshold) {
-    const violations = [];
-    const n = vectors.length;
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            const vi = vectors[i];
-            const vj = vectors[j];
-            const similarity = cosineSimilarity(vi, vj);
-            // Negative similarity indicates potential contradiction
-            if (similarity < -0.3) {
-                violations.push(`Contradiction between vectors ${i} and ${j} (similarity: ${similarity.toFixed(3)})`);
-            }
-            // Low similarity with high threshold indicates inconsistency
-            else if (similarity < threshold && similarity > 0) {
-                violations.push(`Weak coherence between vectors ${i} and ${j} (similarity: ${similarity.toFixed(3)})`);
-            }
-        }
-    }
-    return violations;
-}
-/**
- * Get interpretation of energy level
- */
-function getInterpretation(energy) {
-    if (energy < 0.1)
-        return 'Fully coherent - vectors are highly consistent';
-    if (energy < 0.3)
-        return 'Minor inconsistencies - generally coherent with small variations';
-    if (energy < 0.5)
-        return 'Moderate inconsistencies - some conflicting information detected';
-    if (energy < 0.7)
-        return 'Significant contradictions - vectors contain conflicting content';
-    return 'Major contradictions detected - high disagreement between vectors';
-}
-/**
- * Handler for pr_coherence_check tool
- */
-async function handler(input, context) {
-    const logger = context?.logger ?? defaultLogger;
-    const startTime = performance.now();
-    try {
-        // Validate input
-        const validationResult = CoherenceInputSchema.safeParse(input);
-        if (!validationResult.success) {
-            logger.error('Input validation failed', { error: validationResult.error.message });
-            return errorResult(`Invalid input: ${validationResult.error.message}`);
-        }
-        const { vectors, threshold } = validationResult.data;
-        logger.debug('Processing coherence check', { vectorCount: vectors.length, threshold });
-        // Convert to Float32Arrays
-        const float32Vectors = vectors.map(v => new Float32Array(v));
-        let energy;
-        let violations;
-        // Try to use WASM bridge if available
-        if (context?.bridge?.initialized) {
-            try {
-                logger.debug('Using WASM bridge for coherence check');
-                const result = await context.bridge.checkCoherence(float32Vectors);
-                energy = result.energy;
-                violations = result.violations;
-            }
-            catch (wasmError) {
-                logger.warn('WASM bridge failed, falling back to JS implementation', {
-                    error: wasmError instanceof Error ? wasmError.message : String(wasmError),
-                });
-                energy = computeSheafLaplacianEnergy(float32Vectors);
-                violations = detectContradictions(float32Vectors, threshold);
-            }
-        }
-        else {
-            // Pure JavaScript fallback implementation
-            logger.debug('Using JavaScript fallback for coherence check');
-            energy = computeSheafLaplacianEnergy(float32Vectors);
-            violations = detectContradictions(float32Vectors, threshold);
-        }
-        const isCoherent = energy < threshold;
-        const confidence = 1 - energy;
-        const output = {
-            energy,
-            isCoherent,
-            details: {
-                violations,
-                confidence,
-                interpretation: getInterpretation(energy),
-                vectorCount: vectors.length,
-                threshold,
-            },
-        };
-        const duration = performance.now() - startTime;
-        logger.info('Coherence check completed', {
-            energy: energy.toFixed(4),
-            isCoherent,
-            violations: violations.length,
-            durationMs: duration.toFixed(2),
-        });
-        return successResult(output);
-    }
-    catch (error) {
-        const duration = performance.now() - startTime;
-        logger.error('Coherence check failed', {
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: duration.toFixed(2),
-        });
-        return errorResult(error instanceof Error ? error : new Error(String(error)));
-    }
-}
-/**
- * pr_coherence_check MCP Tool Definition
- */
-export const coherenceCheckTool = {
-    name: 'pr_coherence_check',
-    description: 'Check coherence of vectors using Sheaf Laplacian energy. Energy 0 = fully coherent, 1 = contradictory. Uses CohomologyEngine for mathematical validation of vector consistency.',
-    category: 'coherence',
-    version: '0.1.3',
-    tags: ['coherence', 'sheaf-laplacian', 'contradiction-detection', 'ai-interpretability'],
-    cacheable: true,
-    cacheTTL: 60000, // 1 minute cache
-    inputSchema: {
-        type: 'object',
-        properties: {
-            vectors: {
-                type: 'array',
-                items: { type: 'array', items: { type: 'number' } },
-                description: 'Array of embedding vectors to check for coherence',
-            },
-            threshold: {
-                type: 'number',
-                default: 0.3,
-                description: 'Energy threshold for coherence (0-1). Lower = stricter coherence requirement.',
-            },
-        },
-        required: ['vectors'],
-    },
-    handler,
-};
-export default coherenceCheckTool;
-//# sourceMappingURL=coherence-check.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/consensus-verify.d.ts

@@ -1,14 +0,0 @@
-/**
- * Consensus Verification Tool - pr_consensus_verify
- *
- * Verifies multi-agent consensus using cosine-similarity coherence analysis.
- * Identifies divergent agents and measures agreement ratios.
- * Connectivity stability uses a degree-ratio heuristic (not spectral decomposition).
- */
-import type { MCPTool } from './types.js';
-/**
- * pr_consensus_verify MCP Tool Definition
- */
-export declare const consensusVerifyTool: MCPTool;
-export default consensusVerifyTool;
-//# sourceMappingURL=consensus-verify.d.ts.map