claude-flow-novice 1.3.0 → 1.3.2

package/src/cli/simple-commands/task.js

@@ -0,0 +1,228 @@
+// task.js - Task management commands with improved argument parsing
+import { printSuccess, printError, printWarning } from '../utils.js';
+import { Command } from 'commander';
+
+export async function taskCommand(subArgs, flags) {
+  const taskCmd = subArgs[0];
+
+  switch (taskCmd) {
+    case 'create':
+      await createTask(subArgs, flags);
+      break;
+
+    case 'list':
+      await listTasks(subArgs, flags);
+      break;
+
+    case 'status':
+      await showTaskStatus(subArgs, flags);
+      break;
+
+    case 'cancel':
+      await cancelTask(subArgs, flags);
+      break;
+
+    case 'workflow':
+      await executeWorkflow(subArgs, flags);
+      break;
+
+    case 'coordination':
+      await manageCoordination(subArgs, flags);
+      break;
+
+    default:
+      showTaskHelp();
+  }
+}
+
+async function createTask(subArgs, flags) {
+  // Use commander for robust argument parsing
+  const program = new Command()
+    .exitOverride()
+    .allowUnknownOption()
+    .option('--priority <value>', 'Set task priority (1-10)', '5');
+
+  try {
+    // Parse the arguments starting from the create command
+    program.parse(subArgs, { from: 'user' });
+  } catch (err) {
+    // Continue even if commander throws
+  }
+
+  const opts = program.opts();
+  const args = program.args;
+
+  // Extract task type and description with proper quote handling
+  const taskType = args[1]; // First arg after 'create'
+
+  // Join remaining args for description, handling quoted strings properly
+  let description = '';
+  if (args.length > 2) {
+    // If the description starts with a quote, find the matching end quote
+    const descriptionArgs = args.slice(2);
+    description = parseQuotedDescription(descriptionArgs);
+  }
+
+  if (!taskType || !description) {
+    printError('Usage: task create <type> "<description>"');
+    console.log('Types: research, code, analysis, coordination, general');
+    return;
+  }
+
+  const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  const priority = opts.priority || '5';
+
+  printSuccess(`Creating ${taskType} task: ${taskId}`);
+  console.log(`📋 Description: ${description}`);
+  console.log(`⚡ Priority: ${priority}/10`);
+  console.log(`🏷️  Type: ${taskType}`);
+  console.log('📅 Status: Queued');
+  console.log('\n📋 Note: Task queued for execution when orchestrator starts');
+}
+
+function parseQuotedDescription(args) {
+  const fullString = args.join(' ');
+
+  // Check if it starts with a quote
+  if (fullString.startsWith('"') || fullString.startsWith("'")) {
+    const quoteChar = fullString[0];
+    const endIndex = fullString.lastIndexOf(quoteChar);
+
+    if (endIndex > 0) {
+      // Extract the quoted content
+      return fullString.substring(1, endIndex);
+    }
+  }
+
+  // If not quoted or improperly quoted, return the full string
+  return fullString;
+}
+
+async function listTasks(subArgs, flags) {
+  const program = new Command()
+    .exitOverride()
+    .allowUnknownOption()
+    .option('--filter <status>', 'Filter by task status')
+    .option('--verbose', 'Show detailed output')
+    .option('-v', 'Show detailed output');
+
+  try {
+    program.parse(subArgs, { from: 'user' });
+  } catch (err) {
+    // Continue
+  }
+
+  const opts = program.opts();
+  const filter = opts.filter;
+  const verbose = opts.verbose || opts.v;
+
+  printSuccess('Task queue:');
+
+  if (filter) {
+    console.log(`📊 Filtered by status: ${filter}`);
+  }
+
+  console.log('📋 No active tasks (orchestrator not running)');
+  console.log('\nTask statuses: queued, running, completed, failed, cancelled');
+
+  if (verbose) {
+    console.log('\nTo create tasks:');
+    console.log('  claude-flow task create research "Market analysis"');
+    console.log('  claude-flow task create code "Implement API"');
+    console.log('  claude-flow task create analysis "Data processing"');
+  }
+}
+
+async function showTaskStatus(subArgs, flags) {
+  const taskId = subArgs[1];
+
+  if (!taskId) {
+    printError('Usage: task status <task-id>');
+    return;
+  }
+
+  printSuccess(`Task status: ${taskId}`);
+  console.log('📊 Task details would include:');
+  console.log('   Status, progress, assigned agent, execution time, results');
+}
+
+async function cancelTask(subArgs, flags) {
+  const taskId = subArgs[1];
+
+  if (!taskId) {
+    printError('Usage: task cancel <task-id>');
+    return;
+  }
+
+  printSuccess(`Cancelling task: ${taskId}`);
+  console.log('🛑 Task would be gracefully cancelled');
+}
+
+async function executeWorkflow(subArgs, flags) {
+  const workflowFile = subArgs[1];
+
+  if (!workflowFile) {
+    printError('Usage: task workflow <workflow-file>');
+    return;
+  }
+
+  printSuccess(`Executing workflow: ${workflowFile}`);
+  console.log('🔄 Workflow execution would include:');
+  console.log('   - Parsing workflow definition');
+  console.log('   - Creating dependent tasks');
+  console.log('   - Orchestrating execution');
+  console.log('   - Progress tracking');
+}
+
+async function manageCoordination(subArgs, flags) {
+  const coordCmd = subArgs[1];
+
+  switch (coordCmd) {
+    case 'status':
+      printSuccess('Task coordination status:');
+      console.log('🎯 Coordination engine: Not running');
+      console.log('   Active coordinators: 0');
+      console.log('   Pending tasks: 0');
+      console.log('   Resource utilization: 0%');
+      break;
+
+    case 'optimize':
+      printSuccess('Optimizing task coordination...');
+      console.log('⚡ Optimization would include:');
+      console.log('   - Task dependency analysis');
+      console.log('   - Resource allocation optimization');
+      console.log('   - Parallel execution planning');
+      break;
+
+    default:
+      console.log('Coordination commands: status, optimize');
+  }
+}
+
+function showTaskHelp() {
+  console.log('Task commands:');
+  console.log('  create <type> "<description>"    Create new task');
+  console.log('  list [--filter <status>]        List tasks');
+  console.log('  status <id>                      Show task details');
+  console.log('  cancel <id>                      Cancel running task');
+  console.log('  workflow <file>                  Execute workflow file');
+  console.log('  coordination <status|optimize>   Manage coordination');
+  console.log();
+  console.log('Task Types:');
+  console.log('  research      Information gathering and analysis');
+  console.log('  code          Software development tasks');
+  console.log('  analysis      Data processing and insights');
+  console.log('  coordination  Task orchestration and management');
+  console.log('  general       General purpose tasks');
+  console.log();
+  console.log('Options:');
+  console.log('  --priority <1-10>                Set task priority');
+  console.log('  --filter <status>                Filter by status');
+  console.log('  --verbose, -v                    Show detailed output');
+  console.log();
+  console.log('Examples:');
+  console.log('  claude-flow task create research "Market analysis" --priority 8');
+  console.log('  claude-flow task list --filter running');
+  console.log('  claude-flow task workflow examples/development-workflow.json');
+  console.log('  claude-flow task coordination status');
+}

package/src/cli/simple-commands/templates/mle-star-workflow.json

@@ -0,0 +1,294 @@
+{
+  "name": "MLE-STAR Machine Learning Engineering Workflow",
+  "version": "1.0.0",
+  "description": "Complete Machine Learning Engineering workflow using MLE-STAR methodology (Search and Targeted Refinement)",
+  "variables": {
+    "dataset_path": "data/ml_dataset.csv",
+    "target_metric": "accuracy",
+    "model_output_dir": "models/",
+    "experiment_name": "mle-star-experiment",
+    "search_iterations": 3,
+    "refinement_iterations": 5
+  },
+  "agents": [
+    {
+      "id": "search_agent",
+      "type": "researcher",
+      "name": "Web Search & Foundation Agent",
+      "config": {
+        "capabilities": ["web_search", "model_research", "approach_validation"],
+        "search_depth": "comprehensive",
+        "domains": ["machine_learning", "data_science", "kaggle_solutions"]
+      }
+    },
+    {
+      "id": "foundation_agent",
+      "type": "coder",
+      "name": "Foundation Model Builder",
+      "config": {
+        "capabilities": ["data_preprocessing", "initial_modeling", "baseline_creation"],
+        "programming_languages": ["python", "jupyter"],
+        "frameworks": ["scikit-learn", "pandas", "numpy", "matplotlib"]
+      }
+    },
+    {
+      "id": "refinement_agent",
+      "type": "optimizer",
+      "name": "Targeted Refinement Specialist",
+      "config": {
+        "capabilities": ["feature_engineering", "model_optimization", "hyperparameter_tuning"],
+        "optimization_methods": ["grid_search", "bayesian", "evolutionary"],
+        "ablation_analysis": true
+      }
+    },
+    {
+      "id": "ensemble_agent",
+      "type": "architect",
+      "name": "Ensemble & Meta-Learning Expert",
+      "config": {
+        "capabilities": ["model_stacking", "ensemble_methods", "meta_learning"],
+        "ensemble_strategies": ["voting", "stacking", "blending", "dynamic_weighting"]
+      }
+    },
+    {
+      "id": "validation_agent",
+      "type": "tester",
+      "name": "Validation & Debugging Agent",
+      "config": {
+        "capabilities": ["cross_validation", "error_detection", "data_leakage_prevention"],
+        "validation_strategies": ["stratified_kfold", "time_series_split", "leave_one_out"],
+        "debugging_tools": ["profiling", "error_correction", "data_integrity_checks"]
+      }
+    },
+    {
+      "id": "orchestrator",
+      "type": "coordinator",
+      "name": "MLE-STAR Orchestrator",
+      "config": {
+        "capabilities": ["workflow_coordination", "performance_tracking", "resource_management"],
+        "coordination_mode": "adaptive",
+        "monitoring_enabled": true
+      }
+    }
+  ],
+  "tasks": [
+    {
+      "id": "web_search_phase",
+      "name": "Web Search for ML Approaches",
+      "type": "research",
+      "description": "Search web for state-of-the-art ML approaches, model architectures, and proven solutions for the given problem domain",
+      "assignTo": "search_agent",
+      "input": {
+        "problem_type": "${dataset_analysis.problem_type}",
+        "data_characteristics": "${dataset_analysis.characteristics}",
+        "search_queries": [
+          "latest machine learning models ${problem_type}",
+          "kaggle winning solutions ${problem_type}",
+          "state-of-the-art ${problem_type} benchmarks",
+          "feature engineering techniques ${problem_type}"
+        ]
+      },
+      "timeout": 900,
+      "retries": 2,
+      "output": {
+        "recommended_approaches": "array",
+        "model_cards": "array",
+        "benchmark_results": "object",
+        "implementation_examples": "array"
+      }
+    },
+    {
+      "id": "dataset_analysis",
+      "name": "Dataset Analysis & Profiling",
+      "type": "analysis",
+      "description": "Comprehensive analysis of dataset characteristics, quality, and problem type identification",
+      "assignTo": "foundation_agent",
+      "input": {
+        "dataset_path": "${dataset_path}",
+        "target": "${target_column}"
+      },
+      "timeout": 300,
+      "output": {
+        "problem_type": "string",
+        "characteristics": "object",
+        "data_quality_report": "object",
+        "recommended_preprocessing": "array"
+      }
+    },
+    {
+      "id": "foundation_building",
+      "name": "Foundation Model Creation",
+      "type": "implementation",
+      "description": "Build initial ML pipeline based on web search findings and dataset analysis",
+      "assignTo": "foundation_agent",
+      "depends": ["web_search_phase", "dataset_analysis"],
+      "input": {
+        "search_results": "${web_search_phase.output}",
+        "dataset_info": "${dataset_analysis.output}",
+        "approaches_to_implement": "${web_search_phase.output.recommended_approaches}"
+      },
+      "timeout": 1800,
+      "output": {
+        "baseline_models": "array",
+        "preprocessing_pipeline": "object",
+        "initial_results": "object",
+        "code_components": "object"
+      }
+    },
+    {
+      "id": "ablation_analysis",
+      "name": "Component Impact Analysis",
+      "type": "analysis",
+      "description": "Systematically analyze which pipeline components have the highest performance impact",
+      "assignTo": "refinement_agent",
+      "depends": ["foundation_building"],
+      "input": {
+        "foundation_pipeline": "${foundation_building.output}",
+        "baseline_performance": "${foundation_building.output.initial_results}",
+        "components_to_test": [
+          "data_preprocessing",
+          "feature_engineering",
+          "model_selection",
+          "hyperparameters"
+        ]
+      },
+      "timeout": 1200,
+      "output": {
+        "component_rankings": "array",
+        "impact_scores": "object",
+        "highest_impact_component": "string",
+        "improvement_opportunities": "array"
+      }
+    },
+    {
+      "id": "targeted_refinement",
+      "name": "Iterative Component Refinement",
+      "type": "optimization",
+      "description": "Deep, focused improvements on the highest-impact pipeline components identified through ablation",
+      "assignTo": "refinement_agent",
+      "depends": ["ablation_analysis"],
+      "input": {
+        "target_component": "${ablation_analysis.output.highest_impact_component}",
+        "baseline_performance": "${ablation_analysis.output.impact_scores}",
+        "improvement_strategies": "${ablation_analysis.output.improvement_opportunities}",
+        "max_iterations": "${refinement_iterations}"
+      },
+      "timeout": 2400,
+      "output": {
+        "optimized_components": "object",
+        "performance_improvements": "object",
+        "refinement_history": "array",
+        "best_configuration": "object"
+      }
+    },
+    {
+      "id": "ensemble_creation",
+      "name": "Adaptive Ensemble Building",
+      "type": "architecture",
+      "description": "Intelligently combine models using advanced ensemble techniques, not just averaging",
+      "assignTo": "ensemble_agent",
+      "depends": ["targeted_refinement"],
+      "input": {
+        "base_models": "${targeted_refinement.output.optimized_components}",
+        "individual_performances": "${targeted_refinement.output.performance_improvements}",
+        "ensemble_strategies": [
+          "stacking_with_meta_learner",
+          "dynamic_weighting",
+          "bayesian_model_averaging",
+          "mixture_of_experts"
+        ]
+      },
+      "timeout": 1800,
+      "output": {
+        "ensemble_model": "object",
+        "ensemble_performance": "object",
+        "combination_strategy": "string",
+        "meta_learner_details": "object"
+      }
+    },
+    {
+      "id": "validation_and_debugging",
+      "name": "Comprehensive Validation & Error Correction",
+      "type": "testing",
+      "description": "Rigorous validation with data leakage prevention, error correction, and performance verification",
+      "assignTo": "validation_agent",
+      "depends": ["ensemble_creation"],
+      "input": {
+        "final_model": "${ensemble_creation.output.ensemble_model}",
+        "full_pipeline": "${targeted_refinement.output.best_configuration}",
+        "validation_config": {
+          "cv_folds": 5,
+          "test_size": 0.2,
+          "stratification": true,
+          "random_seed": 42
+        }
+      },
+      "timeout": 900,
+      "output": {
+        "validation_results": "object",
+        "cross_validation_scores": "array",
+        "data_leakage_check": "boolean",
+        "error_analysis": "object",
+        "final_performance_metrics": "object"
+      }
+    },
+    {
+      "id": "model_deployment_prep",
+      "name": "Production Readiness & Deployment",
+      "type": "deployment",
+      "description": "Prepare model for production deployment with monitoring, versioning, and documentation",
+      "assignTo": "orchestrator",
+      "depends": ["validation_and_debugging"],
+      "input": {
+        "validated_model": "${validation_and_debugging.output}",
+        "performance_benchmarks": "${validation_and_debugging.output.final_performance_metrics}",
+        "deployment_target": "production"
+      },
+      "timeout": 600,
+      "condition": "${validation_and_debugging.output.final_performance_metrics.accuracy} > 0.85",
+      "output": {
+        "deployment_package": "object",
+        "model_documentation": "object",
+        "monitoring_config": "object",
+        "deployment_instructions": "string"
+      }
+    }
+  ],
+  "dependencies": {
+    "foundation_building": ["web_search_phase", "dataset_analysis"],
+    "ablation_analysis": ["foundation_building"],
+    "targeted_refinement": ["ablation_analysis"],
+    "ensemble_creation": ["targeted_refinement"],
+    "validation_and_debugging": ["ensemble_creation"],
+    "model_deployment_prep": ["validation_and_debugging"]
+  },
+  "settings": {
+    "maxConcurrency": 3,
+    "timeout": 7200,
+    "retryPolicy": "exponential",
+    "failurePolicy": "continue",
+    "quality_threshold": 0.8,
+    "enable_monitoring": true,
+    "save_intermediate_results": true,
+    "auto_documentation": true
+  },
+  "metadata": {
+    "methodology": "MLE-STAR",
+    "version": "2.0.0",
+    "created_by": "Claude Flow Automation",
+    "tags": ["machine_learning", "automation", "mle_star", "ensemble", "optimization"],
+    "description_detailed": "This workflow implements the MLE-STAR (Machine Learning Engineering via Search and Targeted Refinement) methodology. It starts with web search to find state-of-the-art approaches, builds a foundation model, performs ablation analysis to identify high-impact components, then deeply refines those components before creating intelligent ensembles and comprehensive validation.",
+    "success_criteria": [
+      "Performance improvement over baseline > 5%",
+      "No data leakage detected",
+      "Cross-validation score variance < 0.05",
+      "All components properly documented"
+    ],
+    "expected_runtime": "2-4 hours",
+    "resource_requirements": {
+      "memory": "8GB+",
+      "storage": "10GB+",
+      "compute": "4+ CPU cores recommended"
+    }
+  }
+}

package/src/cli/simple-commands/timestamp-fix.js

@@ -0,0 +1,104 @@
+/**
+ * Fix for hive-mind creation time issue #246
+ * This file demonstrates how to properly handle timezones in hive-mind displays
+ */
+
+import {
+  getLocalTimestamp,
+  convertToLocalTime,
+  formatTimestampForDisplay,
+  getTimezoneInfo,
+} from '../../utils/timezone-utils.js';
+
+/**
+ * Fixed function to create session with proper timezone handling
+ */
+export function createSessionWithProperTimezone(objective, options = {}) {
+  const sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+  // Store both UTC timestamp (for consistency) and timezone info
+  const utcTimestamp = new Date().toISOString();
+  const localTimestamp = getLocalTimestamp();
+  const timezoneInfo = getTimezoneInfo();
+
+  const session = {
+    id: sessionId,
+    objective,
+    createdAt: utcTimestamp,
+    createdAtLocal: localTimestamp,
+    timezone: timezoneInfo,
+    status: 'active',
+    ...options,
+  };
+
+  return session;
+}
+
+/**
+ * Fixed function to display session info with proper timezone
+ */
+export function displaySessionInfo(session) {
+  const timeDisplay = formatTimestampForDisplay(session.createdAt);
+
+  console.log(`🐝 Hive Mind Session`);
+  console.log(`📋 ID: ${session.id}`);
+  console.log(`🎯 Objective: ${session.objective}`);
+  console.log(`⏰ Created: ${timeDisplay.display}`);
+  console.log(`🌍 Timezone: ${session.timezone?.name || 'Unknown'}`);
+  console.log(`📊 Status: ${session.status}`);
+}
+
+/**
+ * Fixed function to list sessions with proper timezone display
+ */
+export function listSessionsWithTimezone(sessions) {
+  console.log('📋 Hive Mind Sessions:\n');
+
+  if (sessions.length === 0) {
+    console.log('No sessions found.');
+    return;
+  }
+
+  // Table header
+  console.log('ID'.padEnd(25) + 'Objective'.padEnd(30) + 'Created'.padEnd(25) + 'Status');
+  console.log('-'.repeat(100));
+
+  sessions.forEach((session) => {
+    const timeDisplay = formatTimestampForDisplay(session.createdAt);
+    const id = session.id.length > 22 ? session.id.substr(0, 22) + '...' : session.id;
+    const objective =
+      session.objective.length > 27 ? session.objective.substr(0, 27) + '...' : session.objective;
+
+    console.log(
+      id.padEnd(25) + objective.padEnd(30) + timeDisplay.relative.padEnd(25) + session.status,
+    );
+  });
+
+  console.log(`\n💡 Times shown in your timezone: ${getTimezoneInfo().name}`);
+}
+
+/**
+ * Example usage and test function
+ */
+export function demonstrateTimezonefix() {
+  console.log('🧪 Testing timezone fix for issue #246\n');
+
+  // Show timezone info
+  const tz = getTimezoneInfo();
+  console.log(`🌍 Your timezone: ${tz.name} (${tz.abbreviation})`);
+  console.log(`⏰ UTC offset: ${tz.offset > 0 ? '+' : ''}${tz.offset} hours\n`);
+
+  // Create sample session
+  const session = createSessionWithProperTimezone('Build microservices API', {
+    queenType: 'strategic',
+    maxWorkers: 6,
+  });
+
+  // Display with proper timezone
+  displaySessionInfo(session);
+
+  console.log('\n📋 Session list example:');
+  listSessionsWithTimezone([session]);
+
+  console.log("\n✅ Fix applied - timestamps now show in user's local timezone!");
+}