claude-flow-novice 2.15.0 → 2.15.1

package/claude-assets/skills/cfn-error-batching-strategy/analyze-errors.sh

@@ -0,0 +1,327 @@
+#!/bin/bash
+
+# CFN Error Batching Strategy - Phase 1: Analyze Errors
+# Parses error output from multiple languages and tools
+
+set -eo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Defaults
+COMMAND=""
+WORKSPACE=""
+LANGUAGE=""
+OUTPUT_FORMAT="json"
+TIMEOUT=30
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --command)
+      COMMAND="$2"
+      shift 2
+      ;;
+    --workspace)
+      WORKSPACE="$2"
+      shift 2
+      ;;
+    --language)
+      LANGUAGE="$2"
+      shift 2
+      ;;
+    --output-format)
+      OUTPUT_FORMAT="$2"
+      shift 2
+      ;;
+    --timeout)
+      TIMEOUT="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validate inputs
+if [ -z "$COMMAND" ] || [ -z "$WORKSPACE" ]; then
+  echo "Error: Missing required options --command and --workspace" >&2
+  exit 1
+fi
+
+# Run error command with timeout
+run_error_command() {
+  cd "$WORKSPACE" || return 1
+
+  # Execute with timeout, capturing both stdout and stderr
+  timeout "$TIMEOUT" bash -c "$COMMAND" 2>&1 || {
+    local exit_code=$?
+    # Timeout (124) or other errors are expected for error-detecting tools
+    if [ $exit_code -eq 124 ]; then
+      echo "[ERROR] Command timeout after ${TIMEOUT}s" >&2
+    fi
+    # Return command output anyway if available
+  }
+}
+
+# Parse TypeScript errors (tsc output)
+parse_typescript() {
+  local output="$1"
+
+  # Pattern: src/file.ts(line,col): error TSxxxx: message
+  jq -R -s '
+    split("\n") |
+    map(select(test("error TS[0-9]+"))) |
+    map(
+      capture("^(?<file>[^(]+)\\((?<line>[0-9]+),(?<col>[0-9]+)\\): error TS(?<code>[0-9]+): (?<message>.*)$") |
+      select(.file != null) |
+      {
+        file: .file,
+        line: (.line | tonumber),
+        column: (.col | tonumber),
+        code: .code,
+        error: .message
+      }
+    )
+  ' <<< "$output"
+}
+
+# Parse Python mypy errors
+parse_python_mypy() {
+  local output="$1"
+
+  # Pattern: file.py:line:col: error: message
+  jq -R -s '
+    split("\n") |
+    map(select(test("error:"))) |
+    map(
+      capture("^(?<file>[^:]+):(?<line>[0-9]+):(?<col>[0-9]+): error: (?<message>.*)$") |
+      select(.file != null) |
+      {
+        file: .file,
+        line: (.line | tonumber),
+        column: (.col | tonumber),
+        error: .message,
+        code: "mypy"
+      }
+    )
+  ' <<< "$output"
+}
+
+# Parse Python ruff errors
+parse_python_ruff() {
+  local output="$1"
+
+  # Pattern: file.py:line:col: E/W/Fxxx: message
+  jq -R -s '
+    split("\n") |
+    map(select(test("[EWF][0-9]{3}"))) |
+    map(
+      capture("^(?<file>[^:]+):(?<line>[0-9]+):(?<col>[0-9]+): (?<code>[EWF][0-9]{3}): (?<message>.*)$") |
+      select(.file != null) |
+      {
+        file: .file,
+        line: (.line | tonumber),
+        column: (.col | tonumber),
+        code: .code,
+        error: .message
+      }
+    )
+  ' <<< "$output"
+}
+
+# Parse Rust cargo errors
+parse_rust() {
+  local output="$1"
+
+  # Pattern: error[Exxx]: message
+  jq -R -s '
+    split("\n") |
+    map(select(test("^error\\["))) |
+    map(
+      capture("^error\\[(?<code>E[0-9]{4})\\]: (?<message>.*)") |
+      select(.code != null) |
+      {
+        file: "unknown",
+        line: 0,
+        column: 0,
+        code: .code,
+        error: .message
+      }
+    )
+  ' <<< "$output"
+}
+
+# Parse ESLint errors
+parse_eslint() {
+  local output="$1"
+
+  # Pattern: file.js:line:col: level: message (rule)
+  jq -R -s '
+    split("\n") |
+    map(select(test("error|warning"))) |
+    map(
+      capture("^(?<file>[^:]+):(?<line>[0-9]+):(?<col>[0-9]+): (?<level>error|warning): (?<message>[^(]+)") |
+      select(.file != null) |
+      {
+        file: .file,
+        line: (.line | tonumber),
+        column: (.col | tonumber),
+        error: .message | gsub("\\s+$"; ""),
+        code: .level
+      }
+    )
+  ' <<< "$output"
+}
+
+# Parse ShellCheck errors
+parse_shell() {
+  local output="$1"
+
+  # Pattern: file:line:col: level: code: message
+  jq -R -s '
+    split("\n") |
+    map(select(test("error|warning"))) |
+    map(
+      capture("^(?<file>[^:]+):(?<line>[0-9]+):(?<col>[0-9]+): (?<level>error|warning): (?<message>[^\\[]+)") |
+      select(.file != null) |
+      {
+        file: .file,
+        line: (.line | tonumber),
+        column: (.col | tonumber),
+        error: .message | gsub("\\s+$"; ""),
+        code: .level
+      }
+    )
+  ' <<< "$output"
+}
+
+# Generic parser (file:line:message)
+parse_generic() {
+  local output="$1"
+
+  # Try to extract file:line:message pattern
+  jq -R -s '
+    split("\n") |
+    map(select(length > 0)) |
+    map(
+      capture("^(?<file>[^:]+):(?<line>[0-9]+):(?<message>.*)$") |
+      select(.file != null) |
+      {
+        file: .file,
+        line: (.line | tonumber),
+        column: 0,
+        error: .message | gsub("^\\s+"; ""),
+        code: "unknown"
+      }
+    )
+  ' <<< "$output"
+}
+
+# Auto-detect language from command
+auto_detect_language() {
+  if [ -n "$LANGUAGE" ]; then
+    return
+  fi
+
+  case "$COMMAND" in
+    *tsc*|*typescript*)
+      LANGUAGE="typescript"
+      ;;
+    *mypy*)
+      LANGUAGE="python_mypy"
+      ;;
+    *ruff*)
+      LANGUAGE="python_ruff"
+      ;;
+    *cargo*|*rustc*)
+      LANGUAGE="rust"
+      ;;
+    *eslint*|*prettier*)
+      LANGUAGE="eslint"
+      ;;
+    *shellcheck*)
+      LANGUAGE="shell"
+      ;;
+    *)
+      LANGUAGE="generic"
+      ;;
+  esac
+}
+
+# Select parser based on language
+select_parser() {
+  local language="${1:-generic}"
+
+  case "$language" in
+    typescript|ts)
+      parse_typescript
+      ;;
+    python_mypy)
+      parse_python_mypy
+      ;;
+    python_ruff|python)
+      parse_python_ruff
+      ;;
+    rust)
+      parse_rust
+      ;;
+    eslint|tslint)
+      parse_eslint
+      ;;
+    shell|shellcheck)
+      parse_shell
+      ;;
+    *)
+      parse_generic
+      ;;
+  esac
+}
+
+# Main analysis
+main() {
+  auto_detect_language
+
+  # Run error command
+  local error_output
+  error_output=$(run_error_command)
+
+  # Parse errors using selected parser
+  local parsed_errors
+  parsed_errors=$(select_parser "$LANGUAGE" <<< "$error_output")
+
+  # Count errors
+  local total_errors
+  total_errors=$(echo "$parsed_errors" | jq 'length')
+
+  # Group by file
+  local files_with_errors
+  files_with_errors=$(echo "$parsed_errors" | jq 'group_by(.file) | map({(.[0].file): length}) | add // {}')
+
+  # Get error code distribution (if available)
+  local error_distribution
+  error_distribution=$(echo "$parsed_errors" | \
+    jq '[.[] | select(.code != null and .code != "unknown")] | group_by(.code) | map({code: .[0].code, count: length}) | from_entries')
+
+  # Get sample errors (first 10)
+  local error_samples
+  error_samples=$(echo "$parsed_errors" | jq '.[0:10]')
+
+  # Output JSON
+  jq -n \
+    --argjson total_errors "$total_errors" \
+    --argjson files_with_errors "$files_with_errors" \
+    --argjson error_distribution "$error_distribution" \
+    --argjson error_samples "$error_samples" \
+    --arg language "$LANGUAGE" \
+    '{
+      total_errors: $total_errors,
+      files_with_errors: $files_with_errors,
+      error_distribution: $error_distribution,
+      error_samples: $error_samples,
+      language: $language
+    }'
+}
+
+main

package/claude-assets/skills/cfn-error-batching-strategy/calculate-waves.sh

@@ -0,0 +1,256 @@
+#!/bin/bash
+
+# CFN Error Batching Strategy - Phase 5: Calculate Spawn Waves
+# Plans memory-aware spawning waves respecting budget and parallelism constraints
+
+set -eo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Defaults
+BATCHES="[]"
+MEMORY_BUDGET="40g"
+MAX_PARALLEL=32
+OUTPUT_FORMAT="json"
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --batches)
+      BATCHES="$2"
+      shift 2
+      ;;
+    --budget)
+      MEMORY_BUDGET="$2"
+      shift 2
+      ;;
+    --max-parallel)
+      MAX_PARALLEL="$2"
+      shift 2
+      ;;
+    --output-format)
+      OUTPUT_FORMAT="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Parse memory to bytes
+parse_memory() {
+  local mem="$1"
+  local num=$(echo "$mem" | sed 's/[^0-9]//g')
+  local unit=$(echo "$mem" | sed 's/[0-9]//g' | tr '[:upper:]' '[:lower:]')
+
+  case "$unit" in
+    g) echo "$((num * 1024 * 1024 * 1024))" ;;
+    m) echo "$((num * 1024 * 1024))" ;;
+    k) echo "$((num * 1024))" ;;
+    *) echo "$num" ;;
+  esac
+}
+
+# Format bytes to human-readable
+format_memory() {
+  local bytes="$1"
+
+  if [ "$bytes" -ge $((1024 * 1024 * 1024)) ]; then
+    echo "$((bytes / (1024 * 1024 * 1024)))GB"
+  elif [ "$bytes" -ge $((1024 * 1024)) ]; then
+    echo "$((bytes / (1024 * 1024)))MB"
+  else
+    echo "$((bytes / 1024))KB"
+  fi
+}
+
+# Estimate task duration (rough heuristic)
+estimate_duration() {
+  local error_count="$1"
+
+  # Rough estimate: 1-2 errors fixed per second
+  # Lower bound: 30 seconds, upper bound: 10 minutes
+  local seconds=$((error_count / 2 + 30))
+
+  if [ $seconds -gt 600 ]; then
+    seconds=600
+  fi
+
+  # Convert to m:ss format
+  local minutes=$((seconds / 60))
+  local secs=$((seconds % 60))
+
+  printf "%dm%02ds\n" "$minutes" "$secs"
+}
+
+# Calculate spawn waves
+calculate_waves() {
+  local batches="$1"
+  local budget_bytes="$2"
+  local max_parallel="$3"
+
+  jq -n \
+    --argjson batches "$batches" \
+    --argjson budget_bytes "$budget_bytes" \
+    --argjson max_parallel "$max_parallel" \
+    '
+    # Sort batches by tier (tier 1 first for max parallelism)
+    ($batches.batches | sort_by(.tier)) as $sorted_batches |
+
+    # Calculate wave groupings respecting budget
+    reduce $sorted_batches[] as $batch (
+      {
+        waves: [],
+        current_wave: [],
+        current_memory: 0,
+        wave_count: 0
+      };
+      . as $acc |
+      (
+        if ($batch.memory | contains("g")) then
+          ($batch.memory | gsub("[^0-9]"; "") | tonumber) * 1024 * 1024 * 1024
+        elif ($batch.memory | contains("m")) then
+          ($batch.memory | gsub("[^0-9]"; "") | tonumber) * 1024 * 1024
+        else
+          ($batch.memory | gsub("[^0-9]"; "") | tonumber)
+        end
+      ) as $batch_memory |
+
+      if (($acc.current_memory + $batch_memory) <= $budget_bytes) and
+         (($acc.current_wave | length) < $max_parallel) then
+        # Add to current wave
+        $acc |
+        .current_wave += [$batch] |
+        .current_memory += $batch_memory
+      else
+        # Start new wave if current has items
+        if ($acc.current_wave | length) > 0 then
+          $acc |
+          .waves += [{
+            wave_number: (.wave_count + 1),
+            batches: .current_wave,
+            batch_count: (.current_wave | length),
+            memory_needed: (
+              if (.current_memory >= (1024 * 1024 * 1024)) then
+                "\((.current_memory / (1024 * 1024 * 1024)) | floor).\((((.current_memory % (1024 * 1024 * 1024)) / (1024 * 1024 * 1024) * 10) | floor))GB"
+              else
+                "\((.current_memory / (1024 * 1024)) | floor)MB"
+              end
+            ),
+            parallelism: (.current_wave | length),
+            estimated_duration: (
+              ([.current_wave[] | .error_count] | add // 0) as $errors |
+              if $errors > 0 then
+                "\(($errors / 2 / 60 | floor))m\((($errors / 2 % 60) | floor))s"
+              else
+                "Unknown"
+              end
+            )
+          }] |
+          .current_wave = [$batch] |
+          .current_memory = $batch_memory |
+          .wave_count += 1
+        else
+          $acc |
+          .current_wave = [$batch] |
+          .current_memory = $batch_memory
+        end
+      end
+    ) |
+
+    # Add final wave
+    if (.current_wave | length) > 0 then
+      .waves += [{
+        wave_number: (.wave_count + 1),
+        batches: .current_wave,
+        batch_count: (.current_wave | length),
+        memory_needed: (
+          if (.current_memory >= (1024 * 1024 * 1024)) then
+            "\((.current_memory / (1024 * 1024 * 1024)) | floor).\((((.current_memory % (1024 * 1024 * 1024)) / (1024 * 1024 * 1024) * 10) | floor))GB"
+          else
+            "\((.current_memory / (1024 * 1024)) | floor)MB"
+          end
+        ),
+        parallelism: (.current_wave | length),
+        estimated_duration: (
+          ([.current_wave[] | .error_count] | add // 0) as $errors |
+          if $errors > 0 then
+            "\(($errors / 2 / 60 | floor))m\((($errors / 2 % 60) | floor))s"
+          else
+            "Unknown"
+          end
+        )
+      }]
+    else
+      .
+    end |
+
+    # Calculate summary
+    {
+      waves: .waves,
+      summary: {
+        total_waves: (.waves | length),
+        total_agents: ([.waves[] | .batch_count] | add // 0),
+        total_memory: (
+          ([.waves[] | .memory_needed] | map(
+            if contains("GB") then
+              (split("GB")[0] | tonumber) * 1024
+            else
+              (split("MB")[0] | tonumber)
+            end
+          ) | add // 0) as $total_mb |
+          if $total_mb >= 1024 then
+            "\(($total_mb / 1024) | floor).\((($total_mb % 1024) * 10 / 1024 | floor))GB"
+          else
+            "\($total_mb)MB"
+          end
+        ),
+        max_parallelism: ([.waves[] | .parallelism] | max // 0),
+        budget_utilization: (
+          ([.waves[] | .memory_needed] | map(
+            if contains("GB") then
+              (split("GB")[0] | tonumber) * 1024
+            else
+              (split("MB")[0] | tonumber)
+            end
+          ) | add // 0) as $total_mb |
+          (($budget_bytes / (1024 * 1024)) as $budget_mb |
+          (($total_mb / $budget_mb) * 100 | floor) as $percent |
+          "\($percent).\((($total_mb / $budget_mb) * 1000 % 10) | floor)%")
+        )
+      }
+    }
+    '
+}
+
+# Main wave calculation
+main() {
+  # Parse inputs
+  if [ "$BATCHES" = "[]" ] || [ -z "$BATCHES" ]; then
+    jq -n '{
+      waves: [],
+      summary: {
+        total_waves: 0,
+        total_agents: 0,
+        total_memory: "0GB",
+        max_parallelism: 0,
+        budget_utilization: "0%"
+      }
+    }'
+    return 0
+  fi
+
+  # Parse memory budget
+  local budget_bytes
+  budget_bytes=$(parse_memory "$MEMORY_BUDGET")
+
+  # Calculate waves
+  local result
+  result=$(calculate_waves "$BATCHES" "$budget_bytes" "$MAX_PARALLEL")
+
+  echo "$result"
+}
+
+main