monomind 1.11.12 → 1.11.13

package/packages/@monomind/cli/dist/src/runtime/headless.js

@@ -1,284 +0,0 @@
-#!/usr/bin/env node
-/**
- * Headless Runtime for Background Workers
- * Runs without TTY for daemon processes and scheduled tasks
- *
- * Usage:
- *   npx @monomind/cli headless --worker <type>
- *   npx @monomind/cli headless --daemon
- *   npx @monomind/cli headless --benchmark
- *
- * Environment:
- *   MONOMIND_HEADLESS=true
- *   CLAUDE_CODE_HEADLESS=true
- *
- * @module v1/cli/runtime/headless
- */
-import { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES } from '../services/headless-worker-executor.js';
-import { getDaemon, startDaemon, stopDaemon } from '../services/worker-daemon.js';
-import { initializeIntelligence, benchmarkAdaptation, getIntelligenceStats } from '../memory/intelligence.js';
-import { getHNSWStatus, batchCosineSim, flashAttentionSearch } from '../memory/memory-initializer.js';
-// ============================================================================
-// Main Runtime
-// ============================================================================
-/**
- * Parse command line arguments
- */
-function parseArgs() {
-    const args = process.argv.slice(2);
-    const config = {
-        mode: 'status',
-        verbose: false
-    };
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--worker' || arg === '-w') {
-            config.mode = 'worker';
-            config.workerType = args[++i];
-        }
-        else if (arg === '--daemon' || arg === '-d') {
-            config.mode = 'daemon';
-        }
-        else if (arg === '--benchmark' || arg === '-b') {
-            config.mode = 'benchmark';
-        }
-        else if (arg === '--status' || arg === '-s') {
-            config.mode = 'status';
-        }
-        else if (arg === '--timeout' || arg === '-t') {
-            config.timeout = parseInt(args[++i], 10) || 60000;
-        }
-        else if (arg === '--verbose' || arg === '-v') {
-            config.verbose = true;
-        }
-        else if (arg === '--help' || arg === '-h') {
-            showHelp();
-            process.exit(0);
-        }
-    }
-    return config;
-}
-/**
- * Show help message
- */
-function showHelp() {
-    console.log(`
-Headless Runtime for Monomind
-
-Usage:
-  headless --worker <type>    Run a specific worker
-  headless --daemon           Start background daemon
-  headless --benchmark        Run performance benchmarks
-  headless --status           Show system status
-
-Workers: ${HEADLESS_WORKER_TYPES.join(', ')}
-
-Options:
-  -w, --worker <type>   Worker type to run
-  -d, --daemon          Run as daemon
-  -b, --benchmark       Run benchmarks
-  -s, --status          Show status
-  -t, --timeout <ms>    Execution timeout (default: 60000)
-  -v, --verbose         Verbose output
-  -h, --help            Show help
-
-Environment:
-  MONOMIND_HEADLESS=true   Enable headless mode
-  CLAUDE_CODE_HEADLESS=true   Enable Claude Code headless
-
-Examples:
-  headless --worker audit --timeout 120000
-  headless --daemon
-  headless --benchmark
-`);
-}
-/**
- * Run a specific worker
- */
-async function runWorker(workerType, timeout) {
-    console.log(`[Headless] Starting worker: ${workerType}`);
-    const executor = new HeadlessWorkerExecutor(process.cwd(), {
-        maxConcurrent: 1,
-        defaultTimeoutMs: timeout
-    });
-    try {
-        const result = await executor.execute(workerType, {
-            timeoutMs: timeout,
-            model: 'sonnet',
-            sandbox: 'permissive'
-        });
-        if (result.success) {
-            console.log(`[Headless] Worker ${workerType} completed successfully`);
-            console.log(`[Headless] Duration: ${result.durationMs}ms`);
-            if (result.output) {
-                console.log(`[Headless] Output: ${JSON.stringify(result.output).slice(0, 500)}...`);
-            }
-        }
-        else {
-            console.error(`[Headless] Worker ${workerType} failed: ${result.error}`);
-            process.exit(1);
-        }
-    }
-    finally {
-        // executor doesn't have shutdown, just let it be garbage collected
-    }
-}
-/**
- * Run daemon mode
- */
-async function runDaemon() {
-    console.log('[Headless] Starting daemon mode...');
-    // Start the daemon
-    const daemon = await startDaemon(process.cwd());
-    console.log('[Headless] Daemon started');
-    console.log('[Headless] Press Ctrl+C to stop');
-    // Handle shutdown
-    process.on('SIGINT', async () => {
-        console.log('\n[Headless] Shutting down daemon...');
-        await stopDaemon();
-        process.exit(0);
-    });
-    process.on('SIGTERM', async () => {
-        console.log('\n[Headless] Received SIGTERM, shutting down...');
-        await stopDaemon();
-        process.exit(0);
-    });
-    // Keep process running
-    await new Promise(() => { });
-}
-/**
- * Run benchmarks
- */
-async function runBenchmarks() {
-    console.log('=== Monomind Performance Benchmarks ===\n');
-    // Initialize intelligence
-    await initializeIntelligence();
-    // SONA Benchmark
-    console.log('1. SONA Adaptation Benchmark (10,000 iterations)...');
-    const sonaResult = benchmarkAdaptation(10000);
-    console.log(`   Average: ${sonaResult.avgMs.toFixed(4)}ms`);
-    console.log(`   Target (<0.05ms): ${sonaResult.targetMet ? '✅ ACHIEVED' : '❌ NOT MET'}`);
-    // Flash Attention Benchmark
-    console.log('\n2. Flash Attention Search Benchmark...');
-    const dim = 384;
-    const count = 10000;
-    const query = new Float32Array(dim).map(() => Math.random() - 0.5);
-    const vectors = Array.from({ length: count }, () => new Float32Array(dim).map(() => Math.random() - 0.5));
-    // Warmup
-    flashAttentionSearch(query, vectors, { k: 10 });
-    const flashStart = performance.now();
-    for (let i = 0; i < 10; i++) {
-        flashAttentionSearch(query, vectors, { k: 10 });
-    }
-    const flashTime = (performance.now() - flashStart) / 10;
-    const throughput = count / flashTime;
-    // Brute force comparison
-    const bruteStart = performance.now();
-    for (let i = 0; i < 10; i++) {
-        const scores = batchCosineSim(query, vectors);
-        Array.from({ length: count }, (_, i) => i)
-            .sort((a, b) => scores[b] - scores[a])
-            .slice(0, 10);
-    }
-    const bruteTime = (performance.now() - bruteStart) / 10;
-    const speedup = bruteTime / flashTime;
-    console.log(`   Throughput: ${throughput.toFixed(0)} vectors/ms`);
-    console.log(`   Time for 10k vectors: ${flashTime.toFixed(2)}ms`);
-    console.log(`   Speedup vs brute force: ${speedup.toFixed(2)}x`);
-    // HNSW Status
-    console.log('\n3. HNSW Index Status...');
-    const hnswStatus = getHNSWStatus();
-    console.log(`   Entries indexed: ${hnswStatus.entryCount}`);
-    console.log(`   Initialized: ${hnswStatus.initialized}`);
-    // Intelligence Stats
-    console.log('\n4. Intelligence System Stats...');
-    const stats = getIntelligenceStats();
-    console.log(`   SONA enabled: ${stats.sonaEnabled}`);
-    console.log(`   Patterns learned: ${stats.patternsLearned}`);
-    console.log(`   Avg adaptation time: ${stats.avgAdaptationTime.toFixed(4)}ms`);
-    console.log('\n=== Benchmark Complete ===');
-    return {
-        sona: {
-            avgMs: sonaResult.avgMs,
-            targetMet: sonaResult.targetMet
-        },
-        flashAttention: {
-            throughputPerMs: throughput,
-            speedup
-        },
-        hnsw: {
-            entriesIndexed: hnswStatus.entryCount,
-            searchTime: flashTime
-        }
-    };
-}
-/**
- * Show system status
- */
-async function showStatus() {
-    console.log('=== Monomind System Status ===\n');
-    // Check daemon
-    const daemon = getDaemon();
-    console.log('Daemon:');
-    if (daemon) {
-        const status = daemon.getStatus();
-        console.log(`  Running: ${status.running}`);
-        console.log(`  PID: ${status.pid}`);
-        console.log(`  Workers: ${status.workers.size}`);
-    }
-    else {
-        console.log('  Not initialized');
-    }
-    // Intelligence
-    const stats = getIntelligenceStats();
-    console.log('\nIntelligence:');
-    console.log(`  SONA enabled: ${stats.sonaEnabled}`);
-    console.log(`  ReasoningBank size: ${stats.reasoningBankSize}`);
-    console.log(`  Patterns learned: ${stats.patternsLearned}`);
-    // HNSW
-    const hnsw = getHNSWStatus();
-    console.log('\nHNSW Index:');
-    console.log(`  Initialized: ${hnsw.initialized}`);
-    console.log(`  Entries: ${hnsw.entryCount}`);
-    console.log('\nEnvironment:');
-    console.log(`  MONOMIND_HEADLESS: ${process.env.MONOMIND_HEADLESS || 'not set'}`);
-    console.log(`  CLAUDE_CODE_HEADLESS: ${process.env.CLAUDE_CODE_HEADLESS || 'not set'}`);
-    console.log(`  NODE_ENV: ${process.env.NODE_ENV || 'development'}`);
-}
-/**
- * Main entry point
- */
-async function main() {
-    // Set headless environment
-    process.env.MONOMIND_HEADLESS = 'true';
-    const config = parseArgs();
-    try {
-        switch (config.mode) {
-            case 'worker':
-                if (!config.workerType || !HEADLESS_WORKER_TYPES.includes(config.workerType)) {
-                    console.error(`Invalid worker type. Available: ${HEADLESS_WORKER_TYPES.join(', ')}`);
-                    process.exit(1);
-                }
-                await runWorker(config.workerType, config.timeout || 60000);
-                break;
-            case 'daemon':
-                await runDaemon();
-                break;
-            case 'benchmark':
-                await runBenchmarks();
-                break;
-            case 'status':
-            default:
-                await showStatus();
-                break;
-        }
-    }
-    catch (error) {
-        console.error('[Headless] Error:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-}
-// Run if executed directly
-main().catch(console.error);
-export { main, runWorker, runDaemon, runBenchmarks, showStatus };
-//# sourceMappingURL=headless.js.map

package/packages/@monomind/cli/dist/src/services/agentic-flow-bridge.d.ts

@@ -1,50 +0,0 @@
-/**
- * agentic-flow v1 integration bridge
- *
- * Provides a single lazy-loading entry point for all agentic-flow v1
- * subpath exports. Every accessor returns `null` when agentic-flow is
- * not installed — callers never throw on missing optional dependency.
- *
- * @module agentic-flow-bridge
- */
-/**
- * Load the ReasoningBank module (4-step learning pipeline).
- * Returns null if agentic-flow is not installed.
- * Race-safe: concurrent callers share the same import Promise.
- */
-export declare function getReasoningBank(): Promise<typeof import("agentic-flow/reasoningbank") | null>;
-/**
- * Load the ModelRouter module (multi-provider LLM routing).
- * Returns null if agentic-flow is not installed.
- */
-export declare function getRouter(): Promise<typeof import("agentic-flow/router") | null>;
-/**
- * Load the Orchestration module (workflow engine).
- * Returns null if agentic-flow is not installed.
- */
-export declare function getOrchestration(): Promise<typeof import("agentic-flow/orchestration") | null>;
-/**
- * Compute an embedding vector via ReasoningBank, falling back to null.
- */
-export declare function computeEmbedding(text: string): Promise<number[] | null>;
-/**
- * Retrieve memories matching a query via ReasoningBank.
- */
-export declare function retrieveMemories(query: string, opts?: {
-    k?: number;
-}): Promise<any[]>;
-/**
- * Check whether agentic-flow v1 is available at runtime.
- */
-export declare function isAvailable(): Promise<boolean>;
-/**
- * Return a summary of available agentic-flow v1 capabilities.
- */
-export declare function capabilities(): Promise<{
-    available: boolean;
-    reasoningBank: boolean;
-    router: boolean;
-    orchestration: boolean;
-    version: string | null;
-}>;
-//# sourceMappingURL=agentic-flow-bridge.d.ts.map

package/packages/@monomind/cli/dist/src/services/agentic-flow-bridge.js

@@ -1,95 +0,0 @@
-/**
- * agentic-flow v1 integration bridge
- *
- * Provides a single lazy-loading entry point for all agentic-flow v1
- * subpath exports. Every accessor returns `null` when agentic-flow is
- * not installed — callers never throw on missing optional dependency.
- *
- * @module agentic-flow-bridge
- */
-// ---------------------------------------------------------------------------
-// Cached module handles (Promise-based to prevent TOCTOU races)
-// ---------------------------------------------------------------------------
-let _reasoningBankP = null;
-let _routerP = null;
-let _orchestrationP = null;
-// ---------------------------------------------------------------------------
-// Public loaders
-// ---------------------------------------------------------------------------
-/**
- * Load the ReasoningBank module (4-step learning pipeline).
- * Returns null if agentic-flow is not installed.
- * Race-safe: concurrent callers share the same import Promise.
- */
-export function getReasoningBank() {
-    if (_reasoningBankP === null) {
-        _reasoningBankP = import('agentic-flow/reasoningbank').catch(() => null);
-    }
-    return _reasoningBankP;
-}
-/**
- * Load the ModelRouter module (multi-provider LLM routing).
- * Returns null if agentic-flow is not installed.
- */
-export function getRouter() {
-    if (_routerP === null) {
-        _routerP = import('agentic-flow/router').catch(() => null);
-    }
-    return _routerP;
-}
-/**
- * Load the Orchestration module (workflow engine).
- * Returns null if agentic-flow is not installed.
- */
-export function getOrchestration() {
-    if (_orchestrationP === null) {
-        _orchestrationP = import('agentic-flow/orchestration').catch(() => null);
-    }
-    return _orchestrationP;
-}
-// ---------------------------------------------------------------------------
-// Convenience helpers
-// ---------------------------------------------------------------------------
-/**
- * Compute an embedding vector via ReasoningBank, falling back to null.
- */
-export async function computeEmbedding(text) {
-    const rb = await getReasoningBank();
-    if (!rb?.computeEmbedding)
-        return null;
-    return rb.computeEmbedding(text);
-}
-/**
- * Retrieve memories matching a query via ReasoningBank.
- */
-export async function retrieveMemories(query, opts) {
-    const rb = await getReasoningBank();
-    if (!rb?.retrieveMemories)
-        return [];
-    return rb.retrieveMemories(query, opts);
-}
-/**
- * Check whether agentic-flow v1 is available at runtime.
- */
-export async function isAvailable() {
-    const rb = await getReasoningBank();
-    return rb !== null;
-}
-/**
- * Return a summary of available agentic-flow v1 capabilities.
- */
-export async function capabilities() {
-    const [rb, router, orch] = await Promise.all([
-        getReasoningBank(),
-        getRouter(),
-        getOrchestration(),
-    ]);
-    return {
-        available: rb !== null || router !== null || orch !== null,
-        reasoningBank: rb !== null,
-        router: router !== null,
-        orchestration: orch !== null,
-        version: rb?.VERSION ?? null,
-    };
-}
-//# sourceMappingURL=agentic-flow-bridge.js.map

package/packages/@monomind/cli/dist/src/services/container-worker-pool.d.ts

@@ -1,197 +0,0 @@
-/**
- * Container Worker Pool
- * Docker-based worker pool for high-throughput headless execution.
- *
- * ADR-020: Headless Worker Integration Architecture - Phase 3
- * - Manages pool of Docker containers for isolated worker execution
- * - Supports dynamic scaling based on workload
- * - Provides container lifecycle management
- * - Integrates with WorkerQueue for task distribution
- *
- * Key Features:
- * - Container pooling with configurable size
- * - Health checking and auto-recovery
- * - Resource limits (CPU, memory)
- * - Volume mounting for workspace access
- * - Network isolation per worker type
- */
-import { EventEmitter } from 'events';
-import type { HeadlessWorkerType, HeadlessExecutionResult, SandboxMode } from './headless-worker-executor.js';
-/**
- * Container state
- */
-export type ContainerState = 'creating' | 'ready' | 'busy' | 'unhealthy' | 'terminated';
-/**
- * Container info
- */
-export interface ContainerInfo {
-    id: string;
-    name: string;
-    state: ContainerState;
-    createdAt: Date;
-    lastUsedAt?: Date;
-    workerType?: HeadlessWorkerType;
-    executionCount: number;
-    healthCheckFailures: number;
-    pid?: number;
-}
-/**
- * Container pool configuration
- */
-export interface ContainerPoolConfig {
-    /** Maximum number of containers in the pool */
-    maxContainers: number;
-    /** Minimum number of containers to keep warm */
-    minContainers: number;
-    /** Docker image to use */
-    image: string;
-    /** Container resource limits */
-    resources: {
-        cpus: string;
-        memory: string;
-    };
-    /** Health check interval in ms */
-    healthCheckIntervalMs: number;
-    /** Container idle timeout in ms */
-    idleTimeoutMs: number;
-    /** Workspace volume mount path */
-    workspacePath: string;
-    /** State persistence path */
-    statePath: string;
-    /** Network name for container isolation */
-    network?: string;
-    /** Environment variables for containers */
-    env?: Record<string, string>;
-    /** Default sandbox mode */
-    defaultSandbox: SandboxMode;
-}
-/**
- * Container execution options
- */
-export interface ContainerExecutionOptions {
-    workerType: HeadlessWorkerType;
-    prompt: string;
-    contextPatterns?: string[];
-    sandbox?: SandboxMode;
-    model?: string;
-    timeoutMs?: number;
-}
-/**
- * Pool status
- */
-export interface ContainerPoolStatus {
-    totalContainers: number;
-    readyContainers: number;
-    busyContainers: number;
-    unhealthyContainers: number;
-    queuedTasks: number;
-    containers: ContainerInfo[];
-    dockerAvailable: boolean;
-    lastHealthCheck?: Date;
-}
-/**
- * ContainerWorkerPool - Manages Docker containers for headless worker execution
- */
-export declare class ContainerWorkerPool extends EventEmitter {
-    private config;
-    private projectRoot;
-    private containers;
-    private taskQueue;
-    private healthCheckTimer?;
-    private idleCheckTimer?;
-    private dockerAvailable;
-    private initialized;
-    private isShuttingDown;
-    private exitHandlersRegistered;
-    constructor(projectRoot: string, config?: Partial<ContainerPoolConfig>);
-    /**
-     * Initialize the container pool
-     */
-    initialize(): Promise<boolean>;
-    /**
-     * Register process exit handlers to clean up containers
-     */
-    private registerExitHandlers;
-    /**
-     * Execute a worker in a container
-     */
-    execute(options: ContainerExecutionOptions): Promise<HeadlessExecutionResult>;
-    /**
-     * Scale pool for batch execution
-     */
-    scaleForBatch(workerCount: number): Promise<void>;
-    /**
-     * Get pool status
-     */
-    getStatus(): ContainerPoolStatus;
-    /**
-     * Shutdown the pool
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Check if Docker is available (async)
-     */
-    private checkDockerAvailable;
-    /**
-     * Ensure the container image exists (async)
-     */
-    private ensureImage;
-    /**
-     * Create a new container
-     */
-    private createContainer;
-    /**
-     * Terminate a container (async)
-     */
-    private terminateContainer;
-    /**
-     * Get a ready container
-     */
-    private getReadyContainer;
-    /**
-     * Scale to minimum containers
-     */
-    private scaleToMinimum;
-    /**
-     * Execute worker in a specific container
-     */
-    private executeInContainer;
-    /**
-     * Execute command in container
-     */
-    private execInContainer;
-    /**
-     * Build worker command for container execution
-     */
-    private buildWorkerCommand;
-    /**
-     * Process queued tasks
-     */
-    private processQueue;
-    /**
-     * Start health check timer
-     */
-    private startHealthChecks;
-    /**
-     * Run health checks on all containers
-     */
-    private runHealthChecks;
-    /**
-     * Start idle check timer
-     */
-    private startIdleChecks;
-    /**
-     * Terminate idle containers above minimum
-     */
-    private runIdleChecks;
-    /**
-     * Try to parse JSON from output
-     */
-    private tryParseJson;
-    /**
-     * Create an error result
-     */
-    private createErrorResult;
-}
-export default ContainerWorkerPool;
-//# sourceMappingURL=container-worker-pool.d.ts.map