claude-flow-novice 2.18.6 → 2.18.7

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

@@ -1,327 +0,0 @@
-#!/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-management/lib/batching/calculate-waves.sh

@@ -1,256 +0,0 @@
-#!/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