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

Copy all source files from alpha-110 to ensure neural/goal commands work

rUv1093ea5709a4
diff --git a/src/cli/command-registry.js b/src/cli/command-registry.js
index b1a69c5fe2..6635a88f5b 100644
--- a/src/cli/command-registry.js
+++ b/src/cli/command-registry.js
@@ -23,6 +23,8 @@ import { hookSafetyCommand } from './simple-commands/hook-safety.js';
import { hiveMindCommand } from './simple-commands/hive-mind.js';
import { HelpFormatter } from './help-formatter.js';
import hiveMindOptimizeCommand from './simple-commands/hive-mind-optimize.js';
+import { neuralCommand } from './simple-commands/neural.js';
+import { goalCommand } from './simple-commands/goal.js';
import {
showUnifiedMetrics,
fixTaskAttribution,
@@ -615,6 +617,44 @@ Target metrics:
β€’ <5% automated rollback frequency`,
});
+ commandRegistry.set('neural', {
+ handler: neuralCommand,
+ description: '🧠 Neural module commands for SAFLA self-learning systems',
+ usage: 'neural <command> [options]',
+ examples: [
+ 'neural init # Initialize neural module',
+ 'neural init --force # Force overwrite existing',
+ 'neural init --target ./agents # Custom location',
+ ],
+ details: `
+Neural Module Features:
+ β€’ Self-Aware Feedback Loop Algorithm (SAFLA)
+ β€’ 4-tier memory system (Vector, Episodic, Semantic, Working)
+ β€’ 172,000+ ops/sec processing with WASM optimization
+ β€’ 60% memory compression while maintaining recall
+ β€’ Cross-session learning and persistence
+ β€’ Distributed neural training with MCP integration`,
+ });
+
+ commandRegistry.set('goal', {
+ handler: goalCommand,
+ description: '🎯 Goal module commands for GOAP intelligent planning',
+ usage: 'goal <command> [options]',
+ examples: [
+ 'goal init # Initialize goal module',
+ 'goal init --force # Force overwrite existing',
+ 'goal init --target ./agents # Custom location',
+ ],
+ details: `
+Goal Module Features:
+ β€’ Goal-Oriented Action Planning (GOAP) algorithm
+ β€’ A* pathfinding for optimal plan generation
+ β€’ OODA loop execution monitoring
+ β€’ Adaptive replanning on failures
+ β€’ Mixed LLM + code execution
+ β€’ Cost-optimized action sequences`,
+ });
+
commandRegistry.set('pair', {
handler: async (args, flags) => {
try {
diff --git a/src/cli/commands/goal-init.ts b/src/cli/commands/goal-init.ts
new file mode 100644
index 0000000000..fcd266d669
--- /dev/null
+++ b/src/cli/commands/goal-init.ts
@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { logger } from '../../monitoring/logger.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface InitOptions {
+ force?: boolean;
+ targetDir?: string;
+}
+
+export class GoalInitCommand {
+ private readonly sourcePath = path.resolve(__dirname, '../../../.claude/agents/goal');
+
+ async execute(options: InitOptions = {}): Promise<void> {
+ const targetDir = options.targetDir || '.claude/agents/goal';
+ const absoluteTarget = path.resolve(process.cwd(), targetDir);
+
+ logger.info(chalk.magenta('🎯 Initializing Claude Flow Goal Module...'));
+
+ try {
+ // Check if target exists
+ const exists = await this.checkExists(absoluteTarget);
+
+ if (exists && !options.force) {
+ logger.warn(chalk.yellow('⚠️ Goal module already exists. Use --force to overwrite.'));
+ const prompt = await this.confirmOverwrite();
+ if (!prompt) {
+ logger.info(chalk.gray('Installation cancelled.'));
+ return;
+ }
+ }
+
+ // Create target directory
+ await fs.mkdir(absoluteTarget, { recursive: true });
+
+ // Copy goal agent files
+ await this.copyGoalFiles(absoluteTarget);
+
+ // Initialize configuration
+ await this.initializeConfig(absoluteTarget);
+
+ // Verify installation
+ const verified = await this.verifyInstallation(absoluteTarget);
+
+ if (verified) {
+ logger.success(chalk.green('βœ… Goal module initialized successfully!'));
+ this.printUsage();
+ } else {
+ throw new Error('Installation verification failed');
+ }
+
+ } catch (error) {
+ logger.error(chalk.red('❌ Failed to initialize goal module:'), error);
+ throw error;
+ }
+ }
+
+ private async checkExists(targetPath: string): Promise<boolean> {
+ try {
+ await fs.access(targetPath);
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ private async confirmOverwrite(): Promise<boolean> {
+ // In a real implementation, this would use inquirer or similar
+ // For now, we'll return false to be safe
+ console.log(chalk.yellow('Would you like to overwrite? (y/N)'));
+ return false;
+ }
+
+ private async copyGoalFiles(targetDir: string): Promise<void> {
+ // Copy goal-planner agent
+ const plannerSource = path.join(this.sourcePath, 'goal-planner.md');
+ const plannerTarget = path.join(targetDir, 'goal-planner.md');
+
+ // Check if source exists in package
+ try {
+ // First try to copy from local installation
+ await fs.copyFile(plannerSource, plannerTarget);
+ logger.info(chalk.gray(' β€’ Copied goal-planner.md'));
+ } catch (error) {
+ // If not found locally, create from embedded template
+ await this.createPlannerTemplate(plannerTarget);
+ logger.info(chalk.gray(' β€’ Created goal-planner.md from template'));
+ }
+
+ // Create additional goal agents if needed
+ await this.createGoalAgents(targetDir);
+ }
+
+ private async createPlannerTemplate(targetPath: string): Promise<void> {
+ const template = `---
+name: goal-planner
+description: "Goal-Oriented Action Planning (GOAP) specialist"
+color: purple
+---
+
+# Goal-Oriented Action Planning Agent
+
+Uses gaming AI techniques to create intelligent plans for achieving complex objectives.
+
+## Core Capabilities
+- Dynamic planning with A* search algorithms
+- Precondition analysis and effect prediction
+- Adaptive replanning based on execution results
+- Mixed execution (LLM + deterministic code)
+- Tool group management
+
+## Planning Methodology
+1. **State Assessment**: Analyze current vs goal state
+2. **Action Analysis**: Inventory available actions
+3. **Plan Generation**: A* pathfinding for optimal sequences
+4. **Execution Monitoring**: OODA loop (Observe-Orient-Decide-Act)
+5. **Dynamic Replanning**: Adapt to changing conditions
+
+## Usage
+\`\`\`bash
+# Initialize goal planning
+npx claude-flow goal plan --objective "deploy application"
+
+# Execute plan
+npx claude-flow goal execute --plan deployment-plan
+\`\`\`
+`;
+ await fs.writeFile(targetPath, template);
+ }
+
+ private async createGoalAgents(targetDir: string): Promise<void> {
+ // Create additional goal-oriented agents
+ const agents = [
+ {
+ name: 'goal-executor.md',
+ content: this.getExecutorTemplate()
+ },
+ {
+ name: 'goal-monitor.md',
+ content: this.getMonitorTemplate()
+ },
+ {
+ name: 'goal-optimizer.md',
+ content: this.getOptimizerTemplate()
+ }
+ ];
+
+ for (const agent of agents) {
+ const targetPath = path.join(targetDir, agent.name);
+ await fs.writeFile(targetPath, agent.content);
+ logger.info(chalk.gray(` β€’ Created ${agent.name}`));
+ }
+ }
+
+ private getExecutorTemplate(): string {
+ return `---
+name: goal-executor
+description: "Executes goal-oriented action plans"
+color: green
+---
+
+# Goal Executor Agent
+
+Responsible for executing action plans generated by the goal-planner.
+
+## Features
+- Sequential and parallel action execution
+- Precondition verification
+- Effect validation
+- Rollback on failure
+`;
+ }
+
+ private getMonitorTemplate(): string {
+ return `---
+name: goal-monitor
+description: "Monitors goal progress and triggers replanning"
+color: yellow
+---
+
+# Goal Monitor Agent
+
+Tracks plan execution and identifies when replanning is needed.
+
+## Features
+- Real-time progress tracking
+- Deviation detection
+- Performance metrics
+- Replanning triggers
+`;
+ }
+
+ private getOptimizerTemplate(): string {
+ return `---
+name: goal-optimizer
+description: "Optimizes action plans for efficiency"
+color: blue
+---
+
+# Goal Optimizer Agent
+
+Optimizes action sequences for cost, time, and resource efficiency.
+
+## Features
+- Cost minimization
+- Parallel execution identification
+- Resource allocation
+- Plan compression
+`;
+ }
+
+ private async initializeConfig(targetDir: string): Promise<void> {
+ const config = {
+ version: '1.0.0',
+ goal: {
+ enabled: true,
+ algorithm: 'astar',
+ maxPlanDepth: 100,
+ replanning: {
+ enabled: true,
+ threshold: 0.3,
+ maxRetries: 3
+ },
+ execution: {
+ mode: 'mixed', // mixed, llm, code
+ parallel: true,
+ monitoring: true
+ }
+ },
+ agents: [
+ 'goal-planner',
+ 'goal-executor',
+ 'goal-monitor',
+ 'goal-optimizer'
+ ]
+ };
+
+ const configPath = path.join(targetDir, 'config.json');
+ await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+ logger.info(chalk.gray(' β€’ Created goal config.json'));
+ }
+
+ private async verifyInstallation(targetDir: string): Promise<boolean> {
+ const requiredFiles = [
+ 'goal-planner.md',
+ 'goal-executor.md',
+ 'goal-monitor.md',
+ 'goal-optimizer.md',
+ 'config.json'
+ ];
+
+ for (const file of requiredFiles) {
+ const filePath = path.join(targetDir, file);
+ const exists = await this.checkExists(filePath);
+ if (!exists) {
+ logger.error(chalk.red(` βœ— Missing required file: ${file}`));
+ return false;
+ }
+ logger.info(chalk.gray(` βœ“ Verified ${file}`));
+ }
+
+ return true;
+ }
+
+ private printUsage(): void {
+ console.log('\n' + chalk.magenta('πŸ“š Usage:'));
+ console.log(chalk.gray(' npx claude-flow goal plan --objective "your goal"'));
+ console.log(chalk.gray(' npx claude-flow goal execute --plan plan-id'));
+ console.log(chalk.gray(' @agent-goal-planner "Create deployment plan"'));
+ console.log('\n' + chalk.magenta('πŸ”— Documentation:'));
+ console.log(chalk.gray(' https://github.com/ruvnet/claude-flow'));
+ }
+}
+
+// CLI execution
+if (import.meta.url === `file://${process.argv[1]}`) {
+ const command = new GoalInitCommand();
+ const options: InitOptions = {};
+
+ if (process.argv.includes('--force')) {
+ options.force = true;
+ }
+
+ const targetIndex = process.argv.indexOf('--target');
+ if (targetIndex !== -1 && process.argv[targetIndex + 1]) {
+ options.targetDir = process.argv[targetIndex + 1];
+ }
+
+ command.execute(options).catch(process.exit);
+}
+
+export default GoalInitCommand;
\ No newline at end of file
diff --git a/src/cli/commands/index.ts b/src/cli/commands/index.ts
index 6a7ab80e81..9c959f6a47 100644
--- a/src/cli/commands/index.ts
+++ b/src/cli/commands/index.ts
@@ -78,10 +78,10 @@ export function setupCommands(cli: CLI): void {
},
],
action: async (ctx: CommandContext) => {
- const { neuralCommand } = await import('../simple-commands/neural.js');
- await neuralCommand(['init'], {
+ const { initNeuralModule } = await import('../../scripts/init-neural.js');
+ await initNeuralModule({
force: ctx.flags.force as boolean,
- target: ctx.flags.target as string,
+ targetDir: ctx.flags.target as string,
});
},
},
@@ -112,10 +112,10 @@ export function setupCommands(cli: CLI): void {
},
],
action: async (ctx: CommandContext) => {
- const { goalCommand } = await import('../simple-commands/goal.js');
- await goalCommand(['init'], {
+ const { initGoalModule } = await import('../../scripts/init-goal.js');
+ await initGoalModule({
force: ctx.flags.force as boolean,
- target: ctx.flags.target as string,
+ targetDir: ctx.flags.target as string,
});
},
},
diff --git a/src/cli/commands/neural-goal-init.js b/src/cli/commands/neural-goal-init.js
new file mode 100644
index 0000000000..0a3faf1e0e
--- /dev/null
+++ b/src/cli/commands/neural-goal-init.js
@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * Neural and Goal module initialization commands
+ * Handles both 'neural init' and 'goal init' commands
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function registerNeuralGoalCommands(program) {
+ // Neural init command
+ program
+ .command('neural')
+ .description('Neural module commands')
+ .command('init')
+ .description('Initialize SAFLA neural module')
+ .option('--force', 'Overwrite existing module')
+ .option('--target <dir>', 'Target directory', '.claude/agents/neural')
+ .action(async (options) => {
+ await initNeuralModule(options);
+ });
+
+ // Goal init command
+ program
+ .command('goal')
+ .description('Goal module commands')
+ .command('init')
+ .description('Initialize GOAP goal module')
+ .option('--force', 'Overwrite existing module')
+ .option('--target <dir>', 'Target directory', '.claude/agents/goal')
+ .action(async (options) => {
+ await initGoalModule(options);
+ });
+}
+
+async function initNeuralModule(options) {
+ const targetDir = path.resolve(process.cwd(), options.target || '.claude/agents/neural');
+
+ console.log(chalk.cyan('🧠 Initializing Claude Flow Neural Module...'));
+
+ try {
+ // Check if exists
+ if (await exists(targetDir) && !options.force) {
+ console.log(chalk.yellow('⚠️ Neural module already exists. Use --force to overwrite.'));
+ return;
+ }
+
+ // Create directory
+ await fs.mkdir(targetDir, { recursive: true });
+
+ // Create SAFLA neural agent
+ const saflaContent = `---
+name: safla-neural
+description: "Self-Aware Feedback Loop Algorithm (SAFLA) neural specialist"
+color: cyan
+---
+
+You are a SAFLA Neural Specialist with:
+- 4-tier memory (Vector, Episodic, Semantic, Working)
+- 172,000+ ops/sec processing
+- 60% memory compression
+- Cross-session learning
+
+## MCP Integration
+\`\`\`javascript
+mcp__claude-flow__neural_train {
+ pattern_type: "coordination",
+ training_data: safla_config
+}
+\`\`\`
+`;
+
+ await fs.writeFile(path.join(targetDir, 'safla-neural.md'), saflaContent);
+ console.log(chalk.gray(' βœ“ Created safla-neural.md'));
+
+ // Create config
+ const config = {
+ version: '1.0.0',
+ neural: {
+ enabled: true,
+ defaultModel: 'safla',
+ wasmOptimization: true,
+ memoryCompression: 0.6
+ }
+ };
+
+ await fs.writeFile(
+ path.join(targetDir, 'config.json'),
+ JSON.stringify(config, null, 2)
+ );
+ console.log(chalk.gray(' βœ“ Created config.json'));
+
+ console.log(chalk.green('βœ… Neural module initialized successfully!'));
+ console.log(chalk.cyan('\nπŸ“š Usage:'));
+ console.log(chalk.gray(' @agent-safla-neural "Create self-improving system"'));
+
+ } catch (error) {
+ console.error(chalk.red('❌ Failed:'), error.message);
+ process.exit(1);
+ }
+}
+
+async function initGoalModule(options) {
+ const targetDir = path.resolve(process.cwd(), options.target || '.claude/agents/goal');
+
+ console.log(chalk.magenta('🎯 Initializing Claude Flow Goal Module...'));
+
+ try {
+ // Check if exists
+ if (await exists(targetDir) && !options.force) {
+ console.log(chalk.yellow('⚠️ Goal module already exists. Use --force to overwrite.'));
+ return;
+ }
+
+ // Create directory
+ await fs.mkdir(targetDir, { recursive: true });
+
+ // Create goal-planner agent
+ const plannerContent = `---
+name: goal-planner
+description: "Goal-Oriented Action Planning (GOAP) specialist"
+color: purple
+---
+
+You are a GOAP specialist with:
+- A* search algorithms
+- OODA loop execution
+- Adaptive replanning
+- Mixed LLM + code execution
+
+## MCP Integration
+\`\`\`javascript
+mcp__claude-flow__task_orchestrate {
+ task: "achieve_goal",
+ strategy: "adaptive"
+}
+\`\`\`
+`;
+
+ await fs.writeFile(path.join(targetDir, 'goal-planner.md'), plannerContent);
+ console.log(chalk.gray(' βœ“ Created goal-planner.md'));
+
+ // Create config
+ const config = {
+ version: '1.0.0',
+ goal: {
+ enabled: true,
+ algorithm: 'astar',
+ maxPlanDepth: 100,
+ replanning: {
+ enabled: true,
+ threshold: 0.3
+ }
+ }
+ };
+
+ await fs.writeFile(
+ path.join(targetDir, 'config.json'),
+ JSON.stringify(config, null, 2)
+ );
+ console.log(chalk.gray(' βœ“ Created config.json'));
+
+ console.log(chalk.green('βœ… Goal module initialized successfully!'));
+ console.log(chalk.magenta('\nπŸ“š Usage:'));
+ console.log(chalk.gray(' @agent-goal-planner "Create deployment plan"'));
+
+ } catch (error) {
+ console.error(chalk.red('❌ Failed:'), error.message);
+ process.exit(1);
+ }
+}
+
+async function exists(path) {
+ try {
+ await fs.access(path);
+ return true;
+ } catch {
+ return false;
+ }
+}
+
+export default { registerNeuralGoalCommands };
\ No newline at end of file
diff --git a/src/cli/commands/neural-init.ts b/src/cli/commands/neural-init.ts
new file mode 100644
index 0000000000..2e932f8203
--- /dev/null
+++ b/src/cli/commands/neural-init.ts
@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { logger } from '../../monitoring/logger.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface InitOptions {
+ force?: boolean;
+ targetDir?: string;
+}
+
+export class NeuralInitCommand {
+ private readonly sourcePath = path.resolve(__dirname, '../../../.claude/agents/neural');
+
+ async execute(options: InitOptions = {}): Promise<void> {
+ const targetDir = options.targetDir || '.claude/agents/neural';
+ const absoluteTarget = path.resolve(process.cwd(), targetDir);
+
+ logger.info(chalk.cyan('🧠 Initializing Claude Flow Neural Module...'));
+
+ try {
+ // Check if target exists
+ const exists = await this.checkExists(absoluteTarget);
+
+ if (exists && !options.force) {
+ logger.warn(chalk.yellow('⚠️ Neural module already exists. Use --force to overwrite.'));
+ const prompt = await this.confirmOverwrite();
+ if (!prompt) {
+ logger.info(chalk.gray('Installation cancelled.'));
+ return;
+ }
+ }
+
+ // Create target directory
+ await fs.mkdir(absoluteTarget, { recursive: true });
+
+ // Copy neural agent files
+ await this.copyNeuralFiles(absoluteTarget);
+
+ // Initialize configuration
+ await this.initializeConfig(absoluteTarget);
+
+ // Verify installation
+ const verified = await this.verifyInstallation(absoluteTarget);
+
+ if (verified) {
+ logger.success(chalk.green('βœ… Neural module initialized successfully!'));
+ this.printUsage();
+ } else {
+ throw new Error('Installation verification failed');
+ }
+
+ } catch (error) {
+ logger.error(chalk.red('❌ Failed to initialize neural module:'), error);
+ throw error;
+ }
+ }
+
+ private async checkExists(targetPath: string): Promise<boolean> {
+ try {
+ await fs.access(targetPath);
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ private async confirmOverwrite(): Promise<boolean> {
+ // In a real implementation, this would use inquirer or similar
+ // For now, we'll return false to be safe
+ console.log(chalk.yellow('Would you like to overwrite? (y/N)'));
+ return false;
+ }
+
+ private async copyNeuralFiles(targetDir: string): Promise<void> {
+ // Copy SAFLA neural agent
+ const saflaSource = path.join(this.sourcePath, 'safla-neural.md');
+ const saflaTarget = path.join(targetDir, 'safla-neural.md');
+
+ // Check if source exists in package
+ try {
+ // First try to copy from local installation
+ await fs.copyFile(saflaSource, saflaTarget);
+ logger.info(chalk.gray(' β€’ Copied safla-neural.md'));
+ } catch (error) {
+ // If not found locally, create from embedded template
+ await this.createSaflaTemplate(saflaTarget);
+ logger.info(chalk.gray(' β€’ Created safla-neural.md from template'));
+ }
+
+ // Create additional neural agents if needed
+ await this.createNeuralAgents(targetDir);
+ }
+
+ private async createSaflaTemplate(targetPath: string): Promise<void> {
+ const template = `---
+name: safla-neural
+description: "Self-Aware Feedback Loop Algorithm (SAFLA) neural specialist"
+color: cyan
+---
+
+# SAFLA Neural Agent
+
+Integrated with Claude Flow neural system for persistent memory and self-learning capabilities.
+
+## Core Features
+- 4-tier memory architecture (Vector, Episodic, Semantic, Working)
+- Feedback loop engineering for continuous improvement
+- 172,000+ operations per second
+- 60% memory compression
+- WASM SIMD optimization
+
+## Usage
+\`\`\`bash
+# Initialize SAFLA neural training
+npx claude-flow neural train --type safla
+
+# Run inference
+npx claude-flow neural predict --model safla
+\`\`\`
+`;
+ await fs.writeFile(targetPath, template);
+ }
+
+ private async createNeuralAgents(targetDir: string): Promise<void> {
+ // Create additional neural agent templates
+ const agents = [
+ {
+ name: 'neural-trainer.md',
+ content: this.getTrainerTemplate()
+ },
+ {
+ name: 'neural-predictor.md',
+ content: this.getPredictorTemplate()
+ }
+ ];
+
+ for (const agent of agents) {
+ const targetPath = path.join(targetDir, agent.name);
+ await fs.writeFile(targetPath, agent.content);
+ logger.info(chalk.gray(` β€’ Created ${agent.name}`));
+ }
+ }
+
+ private getTrainerTemplate(): string {
+ return `---
+name: neural-trainer
+description: "Neural network training specialist"
+color: purple
+---
+
+# Neural Trainer Agent
+
+Manages distributed neural network training with Claude Flow.
+`;
+ }
+
+ private getPredictorTemplate(): string {
+ return `---
+name: neural-predictor
+description: "Neural inference and prediction specialist"
+color: blue
+---
+
+# Neural Predictor Agent
+
+Handles neural network inference and predictions.
+`;
+ }
+
+ private async initializeConfig(targetDir: string): Promise<void> {
+ const config = {
+ version: '1.0.0',
+ neural: {
+ enabled: true,
+ defaultModel: 'safla',
+ wasmOptimization: true,
+ memoryCompression: 0.6,
+ operationsPerSecond: 172000
+ },
+ agents: [
+ 'safla-neural',
+ 'neural-trainer',
+ 'neural-predictor'
+ ]
+ };
+
+ const configPath = path.join(targetDir, 'config.json');
+ await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+ logger.info(chalk.gray(' β€’ Created neural config.json'));
+ }
+
+ private async verifyInstallation(targetDir: string): Promise<boolean> {
+ const requiredFiles = [
+ 'safla-neural.md',
+ 'neural-trainer.md',
+ 'neural-predictor.md',
+ 'config.json'
+ ];
+
+ for (const file of requiredFiles) {
+ const filePath = path.join(targetDir, file);
+ const exists = await this.checkExists(filePath);
+ if (!exists) {
+ logger.error(chalk.red(` βœ— Missing required file: ${file}`));
+ return false;
+ }
+ logger.info(chalk.gray(` βœ“ Verified ${file}`));
+ }
+
+ return true;
+ }
+
+ private printUsage(): void {
+ console.log('\n' + chalk.cyan('πŸ“š Usage:'));
+ console.log(chalk.gray(' npx claude-flow neural train --type safla'));
+ console.log(chalk.gray(' npx claude-flow neural predict --model safla'));
+ console.log(chalk.gray(' @agent-safla-neural "Create self-improving system"'));
+ console.log('\n' + chalk.cyan('πŸ”— Documentation:'));
+ console.log(chalk.gray(' https://github.com/ruvnet/SAFLA'));
+ }
+}
+
+// CLI execution
+if (import.meta.url === `file://${process.argv[1]}`) {
+ const command = new NeuralInitCommand();
+ const options: InitOptions = {};
+
+ if (process.argv.includes('--force')) {
+ options.force = true;
+ }
+
+ const targetIndex = process.argv.indexOf('--target');
+ if (targetIndex !== -1 && process.argv[targetIndex + 1]) {
+ options.targetDir = process.argv[targetIndex + 1];
+ }
+
+ command.execute(options).catch(process.exit);
+}
+
+export default NeuralInitCommand;
\ No newline at end of file
diff --git a/src/cli/help-text.js b/src/cli/help-text.js
index 714e8a28f7..627b2db896 100644
--- a/src/cli/help-text.js
+++ b/src/cli/help-text.js
@@ -11,17 +11,17 @@ export { VERSION };
export const MAIN_HELP = `
🌊 Claude-Flow v${VERSION} - Enterprise-Grade AI Agent Orchestration Platform
-🎯 ENTERPRISE FEATURES: Complete ruv-swarm integration with 90+ MCP tools, neural networking, and production-ready infrastructure
-🐝 NEW: Claude Code 1.0.51+ full compatibility with enhanced hooks and batch processing
-⚑ ALPHA 90: Major MCP Implementation & Quality Update
-
-πŸ” ALPHA 90 HIGHLIGHTS:
- βœ… 15+ Real MCP Tools - DAA, Workflow, Performance tools fully implemented
- πŸ› Critical Bug Fixes - agent_metrics, swarm_monitor, neural_train errors resolved
- 🧠 Real WASM Neural Networks - ruv-fann powered actual neural processing
- πŸ“Š >95% Functionality - Mock rate reduced from 40% to <5%
- πŸ”§ MCP Routing Fixed - All workflow/performance tools properly routed
- πŸ”§ Non-interactive Fixes - Proper prompt injection for CI/CD & automation
+🎯 ENTERPRISE FEATURES: Complete ruv-swarm integration with 100+ MCP tools, Flow Nexus cloud platform, and production-ready infrastructure
+🐝 NEW: Claude Code 1.0.51+ full compatibility with enhanced hooks and cross-platform support
+⚑ ALPHA 107: Flow Nexus Integration & Enhanced Cloud Features
+
+πŸ” ALPHA 107 HIGHLIGHTS:
+ βœ… Flow Nexus Cloud Platform - Full integration with sandboxes, neural networks, and workflows
+ πŸ› macOS Compatibility Fixes - Enhanced settings.json hooks for cross-platform support
+ 🧠 Distributed Neural Networks - Real multi-node training with E2B sandbox clusters
+ πŸ“Š 100% Real Functionality - All MCP tools fully implemented with real backends
+ πŸ”§ Enhanced GitHub Integration - Automated releases, checkpoints, and workflow orchestration
+ πŸ”§ Production-Ready Infrastructure - Enterprise-grade reliability and performance
USAGE:
npx claude-flow@alpha <command> [options] # Run latest alpha version
@@ -36,7 +36,12 @@ USAGE:
# First time setup (creates CLAUDE.md & .claude/commands)
npx claude-flow@alpha init
- # 🐝 HIVE MIND QUICK START (NEW!):
+ # 🌐 FLOW NEXUS CLOUD (NEW!):
+ mcp__flow-nexus__user_register # Register for cloud features
+ mcp__flow-nexus__user_login # Login to access sandboxes & neural networks
+ mcp__flow-nexus__sandbox_create # Create cloud execution environments
+
+ # 🐝 HIVE MIND QUICK START:
claude-flow hive-mind wizard # Interactive setup wizard
claude-flow hive-mind spawn "objective" # Create intelligent swarm
claude-flow hive-mind spawn "Build API" --claude # Open Claude Code CLI