monomind 1.15.4 → 1.15.5

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

@@ -0,0 +1,159 @@
+/**
+ * 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),
+            },
+        };
+    });
+}
+/**
+ * Calculate cosine similarity between two vectors
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0)
+        return 0;
+    return dotProduct / denominator;
+}
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Coherence Tools — migrated from packages/plugins/prime-radiant
+ *
+ * Wraps all 6 prime-radiant tools as CLI MCPTool entries with renamed names
+ * (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

@@ -0,0 +1,25 @@
+/**
+ * Coherence Tools — migrated from packages/plugins/prime-radiant
+ *
+ * Wraps all 6 prime-radiant tools as CLI MCPTool entries with renamed names
+ * (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/quality/chaos-resilience/chaos-inject.d.ts

@@ -0,0 +1,163 @@
+/**
+ * chaos-inject.ts - Chaos failure injection MCP tool handler
+ *
+ * Injects controlled failures for resilience testing including network
+ * latency, process termination, resource exhaustion, and more.
+ * Includes dryRun safety mode.
+ */
+import { z } from 'zod';
+export declare const ChaosInjectInputSchema: z.ZodObject<{
+    target: z.ZodString;
+    failureType: z.ZodEnum<{
+        "network-latency": "network-latency";
+        "network-partition": "network-partition";
+        "cpu-stress": "cpu-stress";
+        "memory-pressure": "memory-pressure";
+        "disk-failure": "disk-failure";
+        "process-kill": "process-kill";
+        "dns-failure": "dns-failure";
+        "dependency-failure": "dependency-failure";
+        "clock-skew": "clock-skew";
+        "packet-loss": "packet-loss";
+    }>;
+    duration: z.ZodDefault<z.ZodNumber>;
+    intensity: z.ZodDefault<z.ZodNumber>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    rollbackOnFailure: z.ZodDefault<z.ZodBoolean>;
+    monitorMetrics: z.ZodDefault<z.ZodBoolean>;
+    notifyChannels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    parameters: z.ZodOptional<z.ZodObject<{
+        latencyMs: z.ZodOptional<z.ZodNumber>;
+        packetLossPercent: z.ZodOptional<z.ZodNumber>;
+        cpuCores: z.ZodOptional<z.ZodNumber>;
+        memoryPercent: z.ZodOptional<z.ZodNumber>;
+        targetProcesses: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChaosInjectInput = z.infer<typeof ChaosInjectInputSchema>;
+export interface ChaosInjectOutput {
+    success: boolean;
+    experimentId: string;
+    status: ExperimentStatus;
+    injection: InjectionDetails;
+    impact: ImpactAssessment;
+    metrics: ChaosMetrics;
+    timeline: TimelineEvent[];
+    recommendations: ChaosRecommendation[];
+    metadata: ChaosMetadata;
+}
+export interface ExperimentStatus {
+    state: 'planned' | 'running' | 'completed' | 'aborted' | 'dry-run';
+    progress: number;
+    startTime: string | null;
+    endTime: string | null;
+    rollbackRequired: boolean;
+    rollbackCompleted: boolean;
+}
+export interface InjectionDetails {
+    type: string;
+    target: string;
+    intensity: number;
+    duration: number;
+    parameters: Record<string, unknown>;
+    affectedComponents: string[];
+}
+export interface ImpactAssessment {
+    severity: 'none' | 'low' | 'medium' | 'high' | 'critical';
+    systemsAffected: string[];
+    usersAffected: number;
+    recoveryTime: number;
+    dataLoss: boolean;
+    serviceDisruption: ServiceDisruption;
+}
+export interface ServiceDisruption {
+    totalRequests: number;
+    failedRequests: number;
+    errorRate: number;
+    avgLatency: number;
+    p99Latency: number;
+}
+export interface ChaosMetrics {
+    baseline: MetricSnapshot;
+    duringChaos: MetricSnapshot;
+    afterChaos: MetricSnapshot;
+    degradation: number;
+    recoveryTime: number;
+}
+export interface MetricSnapshot {
+    timestamp: string;
+    cpu: number;
+    memory: number;
+    networkLatency: number;
+    errorRate: number;
+    requestsPerSecond: number;
+}
+export interface TimelineEvent {
+    timestamp: string;
+    event: string;
+    type: 'info' | 'warning' | 'error' | 'recovery';
+    details: string;
+}
+export interface ChaosRecommendation {
+    category: 'resilience' | 'recovery' | 'monitoring' | 'configuration';
+    priority: 'high' | 'medium' | 'low';
+    finding: string;
+    recommendation: string;
+    evidence: string;
+}
+export interface ChaosMetadata {
+    experimentId: string;
+    createdAt: string;
+    completedAt: string | null;
+    dryRun: boolean;
+    version: string;
+}
+export interface ToolContext {
+    get<T>(key: string): T | undefined;
+}
+/**
+ * MCP Tool Handler for chaos-inject
+ */
+export declare function handler(input: ChaosInjectInput, context: ToolContext): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+export declare const toolDefinition: {
+    name: string;
+    description: string;
+    category: string;
+    version: string;
+    inputSchema: z.ZodObject<{
+        target: z.ZodString;
+        failureType: z.ZodEnum<{
+            "network-latency": "network-latency";
+            "network-partition": "network-partition";
+            "cpu-stress": "cpu-stress";
+            "memory-pressure": "memory-pressure";
+            "disk-failure": "disk-failure";
+            "process-kill": "process-kill";
+            "dns-failure": "dns-failure";
+            "dependency-failure": "dependency-failure";
+            "clock-skew": "clock-skew";
+            "packet-loss": "packet-loss";
+        }>;
+        duration: z.ZodDefault<z.ZodNumber>;
+        intensity: z.ZodDefault<z.ZodNumber>;
+        dryRun: z.ZodDefault<z.ZodBoolean>;
+        rollbackOnFailure: z.ZodDefault<z.ZodBoolean>;
+        monitorMetrics: z.ZodDefault<z.ZodBoolean>;
+        notifyChannels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        parameters: z.ZodOptional<z.ZodObject<{
+            latencyMs: z.ZodOptional<z.ZodNumber>;
+            packetLossPercent: z.ZodOptional<z.ZodNumber>;
+            cpuCores: z.ZodOptional<z.ZodNumber>;
+            memoryPercent: z.ZodOptional<z.ZodNumber>;
+            targetProcesses: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    handler: typeof handler;
+};
+export default toolDefinition;
+//# sourceMappingURL=chaos-inject.d.ts.map