claude-flow-novice 1.3.0 → 1.3.2

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

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+/**
+ * GitHub command wrapper for simple CLI
+ * Provides GitHub workflow automation capabilities
+ */
+
+import { printSuccess, printError, printWarning } from '../utils.js';
+import { platform } from 'os';
+import { access, constants } from 'fs/promises';
+import { join } from 'path';
+
+/**
+ * Cross-platform check for executable availability
+ * @param {string} command - The command to check
+ * @returns {Promise<boolean>} - True if command is available
+ */
+async function checkCommandAvailable(command) {
+  const { execSync } = await import('child_process');
+
+  if (platform() === 'win32') {
+    // Windows: Use 'where' command
+    try {
+      execSync(`where ${command}`, { stdio: 'ignore' });
+      return true;
+    } catch (e) {
+      return false;
+    }
+  } else {
+    // Unix-like systems: Check common paths and use 'command -v'
+    try {
+      execSync(`command -v ${command}`, { stdio: 'ignore', shell: true });
+      return true;
+    } catch (e) {
+      // Fallback: Check common installation paths
+      const commonPaths = [
+        '/usr/local/bin',
+        '/usr/bin',
+        '/opt/homebrew/bin',
+        join(process.env.HOME || '', '.local', 'bin'),
+        join(process.env.HOME || '', 'bin'),
+      ];
+
+      for (const dir of commonPaths) {
+        try {
+          await access(join(dir, command), constants.X_OK);
+          return true;
+        } catch (e) {
+          // Continue checking other paths
+        }
+      }
+      return false;
+    }
+  }
+}
+
+/**
+ * Check if Claude CLI is available
+ * @returns {Promise<boolean>} - True if Claude is available
+ */
+async function checkClaudeAvailable() {
+  return checkCommandAvailable('claude');
+}
+
+const GITHUB_MODES = {
+  init: {
+    description: 'Initialize GitHub-specific hooks and checkpoint system',
+    examples: ['github init', 'github init --force', 'github init --checkpoints-only'],
+  },
+  'gh-coordinator': {
+    description: 'GitHub workflow orchestration and coordination',
+    examples: [
+      'github gh-coordinator "setup CI/CD pipeline"',
+      'github gh-coordinator "coordinate release process" --auto-approve',
+    ],
+  },
+  'pr-manager': {
+    description: 'Pull request management with multi-reviewer coordination',
+    examples: [
+      'github pr-manager "create feature PR with automated testing"',
+      'github pr-manager "coordinate code review for security update"',
+    ],
+  },
+  'issue-tracker': {
+    description: 'Issue management and project coordination',
+    examples: [
+      'github issue-tracker "analyze project roadmap issues"',
+      'github issue-tracker "coordinate bug triage process"',
+    ],
+  },
+  'release-manager': {
+    description: 'Release coordination and deployment pipelines',
+    examples: [
+      'github release-manager "prepare v2.0.0 release"',
+      'github release-manager "coordinate hotfix deployment"',
+    ],
+  },
+  'repo-architect': {
+    description: 'Repository structure optimization',
+    examples: [
+      'github repo-architect "optimize repository structure"',
+      'github repo-architect "setup monorepo architecture"',
+    ],
+  },
+  'sync-coordinator': {
+    description: 'Multi-package synchronization and version alignment',
+    examples: [
+      'github sync-coordinator "sync package versions across repos"',
+      'github sync-coordinator "coordinate dependency updates"',
+    ],
+  },
+};
+
+function showGitHubHelp() {
+  console.log(`
+🐙 Claude Flow GitHub Workflow Automation
+
+USAGE:
+  claude-flow github <mode> <objective> [options]
+
+GITHUB AUTOMATION MODES:
+`);
+
+  for (const [mode, info] of Object.entries(GITHUB_MODES)) {
+    console.log(`  ${mode.padEnd(18)} ${info.description}`);
+  }
+
+  console.log(`
+EXAMPLES:
+  claude-flow github pr-manager "create feature PR with automated testing"
+  claude-flow github gh-coordinator "setup CI/CD pipeline" --auto-approve
+  claude-flow github release-manager "prepare v2.0.0 release"
+  claude-flow github repo-architect "optimize repository structure"
+  claude-flow github issue-tracker "analyze project roadmap issues"
+  claude-flow github sync-coordinator "sync package versions across repos"
+
+OPTIONS:
+  --auto-approve             Auto-approve Claude permissions
+  --verbose                  Enable detailed logging
+  --dry-run                  Show what would be executed
+  --repo <name>              Target specific repository
+  --branch <name>            Target specific branch
+  --template <name>          Use specific workflow template
+
+ADVANCED FEATURES:
+  • Multi-reviewer coordination with automated scheduling
+  • Intelligent issue categorization and assignment
+  • Automated testing integration and quality gates
+  • Release pipeline orchestration with rollback capabilities
+  • Repository structure analysis and optimization recommendations
+  • Cross-repository dependency management and synchronization
+
+For complete documentation:
+https://github.com/ruvnet/claude-code-flow/docs/github.md
+`);
+}
+
+export async function githubCommand(args, flags) {
+  if (!args || args.length === 0) {
+    showGitHubHelp();
+    return;
+  }
+
+  const mode = args[0];
+
+  // Handle init mode separately
+  if (mode === 'init') {
+    const { githubInitCommand } = await import('./github/init.js');
+    return await githubInitCommand(flags);
+  }
+
+  const objective = args.slice(1).join(' ').trim();
+
+  if (!objective) {
+    printError(`❌ Usage: github ${mode} <objective>`);
+
+    if (GITHUB_MODES[mode]) {
+      console.log(`\nExamples for ${mode}:`);
+      for (const example of GITHUB_MODES[mode].examples) {
+        console.log(`  ${example}`);
+      }
+    } else {
+      console.log('\nAvailable modes:');
+      for (const [modeName, info] of Object.entries(GITHUB_MODES)) {
+        console.log(`  ${modeName} - ${info.description}`);
+      }
+    }
+    return;
+  }
+
+  if (!GITHUB_MODES[mode]) {
+    printError(`❌ Unknown GitHub mode: ${mode}`);
+    console.log('\nAvailable modes:');
+    for (const [modeName, info] of Object.entries(GITHUB_MODES)) {
+      console.log(`  ${modeName} - ${info.description}`);
+    }
+    return;
+  }
+
+  printSuccess(`🐙 GitHub ${mode} mode activated`);
+  console.log(`📋 Objective: ${objective}`);
+
+  if (flags['dry-run']) {
+    console.log('\n🎛️  Configuration:');
+    console.log(`  Mode: ${mode}`);
+    console.log(`  Repository: ${flags.repo || 'current'}`);
+    console.log(`  Branch: ${flags.branch || 'current'}`);
+    console.log(`  Template: ${flags.template || 'default'}`);
+    console.log(`  Auto-approve: ${flags['auto-approve'] || false}`);
+    console.log(`  Verbose: ${flags.verbose || false}`);
+    console.log('\n⚠️  DRY RUN - GitHub workflow configuration preview');
+    return;
+  }
+
+  try {
+    // Check if Claude is available
+    const { execSync } = await import('child_process');
+
+    // Cross-platform check for Claude CLI
+    const isClaudeAvailable = await checkClaudeAvailable();
+    if (!isClaudeAvailable) {
+      printWarning('⚠️  Claude CLI not found. GitHub automation requires Claude.');
+      console.log('Install Claude: https://claude.ai/code');
+      console.log('\nAlternatively, this would execute:');
+      console.log(`1. Initialize ${mode} workflow for: ${objective}`);
+      console.log('2. Set up GitHub integration and permissions');
+      console.log('3. Configure automation rules and triggers');
+      console.log('4. Execute workflow with monitoring and reporting');
+      return;
+    }
+
+    // Build the prompt for Claude using GitHub workflow methodology
+    const githubPrompt = `Execute GitHub workflow automation using ${mode} mode:
+
+OBJECTIVE: ${objective}
+
+GITHUB MODE: ${mode}
+DESCRIPTION: ${GITHUB_MODES[mode].description}
+
+CONFIGURATION:
+- Repository: ${flags.repo || 'current directory repository'}
+- Branch: ${flags.branch || 'current branch'}
+- Template: ${flags.template || 'default workflow'}
+- Auto-approve: ${flags['auto-approve'] || false}
+- Verbose: ${flags.verbose || false}
+
+GITHUB WORKFLOW REQUIREMENTS:
+
+1. REPOSITORY ANALYSIS:
+   - Analyze current repository structure and configuration
+   - Check existing workflows, branches, and protection rules
+   - Identify integration points and dependencies
+   - Document current state and proposed changes
+
+2. WORKFLOW DESIGN:
+   - Design GitHub Actions workflows appropriate for the objective
+   - Create or update .github/workflows/ files
+   - Configure triggers, jobs, and steps
+   - Set up proper permissions and security measures
+
+3. INTEGRATION SETUP:
+   - Configure branch protection rules if needed
+   - Set up automated testing and quality gates
+   - Configure deployment pipelines if applicable
+   - Set up notifications and monitoring
+
+4. AUTOMATION IMPLEMENTATION:
+   - Create or update GitHub Actions YAML files
+   - Set up any required secrets and environment variables
+   - Configure automated issue and PR management
+   - Implement approval workflows and review assignments
+
+5. MONITORING & REPORTING:
+   - Set up workflow monitoring and status reporting
+   - Configure failure notifications and alerts
+   - Create documentation for the automation
+   - Set up metrics and analytics collection
+
+EXECUTION APPROACH:
+1. Analyze the current repository and GitHub configuration
+2. Design the appropriate workflow automation for the objective
+3. Create or update GitHub Actions and configuration files
+4. Test the workflow with proper validation
+5. Document the automation and provide usage instructions
+
+TARGET DIRECTORY:
+Use the current repository's .github/ directory for workflows and configuration.
+
+IMPORTANT:
+- Create actual, working GitHub Actions workflows - not templates
+- Include proper error handling and security measures
+- Add comprehensive documentation and usage instructions
+- Follow GitHub Actions best practices and conventions
+- Ensure workflows are production-ready and maintainable
+- Include proper testing and validation steps
+
+Begin execution now. Create all necessary GitHub workflow files and configuration.`;
+
+    console.log('🚀 Launching GitHub automation via Claude...');
+
+    // Execute Claude with the GitHub prompt
+    const { spawn } = await import('child_process');
+
+    const claudeArgs = [];
+
+    // Add auto-permission flag if requested
+    if (flags['auto-approve'] || flags['dangerously-skip-permissions']) {
+      claudeArgs.push('--dangerously-skip-permissions');
+    }
+
+    // Spawn claude process
+    const claudeProcess = spawn('claude', claudeArgs, {
+      stdio: ['pipe', 'inherit', 'inherit'],
+      shell: false,
+    });
+
+    // Write the prompt to stdin and close it
+    claudeProcess.stdin.write(githubPrompt);
+    claudeProcess.stdin.end();
+
+    // Wait for the process to complete
+    await new Promise((resolve, reject) => {
+      claudeProcess.on('close', (code) => {
+        if (code === 0) {
+          printSuccess('✅ GitHub automation completed successfully!');
+          resolve();
+        } else {
+          reject(new Error(`Claude process exited with code ${code}`));
+        }
+      });
+
+      claudeProcess.on('error', (err) => {
+        reject(err);
+      });
+    });
+  } catch (error) {
+    printError(`❌ GitHub automation failed: ${error.message}`);
+
+    // Fallback implementation details
+    console.log('\n📋 Fallback execution plan:');
+    console.log(`1. ${mode} workflow would be configured for: ${objective}`);
+    console.log('2. GitHub Actions YAML files would be created');
+    console.log('3. Repository settings would be configured');
+    console.log('4. Automation rules would be established');
+    console.log('5. Monitoring and reporting would be set up');
+
+    printWarning('\n⚠️  Note: Full GitHub automation requires Claude CLI.');
+    console.log('Install Claude: https://claude.ai/code');
+  }
+}
+
+// Allow direct execution for testing
+if (import.meta.main) {
+  const args = [];
+  const flags = {};
+
+  // Parse arguments and flags from Deno.args if available
+  if (typeof Deno !== 'undefined' && Deno.args) {
+    for (let i = 0; i < Deno.args.length; i++) {
+      const arg = Deno.args[i];
+      if (arg.startsWith('--')) {
+        const flagName = arg.substring(2);
+        const nextArg = Deno.args[i + 1];
+
+        if (nextArg && !nextArg.startsWith('--')) {
+          flags[flagName] = nextArg;
+          i++; // Skip the next argument
+        } else {
+          flags[flagName] = true;
+        }
+      } else {
+        args.push(arg);
+      }
+    }
+  }
+
+  await githubCommand(args, flags);
+}

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

@@ -0,0 +1,145 @@
+/**
+ * Goal module commands
+ * Handles 'goal init' and other goal-related commands
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+export async function goalCommand(args, flags) {
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    console.log(chalk.magenta('🎯 Claude Flow Goal Module'));
+    console.log('\nUsage: claude-flow goal <command> [options]');
+    console.log('\nCommands:');
+    console.log('  init    Initialize GOAP goal module');
+    console.log('\nOptions:');
+    console.log('  --force        Overwrite existing module');
+    console.log('  --target <dir> Target directory (default: .claude/agents/goal)');
+    return;
+  }
+
+  if (subcommand === 'init') {
+    await initGoalModule(flags);
+  } else {
+    console.error(chalk.red(`Unknown goal subcommand: ${subcommand}`));
+    process.exit(1);
+  }
+}
+
+async function initGoalModule(flags = {}) {
+  const targetDir = path.resolve(process.cwd(), flags.target || '.claude/agents/goal');
+
+  console.log(chalk.magenta('🎯 Initializing Claude Flow Goal Module...'));
+  console.log(chalk.gray(`  Target: ${targetDir}`));
+
+  try {
+    // Check if exists
+    if ((await exists(targetDir)) && !flags.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 content (full content from memory)
+    const plannerContent = `---
+name: goal-planner
+description: "Goal-Oriented Action Planning (GOAP) specialist that dynamically creates intelligent plans to achieve complex objectives. Uses gaming AI techniques to discover novel solutions by combining actions in creative ways. Excels at adaptive replanning, multi-step reasoning, and finding optimal paths through complex state spaces."
+color: purple
+---
+
+You are a Goal-Oriented Action Planning (GOAP) specialist, an advanced AI planner that uses intelligent algorithms to dynamically create optimal action sequences for achieving complex objectives. Your expertise combines gaming AI techniques with practical software engineering to discover novel solutions through creative action composition.
+
+Your core capabilities:
+- **Dynamic Planning**: Use A* search algorithms to find optimal paths through state spaces
+- **Precondition Analysis**: Evaluate action requirements and dependencies
+- **Effect Prediction**: Model how actions change world state
+- **Adaptive Replanning**: Adjust plans based on execution results and changing conditions
+- **Goal Decomposition**: Break complex objectives into achievable sub-goals
+- **Cost Optimization**: Find the most efficient path considering action costs
+- **Novel Solution Discovery**: Combine known actions in creative ways
+- **Mixed Execution**: Blend LLM-based reasoning with deterministic code actions
+- **Tool Group Management**: Match actions to available tools and capabilities
+- **Domain Modeling**: Work with strongly-typed state representations
+- **Continuous Learning**: Update planning strategies based on execution feedback
+
+Your planning methodology follows the GOAP algorithm:
+
+1. **State Assessment**:
+   - Analyze current world state (what is true now)
+   - Define goal state (what should be true)
+   - Identify the gap between current and goal states
+
+2. **Action Analysis**:
+   - Inventory available actions with their preconditions and effects
+   - Determine which actions are currently applicable
+   - Calculate action costs and priorities
+
+3. **Plan Generation**:
+   - Use A* pathfinding to search through possible action sequences
+   - Evaluate paths based on cost and heuristic distance to goal
+   - Generate optimal plan that transforms current state to goal state
+
+4. **Execution Monitoring** (OODA Loop):
+   - **Observe**: Monitor current state and execution progress
+   - **Orient**: Analyze changes and deviations from expected state
+   - **Decide**: Determine if replanning is needed
+   - **Act**: Execute next action or trigger replanning
+
+5. **Dynamic Replanning**:
+   - Detect when actions fail or produce unexpected results
+   - Recalculate optimal path from new current state
+   - Adapt to changing conditions and new information
+
+## MCP Integration Examples
+
+\`\`\`javascript
+// Orchestrate complex goal achievement
+mcp__claude-flow__task_orchestrate {
+  task: "achieve_production_deployment",
+  strategy: "adaptive",
+  priority: "high"
+}
+
+// Coordinate with swarm for parallel planning
+mcp__claude-flow__swarm_init {
+  topology: "hierarchical",
+  maxAgents: 5
+}
+
+// Store successful plans for reuse
+mcp__claude-flow__memory_usage {
+  action: "store",
+  namespace: "goap-plans",
+  key: "deployment_plan_v1",
+  value: JSON.stringify(successful_plan)
+}
+\`\`\``;
+
+    await fs.writeFile(path.join(targetDir, 'goal-planner.md'), plannerContent);
+    console.log(chalk.gray('  ✓ Created goal-planner.md'));
+
+    console.log(chalk.green('\n✅ Goal module initialized successfully!'));
+    console.log(chalk.magenta('\n📚 Usage:'));
+    console.log(chalk.gray('  • In Claude Code: @agent-goal-planner "Create deployment plan"'));
+    console.log(chalk.gray('  • View agent: cat .claude/agents/goal/goal-planner.md'));
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to initialize goal module:'), error.message);
+    process.exit(1);
+  }
+}
+
+async function exists(path) {
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export default goalCommand;