claude-flow-novice 1.3.0 → 1.3.2

package/src/cli/simple-commands/init/claude-commands/sparc-commands.js

@@ -0,0 +1,296 @@
+// sparc-commands.js - SPARC-specific slash commands
+
+// Create SPARC mode slash command
+export function createSparcSlashCommand(mode) {
+  // Extract the full description without truncation
+  const fullDescription =
+    mode.roleDefinition.length > 100
+      ? `${mode.roleDefinition.substring(0, 97)}...`
+      : mode.roleDefinition;
+
+  return `---
+name: sparc-${mode.slug}
+description: ${mode.name} - ${fullDescription}
+---
+
+# ${mode.name}
+
+## Role Definition
+${mode.roleDefinition}
+
+## Custom Instructions
+${mode.customInstructions}
+
+## Available Tools
+${
+  Array.isArray(mode.groups)
+    ? mode.groups
+        .map((g) => {
+          if (typeof g === 'string') {
+            return `- **${g}**: ${getToolDescription(g)}`;
+          } else if (Array.isArray(g)) {
+            return `- **${g[0]}**: ${g[1]?.description || getToolDescription(g[0])} ${g[1]?.fileRegex ? `(Files matching: ${g[1].fileRegex})` : ''}`;
+          }
+          return `- ${JSON.stringify(g)}`;
+        })
+        .join('\n')
+    : 'None'
+}
+
+## Usage
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+\`\`\`javascript
+mcp__claude-flow__sparc_mode {
+  mode: "${mode.slug}",
+  task_description: "${getExampleTask(mode.slug)}",
+  options: {
+    namespace: "${mode.slug}",
+    non_interactive: false
+  }
+}
+\`\`\`
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+\`\`\`bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow sparc run ${mode.slug} "${getExampleTask(mode.slug)}"
+
+# For alpha features
+npx claude-flow@alpha sparc run ${mode.slug} "${getExampleTask(mode.slug)}"
+
+# With namespace
+npx claude-flow sparc run ${mode.slug} "your task" --namespace ${mode.slug}
+
+# Non-interactive mode
+npx claude-flow sparc run ${mode.slug} "your task" --non-interactive
+\`\`\`
+
+### Option 3: Local Installation
+\`\`\`bash
+# If claude-flow is installed locally
+./claude-flow sparc run ${mode.slug} "${getExampleTask(mode.slug)}"
+\`\`\`
+
+## Memory Integration
+
+### Using MCP Tools (Preferred)
+\`\`\`javascript
+// Store mode-specific context
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "${mode.slug}_context",
+  value: "important decisions",
+  namespace: "${mode.slug}"
+}
+
+// Query previous work
+mcp__claude-flow__memory_search {
+  pattern: "${mode.slug}",
+  namespace: "${mode.slug}",
+  limit: 5
+}
+\`\`\`
+
+### Using NPX CLI (Fallback)
+\`\`\`bash
+# Store mode-specific context
+npx claude-flow memory store "${mode.slug}_context" "important decisions" --namespace ${mode.slug}
+
+# Query previous work
+npx claude-flow memory query "${mode.slug}" --limit 5
+\`\`\`
+`;
+}
+
+// Helper function to get tool descriptions
+function getToolDescription(tool) {
+  const toolDescriptions = {
+    read: 'File reading and viewing',
+    edit: 'File modification and creation',
+    browser: 'Web browsing capabilities',
+    mcp: 'Model Context Protocol tools',
+    command: 'Command execution',
+  };
+  return toolDescriptions[tool] || 'Tool access';
+}
+
+// Helper function to get example tasks
+function getExampleTask(slug) {
+  const examples = {
+    architect: 'design microservices architecture',
+    code: 'implement REST API endpoints',
+    tdd: 'create user authentication tests',
+    debug: 'fix memory leak in service',
+    'security-review': 'audit API security',
+    'docs-writer': 'create API documentation',
+    integration: 'connect payment service',
+    'post-deployment-monitoring-mode': 'monitor production metrics',
+    'refinement-optimization-mode': 'optimize database queries',
+    devops: 'deploy to AWS Lambda',
+    'supabase-admin': 'create user authentication schema',
+    'spec-pseudocode': 'define payment flow requirements',
+    mcp: 'integrate with external API',
+    swarm: 'build complete feature with tests',
+    sparc: 'orchestrate authentication system',
+    ask: 'help me choose the right mode',
+    tutorial: 'guide me through SPARC methodology',
+  };
+  return examples[slug] || 'implement feature';
+}
+
+// Create main SPARC command
+export function createMainSparcCommand(modes) {
+  const modeList = modes.map((m) => `- \`/sparc-${m.slug}\` - ${m.name}`).join('\n');
+
+  // Find the sparc orchestrator mode for its full description
+  const sparcMode = modes.find((m) => m.slug === 'sparc');
+  const sparcDescription = sparcMode
+    ? sparcMode.roleDefinition
+    : 'SPARC orchestrator for complex workflows';
+  const sparcInstructions = sparcMode ? sparcMode.customInstructions : '';
+
+  return `---
+name: sparc
+description: Execute SPARC methodology workflows with Claude-Flow
+---
+
+# ⚡️ SPARC Development Methodology
+
+${sparcDescription}
+
+## SPARC Workflow
+
+${sparcInstructions.split('\n').slice(0, 10).join('\n')}
+
+## Available SPARC Modes
+
+${modeList}
+
+## Quick Start
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+\`\`\`javascript
+// Run SPARC orchestrator (default)
+mcp__claude-flow__sparc_mode {
+  mode: "sparc",
+  task_description: "build complete authentication system"
+}
+
+// Run a specific mode
+mcp__claude-flow__sparc_mode {
+  mode: "architect",
+  task_description: "design API structure"
+}
+
+// TDD workflow
+mcp__claude-flow__sparc_mode {
+  mode: "tdd",
+  task_description: "implement user authentication",
+  options: {workflow: "full"}
+}
+\`\`\`
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+\`\`\`bash
+# Run SPARC orchestrator (default)
+npx claude-flow sparc "build complete authentication system"
+
+# Run a specific mode
+npx claude-flow sparc run architect "design API structure"
+npx claude-flow sparc run tdd "implement user service"
+
+# Execute full TDD workflow
+npx claude-flow sparc tdd "implement user authentication"
+
+# List all modes with details
+npx claude-flow sparc modes --verbose
+
+# For alpha features
+npx claude-flow@alpha sparc run <mode> "your task"
+\`\`\`
+
+### Option 3: Local Installation
+\`\`\`bash
+# If claude-flow is installed locally
+./claude-flow sparc "build complete authentication system"
+./claude-flow sparc run architect "design API structure"
+\`\`\`
+
+## SPARC Methodology Phases
+
+1. **📋 Specification**: Define requirements, constraints, and acceptance criteria
+2. **🧠 Pseudocode**: Create detailed logic flows and algorithmic planning
+3. **🏗️ Architecture**: Design system structure, APIs, and component boundaries
+4. **🔄 Refinement**: Implement with TDD (Red-Green-Refactor cycle)
+5. **✅ Completion**: Integrate, document, and validate against requirements
+
+## Memory Integration
+
+### Using MCP Tools (Preferred)
+\`\`\`javascript
+// Store specifications
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "spec_auth",
+  value: "OAuth2 + JWT requirements",
+  namespace: "spec"
+}
+
+// Store architectural decisions
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "arch_decisions",
+  value: "Microservices with API Gateway",
+  namespace: "architecture"
+}
+\`\`\`
+
+### Using NPX CLI (Fallback)
+\`\`\`bash
+# Store specifications
+npx claude-flow memory store "spec_auth" "OAuth2 + JWT requirements" --namespace spec
+
+# Store architectural decisions
+./claude-flow memory store "arch_api" "RESTful microservices design" --namespace arch
+
+# Query previous work
+./claude-flow memory query "authentication" --limit 10
+
+# Export project memory
+./claude-flow memory export sparc-project-backup.json
+\`\`\`
+
+## Advanced Swarm Mode
+
+For complex tasks requiring multiple agents with timeout-free execution:
+\`\`\`bash
+# Development swarm with monitoring
+./claude-flow swarm "Build e-commerce platform" --strategy development --monitor --review
+
+# Background optimization swarm
+./claude-flow swarm "Optimize system performance" --strategy optimization --background
+
+# Distributed research swarm
+./claude-flow swarm "Analyze market trends" --strategy research --distributed --ui
+\`\`\`
+
+## Non-Interactive Mode
+
+For CI/CD integration and automation:
+\`\`\`bash
+./claude-flow sparc run code "implement API" --non-interactive
+./claude-flow sparc tdd "user tests" --non-interactive --enable-permissions
+\`\`\`
+
+## Best Practices
+
+✅ **Modular Design**: Keep files under 500 lines
+✅ **Environment Safety**: Never hardcode secrets or env values
+✅ **Test-First**: Always write tests before implementation
+✅ **Memory Usage**: Store important decisions and context
+✅ **Task Completion**: All tasks should end with \`attempt_completion\`
+
+See \`/claude-flow-help\` for all available commands.
+`;
+}

package/src/cli/simple-commands/init/copy-revised-templates.js

@@ -0,0 +1,175 @@
+// copy-revised-templates.js - Copy the revised template files from repository
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Source directory for revised templates (repository root .claude/commands)
+const REPO_TEMPLATES_DIR = path.join(__dirname, '../../../../.claude/commands');
+
+/**
+ * Copy revised template files from repository to target project
+ */
+export async function copyRevisedTemplates(targetDir, options = {}) {
+  const results = {
+    success: true,
+    copiedFiles: [],
+    skippedFiles: [],
+    errors: [],
+  };
+
+  const targetCommandsDir = path.join(targetDir, '.claude/commands');
+
+  try {
+    // Ensure target directory exists
+    await fs.promises.mkdir(targetCommandsDir, { recursive: true });
+
+    // Copy all template files recursively
+    await copyDirectoryRecursive(REPO_TEMPLATES_DIR, targetCommandsDir, options, results);
+
+    // Copy additional .claude files if they exist
+    const additionalFiles = [
+      { source: '../config.json', target: '.claude/config.json' },
+      { source: '../settings.json', target: '.claude/settings.json' },
+    ];
+
+    for (const file of additionalFiles) {
+      const sourcePath = path.join(REPO_TEMPLATES_DIR, file.source);
+      const targetPath = path.join(targetDir, file.target);
+
+      if (fs.existsSync(sourcePath)) {
+        try {
+          const targetDirPath = path.dirname(targetPath);
+          await fs.promises.mkdir(targetDirPath, { recursive: true });
+
+          if (!fs.existsSync(targetPath) || options.force) {
+            await fs.promises.copyFile(sourcePath, targetPath);
+            results.copiedFiles.push(file.target);
+            if (!options.dryRun) {
+              console.log(`  ✓ Copied ${file.target}`);
+            }
+          } else {
+            results.skippedFiles.push(file.target);
+            if (!options.dryRun) {
+              console.log(`  ⏭️  Skipped ${file.target} (already exists)`);
+            }
+          }
+        } catch (err) {
+          results.errors.push(`Failed to copy ${file.target}: ${err.message}`);
+        }
+      }
+    }
+
+    results.success = results.errors.length === 0;
+  } catch (err) {
+    results.success = false;
+    results.errors.push(`Failed to copy revised templates: ${err.message}`);
+  }
+
+  return results;
+}
+
+/**
+ * Recursively copy directory contents
+ */
+async function copyDirectoryRecursive(sourceDir, targetDir, options, results) {
+  try {
+    const entries = await fs.promises.readdir(sourceDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const sourcePath = path.join(sourceDir, entry.name);
+      const targetPath = path.join(targetDir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Create directory and recurse
+        await fs.promises.mkdir(targetPath, { recursive: true });
+        await copyDirectoryRecursive(sourcePath, targetPath, options, results);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        // Copy markdown files
+        try {
+          if (!fs.existsSync(targetPath) || options.force) {
+            if (!options.dryRun) {
+              await fs.promises.copyFile(sourcePath, targetPath);
+            }
+            const relativePath = path.relative(targetDir, targetPath);
+            results.copiedFiles.push(relativePath);
+            if (!options.dryRun && options.verbose) {
+              console.log(`  ✓ Copied ${relativePath}`);
+            }
+          } else {
+            const relativePath = path.relative(targetDir, targetPath);
+            results.skippedFiles.push(relativePath);
+            if (!options.dryRun && options.verbose) {
+              console.log(`  ⏭️  Skipped ${relativePath} (already exists)`);
+            }
+          }
+        } catch (err) {
+          results.errors.push(`Failed to copy ${entry.name}: ${err.message}`);
+        }
+      }
+    }
+  } catch (err) {
+    results.errors.push(`Failed to read directory ${sourceDir}: ${err.message}`);
+  }
+}
+
+/**
+ * Copy only specific categories
+ */
+export async function copyRevisedTemplatesByCategory(targetDir, categories, options = {}) {
+  const results = {
+    success: true,
+    copiedFiles: [],
+    skippedFiles: [],
+    errors: [],
+  };
+
+  for (const category of categories) {
+    const sourceCategoryDir = path.join(REPO_TEMPLATES_DIR, category);
+    const targetCategoryDir = path.join(targetDir, '.claude/commands', category);
+
+    if (fs.existsSync(sourceCategoryDir)) {
+      await fs.promises.mkdir(targetCategoryDir, { recursive: true });
+      await copyDirectoryRecursive(sourceCategoryDir, targetCategoryDir, options, results);
+    } else {
+      results.errors.push(`Category '${category}' not found in templates`);
+    }
+  }
+
+  results.success = results.errors.length === 0;
+  return results;
+}
+
+/**
+ * Validate that source templates exist
+ */
+export function validateTemplatesExist() {
+  if (!fs.existsSync(REPO_TEMPLATES_DIR)) {
+    return {
+      valid: false,
+      error: `Template directory not found: ${REPO_TEMPLATES_DIR}`,
+    };
+  }
+
+  const requiredCategories = ['analysis', 'github', 'sparc', 'coordination'];
+  const missingCategories = [];
+
+  for (const category of requiredCategories) {
+    const categoryPath = path.join(REPO_TEMPLATES_DIR, category);
+    if (!fs.existsSync(categoryPath)) {
+      missingCategories.push(category);
+    }
+  }
+
+  if (missingCategories.length > 0) {
+    return {
+      valid: false,
+      error: `Missing required template categories: ${missingCategories.join(', ')}`,
+    };
+  }
+
+  return { valid: true };
+}

package/src/cli/simple-commands/init/executable-wrapper.js

@@ -0,0 +1,122 @@
+// executable-wrapper.js - Create local executable wrapper
+
+import { writeFile, chmod } from 'fs/promises';
+import { platform } from 'os';
+
+export async function createLocalExecutable(workingDir, dryRun = false) {
+  try {
+    if (platform() === 'win32') {
+      // Create Windows batch file
+      const wrapperScript = `@echo off
+REM Claude-Flow local wrapper
+REM This script ensures claude-flow runs from your project directory
+
+set PROJECT_DIR=%CD%
+set PWD=%PROJECT_DIR%
+set CLAUDE_WORKING_DIR=%PROJECT_DIR%
+
+REM Try to find claude-flow binary
+REM Check common locations for npm/npx installations
+
+REM 1. Local node_modules (npm install claude-flow)
+if exist "%PROJECT_DIR%\\node_modules\\.bin\\claude-flow.cmd" (
+  cd /d "%PROJECT_DIR%"
+  "%PROJECT_DIR%\\node_modules\\.bin\\claude-flow.cmd" %*
+  exit /b %ERRORLEVEL%
+)
+
+REM 2. Parent directory node_modules (monorepo setup)
+if exist "%PROJECT_DIR%\\..\\node_modules\\.bin\\claude-flow.cmd" (
+  cd /d "%PROJECT_DIR%"
+  "%PROJECT_DIR%\\..\\node_modules\\.bin\\claude-flow.cmd" %*
+  exit /b %ERRORLEVEL%
+)
+
+REM 3. Global installation (npm install -g claude-flow)
+where claude-flow >nul 2>nul
+if %ERRORLEVEL% EQU 0 (
+  cd /d "%PROJECT_DIR%"
+  claude-flow %*
+  exit /b %ERRORLEVEL%
+)
+
+REM 4. Fallback to npx (will download if needed)
+cd /d "%PROJECT_DIR%"
+npx claude-flow@latest %*
+`;
+
+      // Write the Windows batch file
+      if (!dryRun) {
+        await writeFile(`${workingDir}/claude-flow.cmd`, wrapperScript, 'utf8');
+        console.log('  ✓ Created local claude-flow.cmd executable wrapper');
+        console.log('    You can now use: claude-flow instead of npx claude-flow');
+      }
+    } else {
+      // Check if we're in development mode (claude-code-flow repo)
+      const isDevelopment = workingDir.includes('claude-code-flow');
+      const devBinPath = isDevelopment
+        ? workingDir.split('claude-code-flow')[0] + 'claude-code-flow/bin/claude-flow'
+        : '';
+
+      // Create Unix/Linux/Mac shell script
+      const wrapperScript = `#!/usr/bin/env bash
+# Claude-Flow local wrapper
+# This script ensures claude-flow runs from your project directory
+
+# Save the current directory
+PROJECT_DIR="\${PWD}"
+
+# Set environment to ensure correct working directory
+export PWD="\${PROJECT_DIR}"
+export CLAUDE_WORKING_DIR="\${PROJECT_DIR}"
+
+# Try to find claude-flow binary
+# Check common locations for npm/npx installations
+
+${
+  isDevelopment
+    ? `# Development mode - use local bin
+if [ -f "${devBinPath}" ]; then
+  cd "\${PROJECT_DIR}"
+  exec "${devBinPath}" "$@"
+fi
+
+`
+    : ''
+}# 1. Local node_modules (npm install claude-flow)
+if [ -f "\${PROJECT_DIR}/node_modules/.bin/claude-flow" ]; then
+  cd "\${PROJECT_DIR}"
+  exec "\${PROJECT_DIR}/node_modules/.bin/claude-flow" "$@"
+
+# 2. Parent directory node_modules (monorepo setup)
+elif [ -f "\${PROJECT_DIR}/../node_modules/.bin/claude-flow" ]; then
+  cd "\${PROJECT_DIR}"
+  exec "\${PROJECT_DIR}/../node_modules/.bin/claude-flow" "$@"
+
+# 3. Global installation (npm install -g claude-flow)
+elif command -v claude-flow &> /dev/null; then
+  cd "\${PROJECT_DIR}"
+  exec claude-flow "$@"
+
+# 4. Fallback to npx (will download if needed)
+else
+  cd "\${PROJECT_DIR}"
+  exec npx claude-flow@latest "$@"
+fi
+`;
+
+      // Write the wrapper script
+      if (!dryRun) {
+        await writeFile(`${workingDir}/claude-flow`, wrapperScript, 'utf8');
+
+        // Make it executable
+        await chmod(`${workingDir}/claude-flow`, 0o755);
+
+        console.log('  ✓ Created local claude-flow executable wrapper');
+        console.log('    You can now use: ./claude-flow instead of npx claude-flow');
+      }
+    }
+  } catch (err) {
+    console.log(`  ⚠️  Could not create local executable: ${err.message}`);
+  }
+}