claude-flow-novice 1.3.6 → 1.5.0

package/src/swarm-fullstack/workflows/workflow-metrics.ts

@@ -0,0 +1,399 @@
+/**
+ * Workflow Metrics - Track and Calculate Iteration Performance Metrics
+ *
+ * Provides comprehensive metrics tracking for the iterative workflow,
+ * including efficiency, quality, velocity, and convergence metrics.
+ */
+
+import { EventEmitter } from 'events';
+import { ILogger } from '../../core/logger.js';
+import { FeatureIteration, IterationMetrics } from './iterative-build-test.js';
+
+export interface MetricSnapshot {
+  timestamp: string;
+  featureId: string;
+  iteration: number;
+  metrics: IterationMetrics;
+  trends: MetricTrends;
+}
+
+export interface MetricTrends {
+  testPassRateTrend: number; // positive = improving
+  fixSuccessRateTrend: number;
+  convergenceRateTrend: number;
+  efficiencyTrend: number;
+  velocityChange: number; // iterations per hour
+}
+
+export interface AggregateMetrics {
+  featureId: string;
+  totalIterations: number;
+  totalDuration: number;
+  averageIterationTime: number;
+  totalTests: number;
+  overallPassRate: number;
+  totalFixes: number;
+  overallFixSuccessRate: number;
+  averageConvergenceRate: number;
+  averageEfficiency: number;
+  overallQualityScore: number;
+  timeToConvergence: number;
+}
+
+export class WorkflowMetrics extends EventEmitter {
+  private snapshots = new Map<string, MetricSnapshot[]>();
+
+  constructor(private logger: ILogger) {
+    super();
+  }
+
+  /**
+   * Calculate metrics for an iteration
+   */
+  async calculateIterationMetrics(iteration: FeatureIteration): Promise<IterationMetrics> {
+    const startTime = new Date(iteration.startTime).getTime();
+    const endTime = iteration.endTime ? new Date(iteration.endTime).getTime() : Date.now();
+    const duration = endTime - startTime;
+
+    // Test metrics
+    const testsExecuted = iteration.testResults.totalTests;
+    const testPassRate = testsExecuted > 0
+      ? iteration.testResults.passed / testsExecuted
+      : 0;
+
+    // Fix metrics
+    const fixesApplied = iteration.fixResults.length;
+    const successfulFixes = iteration.fixResults.filter((f) => f.status === 'completed').length;
+    const fixSuccessRate = fixesApplied > 0 ? successfulFixes / fixesApplied : 0;
+
+    // Code churn (total lines changed)
+    const codeChurn = iteration.fixResults.reduce(
+      (sum, fix) =>
+        sum + fix.changes.reduce((lineSum, change) => lineSum + change.linesChanged, 0),
+      0,
+    );
+
+    // Convergence rate (how quickly approaching convergence)
+    const convergenceRate = this.calculateConvergenceRate(iteration);
+
+    // Efficiency (value delivered per time)
+    const efficiency = this.calculateEfficiency(
+      testPassRate,
+      fixSuccessRate,
+      duration,
+      testsExecuted,
+    );
+
+    // Quality score
+    const qualityScore = this.calculateQualityScore(iteration);
+
+    const metrics: IterationMetrics = {
+      duration,
+      testsExecuted,
+      testPassRate,
+      fixesApplied,
+      fixSuccessRate,
+      codeChurn,
+      convergenceRate,
+      efficiency,
+      qualityScore,
+    };
+
+    // Store snapshot
+    await this.storeSnapshot(iteration.featureId, iteration.iterationNumber, metrics);
+
+    // Emit metrics event
+    this.emit('metrics:updated', {
+      featureId: iteration.featureId,
+      iteration: iteration.iterationNumber,
+      metrics,
+    });
+
+    return metrics;
+  }
+
+  /**
+   * Calculate convergence rate
+   */
+  private calculateConvergenceRate(iteration: FeatureIteration): number {
+    const passRate = iteration.testResults.passed / iteration.testResults.totalTests || 0;
+
+    // Get historical pass rates
+    const history = this.snapshots.get(iteration.featureId) || [];
+    if (history.length === 0) {
+      return passRate; // First iteration
+    }
+
+    const previousPassRate = history[history.length - 1].metrics.testPassRate;
+    const improvement = passRate - previousPassRate;
+
+    // Convergence rate is the improvement rate
+    return Math.max(improvement, 0);
+  }
+
+  /**
+   * Calculate efficiency score
+   */
+  private calculateEfficiency(
+    testPassRate: number,
+    fixSuccessRate: number,
+    duration: number,
+    testsExecuted: number,
+  ): number {
+    // Efficiency = (quality * throughput) / time
+    const quality = (testPassRate + fixSuccessRate) / 2;
+    const throughput = testsExecuted / 100; // normalized
+    const time = duration / 1800000; // normalized to 30-min units
+
+    const efficiency = time > 0 ? (quality * throughput) / time : 0;
+
+    return Math.min(efficiency, 1);
+  }
+
+  /**
+   * Calculate quality score
+   */
+  private calculateQualityScore(iteration: FeatureIteration): number {
+    let score = 100;
+
+    // Deduct for test failures
+    const { testResults } = iteration;
+    const criticalFailures = testResults.failures.filter((f) => f.severity === 'critical').length;
+    const highFailures = testResults.failures.filter((f) => f.severity === 'high').length;
+    const mediumFailures = testResults.failures.filter((f) => f.severity === 'medium').length;
+
+    score -= criticalFailures * 15;
+    score -= highFailures * 10;
+    score -= mediumFailures * 5;
+
+    // Deduct for warnings
+    const highWarnings = testResults.warnings.filter((w) => w.severity === 'high').length;
+    const mediumWarnings = testResults.warnings.filter((w) => w.severity === 'medium').length;
+
+    score -= highWarnings * 3;
+    score -= mediumWarnings * 1;
+
+    // Deduct for failed fixes
+    const failedFixes = iteration.fixResults.filter((f) => f.status === 'failed').length;
+    score -= failedFixes * 5;
+
+    // Bonus for coverage
+    const avgCoverage =
+      (testResults.coverage.lines +
+        testResults.coverage.functions +
+        testResults.coverage.branches +
+        testResults.coverage.statements) /
+      4;
+
+    score += (avgCoverage - 80) * 0.2; // Bonus for coverage above 80%
+
+    return Math.max(Math.min(score, 100), 0);
+  }
+
+  /**
+   * Store metric snapshot
+   */
+  private async storeSnapshot(
+    featureId: string,
+    iteration: number,
+    metrics: IterationMetrics,
+  ): Promise<void> {
+    if (!this.snapshots.has(featureId)) {
+      this.snapshots.set(featureId, []);
+    }
+
+    const history = this.snapshots.get(featureId)!;
+    const trends = this.calculateTrends(history, metrics);
+
+    const snapshot: MetricSnapshot = {
+      timestamp: new Date().toISOString(),
+      featureId,
+      iteration,
+      metrics,
+      trends,
+    };
+
+    history.push(snapshot);
+  }
+
+  /**
+   * Calculate metric trends
+   */
+  private calculateTrends(history: MetricSnapshot[], current: IterationMetrics): MetricTrends {
+    if (history.length === 0) {
+      return {
+        testPassRateTrend: 0,
+        fixSuccessRateTrend: 0,
+        convergenceRateTrend: 0,
+        efficiencyTrend: 0,
+        velocityChange: 0,
+      };
+    }
+
+    const previous = history[history.length - 1].metrics;
+
+    return {
+      testPassRateTrend: current.testPassRate - previous.testPassRate,
+      fixSuccessRateTrend: current.fixSuccessRate - previous.fixSuccessRate,
+      convergenceRateTrend: current.convergenceRate - previous.convergenceRate,
+      efficiencyTrend: current.efficiency - previous.efficiency,
+      velocityChange: this.calculateVelocityChange(history),
+    };
+  }
+
+  /**
+   * Calculate velocity change (iterations per hour)
+   */
+  private calculateVelocityChange(history: MetricSnapshot[]): number {
+    if (history.length < 2) return 0;
+
+    const recent = history.slice(-2);
+    const timeDiff =
+      new Date(recent[1].timestamp).getTime() - new Date(recent[0].timestamp).getTime();
+    const iterationTime = timeDiff / 3600000; // hours
+
+    return 1 / iterationTime; // iterations per hour
+  }
+
+  /**
+   * Get aggregate metrics for a feature
+   */
+  getAggregateMetrics(featureId: string): AggregateMetrics | null {
+    const history = this.snapshots.get(featureId);
+    if (!history || history.length === 0) return null;
+
+    const totalIterations = history.length;
+    const totalDuration = history.reduce((sum, s) => sum + s.metrics.duration, 0);
+    const averageIterationTime = totalDuration / totalIterations;
+
+    const totalTests = history.reduce((sum, s) => sum + s.metrics.testsExecuted, 0);
+    const avgTestPassRate =
+      history.reduce((sum, s) => sum + s.metrics.testPassRate, 0) / totalIterations;
+
+    const totalFixes = history.reduce((sum, s) => sum + s.metrics.fixesApplied, 0);
+    const avgFixSuccessRate =
+      history.reduce((sum, s) => sum + s.metrics.fixSuccessRate, 0) / totalIterations;
+
+    const avgConvergenceRate =
+      history.reduce((sum, s) => sum + s.metrics.convergenceRate, 0) / totalIterations;
+
+    const avgEfficiency = history.reduce((sum, s) => sum + s.metrics.efficiency, 0) / totalIterations;
+
+    const avgQualityScore =
+      history.reduce((sum, s) => sum + s.metrics.qualityScore, 0) / totalIterations;
+
+    const timeToConvergence = totalDuration;
+
+    return {
+      featureId,
+      totalIterations,
+      totalDuration,
+      averageIterationTime,
+      totalTests,
+      overallPassRate: avgTestPassRate,
+      totalFixes,
+      overallFixSuccessRate: avgFixSuccessRate,
+      averageConvergenceRate: avgConvergenceRate,
+      averageEfficiency: avgEfficiency,
+      overallQualityScore: avgQualityScore,
+      timeToConvergence,
+    };
+  }
+
+  /**
+   * Get metric snapshots for a feature
+   */
+  getSnapshots(featureId: string): MetricSnapshot[] {
+    return this.snapshots.get(featureId) || [];
+  }
+
+  /**
+   * Get current metrics
+   */
+  getCurrentMetrics(featureId: string): MetricSnapshot | null {
+    const history = this.snapshots.get(featureId);
+    if (!history || history.length === 0) return null;
+    return history[history.length - 1];
+  }
+
+  /**
+   * Compare metrics across features
+   */
+  compareFeatures(featureIds: string[]): Map<string, AggregateMetrics | null> {
+    const comparison = new Map<string, AggregateMetrics | null>();
+
+    for (const featureId of featureIds) {
+      comparison.set(featureId, this.getAggregateMetrics(featureId));
+    }
+
+    return comparison;
+  }
+
+  /**
+   * Export metrics for reporting
+   */
+  exportMetrics(featureId: string): {
+    feature: string;
+    snapshots: MetricSnapshot[];
+    aggregate: AggregateMetrics | null;
+    exportedAt: string;
+  } {
+    return {
+      feature: featureId,
+      snapshots: this.getSnapshots(featureId),
+      aggregate: this.getAggregateMetrics(featureId),
+      exportedAt: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Clear metrics for a feature
+   */
+  clearMetrics(featureId: string): void {
+    this.snapshots.delete(featureId);
+    this.logger.info('Cleared metrics', { featureId });
+  }
+
+  /**
+   * Get performance summary
+   */
+  getPerformanceSummary(): {
+    totalFeatures: number;
+    totalIterations: number;
+    averageIterationsPerFeature: number;
+    averageTimeToConvergence: number;
+    overallQualityScore: number;
+  } {
+    const allFeatures = Array.from(this.snapshots.keys());
+    const totalFeatures = allFeatures.length;
+
+    if (totalFeatures === 0) {
+      return {
+        totalFeatures: 0,
+        totalIterations: 0,
+        averageIterationsPerFeature: 0,
+        averageTimeToConvergence: 0,
+        overallQualityScore: 0,
+      };
+    }
+
+    const aggregates = allFeatures
+      .map((f) => this.getAggregateMetrics(f))
+      .filter(Boolean) as AggregateMetrics[];
+
+    const totalIterations = aggregates.reduce((sum, a) => sum + a.totalIterations, 0);
+    const averageIterationsPerFeature = totalIterations / totalFeatures;
+    const averageTimeToConvergence =
+      aggregates.reduce((sum, a) => sum + a.timeToConvergence, 0) / totalFeatures;
+    const overallQualityScore =
+      aggregates.reduce((sum, a) => sum + a.overallQualityScore, 0) / totalFeatures;
+
+    return {
+      totalFeatures,
+      totalIterations,
+      averageIterationsPerFeature,
+      averageTimeToConvergence,
+      overallQualityScore,
+    };
+  }
+}

package/wiki/command-reference/README.md

@@ -253,8 +253,7 @@ claude mcp add claude-flow-novice npx claude-flow@alpha mcp start
 # RUV Swarm MCP (Enhanced coordination)
 claude mcp add ruv-swarm npx ruv-swarm mcp start
 
-# Flow Nexus MCP (Cloud features - optional)
-claude mcp add flow-nexus npx flow-nexus@latest mcp start
+# Flow Nexus integration removed
 ```
 
 ### IDE Integration

package/wiki/command-reference/mcp-tools/README.md

@@ -674,7 +674,7 @@ claude mcp add claude-flow-novice npx claude-flow@alpha mcp start
 claude mcp add ruv-swarm npx ruv-swarm mcp start
 
 # Optional: Cloud features (requires registration)
-claude mcp add flow-nexus npx flow-nexus@latest mcp start
+# Flow-nexus integration removed
 ```
 
 ### Verify MCP Setup

package/wiki/getting-started/claude-code-mcp/README.md

@@ -22,8 +22,7 @@ claude mcp add claude-flow-novice npx claude-flow@alpha mcp start
 # Optional: Enhanced coordination features
 claude mcp add ruv-swarm npx ruv-swarm mcp start
 
-# Optional: Cloud features (requires registration)
-claude mcp add flow-nexus npx flow-nexus@latest mcp start
+# Flow-nexus integration removed
 ```
 
 ### 2. Verify Installation

package/wiki/getting-started/installation/README.md

@@ -152,8 +152,7 @@ claude mcp add claude-flow-novice npx claude-flow@alpha mcp start
 # Optional: Enhanced coordination
 claude mcp add ruv-swarm npx ruv-swarm mcp start
 
-# Optional: Cloud features (requires registration)
-claude mcp add flow-nexus npx flow-nexus@latest mcp start
+# Flow-nexus integration removed
 ```
 
 ### Step 2: Verify MCP Installation
@@ -258,14 +257,7 @@ npx claude-flow@alpha config set auth.apiKey "your-key-here"
 
 ### Cloud Features (Optional)
 ```bash
-# Register for Flow-Nexus cloud features
-npx flow-nexus@latest register
-
-# Login to existing account
-npx flow-nexus@latest login
-
-# Verify cloud access
-npx flow-nexus@latest status
+# Flow-nexus registration removed
 ```
 
 ---

package/.claude/commands/flow-nexus/app-store.md

@@ -1,124 +0,0 @@
----
-name: flow-nexus-app-store
-description: Browse, publish, and deploy applications
----
-
-# Flow Nexus App Store
-
-Browse templates, publish apps, and deploy solutions.
-
-## Browse Apps
-```javascript
-// Search apps
-mcp__flow-nexus__app_search({
-  search: "authentication",
-  category: "backend",
-  featured: true,
-  limit: 20
-})
-
-// Get app details
-mcp__flow-nexus__app_get({ app_id: "app_id" })
-
-// List templates
-mcp__flow-nexus__app_store_list_templates({
-  category: "web-api",
-  tags: ["express", "jwt"],
-  limit: 20
-})
-```
-
-## Publish App
-```javascript
-mcp__flow-nexus__app_store_publish_app({
-  name: "My Auth Service",
-  description: "JWT-based authentication microservice",
-  category: "backend",
-  version: "1.0.0",
-  source_code: sourceCode,
-  tags: ["auth", "jwt", "express"],
-  metadata: {
-    author: "Your Name",
-    license: "MIT",
-    repository: "github.com/user/repo"
-  }
-})
-```
-
-## Deploy Templates
-```javascript
-// Get template details
-mcp__flow-nexus__template_get({
-  template_name: "express-api-starter"
-})
-
-// Deploy template
-mcp__flow-nexus__template_deploy({
-  template_name: "express-api-starter",
-  deployment_name: "my-api",
-  variables: {
-    api_key: "your_key",
-    database_url: "postgres://..."
-  },
-  env_vars: {
-    NODE_ENV: "production"
-  }
-})
-```
-
-## Analytics
-```javascript
-// Get app analytics
-mcp__flow-nexus__app_analytics({
-  app_id: "your_app_id",
-  timeframe: "30d" // 24h, 7d, 30d, 90d
-})
-
-// View installed apps
-mcp__flow-nexus__app_installed({
-  user_id: "your_id"
-})
-```
-
-## Update App
-```javascript
-mcp__flow-nexus__app_update({
-  app_id: "app_id",
-  updates: {
-    version: "1.1.0",
-    description: "Updated description",
-    tags: ["new", "tags"]
-  }
-})
-```
-
-## Market Data
-```javascript
-// Get market statistics
-mcp__flow-nexus__market_data()
-```
-
-## Template Categories
-- **web-api**: RESTful APIs and microservices
-- **frontend**: React, Vue, Angular apps
-- **full-stack**: Complete applications
-- **cli-tools**: Command-line utilities
-- **data-processing**: ETL and analytics
-- **ml-models**: Pre-trained models
-- **blockchain**: Web3 applications
-- **mobile**: React Native apps
-
-## Publishing Best Practices
-1. Include comprehensive documentation
-2. Add example usage and configuration
-3. Include tests and CI/CD setup
-4. Use semantic versioning
-5. Add clear license information
-6. Include docker/deployment configs
-7. Provide migration guides for updates
-
-## Revenue Sharing
-- Earn rUv credits when others use your templates
-- Set pricing (0 for free templates)
-- Track usage and earnings in analytics
-- Withdraw credits or use for Flow Nexus services

package/.claude/commands/flow-nexus/challenges.md

@@ -1,120 +0,0 @@
----
-name: flow-nexus-challenges
-description: Coding challenges, achievements, and leaderboards
----
-
-# Flow Nexus Challenges
-
-Complete coding challenges to earn rUv credits and climb the leaderboard.
-
-## List Challenges
-```javascript
-mcp__flow-nexus__challenges_list({
-  difficulty: "intermediate", // beginner, advanced, expert
-  category: "algorithms",
-  status: "active",
-  limit: 20
-})
-```
-
-## Get Challenge Details
-```javascript
-mcp__flow-nexus__challenge_get({
-  challenge_id: "two-sum-problem"
-})
-```
-
-## Submit Solution
-```javascript
-mcp__flow-nexus__challenge_submit({
-  challenge_id: "challenge_id",
-  user_id: "your_id",
-  solution_code: `
-    function solution(nums, target) {
-      const map = new Map();
-      for (let i = 0; i < nums.length; i++) {
-        const complement = target - nums[i];
-        if (map.has(complement)) {
-          return [map.get(complement), i];
-        }
-        map.set(nums[i], i);
-      }
-      return [];
-    }
-  `,
-  language: "javascript",
-  execution_time: 45 // milliseconds
-})
-```
-
-## Complete Challenge
-```javascript
-mcp__flow-nexus__app_store_complete_challenge({
-  challenge_id: "challenge_id",
-  user_id: "your_id",
-  submission_data: {
-    passed_tests: 10,
-    total_tests: 10,
-    execution_time: 45
-  }
-})
-```
-
-## Leaderboards
-```javascript
-// Global leaderboard
-mcp__flow-nexus__leaderboard_get({
-  type: "global", // weekly, monthly, challenge
-  limit: 10
-})
-
-// Challenge-specific leaderboard
-mcp__flow-nexus__leaderboard_get({
-  type: "challenge",
-  challenge_id: "specific_challenge",
-  limit: 25
-})
-```
-
-## Achievements
-```javascript
-mcp__flow-nexus__achievements_list({
-  user_id: "your_id",
-  category: "speed_demon" // Categories vary
-})
-```
-
-## rUv Credits
-```javascript
-// Check balance
-mcp__flow-nexus__ruv_balance({ user_id: "your_id" })
-
-// View history
-mcp__flow-nexus__ruv_history({
-  user_id: "your_id",
-  limit: 20
-})
-
-// Earn credits (automatic on completion)
-mcp__flow-nexus__app_store_earn_ruv({
-  user_id: "your_id",
-  amount: 100,
-  reason: "Completed expert challenge",
-  source: "challenge"
-})
-```
-
-## Challenge Categories
-- **algorithms**: Classic algorithm problems
-- **data-structures**: DS implementation challenges
-- **system-design**: Architecture challenges
-- **optimization**: Performance challenges
-- **security**: Security-focused problems
-- **ml-basics**: Machine learning fundamentals
-
-## Tips
-1. Start with beginner challenges
-2. Review other solutions after completing
-3. Optimize for both correctness and speed
-4. Complete daily challenges for bonus credits
-5. Unlock achievements for extra rewards