claude-flow-novice 1.5.2 → 1.5.3

package/.claude-flow-novice/dist/src/cli/simple-commands/init/verification-claude-md.js

@@ -0,0 +1,432 @@
+// verification-claude-md.js - Verification and Pair Programming CLAUDE.md template
+
+export function createVerificationClaudeMd() {
+  return `# Claude Code Configuration - Truth Verification & Pair Programming Environment
+
+## 🔍 VERIFICATION-FIRST DEVELOPMENT
+
+This project enforces **"truth is enforced, not assumed"** with mandatory verification for all operations.
+
+### 🎯 Truth Verification System Active
+- **Threshold**: 0.95 (95% accuracy required)
+- **Mode**: Strict verification with auto-rollback
+- **Pair Programming**: Real-time collaborative development
+- **Background Monitoring**: Continuous validation enabled
+
+## 🚨 CRITICAL: VERIFICATION COMMANDS
+
+### Initialize Verification System
+\`\`\`bash
+# Set verification mode (strict/moderate/development)
+./claude-flow-novice verify init strict     # 95% threshold, auto-rollback
+./claude-flow-novice verify init moderate   # 85% threshold, no auto-rollback
+./claude-flow-novice verify init development # 75% threshold, for prototyping
+\`\`\`
+
+### Run Verification
+\`\`\`bash
+# Verify specific tasks
+./claude-flow-novice verify verify task-123 --agent coder
+./claude-flow-novice verify verify task-456 --agent reviewer --threshold 0.90
+
+# Check truth scores
+./claude-flow-novice truth                  # View current truth scores
+./claude-flow-novice truth --report         # Generate detailed report
+./claude-flow-novice truth --analyze        # Analyze failure patterns
+\`\`\`
+
+### Pair Programming Mode
+\`\`\`bash
+# Start pair programming with real-time verification
+./claude-flow-novice pair --start           # Begin collaborative session
+./claude-flow-novice pair --start --mode strict  # Production-quality pairing
+./claude-flow-novice pair --verify --threshold 0.90  # Custom threshold
+
+# Background monitoring (use run_in_background: true)
+./claude-flow-novice pair --start --monitor # Continuous monitoring dashboard
+\`\`\`
+
+## 📊 VERIFICATION REQUIREMENTS BY AGENT TYPE
+
+### Coder Agents
+- **Compile**: Code must compile without errors (35% weight)
+- **Test**: All tests must pass (25% weight)
+- **Lint**: Code quality checks (20% weight)
+- **Typecheck**: Type safety verification (20% weight)
+
+### Reviewer Agents
+- **Code Analysis**: Static code analysis
+- **Security Scan**: Vulnerability detection
+- **Performance Check**: Regression testing
+
+### Tester Agents
+- **Unit Tests**: Component-level testing
+- **Integration Tests**: System-wide validation
+- **Coverage Check**: Minimum coverage thresholds
+
+### Planner Agents
+- **Task Decomposition**: Valid task breakdown
+- **Dependency Check**: Dependency validation
+- **Feasibility**: Resource analysis
+
+## 🔄 BACKGROUND TASK MANAGEMENT
+
+### Running Verification in Background
+\`\`\`javascript
+// Use run_in_background parameter for continuous monitoring
+{
+  "tool": "Bash",
+  "command": "./claude-flow-novice pair --start --monitor",
+  "run_in_background": true  // Enables background execution
+}
+\`\`\`
+
+### Managing Background Tasks
+\`\`\`bash
+# Interactive management
+/bashes                      # View all background tasks
+
+# Check specific verification task
+"Check status of bash_1"     # Via prompt to Claude
+
+# Monitor verification output
+"Show output from bash_1"    # Real-time monitoring
+
+# Kill verification session
+"Kill bash_1"                # Stop background verification
+\`\`\`
+
+## 🚨 CRITICAL: CONCURRENT VERIFICATION
+
+**MANDATORY**: All verification operations MUST be concurrent:
+
+### ✅ CORRECT - Parallel Verification
+\`\`\`javascript
+[Single Message]:
+  // Initialize verification for multiple tasks
+  - Bash("./claude-flow-novice verify verify task-1 --agent coder")
+  - Bash("./claude-flow-novice verify verify task-2 --agent reviewer")
+  - Bash("./claude-flow-novice verify verify task-3 --agent tester")
+  
+  // Check all truth scores
+  - Bash("./claude-flow-novice truth --json")
+  
+  // Start monitoring in background
+  - Bash("./claude-flow-novice pair --start --monitor", run_in_background: true)
+\`\`\`
+
+### ❌ WRONG - Sequential Verification
+\`\`\`javascript
+Message 1: Verify task-1
+Message 2: Verify task-2
+Message 3: Check truth score
+// This is 3x slower!
+\`\`\`
+
+## 📈 VERIFICATION METRICS & THRESHOLDS
+
+### Target Metrics
+- **Truth Accuracy Rate**: >95%
+- **Integration Success Rate**: >90%
+- **Automated Rollback Frequency**: <5%
+- **Human Intervention Rate**: <10%
+
+### Verification Modes
+| Mode | Threshold | Auto-Rollback | Use Case |
+|------|-----------|---------------|----------|
+| **Strict** | 0.95 | ✅ Enabled | Production |
+| **Moderate** | 0.85 | ❌ Disabled | Development |
+| **Development** | 0.75 | ❌ Disabled | Prototyping |
+
+## 🤝 PAIR PROGRAMMING WORKFLOW
+
+### 1. Start Session
+\`\`\`bash
+# Initialize pair programming with verification
+./claude-flow-novice pair --start --mode strict
+\`\`\`
+
+### 2. Real-time Verification Cycle
+\`\`\`
+Developer writes code
+    ↓
+AI agent reviews in real-time
+    ↓
+Verification engine checks:
+  - Compilation (35%)
+  - Tests (25%)
+  - Linting (20%)
+  - Type safety (20%)
+    ↓
+Truth score calculated
+    ↓
+Pass (>0.95) → Accept change
+Fail (<0.95) → Suggest fixes or rollback
+\`\`\`
+
+### 3. Continuous Monitoring
+\`\`\`bash
+# Monitor in background
+./claude-flow-novice pair --start --monitor &
+
+# Check verification output
+/bashes  # Interactive view
+"Check bash_1 output"  # Via prompt
+\`\`\`
+
+## 🔒 SECURITY & AUDIT FEATURES
+
+### Cryptographic Verification
+- All verification results are cryptographically signed
+- SHA256 checksums for integrity
+- Immutable audit trail
+
+### Byzantine Fault Tolerance
+- Protection against incorrect agents
+- Consensus requirements (2/3+ majority)
+- Automatic agent quarantine
+
+### Audit Trail
+\`\`\`bash
+# View verification history
+cat .swarm/verification-memory.json | jq .history
+
+# Check agent reliability
+./claude-flow-novice truth --agent coder --detailed
+\`\`\`
+
+## 🚀 QUICK START VERIFICATION WORKFLOW
+
+### Step 1: Initialize Project with Verification
+\`\`\`bash
+# Initialize with verification-first approach
+npx claude-flow@alpha init --verify --pair
+
+# Set up strict verification
+./claude-flow-novice verify init strict
+\`\`\`
+
+### Step 2: Start Development with Pair Programming
+\`\`\`bash
+# Start pair programming session
+./claude-flow-novice pair --start --mode strict --monitor &
+
+# Monitor verification (background task)
+/bashes  # Check bash_1 status
+\`\`\`
+
+### Step 3: Develop with Continuous Verification
+\`\`\`bash
+# All changes are automatically verified
+# Truth scores maintained above 0.95
+# Auto-rollback on verification failures
+\`\`\`
+
+### Step 4: Check Truth Metrics
+\`\`\`bash
+# View current truth scores
+./claude-flow-novice truth
+
+# Generate detailed report
+./claude-flow-novice truth --report --export metrics.json
+\`\`\`
+
+## 📋 VERIFICATION CHECKLIST
+
+Before ANY operation:
+- ✅ Is verification system initialized?
+- ✅ Is pair programming mode active?
+- ✅ Are background monitors running?
+- ✅ Is truth threshold configured correctly?
+- ✅ Are all agents configured for verification?
+
+## 🛠️ BUILD COMMANDS WITH VERIFICATION
+
+### Standard Commands (with verification)
+- \`npm run build\`: Build with verification checks
+- \`npm run test\`: Test with truth scoring
+- \`npm run lint\`: Lint with verification tracking
+- \`npm run typecheck\`: Type check with validation
+
+### Verification Commands
+- \`./claude-flow-novice verify status\`: Check system status
+- \`./claude-flow-novice verify verify <task>\`: Run verification
+- \`./claude-flow-novice truth\`: View truth scores
+- \`./claude-flow-novice pair --start\`: Begin pair programming
+
+## 💾 PERSISTENT VERIFICATION MEMORY
+
+Verification data stored in:
+- \`.swarm/verification-memory.json\`: Verification history
+- \`.swarm/memory.db\`: Persistent swarm memory
+- \`.claude/verification-config.json\`: Custom configuration
+
+## 🎯 AGENT VERIFICATION PATTERNS
+
+### Full-Stack Development with Verification
+\`\`\`javascript
+// Deploy agents with verification requirements
+Task("System architecture", "Design with verification", "system-architect")
+Task("Backend APIs", "Implement with 95% accuracy", "backend-dev")
+Task("Frontend", "Build with validation", "mobile-dev")
+Task("Testing", "Comprehensive verification", "tester")
+Task("Review", "Verify all changes", "reviewer")
+\`\`\`
+
+### Verification-First TDD
+\`\`\`javascript
+// TDD with mandatory verification
+Task("Write failing tests", "Verify test quality", "tester")
+Task("Implement code", "Verify implementation", "coder")
+Task("Refactor", "Verify improvements", "reviewer")
+Task("Validate", "Final verification", "production-validator")
+\`\`\`
+
+## ⚡ PERFORMANCE WITH VERIFICATION
+
+### Optimized Verification
+- **Parallel Checks**: Run all verifications concurrently
+- **Cached Results**: Skip unchanged file verification
+- **Smart Batching**: Group related verifications
+- **Background Execution**: Non-blocking verification
+
+### Expected Performance
+- Verification overhead: <10% for most operations
+- Truth score calculation: <500ms
+- Rollback execution: <2 seconds
+- Background monitoring: Minimal impact
+
+## 🔄 AUTOMATED WORKFLOWS
+
+### CI/CD Integration
+\`\`\`yaml
+# .github/workflows/verification.yml
+- name: Run Verification
+  run: |
+    npx claude-flow-novice verify init strict
+    npx claude-flow-novice verify verify \${{ github.run_id }}
+    npx claude-flow-novice truth --threshold 0.95
+\`\`\`
+
+### Pre-commit Hooks
+\`\`\`bash
+# .git/hooks/pre-commit
+#!/bin/bash
+npx claude-flow-novice verify verify pre-commit --agent coder
+SCORE=\$(npx claude-flow-novice truth --json | jq .averageScore)
+if [ "\$SCORE" -lt "0.85" ]; then
+  echo "❌ Commit blocked: Truth score \$SCORE below threshold"
+  exit 1
+fi
+\`\`\`
+
+## 📚 DOCUMENTATION
+
+- [Truth Verification System](https://github.com/ruvnet/claude-flow/wiki/Truth-Verification-System)
+- [Pair Programming Guide](https://github.com/ruvnet/claude-flow/wiki/Pair-Programming-System)
+- [Background Commands](https://github.com/ruvnet/claude-flow/wiki/background-commands)
+- [Agent Verification](https://github.com/ruvnet/claude-flow/wiki/Agent-Verification)
+
+## 🚨 IMPORTANT REMINDERS
+
+1. **Truth is Enforced**: Every operation requires verification
+2. **Parallel Execution**: All verifications run concurrently
+3. **Background Monitoring**: Use run_in_background for continuous checks
+4. **Persistent Memory**: All verification data is saved
+5. **Auto-Rollback**: Failed verifications trigger automatic recovery
+
+---
+
+Remember: **"Truth is enforced, not assumed"** - All operations require verification!
+`;
+}
+
+export function createVerificationSettingsJson() {
+  return JSON.stringify(
+    {
+      version: '1.0.0',
+      verification: {
+        enabled: true,
+        mode: 'strict',
+        threshold: 0.95,
+        autoRollback: true,
+        requireConsensus: true,
+      },
+      pairProgramming: {
+        enabled: true,
+        mode: 'strict',
+        realTimeVerification: true,
+        continuousMonitoring: true,
+        backgroundExecution: true,
+      },
+      agentVerification: {
+        coder: {
+          checks: ['compile', 'test', 'lint', 'typecheck'],
+          weights: {
+            compile: 0.35,
+            test: 0.25,
+            lint: 0.2,
+            typecheck: 0.2,
+          },
+        },
+        reviewer: {
+          checks: ['code-analysis', 'security-scan', 'performance-check'],
+          weights: {
+            'code-analysis': 0.4,
+            'security-scan': 0.35,
+            'performance-check': 0.25,
+          },
+        },
+        tester: {
+          checks: ['unit-tests', 'integration-tests', 'coverage-check'],
+          weights: {
+            'unit-tests': 0.35,
+            'integration-tests': 0.35,
+            'coverage-check': 0.3,
+          },
+        },
+        planner: {
+          checks: ['task-decomposition', 'dependency-check', 'feasibility'],
+          weights: {
+            'task-decomposition': 0.4,
+            'dependency-check': 0.3,
+            feasibility: 0.3,
+          },
+        },
+      },
+      backgroundTasks: {
+        autoBackground: {
+          enabled: true,
+          patterns: [
+            './claude-flow-novice pair --start',
+            './claude-flow-novice verify verify',
+            './claude-flow-novice truth --monitor',
+            '*--monitor*',
+            '*--watch*',
+          ],
+        },
+      },
+      metrics: {
+        targets: {
+          truthAccuracy: 0.95,
+          integrationSuccess: 0.9,
+          rollbackFrequency: 0.05,
+          humanIntervention: 0.1,
+        },
+      },
+      hooks: {
+        'pre-commit': {
+          enabled: true,
+          commands: ['npx claude-flow-novice verify verify pre-commit --agent coder'],
+          threshold: 0.85,
+        },
+        'post-task': {
+          enabled: true,
+          commands: ['npx claude-flow-novice truth --json', 'npx claude-flow-novice verify status'],
+        },
+      },
+    },
+    null,
+    2,
+  );
+}

package/.claude-flow-novice/dist/src/slash-commands/benchmark-prompts.js

@@ -0,0 +1,281 @@
+const path = require('path');
+const { AgentBenchmarkSystem } = require('../../benchmark/agent-benchmarking/index');
+
+/**
+ * Benchmark agent prompt formats
+ *
+ * @command /benchmark-prompts
+ * @description Run automated benchmarks comparing different agent prompt formatting styles
+ * @example /benchmark-prompts run
+ * @example /benchmark-prompts run --rounds 5 --parallel
+ * @example /benchmark-prompts analyze
+ * @example /benchmark-prompts report markdown
+ */
+async function benchmarkPrompts(args) {
+  const system = new AgentBenchmarkSystem();
+
+  const command = args[0] || 'help';
+
+  try {
+    switch (command) {
+      case 'run':
+        return await runBenchmark(system, args);
+
+      case 'test':
+        return await testFormat(system, args);
+
+      case 'analyze':
+        return await analyzeBenchmark(system);
+
+      case 'report':
+        return await generateReport(system, args);
+
+      case 'compare':
+        return await compareBenchmark(system);
+
+      case 'list':
+        return await listBenchmarks(system);
+
+      case 'reset':
+        return await resetBenchmarks(system);
+
+      case 'help':
+      default:
+        return showHelp();
+    }
+  } catch (error) {
+    console.error(`\n❌ Error: ${error.message}\n`);
+    if (args.includes('--verbose')) {
+      console.error(error.stack);
+    }
+    return { success: false, error: error.message };
+  }
+}
+
+async function runBenchmark(system, args) {
+  console.log('\n🎯 Running Agent Prompt Format Benchmark\n');
+
+  const options = {
+    rounds: 3,
+    parallel: false,
+    verbose: false,
+    scenarios: null
+  };
+
+  // Parse options
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--rounds' && args[i + 1]) {
+      options.rounds = parseInt(args[i + 1]);
+      i++;
+    } else if (arg === '--parallel') {
+      options.parallel = true;
+    } else if (arg === '--verbose') {
+      options.verbose = true;
+    } else if (arg === '--scenarios' && args[i + 1]) {
+      options.scenarios = args[i + 1];
+      i++;
+    }
+  }
+
+  console.log('Configuration:');
+  console.log(`  Rounds: ${options.rounds}`);
+  console.log(`  Parallel: ${options.parallel ? 'Yes' : 'No'}`);
+  console.log(`  Scenarios: ${options.scenarios || 'All'}\n`);
+
+  const result = await system.run(options);
+
+  console.log('\n✅ Benchmark complete!');
+  console.log('\nNext steps:');
+  console.log('  /benchmark-prompts analyze   - View statistical analysis');
+  console.log('  /benchmark-prompts report    - Generate detailed reports');
+  console.log('  /benchmark-prompts compare   - Interactive comparison\n');
+
+  return { success: true, result };
+}
+
+async function testFormat(system, args) {
+  const format = args[1];
+  if (!format || !['minimal', 'metadata', 'code-heavy'].includes(format)) {
+    console.error('\n❌ Invalid format. Use: minimal, metadata, or code-heavy\n');
+    return { success: false };
+  }
+
+  console.log(`\n🧪 Testing ${format} format\n`);
+
+  // Run benchmark with only specified format
+  const options = {
+    rounds: parseInt(args[2]) || 3,
+    parallel: false,
+    verbose: args.includes('--verbose')
+  };
+
+  // This would need modification to support single format testing
+  console.log('Note: Currently runs all formats. Single format testing coming soon.\n');
+
+  const result = await system.run(options);
+  return { success: true, result };
+}
+
+async function analyzeBenchmark(system) {
+  console.log('\n📊 Analyzing Benchmark Results\n');
+
+  const result = await system.analyze();
+
+  if (!result) {
+    return { success: false };
+  }
+
+  console.log('\n✅ Analysis complete\n');
+  return { success: true, result };
+}
+
+async function generateReport(system, args) {
+  const format = args[1] || 'all';
+
+  if (!['all', 'markdown', 'csv', 'json'].includes(format)) {
+    console.error('\n❌ Invalid format. Use: all, markdown, csv, or json\n');
+    return { success: false };
+  }
+
+  console.log(`\n📄 Generating ${format} report(s)\n`);
+
+  const result = await system.generateReport(format);
+
+  if (!result) {
+    return { success: false };
+  }
+
+  console.log('\n✅ Report generation complete\n');
+  return { success: true, result };
+}
+
+async function compareBenchmark(system) {
+  console.log('\n📊 Interactive Benchmark Comparison\n');
+
+  // Load and analyze latest results
+  const result = await system.analyze();
+
+  if (!result) {
+    return { success: false };
+  }
+
+  const { results, analysis } = result;
+
+  // Print comparison table
+  console.log('Format Comparison:');
+  console.log('─'.repeat(80));
+  console.log('Format'.padEnd(15) + 'Quality'.padEnd(15) + 'Speed'.padEnd(15) + 'Consistency'.padEnd(15) + 'Success');
+  console.log('─'.repeat(80));
+
+  for (const [formatName, formatData] of Object.entries(results.formats)) {
+    const agg = formatData.aggregated;
+    console.log(
+      formatName.padEnd(15) +
+      `${agg.overallQuality.toFixed(1)}%`.padEnd(15) +
+      `${agg.overallResponseTime.toFixed(0)}ms`.padEnd(15) +
+      `${agg.overallConsistency.toFixed(1)}%`.padEnd(15) +
+      `${agg.successRate.toFixed(1)}%`
+    );
+  }
+  console.log('─'.repeat(80));
+
+  console.log('\n🏆 Winner: ' + results.summary.winner.toUpperCase());
+  console.log('\nRecommendations:');
+  for (const rec of results.summary.recommendation) {
+    console.log(`  • ${rec}`);
+  }
+  console.log('');
+
+  return { success: true, results, analysis };
+}
+
+async function listBenchmarks(system) {
+  console.log('\n📂 Benchmark Results\n');
+  await system.listResults();
+  console.log('');
+  return { success: true };
+}
+
+async function resetBenchmarks(system) {
+  console.log('\n⚠️  This will delete all benchmark results.\n');
+
+  // In interactive mode, would ask for confirmation
+  // For now, proceeding with reset
+
+  await system.reset();
+  console.log('');
+  return { success: true };
+}
+
+function showHelp() {
+  console.log(`
+╔════════════════════════════════════════════════════════════════════════════╗
+║                  Agent Prompt Format Benchmark System                      ║
+╚════════════════════════════════════════════════════════════════════════════╝
+
+Compare different agent prompt formatting styles:
+  • Minimal Format    - Simple frontmatter only
+  • Metadata Format   - Full configuration with hooks and capabilities
+  • Code-Heavy Format - Extensive code examples
+
+COMMANDS:
+  /benchmark-prompts run [options]    Run full benchmark suite
+  /benchmark-prompts test <format>    Test specific format
+  /benchmark-prompts analyze          Analyze collected results
+  /benchmark-prompts report [format]  Generate reports (all|markdown|csv|json)
+  /benchmark-prompts compare          Interactive comparison view
+  /benchmark-prompts list             List all benchmark results
+  /benchmark-prompts reset            Clear all benchmark data
+
+OPTIONS:
+  --rounds <n>         Number of test rounds (default: 3)
+  --parallel           Run tests in parallel
+  --scenarios <list>   Comma-separated scenario IDs to test
+  --verbose            Detailed output
+  --export             Export results
+
+EXAMPLES:
+  /benchmark-prompts run
+  /benchmark-prompts run --rounds 5 --parallel
+  /benchmark-prompts test minimal --verbose
+  /benchmark-prompts analyze
+  /benchmark-prompts report markdown
+  /benchmark-prompts compare
+
+TEST SCENARIOS:
+  • simple-code-analysis          - Basic algorithm optimization
+  • memory-leak-detection         - Memory leak identification
+  • database-query-optimization   - Query performance optimization
+  • caching-strategy              - Cache architecture design
+  • resource-allocation           - Resource calculation
+  • async-pattern-optimization    - Async code optimization
+  • algorithm-complexity-reduction - Algorithm improvement
+  • load-testing-strategy         - Load test planning
+  • bottleneck-identification     - Performance bottleneck analysis
+  • scalability-architecture      - Scalability design
+
+BENCHMARK METRICS:
+  • Quality Score    - Completeness, accuracy, relevance, clarity
+  • Response Time    - Total time to generate response
+  • Consistency      - Variance across multiple rounds
+  • Success Rate     - Percentage of successful completions
+
+For more information, see: /benchmark/agent-benchmarking/README.md
+`);
+
+  return { success: true };
+}
+
+module.exports = {
+  command: 'benchmark-prompts',
+  description: 'Run automated benchmarks comparing agent prompt formats',
+  handler: benchmarkPrompts,
+  examples: [
+    '/benchmark-prompts run',
+    '/benchmark-prompts run --rounds 5 --parallel',
+    '/benchmark-prompts analyze',
+    '/benchmark-prompts report markdown',
+    '/benchmark-prompts compare'
+  ]
+};