Run Generation

SWE task generation is driven by Curator's Claude plugin. The plugin provides slash commands that handle preflight checks, configuration loading, and workflow orchestration automatically.

Recommended Workflow

From a Claude session started inside subblock/curator/:

/curator:collect-prs    # collect PR IDs and wait for completion
/curator:create-tasks   # generate and verify tasks from existing PR IDs
/curator:dashboard      # monitor progress

These commands read all configuration from config.yaml:

• /curator:collect-prs uses runtime_info.input.pr_collection for scope and filters
• /curator:create-tasks uses runtime_info.input.languages for per-language timeouts and concurrency
• Both use runtime_info.input.llm_api for LLM endpoint configuration

Edit config.yaml to adjust parameters, then re-run the command.

Important: These are separate stages. /curator:create-tasks never starts the collector. Wait for the background collector to finish before running generation.

Configuration Guide

All generation parameters live in config.yaml under runtime_info.input.

LLM API Configuration

Two provider modes are supported:

Mode 1: Native Anthropic-compatible endpoint (recommended)

llm_api:
  api_key: <YOUR_API_KEY>
  api_base_url: https://yunwu.ai/v1              # OpenAI-compatible endpoint
  pr_model: claude-opus-4-6
  task_model: claude-opus-4-6
  cc_provider_mode: native
  anthropic_base_url: https://yunwu.ai           # Anthropic-compatible endpoint (no /v1)

Mode 2: OpenAI-compatible model with local proxy

llm_api:
  api_key: <YOUR_API_KEY>
  api_base_url: https://your-openai-endpoint/v1
  pr_model: Qwen3.6-35B-A3B
  task_model: claude-sonnet-4-6                  # proxy alias
  cc_provider_mode: openai_proxy
  anthropic_base_url: http://127.0.0.1:4010      # local LiteLLM proxy
  cc_proxy_port: 4010

Mode native is simpler: both PR evaluation and task completion use the same provider. Mode openai_proxy is for OpenAI-only models: it starts a local LiteLLM proxy to translate Anthropic calls to OpenAI format.

Never commit real API keys to config.yaml. Use environment variables or .env files instead.

PR Collection Configuration

pr_collection:
  enabled: true
  languages: [c, cpp, go, java, javascript, typescript, python, rust]
  repo_num: 100                    # repos per language
  max_prs_per_repo: 50
  output_dir: artifacts/collected_prs
  token_limit: 32                  # first N combined file + env GitHub tokens (0 = use all)
  filters:
    min_stars: 30
    min_merged_prs: 5
    min_language_percentage: 0.4
    max_days_since_push: 1095
    min_issue_body_length: 10
    min_files_changed: 1
    max_files_changed: 25
    max_lines_changed: 1500

Per-Language Generation Parameters

languages:
  py:   { enabled: true,  params: { timeout: 3200, cc_timeout: 2400, n_concurrent: 20 } }
  js:   { enabled: true,  params: { timeout: 3200, cc_timeout: 2400, n_concurrent: 16 } }
  ts:   { enabled: true,  params: { timeout: 3600, cc_timeout: 3000, n_concurrent: 16 } }
  go:   { enabled: true,  params: { timeout: 3200, cc_timeout: 2400, n_concurrent: 16 } }
  java: { enabled: true,  params: { timeout: 3200, cc_timeout: 2400, n_concurrent: 16 } }
  c:    { enabled: true,  params: { timeout: 3200, cc_timeout: 2400, n_concurrent: 16 } }
  cpp:  { enabled: true,  params: { timeout: 3200, cc_timeout: 2400, n_concurrent: 16 } }
  rust: { enabled: true,  params: { timeout: 3600, cc_timeout: 3000, n_concurrent: 16 } }

• timeout: whole PR case timeout (seconds)
• cc_timeout: Claude Code task completion timeout (seconds)
• n_concurrent: parallel PR workers per language

GitHub Tokens

Place tokens in repos/swegen/gh_token.txt (one per line) or set GITHUB_TOKEN / GITHUB_TOKENS environment variables. The collector combines all sources.

Command Reference

/curator:collect-prs

Runs background PR collection for configured languages. Outputs:

artifacts/collected_prs/{language}_pr_ids.txt

This is a separate background job. Wait for it to finish before running /curator:create-tasks.

/curator:create-tasks

Three modes:

The plugin runs preflight checks automatically:

• Config validation
• GitHub token availability
• LLM endpoint connectivity
• Docker daemon access

/curator:dashboard

Generates live progress view and optionally syncs to Cloudflare Pages. Shows:

• Per-language progress (success/total PRs)
• Recent failures
• Estimated completion time

Advanced: Manual Commands

For debugging or custom workflows, you can run the underlying commands directly. These are what the plugin wraps:

# Full collection using config
bash scripts/collect_all_bg.sh

# Single language override
LANGUAGES=python bash scripts/collect_all_bg.sh

# Direct collector call for smoke test
source scripts/load_runtime_env.sh && load_runtime_env
python repos/swegen/tools/collect_prs_wo_image.py \
  --languages python \
  --repo_num 2 \
  --max_prs_per_repo 10 \
  --output_dir ./artifacts/collected_prs \
  --disable_progress_bar

# Single task for validation
swegen create \
  --input-ids-file artifacts/collected_prs/python_pr_ids.txt \
  --max-pr 1 \
  --n-concurrent 1 \
  --output artifacts/swe_tasks/py-cc \
  --state-dir scripts/.swegen-py \
  --timeout 2400 \
  --cc-timeout 1800 \
  --no-require-issue \
  --min-source-files 1 \
  --max-source-files 10

# Production: single language
bash scripts/create_py.sh

# Production: all languages
bash scripts/create_all_bg.sh

Production Checklist

Before running a large-scale generation:

1. ✅ Verify config.yaml has correct LLM endpoint and credentials
2. ✅ Ensure GitHub tokens are fresh (check repos/swegen/gh_token.txt)
3. ✅ Run smoke test: /curator:create-tasks → choose "smoke"
4. ✅ Verify smoke generates 1 task in artifacts/experiments/quick-verify/
5. ✅ Check Docker daemon is running: docker ps
6. ✅ Ensure sufficient disk space for state and artifacts
7. ✅ Start collection: /curator:collect-prs
8. ✅ Wait for collection to finish (monitor logs)
9. ✅ Start generation: /curator:create-tasks → choose "full"
10. ✅ Monitor progress: /curator:dashboard

Open the Dashboard for the live progress view.