Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

Checkpoint: File edits

rUv4cd43086461d
diff --git a/v3/@claude-flow/cli/src/runtime/headless.ts b/v3/@claude-flow/cli/src/runtime/headless.ts
new file mode 100644
index 0000000000..b4c0a01734
--- /dev/null
+++ b/v3/@claude-flow/cli/src/runtime/headless.ts
@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+/**
+ * Headless Runtime for Background Workers
+ * Runs without TTY for daemon processes and scheduled tasks
+ *
+ * Usage:
+ * npx @claude-flow/cli headless --worker <type>
+ * npx @claude-flow/cli headless --daemon
+ * npx @claude-flow/cli headless --benchmark
+ *
+ * Environment:
+ * CLAUDE_FLOW_HEADLESS=true
+ * CLAUDE_CODE_HEADLESS=true
+ *
+ * @module v3/cli/runtime/headless
+ */
+
+import { HeadlessWorkerExecutor, HEADLESS_WORKER_TYPES, type HeadlessWorkerType } from '../services/headless-worker-executor.js';
+import { WorkerDaemon, 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';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface HeadlessConfig {
+ mode: 'worker' | 'daemon' | 'benchmark' | 'status';
+ workerType?: HeadlessWorkerType;
+ timeout?: number;
+ verbose?: boolean;
+}
+
+interface BenchmarkResults {
+ sona: {
+ avgMs: number;
+ targetMet: boolean;
+ };
+ flashAttention: {
+ throughputPerMs: number;
+ speedup: number;
+ };
+ hnsw: {
+ entriesIndexed: number;
+ searchTime: number;
+ };
+}
+
+// ============================================================================
+// Main Runtime
+// ============================================================================
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(): HeadlessConfig {
+ const args = process.argv.slice(2);
+ const config: HeadlessConfig = {
+ 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] as HeadlessWorkerType;
+ } 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(): void {
+ console.log(`
+Headless Runtime for Claude Flow V3
+
+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:
+ CLAUDE_FLOW_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: HeadlessWorkerType, timeout: number): Promise<void> {
+ console.log(`[Headless] Starting worker: ${workerType}`);
+
+ const executor = new HeadlessWorkerExecutor({
+ maxConcurrent: 1,
+ defaultTimeout: timeout,
+ workingDirectory: process.cwd(),
+ sandboxMode: 'permissive'
+ });
+
+ try {
+ const result = await executor.execute(workerType, {
+ 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 {
+ await executor.shutdown();
+ }
+}
+
+/**
+ * Run daemon mode
+ */
+async function runDaemon(): Promise<void> {
+ console.log('[Headless] Starting daemon mode...');
+
+ // Start the daemon
+ const daemon = await startDaemon();
+
+ 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(): Promise<BenchmarkResults> {
+ console.log('=== Claude Flow V3 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.entriesCount}`);
+ 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.entriesCount,
+ searchTime: flashTime
+ }
+ };
+}
+
+/**
+ * Show system status
+ */
+async function showStatus(): Promise<void> {
+ console.log('=== Claude Flow V3 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.entriesCount}`);
+
+ console.log('\nEnvironment:');
+ console.log(` CLAUDE_FLOW_HEADLESS: ${process.env.CLAUDE_FLOW_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(): Promise<void> {
+ // Set headless environment
+ process.env.CLAUDE_FLOW_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 };
+export type { HeadlessConfig, BenchmarkResults };