prodigy 0.4.4

Turn ad-hoc Claude sessions into reproducible development pipelines with parallel AI agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

# Example: Parallel Analysis with Variable Capture
# Demonstrates capturing variables in MapReduce workflows for parallel processing

name: parallel-code-analysis
mode: mapreduce

setup:
  # Capture repository metadata
  - shell: "find src -name '*.rs' | wc -l"
    capture: "total_files"
    capture_format: number

  - shell: "git rev-parse --short HEAD 2>/dev/null || echo 'unknown'"
    capture: "commit_hash"

  - shell: "date +%Y%m%d-%H%M%S"
    capture: "analysis_timestamp"

  - shell: |
      echo '{
        "repository": "'$(basename $(pwd))'",
        "commit": "${commit_hash}",
        "timestamp": "${analysis_timestamp}",
        "total_files": ${total_files}
      }'
    capture: "metadata"
    capture_format: json

map:
  # Process Rust source files in parallel
  input: files.json
  json_path: "$.files[*]"

  agent_template:
    # Analyze each file
    - shell: "wc -l ${item} | awk '{print $1}'"
      capture: "line_count"
      capture_format: number

    - shell: "grep -c '^fn ' ${item} || echo 0"
      capture: "function_count"
      capture_format: number

    - shell: "grep -c '^#\\[test\\]' ${item} || echo 0"
      capture: "test_count"
      capture_format: number

    - shell: "grep -c 'TODO\\|FIXME' ${item} || echo 0"
      capture: "todo_count"
      capture_format: number

    # Check complexity metrics
    - shell: |
        if [ ${line_count} -gt 500 ]; then
          echo "high"
        elif [ ${line_count} -gt 200 ]; then
          echo "medium"
        else
          echo "low"
        fi
      capture: "complexity"

    # Generate file report
    - shell: |
        echo '{
          "file": "${item}",
          "metrics": {
            "lines": ${line_count},
            "functions": ${function_count},
            "tests": ${test_count},
            "todos": ${todo_count},
            "complexity": "${complexity}"
          }
        }'
      capture: "file_report"
      capture_format: json

    # Save individual file report
    - shell: "echo '${file_report}' > reports/$(basename ${item}).json"

reduce:
  # Aggregate results
  - shell: "echo 'Analyzed ${map.total} files from commit ${metadata.commit}'"
    capture: "summary_header"

  # Count high complexity files
  - shell: "grep -l '\"complexity\": \"high\"' reports/*.json | wc -l"
    capture: "high_complexity_count"
    capture_format: number

  # Calculate total lines of code
  - shell: "grep '\"lines\":' reports/*.json | grep -oE '[0-9]+' | awk '{sum+=$1} END {print sum}'"
    capture: "total_lines"
    capture_format: number

  # Calculate total test count
  - shell: "grep '\"tests\":' reports/*.json | grep -oE '[0-9]+' | awk '{sum+=$1} END {print sum}'"
    capture: "total_tests"
    capture_format: number

  # Generate final report
  - shell: |
    cat << EOF
    Code Analysis Report
    ====================
    Repository: ${metadata.repository}
    Commit: ${metadata.commit}
    Timestamp: ${metadata.timestamp}

    Summary Statistics:
    - Files Analyzed: ${map.successful}/${map.total}
    - Total Lines: ${total_lines}
    - Total Tests: ${total_tests}
    - High Complexity Files: ${high_complexity_count}

    Processing Results:
    - Successful: ${map.successful}
    - Failed: ${map.failed}
    - Duration: ${map.duration|default:unknown}
    EOF
  capture: "final_report"

  # Save the final report
  - shell: "echo '${final_report}' > analysis-report-${analysis_timestamp}.txt"

  # Create JSON summary for further processing
  - shell: |
    echo '{
      "metadata": ${metadata},
      "results": {
        "files_processed": ${map.successful},
        "total_lines": ${total_lines},
        "total_tests": ${total_tests},
        "high_complexity_files": ${high_complexity_count}
      },
      "report": "${final_report}"
    }' | jq .
  capture: "json_summary"
  capture_format: json

  # Display completion message
  - shell: |
    echo "✅ Analysis complete! Report saved to analysis-report-${analysis_timestamp}.txt"
    echo "📊 Metrics: ${total_lines} lines, ${total_tests} tests across ${map.successful} files"