monomind 2.7.4 → 2.7.6

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

@@ -1,430 +0,0 @@
-/**
- * Prime Radiant MCP Tool Types
- *
- * Type definitions for Prime Radiant mathematical AI tools.
- */
-import { z } from 'zod';
-export interface MCPToolInputSchema {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-}
-export interface MCPToolResult {
-    content: Array<{
-        type: 'text' | 'image' | 'resource';
-        text?: string;
-        data?: string;
-        mimeType?: string;
-    }>;
-    isError?: boolean;
-}
-export interface MCPTool {
-    name: string;
-    description: string;
-    inputSchema: MCPToolInputSchema;
-    category?: string;
-    tags?: string[];
-    version?: string;
-    cacheable?: boolean;
-    cacheTTL?: number;
-    handler: (input: Record<string, unknown>, context?: ToolContext) => Promise<MCPToolResult>;
-}
-export interface ToolContext {
-    bridge?: PrimeRadiantBridge;
-    config?: PrimeRadiantConfig;
-    logger?: Logger;
-}
-export interface Logger {
-    debug(message: string, meta?: Record<string, unknown>): void;
-    info(message: string, meta?: Record<string, unknown>): void;
-    warn(message: string, meta?: Record<string, unknown>): void;
-    error(message: string, meta?: Record<string, unknown>): void;
-}
-export interface PrimeRadiantConfig {
-    coherence: {
-        warnThreshold: number;
-        rejectThreshold: number;
-        cacheEnabled: boolean;
-        cacheTTL: number;
-    };
-    spectral: {
-        stabilityThreshold: number;
-        maxMatrixSize: number;
-    };
-    causal: {
-        maxBackdoorPaths: number;
-        confidenceThreshold: number;
-    };
-}
-export interface PrimeRadiantBridge {
-    initialized: boolean;
-    initialize(): Promise<void>;
-    dispose(): Promise<void>;
-    checkCoherence(vectors: Float32Array[]): Promise<CoherenceResult>;
-    analyzeSpectral(adjacencyMatrix: Float32Array, size: number): Promise<SpectralResult>;
-    inferCausal(graph: CausalGraph, intervention: string, outcome: string): Promise<CausalResult>;
-    computeTopology(complex: SimplicialComplex): Promise<TopologyResult>;
-}
-export declare const CoherenceInputSchema: z.ZodObject<{
-    vectors: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
-    threshold: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    vectors: number[][];
-    threshold: number;
-}, {
-    vectors: number[][];
-    threshold?: number | undefined;
-}>;
-export type CoherenceInput = z.infer<typeof CoherenceInputSchema>;
-export interface CoherenceResult {
-    coherent: boolean;
-    energy: number;
-    violations: string[];
-    confidence: number;
-}
-export interface CoherenceOutput {
-    energy: number;
-    isCoherent: boolean;
-    details: {
-        violations: string[];
-        confidence: number;
-        interpretation: string;
-        vectorCount: number;
-        threshold: number;
-    };
-}
-export declare const SpectralInputSchema: z.ZodObject<{
-    matrix: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
-    analyzeType: z.ZodDefault<z.ZodEnum<["stability", "clustering", "connectivity"]>>;
-}, "strip", z.ZodTypeAny, {
-    matrix: number[][];
-    analyzeType: "clustering" | "connectivity" | "stability";
-}, {
-    matrix: number[][];
-    analyzeType?: "clustering" | "connectivity" | "stability" | undefined;
-}>;
-export type SpectralInput = z.infer<typeof SpectralInputSchema>;
-export interface SpectralResult {
-    stable: boolean;
-    eigenvalues: number[];
-    spectralGap: number;
-    stabilityIndex: number;
-}
-export interface SpectralOutput {
-    spectralGap: number;
-    eigenvalues: number[];
-    stable: boolean;
-    details: {
-        stabilityIndex: number;
-        interpretation: string;
-        matrixSize: number;
-        analyzeType: string;
-    };
-}
-export declare const CausalGraphSchema: z.ZodObject<{
-    nodes: z.ZodArray<z.ZodString, "many">;
-    edges: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>, "many">;
-}, "strip", z.ZodTypeAny, {
-    nodes: string[];
-    edges: [string, string][];
-}, {
-    nodes: string[];
-    edges: [string, string][];
-}>;
-export type CausalGraph = z.infer<typeof CausalGraphSchema>;
-export declare const CausalInputSchema: z.ZodObject<{
-    graph: z.ZodObject<{
-        nodes: z.ZodArray<z.ZodString, "many">;
-        edges: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        nodes: string[];
-        edges: [string, string][];
-    }, {
-        nodes: string[];
-        edges: [string, string][];
-    }>;
-    intervention: z.ZodString;
-    outcome: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    graph: {
-        nodes: string[];
-        edges: [string, string][];
-    };
-    intervention: string;
-    outcome: string;
-}, {
-    graph: {
-        nodes: string[];
-        edges: [string, string][];
-    };
-    intervention: string;
-    outcome: string;
-}>;
-export type CausalInput = z.infer<typeof CausalInputSchema>;
-export interface CausalResult {
-    confounders: string[];
-    interventionValid: boolean;
-    backdoorPaths: string[][];
-}
-export interface CausalOutput {
-    identifiability: number;
-    backdoorPaths: string[];
-    details: {
-        confounders: string[];
-        interventionValid: boolean;
-        interpretation: string;
-        nodeCount: number;
-        edgeCount: number;
-    };
-}
-export declare const AgentStateSchema: z.ZodObject<{
-    agentId: z.ZodString;
-    embedding: z.ZodArray<z.ZodNumber, "many">;
-    vote: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    agentId: string;
-    embedding: number[];
-    vote?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}, {
-    agentId: string;
-    embedding: number[];
-    vote?: string | undefined;
-    metadata?: Record<string, unknown> | undefined;
-}>;
-export type AgentState = z.infer<typeof AgentStateSchema>;
-export declare const ConsensusInputSchema: z.ZodObject<{
-    agentStates: z.ZodArray<z.ZodObject<{
-        agentId: z.ZodString;
-        embedding: z.ZodArray<z.ZodNumber, "many">;
-        vote: z.ZodOptional<z.ZodString>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, "strip", z.ZodTypeAny, {
-        agentId: string;
-        embedding: number[];
-        vote?: string | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }, {
-        agentId: string;
-        embedding: number[];
-        vote?: string | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }>, "many">;
-    threshold: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    agentStates: {
-        agentId: string;
-        embedding: number[];
-        vote?: string | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }[];
-    threshold: number;
-}, {
-    agentStates: {
-        agentId: string;
-        embedding: number[];
-        vote?: string | undefined;
-        metadata?: Record<string, unknown> | undefined;
-    }[];
-    threshold?: number | undefined;
-}>;
-export type ConsensusInput = z.infer<typeof ConsensusInputSchema>;
-export interface ConsensusOutput {
-    verified: boolean;
-    coherenceScore: number;
-    divergentAgents: string[];
-    details: {
-        agreementRatio: number;
-        coherenceEnergy: number;
-        connectivityStable: boolean;
-        degreeRatio: number;
-        interpretation: string;
-        agentCount: number;
-    };
-}
-export declare const SimplexSchema: z.ZodObject<{
-    vertices: z.ZodArray<z.ZodNumber, "many">;
-    dimension: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    vertices: number[];
-    dimension: number;
-}, {
-    vertices: number[];
-    dimension: number;
-}>;
-export type Simplex = z.infer<typeof SimplexSchema>;
-export declare const SimplicialComplexSchema: z.ZodObject<{
-    vertices: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
-    simplices: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        vertices: z.ZodArray<z.ZodNumber, "many">;
-        dimension: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        vertices: number[];
-        dimension: number;
-    }, {
-        vertices: number[];
-        dimension: number;
-    }>, "many">>;
-    maxDimension: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    vertices: number[][];
-    simplices?: {
-        vertices: number[];
-        dimension: number;
-    }[] | undefined;
-    maxDimension: number;
-}, {
-    vertices: number[][];
-    simplices?: {
-        vertices: number[];
-        dimension: number;
-    }[] | undefined;
-    maxDimension?: number | undefined;
-}>;
-export type SimplicialComplex = z.infer<typeof SimplicialComplexSchema>;
-export declare const TopologyInputSchema: z.ZodObject<{
-    complex: z.ZodObject<{
-        vertices: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
-        simplices: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            vertices: z.ZodArray<z.ZodNumber, "many">;
-            dimension: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            vertices: number[];
-            dimension: number;
-        }, {
-            vertices: number[];
-            dimension: number;
-        }>, "many">>;
-        maxDimension: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        vertices: number[][];
-        simplices?: {
-            vertices: number[];
-            dimension: number;
-        }[] | undefined;
-        maxDimension: number;
-    }, {
-        vertices: number[][];
-        simplices?: {
-            vertices: number[];
-            dimension: number;
-        }[] | undefined;
-        maxDimension?: number | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    complex: {
-        vertices: number[][];
-        simplices?: {
-            vertices: number[];
-            dimension: number;
-        }[] | undefined;
-        maxDimension: number;
-    };
-}, {
-    complex: {
-        vertices: number[][];
-        simplices?: {
-            vertices: number[];
-            dimension: number;
-        }[] | undefined;
-        maxDimension?: number | undefined;
-    };
-}>;
-export type TopologyInput = z.infer<typeof TopologyInputSchema>;
-export interface TopologyResult {
-    bettiNumbers: number[];
-    persistenceDiagram: [number, number][];
-    homologyClasses: number;
-}
-export interface TopologyOutput {
-    bettiNumbers: number[];
-    persistenceDiagram: {
-        birth: number;
-        death: number;
-        dimension: number;
-    }[];
-    details: {
-        homologyClasses: number;
-        interpretation: {
-            b0: string;
-            b1: string;
-        };
-        vertexCount: number;
-        maxDimension: number;
-    };
-}
-export declare const MemoryGateInputSchema: z.ZodObject<{
-    key: z.ZodString;
-    value: z.ZodUnknown;
-    existingVectors: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">>;
-    thresholds: z.ZodOptional<z.ZodObject<{
-        reject: z.ZodDefault<z.ZodNumber>;
-        warn: z.ZodDefault<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        reject: number;
-        warn: number;
-    }, {
-        reject?: number | undefined;
-        warn?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    value?: unknown;
-    existingVectors?: number[][] | undefined;
-    thresholds?: {
-        reject: number;
-        warn: number;
-    } | undefined;
-}, {
-    key: string;
-    value?: unknown;
-    existingVectors?: number[][] | undefined;
-    thresholds?: {
-        reject?: number | undefined;
-        warn?: number | undefined;
-    } | undefined;
-}>;
-export type MemoryGateInput = z.infer<typeof MemoryGateInputSchema>;
-export interface MemoryGateOutput {
-    allowed: boolean;
-    coherenceEnergy: number;
-    reason?: string;
-    details: {
-        action: 'allow' | 'warn' | 'reject';
-        violations: string[];
-        confidence: number;
-        interpretation: string;
-        contextSize: number;
-    };
-}
-export interface PerformanceMetrics {
-    operationName: string;
-    startTime: number;
-    endTime: number;
-    duration: number;
-    success: boolean;
-    inputSize?: number;
-    error?: string;
-}
-/**
- * Create a successful MCP tool result
- */
-export declare function successResult(data: unknown): MCPToolResult;
-/**
- * Create an error MCP tool result
- */
-export declare function errorResult(error: Error | string): MCPToolResult;
-/**
- * Track performance metrics
- */
-export declare function trackPerformance<T>(operationName: string, operation: () => T | Promise<T>): Promise<{
-    result: T;
-    metrics: PerformanceMetrics;
-}>;
-/**
- * Cosine similarity — re-exported from shared utility.
- * Callers that already import from this module continue to work unchanged.
- */
-export { cosineSimilarity } from '../../utils/cosine-similarity.js';
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,144 +0,0 @@
-/**
- * Prime Radiant MCP Tool Types
- *
- * Type definitions for Prime Radiant mathematical AI tools.
- */
-import { z } from 'zod';
-// ============================================================================
-// Coherence Types
-// ============================================================================
-export const CoherenceInputSchema = z.object({
-    vectors: z.array(z.array(z.number())).min(1).describe('Array of embedding vectors to check for coherence'),
-    threshold: z.number().min(0).max(1).default(0.3).describe('Energy threshold for coherence (0-1)'),
-});
-// ============================================================================
-// Spectral Types
-// ============================================================================
-export const SpectralInputSchema = z.object({
-    matrix: z.array(z.array(z.number())).min(1).describe('Adjacency matrix representing connections'),
-    analyzeType: z.enum(['stability', 'clustering', 'connectivity']).default('stability'),
-});
-// ============================================================================
-// Causal Types
-// ============================================================================
-export const CausalGraphSchema = z.object({
-    nodes: z.array(z.string()).min(1).describe('List of variable names'),
-    edges: z.array(z.tuple([z.string(), z.string()])).describe('Directed edges as [from, to] pairs'),
-});
-export const CausalInputSchema = z.object({
-    graph: CausalGraphSchema.describe('Causal graph with nodes and edges'),
-    intervention: z.string().describe('Treatment/intervention variable'),
-    outcome: z.string().describe('Outcome variable to measure effect on'),
-});
-// ============================================================================
-// Consensus Types
-// ============================================================================
-export const AgentStateSchema = z.object({
-    agentId: z.string().describe('Unique agent identifier'),
-    embedding: z.array(z.number()).describe('Agent state embedding vector'),
-    vote: z.string().optional().describe('Agent vote or decision'),
-    metadata: z.record(z.string(), z.unknown()).optional().describe('Additional agent metadata'),
-});
-export const ConsensusInputSchema = z.object({
-    agentStates: z.array(AgentStateSchema).min(1).describe('Array of agent states to verify consensus'),
-    threshold: z.number().min(0).max(1).default(0.8).describe('Required agreement threshold (0-1)'),
-});
-// ============================================================================
-// Topology Types
-// ============================================================================
-export const SimplexSchema = z.object({
-    vertices: z.array(z.number()).describe('Vertex indices forming the simplex'),
-    dimension: z.number().int().min(0).describe('Dimension of the simplex'),
-});
-export const SimplicialComplexSchema = z.object({
-    vertices: z.array(z.array(z.number())).describe('Vertex coordinates'),
-    simplices: z.array(SimplexSchema).optional().describe('Explicit simplices (if not provided, computed from vertices)'),
-    maxDimension: z.number().int().min(0).max(3).default(2).describe('Maximum homology dimension to compute'),
-});
-export const TopologyInputSchema = z.object({
-    complex: SimplicialComplexSchema.describe('Simplicial complex for topological analysis'),
-});
-// ============================================================================
-// Memory Gate Types
-// ============================================================================
-export const MemoryGateInputSchema = z.object({
-    key: z.string().describe('Memory entry key'),
-    value: z.unknown().describe('Value to be stored'),
-    existingVectors: z.array(z.array(z.number())).optional().describe('Existing context embeddings'),
-    thresholds: z.object({
-        reject: z.number().min(0).max(1).default(0.7),
-        warn: z.number().min(0).max(1).default(0.3),
-    }).optional().describe('Custom coherence thresholds'),
-});
-// ============================================================================
-// Helper Functions
-// ============================================================================
-/**
- * Create a successful MCP tool result
- */
-export function successResult(data) {
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(data, null, 2),
-            }],
-    };
-}
-/**
- * Create an error MCP tool result
- */
-export function errorResult(error) {
-    const message = error instanceof Error ? error.message : error;
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({
-                    error: true,
-                    message,
-                    timestamp: new Date().toISOString(),
-                }, null, 2),
-            }],
-        isError: true,
-    };
-}
-/**
- * Track performance metrics
- */
-export function trackPerformance(operationName, operation) {
-    const startTime = performance.now();
-    return Promise.resolve()
-        .then(() => operation())
-        .then((result) => {
-        const endTime = performance.now();
-        return {
-            result,
-            metrics: {
-                operationName,
-                startTime,
-                endTime,
-                duration: endTime - startTime,
-                success: true,
-            },
-        };
-    })
-        .catch((error) => {
-        const endTime = performance.now();
-        throw {
-            error,
-            metrics: {
-                operationName,
-                startTime,
-                endTime,
-                duration: endTime - startTime,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            },
-        };
-    });
-}
-/**
- * Cosine similarity — re-exported from shared utility.
- * Callers that already import from this module continue to work unchanged.
- */
-export { cosineSimilarity } from '../../utils/cosine-similarity.js';
-//# sourceMappingURL=types.js.map

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

@@ -1,9 +0,0 @@
-/**
- * Coherence Tools — built-in coherence MCP tools
- *
- * Wraps all 6 tools for coherence check, spectral, causal, consensus, topology, memory gate
- * (coherence_*). Their inputSchemas are already plain JSON Schema.
- */
-import type { MCPTool } from './types.js';
-export declare const coherenceTools: MCPTool[];
-//# sourceMappingURL=coherence-tools.d.ts.map

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

@@ -1,25 +0,0 @@
-/**
- * Coherence Tools — built-in coherence MCP tools
- *
- * Wraps all 6 tools for coherence check, spectral, causal, consensus, topology, memory gate
- * (coherence_*). Their inputSchemas are already plain JSON Schema.
- */
-import { coherenceCheckTool } from './coherence/coherence-check.js';
-import { spectralAnalyzeTool } from './coherence/spectral-analyze.js';
-import { causalInferTool } from './coherence/causal-infer.js';
-import { consensusVerifyTool } from './coherence/consensus-verify.js';
-import { quantumTopologyTool } from './coherence/quantum-topology.js';
-import { memoryGateTool } from './coherence/memory-gate.js';
-// monolean: remap name only; all other fields (inputSchema, handler, etc.) reused as-is
-function renamed(tool, name) {
-    return { ...tool, name };
-}
-export const coherenceTools = [
-    renamed(coherenceCheckTool, 'coherence_check'),
-    renamed(spectralAnalyzeTool, 'coherence_spectral'),
-    renamed(causalInferTool, 'coherence_causal'),
-    renamed(consensusVerifyTool, 'coherence_consensus'),
-    renamed(quantumTopologyTool, 'coherence_topology'),
-    renamed(memoryGateTool, 'coherence_memory_gate'),
-];
-//# sourceMappingURL=coherence-tools.js.map

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

@@ -1,13 +0,0 @@
-/**
- * Coordination MCP Tools for CLI
- *
- * V2 Compatibility - Swarm coordination and orchestration tools
- *
- * ⚠️ IMPORTANT: These tools provide LOCAL STATE MANAGEMENT.
- * - Topology/consensus state is tracked locally
- * - No actual distributed coordination
- * - Useful for single-machine workflow orchestration
- */
-import type { MCPTool } from './types.js';
-export declare const coordinationTools: MCPTool[];
-//# sourceMappingURL=coordination-tools.d.ts.map