monomind 2.7.4 → 2.7.5

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

@@ -1,279 +0,0 @@
-/**
- * Memory Gate Tool - pr_memory_gate
- *
- * Pre-storage coherence gate for memory entries.
- * Validates that new entries are coherent with existing context before storage.
- * Uses cosine similarity on vectors to compute coherence energy.
- * When no pre-computed embeddings are supplied, falls back to a deterministic
- * hash-based vector (structural proxy, not semantic similarity).
- */
-import { MemoryGateInputSchema, successResult, errorResult, cosineSimilarity, } from './types.js';
-// Default logger
-const defaultLogger = {
-    debug: (msg, meta) => console.debug(`[pr_memory_gate] ${msg}`, meta),
-    info: (msg, meta) => console.info(`[pr_memory_gate] ${msg}`, meta),
-    warn: (msg, meta) => console.warn(`[pr_memory_gate] ${msg}`, meta),
-    error: (msg, meta) => console.error(`[pr_memory_gate] ${msg}`, meta),
-};
-// ============================================================================
-// Memory Gate Functions
-// ============================================================================
-/**
- * Deterministic hash-based vector from value content.
- * This is NOT a semantic embedding -- it produces a normalized vector
- * derived from character codes via an LCG, so only identical (or
- * near-identical) strings will be "similar". It serves as a
- * structural-consistency proxy when no real embedding model is available.
- *
- * For real semantic similarity, use the generateEmbedding() from
- * neural-tools.ts which tries ONNX first and falls back to a
- * deterministic hash.
- */
-function hashVector(value) {
-    const str = typeof value === 'string' ? value : JSON.stringify(value);
-    // Seed from string content
-    let seed = 0;
-    for (let i = 0; i < str.length; i++) {
-        seed = ((seed * 1103515245 + 12345) & 0x7fffffff) ^ (str.charCodeAt(i) * (i + 1));
-    }
-    // Generate deterministic vector via LCG
-    const dims = 64;
-    const vec = new Array(dims);
-    for (let i = 0; i < dims; i++) {
-        seed = (seed * 1103515245 + 12345) & 0x7fffffff;
-        vec[i] = (seed / 0x7fffffff) * 2 - 1;
-    }
-    // Normalize
-    let norm = 0;
-    for (let i = 0; i < dims; i++) {
-        norm += vec[i] * vec[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-        for (let i = 0; i < dims; i++) {
-            vec[i] /= norm;
-        }
-    }
-    return vec;
-}
-/**
- * Compute coherence energy using Sheaf Laplacian
- */
-function computeCoherenceEnergy(newEmbedding, existingEmbeddings) {
-    if (existingEmbeddings.length === 0)
-        return 0;
-    let totalDisagreement = 0;
-    for (const existing of existingEmbeddings) {
-        const similarity = cosineSimilarity(newEmbedding, existing);
-        const disagreement = 1 - Math.max(0, similarity);
-        totalDisagreement += disagreement;
-    }
-    return totalDisagreement / existingEmbeddings.length;
-}
-/**
- * Detect specific violations
- */
-function detectViolations(newEmbedding, existingEmbeddings, warnThreshold) {
-    const violations = [];
-    for (let i = 0; i < existingEmbeddings.length; i++) {
-        const similarity = cosineSimilarity(newEmbedding, existingEmbeddings[i]);
-        if (similarity < -0.3) {
-            violations.push(`Strong contradiction with context entry ${i} (similarity: ${similarity.toFixed(3)})`);
-        }
-        else if (similarity < warnThreshold) {
-            violations.push(`Weak coherence with context entry ${i} (similarity: ${similarity.toFixed(3)})`);
-        }
-    }
-    return violations;
-}
-/**
- * Determine action based on coherence energy
- */
-function determineAction(energy, thresholds) {
-    if (energy >= thresholds.reject) {
-        return 'reject';
-    }
-    if (energy >= thresholds.warn) {
-        return 'warn';
-    }
-    return 'allow';
-}
-/**
- * Get interpretation of memory gate result
- */
-function getInterpretation(action, energy, violations) {
-    switch (action) {
-        case 'allow':
-            return 'Entry is coherent with existing context - storage allowed';
-        case 'warn':
-            return `Entry has minor inconsistencies (energy: ${energy.toFixed(3)}) - storage allowed with warning`;
-        case 'reject':
-            return `Entry contradicts existing context (energy: ${energy.toFixed(3)}) - storage blocked. ${violations.length} violation(s) detected.`;
-    }
-}
-/**
- * Handler for pr_memory_gate tool
- */
-async function handler(input, context) {
-    const logger = context?.logger ?? defaultLogger;
-    const startTime = performance.now();
-    try {
-        // Validate input
-        const validationResult = MemoryGateInputSchema.safeParse(input);
-        if (!validationResult.success) {
-            logger.error('Input validation failed', { error: validationResult.error.message });
-            return errorResult(`Invalid input: ${validationResult.error.message}`);
-        }
-        const { key, value, existingVectors, thresholds } = validationResult.data;
-        // Get thresholds from config or input
-        const warnThreshold = thresholds?.warn ?? context?.config?.coherence?.warnThreshold ?? 0.3;
-        const rejectThreshold = thresholds?.reject ?? context?.config?.coherence?.rejectThreshold ?? 0.7;
-        logger.debug('Processing memory gate check', {
-            key,
-            hasExistingContext: !!existingVectors?.length,
-            contextSize: existingVectors?.length ?? 0,
-            warnThreshold,
-            rejectThreshold,
-        });
-        // Generate hash-based vector for the new value (not a semantic embedding --
-        // only detects near-identical content, not semantic similarity)
-        const newEmbedding = hashVector(value);
-        // If no existing context, always allow
-        if (!existingVectors || existingVectors.length === 0) {
-            const output = {
-                allowed: true,
-                coherenceEnergy: 0,
-                details: {
-                    action: 'allow',
-                    violations: [],
-                    confidence: 1,
-                    interpretation: 'No existing context - entry allowed',
-                    contextSize: 0,
-                },
-            };
-            const duration = performance.now() - startTime;
-            logger.info('Memory gate check completed (no context)', {
-                key,
-                allowed: true,
-                durationMs: duration.toFixed(2),
-            });
-            return successResult(output);
-        }
-        // Validate embedding dimensions match
-        const firstDim = existingVectors[0].length;
-        for (let i = 1; i < existingVectors.length; i++) {
-            if (existingVectors[i].length !== firstDim) {
-                return errorResult(`Context embedding dimension mismatch: entry ${i} has ${existingVectors[i].length} dimensions, expected ${firstDim}`);
-            }
-        }
-        let coherenceEnergy;
-        let violations;
-        // Try to use WASM bridge if available
-        if (context?.bridge?.initialized) {
-            try {
-                logger.debug('Using WASM bridge for coherence check');
-                const allEmbeddings = [
-                    new Float32Array(newEmbedding),
-                    ...existingVectors.map(v => new Float32Array(v)),
-                ];
-                const result = await context.bridge.checkCoherence(allEmbeddings);
-                coherenceEnergy = 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),
-                });
-                coherenceEnergy = computeCoherenceEnergy(newEmbedding, existingVectors);
-                violations = detectViolations(newEmbedding, existingVectors, warnThreshold);
-            }
-        }
-        else {
-            // Pure JavaScript fallback
-            logger.debug('Using JavaScript fallback for memory gate');
-            coherenceEnergy = computeCoherenceEnergy(newEmbedding, existingVectors);
-            violations = detectViolations(newEmbedding, existingVectors, warnThreshold);
-        }
-        const action = determineAction(coherenceEnergy, { warn: warnThreshold, reject: rejectThreshold });
-        const allowed = action !== 'reject';
-        const confidence = 1 - coherenceEnergy;
-        const output = {
-            allowed,
-            coherenceEnergy,
-            reason: !allowed ? `Coherence energy ${coherenceEnergy.toFixed(3)} exceeds reject threshold ${rejectThreshold}` : undefined,
-            details: {
-                action,
-                violations,
-                confidence,
-                interpretation: getInterpretation(action, coherenceEnergy, violations),
-                contextSize: existingVectors.length,
-            },
-        };
-        const duration = performance.now() - startTime;
-        logger.info('Memory gate check completed', {
-            key,
-            allowed,
-            action,
-            coherenceEnergy: coherenceEnergy.toFixed(4),
-            violations: violations.length,
-            durationMs: duration.toFixed(2),
-        });
-        return successResult(output);
-    }
-    catch (error) {
-        const duration = performance.now() - startTime;
-        logger.error('Memory gate 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_memory_gate MCP Tool Definition
- */
-export const memoryGateTool = {
-    name: 'pr_memory_gate',
-    description: 'Pre-storage coherence gate for memory entries. Validates new entries against existing context vectors using cosine-similarity energy. When no pre-computed embeddings are supplied, uses a deterministic hash-based vector (structural proxy, not semantic). Blocks contradictory entries to maintain memory coherence.',
-    category: 'memory',
-    version: '0.1.3',
-    tags: ['memory', 'coherence', 'gate', 'validation', 'ai-interpretability'],
-    cacheable: false, // Context changes frequently
-    inputSchema: {
-        type: 'object',
-        properties: {
-            key: {
-                type: 'string',
-                description: 'Memory entry key',
-            },
-            value: {
-                description: 'Value to be stored (any JSON-serializable type)',
-            },
-            existingVectors: {
-                type: 'array',
-                items: { type: 'array', items: { type: 'number' } },
-                description: 'Existing context embeddings to check against',
-            },
-            thresholds: {
-                type: 'object',
-                properties: {
-                    warn: {
-                        type: 'number',
-                        default: 0.3,
-                        description: 'Energy threshold for warnings (0-1)',
-                    },
-                    reject: {
-                        type: 'number',
-                        default: 0.7,
-                        description: 'Energy threshold for rejection (0-1)',
-                    },
-                },
-                description: 'Custom coherence thresholds',
-            },
-        },
-        required: ['key', 'value'],
-    },
-    handler,
-};
-export default memoryGateTool;
-//# sourceMappingURL=memory-gate.js.map

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

@@ -1,15 +0,0 @@
-/**
- * Computational Topology Tool - pr_quantum_topology
- *
- * Computes topological features including Betti numbers (b0, b1) and
- * persistence diagrams via Vietoris-Rips filtration.
- * Analyzes topological features of point clouds and simplicial complexes.
- * b2 (voids) is not computed -- requires boundary-operator linear algebra.
- */
-import type { MCPTool } from './types.js';
-/**
- * pr_quantum_topology MCP Tool Definition
- */
-export declare const quantumTopologyTool: MCPTool;
-export default quantumTopologyTool;
-//# sourceMappingURL=quantum-topology.d.ts.map

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

@@ -1,400 +0,0 @@
-/**
- * Computational Topology Tool - pr_quantum_topology
- *
- * Computes topological features including Betti numbers (b0, b1) and
- * persistence diagrams via Vietoris-Rips filtration.
- * Analyzes topological features of point clouds and simplicial complexes.
- * b2 (voids) is not computed -- requires boundary-operator linear algebra.
- */
-import { TopologyInputSchema, successResult, errorResult, } from './types.js';
-// Default logger
-const defaultLogger = {
-    debug: (msg, meta) => console.debug(`[pr_quantum_topology] ${msg}`, meta),
-    info: (msg, meta) => console.info(`[pr_quantum_topology] ${msg}`, meta),
-    warn: (msg, meta) => console.warn(`[pr_quantum_topology] ${msg}`, meta),
-    error: (msg, meta) => console.error(`[pr_quantum_topology] ${msg}`, meta),
-};
-// ============================================================================
-// Topology Helper Functions
-// ============================================================================
-/**
- * Compute Euclidean distance between two points
- */
-function euclideanDistance(a, b) {
-    let sum = 0;
-    for (let i = 0; i < a.length; i++) {
-        const diff = a[i] - b[i];
-        sum += diff * diff;
-    }
-    return Math.sqrt(sum);
-}
-/**
- * Build distance matrix from vertices
- */
-function buildDistanceMatrix(vertices) {
-    const n = vertices.length;
-    const matrix = [];
-    for (let i = 0; i < n; i++) {
-        matrix[i] = [];
-        for (let j = 0; j < n; j++) {
-            matrix[i][j] = euclideanDistance(vertices[i], vertices[j]);
-        }
-    }
-    return matrix;
-}
-/**
- * Build Vietoris-Rips complex at given epsilon
- * Returns list of simplices (vertex index arrays)
- */
-function buildRipsComplex(distanceMatrix, epsilon, maxDimension) {
-    const n = distanceMatrix.length;
-    const simplices = [];
-    // Add 0-simplices (vertices)
-    for (let i = 0; i < n; i++) {
-        simplices.push([i]);
-    }
-    if (maxDimension < 1)
-        return simplices;
-    // Add 1-simplices (edges)
-    const edges = [];
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            if (distanceMatrix[i][j] <= epsilon) {
-                edges.push([i, j]);
-                simplices.push([i, j]);
-            }
-        }
-    }
-    if (maxDimension < 2)
-        return simplices;
-    // Add 2-simplices (triangles)
-    // A triangle exists if all three edges exist
-    const edgeSet = new Set(edges.map(e => `${e[0]}-${e[1]}`));
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            if (!edgeSet.has(`${i}-${j}`))
-                continue;
-            for (let k = j + 1; k < n; k++) {
-                if (edgeSet.has(`${i}-${k}`) && edgeSet.has(`${j}-${k}`)) {
-                    simplices.push([i, j, k]);
-                }
-            }
-        }
-    }
-    if (maxDimension < 3)
-        return simplices;
-    // Add 3-simplices (tetrahedra)
-    // Simplified: only add if all faces exist
-    const triangleSet = new Set(simplices
-        .filter(s => s.length === 3)
-        .map(t => `${t[0]}-${t[1]}-${t[2]}`));
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            for (let k = j + 1; k < n; k++) {
-                for (let l = k + 1; l < n; l++) {
-                    // Check all 4 triangular faces exist
-                    const faces = [
-                        `${i}-${j}-${k}`,
-                        `${i}-${j}-${l}`,
-                        `${i}-${k}-${l}`,
-                        `${j}-${k}-${l}`,
-                    ];
-                    if (faces.every(f => triangleSet.has(f))) {
-                        simplices.push([i, j, k, l]);
-                    }
-                }
-            }
-        }
-    }
-    return simplices;
-}
-/**
- * Compute Betti numbers from simplicial complex
- * Uses simplified computation based on simplex counts
- *
- * Betti numbers:
- * - b0: Number of connected components
- * - b1: Number of loops/cycles
- * - b2: Number of voids/cavities
- */
-function computeBettiNumbers(vertices, simplices, maxDimension) {
-    const n = vertices.length;
-    const bettiNumbers = [];
-    // Count simplices by dimension
-    const simplexCounts = new Array(maxDimension + 1).fill(0);
-    for (const simplex of simplices) {
-        const dim = simplex.length - 1;
-        if (dim <= maxDimension) {
-            simplexCounts[dim]++;
-        }
-    }
-    // b0: Connected components (using union-find approximation)
-    const parent = new Array(n).fill(-1);
-    function find(x) {
-        if (parent[x] < 0)
-            return x;
-        parent[x] = find(parent[x]);
-        return parent[x];
-    }
-    function union(x, y) {
-        const px = find(x);
-        const py = find(y);
-        if (px !== py) {
-            parent[px] = py;
-        }
-    }
-    // Connect vertices in edges
-    for (const simplex of simplices) {
-        if (simplex.length === 2) {
-            union(simplex[0], simplex[1]);
-        }
-    }
-    // Count components
-    let b0 = 0;
-    for (let i = 0; i < n; i++) {
-        if (parent[i] < 0)
-            b0++;
-    }
-    bettiNumbers.push(b0);
-    // b1: Approximate using Euler characteristic relationship
-    // For connected graphs: b1 = edges - vertices + components
-    if (maxDimension >= 1) {
-        const edges = simplexCounts[1] || 0;
-        const b1 = Math.max(0, edges - n + b0);
-        bettiNumbers.push(b1);
-    }
-    // b2 requires computing the rank of the boundary matrices (dim-2 and dim-3),
-    // which needs full boundary-operator linear algebra not implemented here.
-    // We do NOT fabricate b2 -- only b0 and b1 are reported.
-    return bettiNumbers;
-}
-/**
- * Compute persistence diagram using filtration
- * Tracks birth and death of topological features
- */
-function computePersistenceDiagram(distanceMatrix, maxDimension) {
-    const diagram = [];
-    // Get all unique distances (filtration values)
-    const distances = [];
-    const n = distanceMatrix.length;
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            distances.push(distanceMatrix[i][j]);
-        }
-    }
-    distances.sort((a, b) => a - b);
-    const uniqueDistances = [...new Set(distances)];
-    // Sample filtration values
-    const sampleCount = Math.min(10, uniqueDistances.length);
-    const sampleIndices = [];
-    for (let i = 0; i < sampleCount; i++) {
-        sampleIndices.push(Math.floor(i * uniqueDistances.length / sampleCount));
-    }
-    const filtrationValues = sampleIndices.map(i => uniqueDistances[i]);
-    if (filtrationValues.length === 0)
-        return diagram;
-    // Track Betti numbers at each filtration value
-    let prevBetti = [];
-    for (let f = 0; f < filtrationValues.length; f++) {
-        const epsilon = filtrationValues[f];
-        const simplices = buildRipsComplex(distanceMatrix, epsilon, maxDimension);
-        const currentBetti = computeBettiNumbers(new Array(n).fill([]).map((_, i) => [i]), simplices, maxDimension);
-        if (f > 0) {
-            // Detect births and deaths
-            for (let dim = 0; dim <= maxDimension && dim < currentBetti.length; dim++) {
-                const prevB = prevBetti[dim] || 0;
-                const currB = currentBetti[dim] || 0;
-                // New features born
-                if (currB > prevB) {
-                    for (let i = 0; i < currB - prevB; i++) {
-                        diagram.push({
-                            birth: filtrationValues[f - 1],
-                            death: Infinity, // Will be updated when feature dies
-                            dimension: dim,
-                        });
-                    }
-                }
-                // Features died
-                if (currB < prevB) {
-                    // Find features to kill (those born earliest)
-                    const toKill = prevB - currB;
-                    let killed = 0;
-                    for (let d = diagram.length - 1; d >= 0 && killed < toKill; d--) {
-                        if (diagram[d].dimension === dim && diagram[d].death === Infinity) {
-                            diagram[d].death = epsilon;
-                            killed++;
-                        }
-                    }
-                }
-            }
-        }
-        else {
-            // Initial features (all vertices born at epsilon = 0)
-            for (let dim = 0; dim <= maxDimension && dim < currentBetti.length; dim++) {
-                for (let i = 0; i < currentBetti[dim]; i++) {
-                    diagram.push({
-                        birth: 0,
-                        death: Infinity,
-                        dimension: dim,
-                    });
-                }
-            }
-        }
-        prevBetti = currentBetti;
-    }
-    return diagram;
-}
-/**
- * Get interpretation of Betti numbers
- */
-function interpretBettiNumbers(bettiNumbers) {
-    return {
-        b0: `${bettiNumbers[0] || 0} connected component(s)`,
-        b1: `${bettiNumbers[1] || 0} loop(s)/cycle(s)`,
-    };
-}
-/**
- * Handler for pr_quantum_topology tool
- */
-async function handler(input, context) {
-    const logger = context?.logger ?? defaultLogger;
-    const startTime = performance.now();
-    try {
-        // Validate input
-        const validationResult = TopologyInputSchema.safeParse(input);
-        if (!validationResult.success) {
-            logger.error('Input validation failed', { error: validationResult.error.message });
-            return errorResult(`Invalid input: ${validationResult.error.message}`);
-        }
-        const { complex } = validationResult.data;
-        const { vertices, maxDimension } = complex;
-        logger.debug('Processing computational topology', {
-            vertexCount: vertices.length,
-            maxDimension,
-        });
-        if (vertices.length === 0) {
-            return errorResult('No vertices provided');
-        }
-        // Validate vertex dimensions are consistent
-        const firstDim = vertices[0].length;
-        for (let i = 1; i < vertices.length; i++) {
-            if (vertices[i].length !== firstDim) {
-                return errorResult(`Vertex dimension mismatch: vertex ${i} has ${vertices[i].length} dimensions, expected ${firstDim}`);
-            }
-        }
-        let bettiNumbers;
-        let persistenceDiagram;
-        let homologyClasses;
-        // Try to use WASM bridge if available
-        if (context?.bridge?.initialized) {
-            try {
-                logger.debug('Using WASM bridge for topology computation');
-                const result = await context.bridge.computeTopology(complex);
-                bettiNumbers = result.bettiNumbers;
-                persistenceDiagram = result.persistenceDiagram.map(([birth, death], i) => ({
-                    birth,
-                    death,
-                    dimension: Math.min(i % (maxDimension + 1), maxDimension),
-                }));
-                homologyClasses = result.homologyClasses;
-            }
-            catch (wasmError) {
-                logger.warn('WASM bridge failed, falling back to JS implementation', {
-                    error: wasmError instanceof Error ? wasmError.message : String(wasmError),
-                });
-                // Use JavaScript implementation
-                const distanceMatrix = buildDistanceMatrix(vertices);
-                const maxDistance = Math.max(...distanceMatrix.flat().filter(d => d > 0));
-                const simplices = buildRipsComplex(distanceMatrix, maxDistance * 0.5, maxDimension);
-                bettiNumbers = computeBettiNumbers(vertices, simplices, maxDimension);
-                persistenceDiagram = computePersistenceDiagram(distanceMatrix, maxDimension);
-                homologyClasses = bettiNumbers.reduce((a, b) => a + b, 0);
-            }
-        }
-        else {
-            // Pure JavaScript fallback
-            logger.debug('Using JavaScript fallback for topology computation');
-            const distanceMatrix = buildDistanceMatrix(vertices);
-            const maxDistance = Math.max(...distanceMatrix.flat().filter(d => d > 0));
-            const simplices = buildRipsComplex(distanceMatrix, maxDistance * 0.5, maxDimension);
-            bettiNumbers = computeBettiNumbers(vertices, simplices, maxDimension);
-            persistenceDiagram = computePersistenceDiagram(distanceMatrix, maxDimension);
-            homologyClasses = bettiNumbers.reduce((a, b) => a + b, 0);
-        }
-        const output = {
-            bettiNumbers,
-            persistenceDiagram,
-            details: {
-                homologyClasses,
-                interpretation: interpretBettiNumbers(bettiNumbers),
-                vertexCount: vertices.length,
-                maxDimension,
-            },
-        };
-        const duration = performance.now() - startTime;
-        logger.info('Topology computation completed', {
-            bettiNumbers: bettiNumbers.join(', '),
-            persistencePoints: persistenceDiagram.length,
-            homologyClasses,
-            durationMs: duration.toFixed(2),
-        });
-        return successResult(output);
-    }
-    catch (error) {
-        const duration = performance.now() - startTime;
-        logger.error('Topology computation failed', {
-            error: error instanceof Error ? error.message : String(error),
-            durationMs: duration.toFixed(2),
-        });
-        return errorResult(error instanceof Error ? error : new Error(String(error)));
-    }
-}
-/**
- * pr_quantum_topology MCP Tool Definition
- */
-export const quantumTopologyTool = {
-    name: 'pr_quantum_topology',
-    description: 'Compute topological features via Vietoris-Rips filtration. Reports Betti numbers b0 (components) and b1 (loops) with persistence diagrams. b2 (voids) is not computed.',
-    category: 'topology',
-    version: '0.1.3',
-    tags: ['topology', 'betti-numbers', 'persistence', 'homology', 'ai-interpretability'],
-    cacheable: true,
-    cacheTTL: 120000, // 2 minute cache (expensive computation)
-    inputSchema: {
-        type: 'object',
-        properties: {
-            complex: {
-                type: 'object',
-                properties: {
-                    vertices: {
-                        type: 'array',
-                        items: { type: 'array', items: { type: 'number' } },
-                        description: 'Vertex coordinates (point cloud)',
-                    },
-                    simplices: {
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                vertices: { type: 'array', items: { type: 'number' } },
-                                dimension: { type: 'number' },
-                            },
-                        },
-                        description: 'Explicit simplices (optional, computed from vertices if not provided)',
-                    },
-                    maxDimension: {
-                        type: 'number',
-                        default: 2,
-                        description: 'Maximum homology dimension to compute (0-3)',
-                    },
-                },
-                required: ['vertices'],
-                description: 'Simplicial complex for topological analysis',
-            },
-        },
-        required: ['complex'],
-    },
-    handler,
-};
-export default quantumTopologyTool;
-//# sourceMappingURL=quantum-topology.js.map