monomind 1.11.13 → 1.11.14

package/packages/@monomind/cli/dist/src/transfer/test-seraphine.js

@@ -0,0 +1,105 @@
+/**
+ * Test Seraphine Genesis Model
+ * Quick validation of the transfer pipeline
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Simple test without complex imports
+async function test() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║           SERAPHINE GENESIS TEST SUITE                    ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    let passed = 0;
+    let failed = 0;
+    // Test 1: Types file exists
+    const typesPath = path.join(__dirname, 'types.ts');
+    if (fs.existsSync(typesPath)) {
+        console.log('✅ Test 1: Types module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 1: Types module missing');
+        failed++;
+    }
+    // Test 2: Seraphine model exists
+    const seraphPath = path.join(__dirname, 'models', 'seraphine.ts');
+    if (fs.existsSync(seraphPath)) {
+        console.log('✅ Test 2: Seraphine model exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 2: Seraphine model missing');
+        failed++;
+    }
+    // Test 3: CFP serializer exists
+    const cfpPath = path.join(__dirname, 'serialization', 'cfp.ts');
+    if (fs.existsSync(cfpPath)) {
+        console.log('✅ Test 3: CFP serializer exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 3: CFP serializer missing');
+        failed++;
+    }
+    // Test 4: Anonymization module exists
+    const anonPath = path.join(__dirname, 'anonymization', 'index.ts');
+    if (fs.existsSync(anonPath)) {
+        console.log('✅ Test 4: Anonymization module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 4: Anonymization module missing');
+        failed++;
+    }
+    // Test 5: IPFS upload module exists
+    const ipfsPath = path.join(__dirname, 'ipfs', 'upload.ts');
+    if (fs.existsSync(ipfsPath)) {
+        console.log('✅ Test 5: IPFS upload module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 5: IPFS upload module missing');
+        failed++;
+    }
+    // Test 6: Export module exists
+    const exportPath = path.join(__dirname, 'export.ts');
+    if (fs.existsSync(exportPath)) {
+        console.log('✅ Test 6: Export module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 6: Export module missing');
+        failed++;
+    }
+    // Test 7: Index module exists
+    const indexPath = path.join(__dirname, 'index.ts');
+    if (fs.existsSync(indexPath)) {
+        console.log('✅ Test 7: Index module exists');
+        passed++;
+    }
+    else {
+        console.log('❌ Test 7: Index module missing');
+        failed++;
+    }
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log(`   Results: ${passed} passed, ${failed} failed`);
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    if (failed === 0) {
+        console.log('🎉 All module tests passed!');
+        console.log('');
+        console.log('Next steps:');
+        console.log('  1. Compile TypeScript: cd packages/@monoes/cli && npm run build');
+        console.log('  2. Run deployment: npx ts-node src/transfer/deploy-seraphine.ts --to-ipfs');
+        console.log('');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+test().catch(console.error);
+//# sourceMappingURL=test-seraphine.js.map

package/packages/@monomind/cli/dist/src/transfer/tests/test-store.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env npx tsx
+/**
+ * Pattern Store Test Suite
+ * Tests list, search, download, and publish functionality
+ */
+export {};
+//# sourceMappingURL=test-store.d.ts.map

package/packages/@monomind/cli/dist/src/transfer/tests/test-store.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env npx tsx
+/**
+ * Pattern Store Test Suite
+ * Tests list, search, download, and publish functionality
+ */
+import { createDiscoveryService } from '../store/discovery.js';
+import { searchPatterns, getSearchSuggestions, getTagCloud } from '../store/search.js';
+import { createDownloader } from '../store/download.js';
+import { createPublisher } from '../store/publish.js';
+import { createSeraphineGenesis } from '../models/seraphine.js';
+// Test results tracking
+const results = [];
+function logTest(name, passed, details) {
+    results.push({ test: name, passed, details });
+    const icon = passed ? '✅' : '❌';
+    console.log(`${icon} ${name}${details ? `: ${details}` : ''}`);
+}
+async function runTests() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║        PATTERN STORE TEST SUITE                          ║');
+    console.log('║        Testing List, Search, Download, Publish           ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    // ==========================================================================
+    // 1. DISCOVERY TESTS
+    // ==========================================================================
+    console.log('─── Discovery Tests ───────────────────────────────────────');
+    try {
+        const discovery = createDiscoveryService();
+        logTest('Discovery service created', true);
+        // List registries
+        const registries = discovery.listRegistries();
+        logTest('List registries', registries.length > 0, `Found ${registries.length} registries`);
+        // Discover registry
+        const result = await discovery.discoverRegistry();
+        logTest('Discover registry', result.success, result.success
+            ? `Loaded ${result.registry?.patterns.length || 0} patterns`
+            : result.error);
+        // Cache test
+        if (result.success) {
+            const cachedResult = await discovery.discoverRegistry();
+            logTest('Cache hit', cachedResult.fromCache, 'Second request from cache');
+        }
+        console.log('');
+        // ==========================================================================
+        // 2. SEARCH TESTS
+        // ==========================================================================
+        console.log('─── Search Tests ──────────────────────────────────────────');
+        if (result.success && result.registry) {
+            const registry = result.registry;
+            // Basic search
+            const basicSearch = searchPatterns(registry);
+            logTest('Basic search', basicSearch.patterns.length > 0, `Found ${basicSearch.total} patterns`);
+            // Query search
+            const querySearch = searchPatterns(registry, { query: 'routing' });
+            logTest('Query search', true, `Query "routing" found ${querySearch.patterns.length} patterns`);
+            // Category filter
+            const categorySearch = searchPatterns(registry, { category: 'routing' });
+            logTest('Category filter', true, `Category "routing" found ${categorySearch.patterns.length} patterns`);
+            // Tag search
+            const tagSearch = searchPatterns(registry, { tags: ['genesis'] });
+            logTest('Tag search', true, `Tag "genesis" found ${tagSearch.patterns.length} patterns`);
+            // Verified filter
+            const verifiedSearch = searchPatterns(registry, { verified: true });
+            logTest('Verified filter', true, `Verified patterns: ${verifiedSearch.patterns.length}`);
+            // Sort by downloads
+            const sortedSearch = searchPatterns(registry, {
+                sortBy: 'downloads',
+                sortOrder: 'desc',
+            });
+            logTest('Sort by downloads', true, `Top pattern: ${sortedSearch.patterns[0]?.displayName || 'none'}`);
+            // Pagination
+            const page1 = searchPatterns(registry, { limit: 5, offset: 0 });
+            logTest('Pagination', page1.pageSize === 5, `Page 1 with ${page1.patterns.length} patterns, hasMore: ${page1.hasMore}`);
+            // Search suggestions
+            const suggestions = getSearchSuggestions(registry, 'rou');
+            logTest('Search suggestions', suggestions.length >= 0, `Suggestions for "rou": ${suggestions.slice(0, 3).join(', ')}`);
+            // Tag cloud
+            const tagCloud = getTagCloud(registry);
+            logTest('Tag cloud', tagCloud.size > 0, `${tagCloud.size} unique tags`);
+        }
+        console.log('');
+        // ==========================================================================
+        // 3. DOWNLOAD TESTS
+        // ==========================================================================
+        console.log('─── Download Tests ────────────────────────────────────────');
+        if (result.success && result.registry && result.registry.patterns.length > 0) {
+            const pattern = result.registry.patterns[0];
+            const downloader = createDownloader();
+            logTest('Downloader created', true);
+            // Download with progress
+            let progressCalled = false;
+            const downloadResult = await downloader.downloadPattern(pattern, {
+                verify: true,
+            }, (progress) => {
+                progressCalled = true;
+            });
+            logTest('Download pattern', downloadResult.success, downloadResult.success
+                ? `Downloaded ${downloadResult.size} bytes`
+                : 'Failed');
+            logTest('Progress callback', progressCalled, progressCalled ? 'Progress events received' : 'No progress events');
+            logTest('Checksum verification', downloadResult.verified !== undefined, `Verified: ${downloadResult.verified}`);
+            // Cache stats
+            const cacheStats = downloader.getCacheStats();
+            logTest('Cache statistics', cacheStats.count >= 0, `${cacheStats.count} items, ${cacheStats.totalSize} bytes`);
+        }
+        console.log('');
+        // ==========================================================================
+        // 4. PUBLISH TESTS
+        // ==========================================================================
+        console.log('─── Publish Tests ─────────────────────────────────────────');
+        const cfp = createSeraphineGenesis();
+        const publisher = createPublisher();
+        logTest('Publisher created', true);
+        // Validation
+        const validation = publisher.validateForPublish(cfp, {
+            name: 'test-pattern',
+            displayName: 'Test Pattern',
+            description: 'A test pattern for validation',
+            categories: ['testing'],
+            tags: ['test', 'validation', 'demo'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish validation', validation.length === 0, validation.length === 0 ? 'All validations passed' : validation.join(', '));
+        // Preview
+        const preview = publisher.createPreview(cfp, {
+            name: 'seraphine-genesis',
+            displayName: 'Seraphine Genesis',
+            description: 'The foundational pattern model',
+            categories: ['routing', 'coordination'],
+            tags: ['genesis', 'foundational'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish preview', preview !== null, `Preview created for ${preview.name}`);
+        // Publish (mock)
+        const publishResult = await publisher.publishPattern(cfp, {
+            name: 'test-pattern',
+            displayName: 'Test Pattern',
+            description: 'A test pattern published to IPFS',
+            categories: ['testing'],
+            tags: ['test', 'demo', 'hello-world'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish to IPFS', publishResult.success, publishResult.success
+            ? `CID: ${publishResult.cid.slice(0, 20)}...`
+            : publishResult.message);
+        console.log('');
+        // ==========================================================================
+        // 5. INTEGRATION TEST
+        // ==========================================================================
+        console.log('─── Integration Test ──────────────────────────────────────');
+        // Full workflow: discover -> search -> download
+        const store = createDiscoveryService();
+        const discoverResult = await store.discoverRegistry();
+        if (discoverResult.success && discoverResult.registry) {
+            const searchResult = searchPatterns(discoverResult.registry, {
+                query: 'seraphine',
+            });
+            if (searchResult.patterns.length > 0) {
+                const dl = createDownloader();
+                const dlResult = await dl.downloadPattern(searchResult.patterns[0], {
+                    verify: true,
+                });
+                logTest('Full workflow', dlResult.success, 'Discover → Search → Download completed');
+            }
+            else {
+                logTest('Full workflow', true, 'Discover → Search completed (no download)');
+            }
+        }
+    }
+    catch (error) {
+        console.error('Test error:', error);
+        logTest('Test suite', false, `Error: ${error}`);
+    }
+    // ==========================================================================
+    // SUMMARY
+    // ==========================================================================
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('                      TEST SUMMARY                          ');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    const passed = results.filter(r => r.passed).length;
+    const failed = results.filter(r => !r.passed).length;
+    const total = results.length;
+    console.log(`   Total Tests: ${total}`);
+    console.log(`   ✅ Passed: ${passed}`);
+    console.log(`   ❌ Failed: ${failed}`);
+    console.log('');
+    if (failed === 0) {
+        console.log('   🎉 All tests passed!');
+        console.log('');
+        console.log('   📦 Store Features Verified:');
+        console.log('      - Registry discovery via IPNS');
+        console.log('      - Pattern search with filters');
+        console.log('      - Download with verification');
+        console.log('      - Publish with anonymization');
+        console.log('');
+    }
+    else {
+        console.log('   ⚠️ Some tests failed. Please review the output above.');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+// Run tests
+runTests().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=test-store.js.map

package/packages/@monomind/cli/dist/src/workflow/condition-evaluator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Evaluate a simple boolean expression with variable substitution.
+ *
+ * 1. Replace `{{variable}}` references using the provided context.
+ * 2. Reject any expression containing dangerous patterns.
+ * 3. Validate that all remaining tokens are safe.
+ * 4. Evaluate using `new Function` with strict mode.
+ */
+export declare function evaluateCondition(expression: string, context: Record<string, unknown>): boolean;
+//# sourceMappingURL=condition-evaluator.d.ts.map

package/packages/@monomind/cli/dist/src/workflow/condition-evaluator.js

@@ -0,0 +1,82 @@
+/**
+ * Substitute context values into a condition expression, JSON-encoding string
+ * values to prevent quote injection via user-controlled context data.
+ */
+function substituteCondition(expression, context) {
+    return expression.replace(/\{\{([\w./-]+)\}\}/g, (_match, path) => {
+        const segments = path.split('.');
+        let current = context;
+        for (const seg of segments) {
+            if (current === null || current === undefined || typeof current !== 'object') {
+                current = undefined;
+                break;
+            }
+            if (seg === '__proto__' || seg === 'constructor' || seg === 'prototype') {
+                current = undefined;
+                break;
+            }
+            current = current[seg];
+        }
+        if (current === undefined)
+            return `{{${path}}}`;
+        if (typeof current === 'string')
+            return JSON.stringify(current);
+        if (typeof current === 'number' || typeof current === 'boolean')
+            return String(current);
+        return JSON.stringify(current);
+    });
+}
+/**
+ * Dangerous patterns that must never appear in condition expressions.
+ */
+const DANGEROUS_PATTERNS = [
+    /\beval\b/,
+    /\brequire\b/,
+    /\bimport\b/,
+    /\bprocess\b/,
+    /\bglobal\b/,
+    /\bglobalThis\b/,
+    /\bFunction\b/,
+    /\b__proto__\b/,
+    /\bconstructor\b/,
+    /\bprototype\b/,
+];
+/**
+ * Allowed token pattern — only permits strings, numbers, booleans,
+ * comparison/logical operators, parentheses, and whitespace.
+ */
+const SAFE_TOKEN = /^(\s*('([^']*)'|"([^"]*)"|-?\d+(\.\d+)?|true|false|null|undefined|===|!==|==|!=|>=|<=|>|<|&&|\|\||!|\(|\)|\s+))+\s*$/;
+/**
+ * Evaluate a simple boolean expression with variable substitution.
+ *
+ * 1. Replace `{{variable}}` references using the provided context.
+ * 2. Reject any expression containing dangerous patterns.
+ * 3. Validate that all remaining tokens are safe.
+ * 4. Evaluate using `new Function` with strict mode.
+ */
+export function evaluateCondition(expression, context) {
+    if (expression.length > 500) {
+        throw new Error('Condition expression too long (max 500 characters)');
+    }
+    // Step 1: substitute variables (string values JSON-encoded to prevent quote injection)
+    const resolved = substituteCondition(expression, context);
+    // Re-check length after substitution — injected values can expand the expression
+    if (resolved.length > 500) {
+        throw new Error('Condition expression too long after variable substitution (max 500 characters)');
+    }
+    // Step 2: reject dangerous patterns
+    for (const pattern of DANGEROUS_PATTERNS) {
+        if (pattern.test(resolved)) {
+            throw new Error(`Unsafe expression rejected: contains forbidden pattern "${pattern.source}"`);
+        }
+    }
+    // Step 3: validate tokens
+    if (!SAFE_TOKEN.test(resolved)) {
+        throw new Error(`Unsafe expression rejected: contains disallowed tokens in "${resolved}"`);
+    }
+    // Step 4: evaluate safely
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    const fn = new Function(`"use strict"; return (${resolved});`);
+    return Boolean(fn());
+}
+//# sourceMappingURL=condition-evaluator.js.map

package/packages/@monomind/cli/dist/src/workflow/context-resolver.d.ts

@@ -0,0 +1,12 @@
+import type { DAGTask, TaskResult } from './dag-types.js';
+export declare class ContextResolutionError extends Error {
+    readonly taskId: string;
+    readonly missingDeps: string[];
+    constructor(taskId: string, missingDeps: string[]);
+}
+/**
+ * Resolves upstream context for a task by collecting results from its dependencies.
+ * Throws ContextResolutionError if any dependency result is missing.
+ */
+export declare function resolveContext(task: DAGTask, results: Map<string, TaskResult>): TaskResult[];
+//# sourceMappingURL=context-resolver.d.ts.map

package/packages/@monomind/cli/dist/src/workflow/context-resolver.js

@@ -0,0 +1,23 @@
+export class ContextResolutionError extends Error {
+    taskId;
+    missingDeps;
+    constructor(taskId, missingDeps) {
+        super(`Task "${taskId}" has unresolved dependencies: ${missingDeps.join(', ')}`);
+        this.taskId = taskId;
+        this.missingDeps = missingDeps;
+        this.name = 'ContextResolutionError';
+    }
+}
+/**
+ * Resolves upstream context for a task by collecting results from its dependencies.
+ * Throws ContextResolutionError if any dependency result is missing.
+ */
+export function resolveContext(task, results) {
+    const deps = task.contextDeps ?? [];
+    const missing = deps.filter((dep) => !results.has(dep));
+    if (missing.length > 0) {
+        throw new ContextResolutionError(task.id, missing);
+    }
+    return deps.map((dep) => results.get(dep));
+}
+//# sourceMappingURL=context-resolver.js.map

package/packages/@monomind/cli/dist/src/workflow/dag-builder.d.ts

@@ -0,0 +1,17 @@
+import type { DAG, DAGTask, DAGLevel } from './dag-types.js';
+/**
+ * Builds a DAG from an array of tasks using their contextDeps.
+ * Throws if any task references a dependency that doesn't exist.
+ */
+export declare function buildDAG(tasks: DAGTask[]): DAG;
+/**
+ * Detects cycles in the DAG using DFS.
+ * Returns an array of cycles, where each cycle is an array of task IDs.
+ */
+export declare function detectCycles(dag: DAG): string[][];
+/**
+ * Performs topological sort using Kahn's algorithm.
+ * Returns levels (arrays of tasks that can execute in parallel).
+ */
+export declare function topologicalSort(dag: DAG): DAGLevel[];
+//# sourceMappingURL=dag-builder.d.ts.map

package/packages/@monomind/cli/dist/src/workflow/dag-builder.js

@@ -0,0 +1,129 @@
+/**
+ * Builds a DAG from an array of tasks using their contextDeps.
+ * Throws if any task references a dependency that doesn't exist.
+ */
+export function buildDAG(tasks) {
+    const taskMap = new Map();
+    const edges = new Map();
+    const reverseEdges = new Map();
+    // Register all tasks
+    for (const task of tasks) {
+        taskMap.set(task.id, task);
+        edges.set(task.id, new Set());
+        reverseEdges.set(task.id, new Set());
+    }
+    // Build edges from contextDeps
+    for (const task of tasks) {
+        const deps = task.contextDeps ?? [];
+        for (const dep of deps) {
+            if (!taskMap.has(dep)) {
+                throw new Error(`Task "${task.id}" depends on "${dep}" which does not exist in the task list`);
+            }
+            // dep → task (dep is upstream, task is downstream)
+            edges.get(dep).add(task.id);
+            reverseEdges.get(task.id).add(dep);
+        }
+    }
+    return { tasks: taskMap, edges, reverseEdges };
+}
+/**
+ * Detects cycles in the DAG using DFS.
+ * Returns an array of cycles, where each cycle is an array of task IDs.
+ */
+export function detectCycles(dag) {
+    const WHITE = 0; // unvisited
+    const GRAY = 1; // in current DFS path
+    const BLACK = 2; // fully processed
+    const color = new Map();
+    const parent = new Map();
+    const cycles = [];
+    for (const id of dag.tasks.keys()) {
+        color.set(id, WHITE);
+        parent.set(id, null);
+    }
+    // Iterative DFS to avoid call-stack overflow on deep linear DAGs
+    function dfs(start) {
+        const stack = [
+            { u: start, neighbors: (dag.edges.get(start) ?? new Set()).values(), entered: false },
+        ];
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            if (!frame.entered) {
+                frame.entered = true;
+                color.set(frame.u, GRAY);
+            }
+            const { value: v, done } = frame.neighbors.next();
+            if (done) {
+                color.set(frame.u, BLACK);
+                stack.pop();
+                continue;
+            }
+            const vColor = color.get(v);
+            if (vColor === GRAY) {
+                // Found a cycle — reconstruct it
+                const cycle = [v];
+                let curr = frame.u;
+                while (curr !== v) {
+                    cycle.push(curr);
+                    const next = parent.get(curr);
+                    if (next == null)
+                        break;
+                    curr = next;
+                }
+                cycle.push(v);
+                cycle.reverse();
+                cycles.push(cycle);
+            }
+            else if (vColor === WHITE) {
+                parent.set(v, frame.u);
+                stack.push({ u: v, neighbors: (dag.edges.get(v) ?? new Set()).values(), entered: false });
+            }
+        }
+    }
+    for (const id of dag.tasks.keys()) {
+        if (color.get(id) === WHITE) {
+            dfs(id);
+        }
+    }
+    return cycles;
+}
+/**
+ * Performs topological sort using Kahn's algorithm.
+ * Returns levels (arrays of tasks that can execute in parallel).
+ */
+export function topologicalSort(dag) {
+    if (dag.tasks.size === 0)
+        return [];
+    // Compute in-degree for each node
+    const inDegree = new Map();
+    for (const id of dag.tasks.keys()) {
+        inDegree.set(id, (dag.reverseEdges.get(id) ?? new Set()).size);
+    }
+    // Start with nodes that have no dependencies
+    let currentLevel = [];
+    for (const [id, deg] of inDegree) {
+        if (deg === 0) {
+            currentLevel.push(id);
+        }
+    }
+    const levels = [];
+    while (currentLevel.length > 0) {
+        // Resolve current level tasks
+        const levelTasks = currentLevel.map(id => dag.tasks.get(id));
+        levels.push(levelTasks);
+        const nextLevel = [];
+        for (const id of currentLevel) {
+            const dependents = dag.edges.get(id) ?? new Set();
+            for (const dep of dependents) {
+                const newDeg = inDegree.get(dep) - 1;
+                inDegree.set(dep, newDeg);
+                if (newDeg === 0) {
+                    nextLevel.push(dep);
+                }
+            }
+        }
+        currentLevel = nextLevel;
+    }
+    return levels;
+}
+//# sourceMappingURL=dag-builder.js.map

package/packages/@monomind/cli/dist/src/workflow/dag-executor.d.ts

@@ -0,0 +1,9 @@
+import type { DAGTask, TaskResult } from './dag-types.js';
+export type TaskRunner = (task: DAGTask, upstreamContext: TaskResult[]) => Promise<TaskResult>;
+export declare class DAGExecutor {
+    private readonly runner;
+    constructor(runner: TaskRunner);
+    execute(tasks: DAGTask[]): Promise<Map<string, TaskResult>>;
+    private runWithRetry;
+}
+//# sourceMappingURL=dag-executor.d.ts.map