ReproVM

task <name> {
  cmd = <shell command>
  inputs = <file1>, <file2>, ...
  outputs = <out1>, <out2>, ...
  deps = <task1>, <task2>, ...
}

# Run all tasks
./reprovm manifest.txt

# Run specific targets
./reprovm manifest.txt target1 target2

# Parallel execution
./reprovm_parallel -j N manifest.txt

# Force rebuild (ignore cache)
rm -rf .reprovm
./reprovm manifest.txt

# Build Docker image
docker build -t reprovm:latest .

# Run with volume mount
docker run --rm -v "$(pwd)":/workspace \
  -w /workspace reprovm:latest \
  ./reprovm_parallel manifest.txt

# Use docker-compose
docker compose up reprovm

# Interactive shell
docker run --rm -it -v "$(pwd)":/workspace \
  -w /workspace reprovm:latest bash

# View cache metadata
cat .reprovm/cache/<task_hash>.meta

# Clean cache
rm -rf .reprovm

# Selective invalidation
rm .reprovm/cache/<specific_task>.meta

# CI cache restoration
./ci_restore_cache.sh

task compile {
  cmd = gcc -c -o app.o app.c
  inputs = app.c
  outputs = app.o
  deps =
}

task link {
  cmd = gcc -o app app.o
  inputs = app.o
  outputs = app
  deps = compile
}

task test {
  cmd = ./app --test > test.log
  inputs = app
  outputs = test.log
  deps = link
}

task fetch_data {
  cmd = curl -o data.csv https://api.example.com/data
  inputs =
  outputs = data.csv
  deps =
}

task clean_data {
  cmd = python3 clean.py data.csv > clean.csv
  inputs = data.csv
  outputs = clean.csv
  deps = fetch_data
}

task analyze {
  cmd = python3 analyze.py clean.csv > report.json
  inputs = clean.csv
  outputs = report.json
  deps = clean_data
}

task visualize {
  cmd = python3 plot.py report.json chart.png
  inputs = report.json
  outputs = chart.png
  deps = analyze
}

task preprocess {
  cmd = python3 preprocess.py raw.csv processed.csv
  inputs = raw.csv
  outputs = processed.csv
  deps =
}

task train_model {
  cmd = python3 train.py processed.csv model.pkl
  inputs = processed.csv
  outputs = model.pkl
  deps = preprocess
}

task evaluate {
  cmd = python3 eval.py model.pkl metrics.json
  inputs = model.pkl, processed.csv
  outputs = metrics.json
  deps = train_model
}

task package {
  cmd = tar czf model.tar.gz model.pkl metrics.json
  inputs = model.pkl, metrics.json
  outputs = model.tar.gz
  deps = evaluate
}

task compile_ts {
  cmd = tsc src/index.ts --outDir dist/
  inputs = src/index.ts
  outputs = dist/index.js
  deps =
}

task bundle_js {
  cmd = webpack dist/index.js -o dist/bundle.js
  inputs = dist/index.js
  outputs = dist/bundle.js
  deps = compile_ts
}

task minify_css {
  cmd = cleancss -o dist/style.min.css src/style.css
  inputs = src/style.css
  outputs = dist/style.min.css
  deps =
}

task package_assets {
  cmd = tar czf assets.tar.gz dist/
  inputs = dist/bundle.js, dist/style.min.css
  outputs = assets.tar.gz
  deps = bundle_js, minify_css
}

# Auto-detect CPU count
./reprovm_parallel manifest.txt

# Specify worker threads
./reprovm_parallel -j 8 manifest.txt

# Set via environment
export REPROVM_JOBS=16
./reprovm_parallel manifest.txt

// cas.h extension point
int cas_push_remote(const char *hash, const char *url);
int cas_pull_remote(const char *hash, const char *url);

// Example: S3 backend
cas_push_remote(hash, "s3://bucket/cas/objects/");
cas_pull_remote(hash, "s3://bucket/cas/objects/");

# .github/workflows/ci.yml
name: CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Restore Cache
        uses: actions/cache@v3
        with:
          path: .reprovm
          key: reprovm-${{ hashFiles('manifest.txt') }}
      - name: Build
        run: |
          make
          ./reprovm_parallel -j 4 manifest.txt
      - name: Save Cache
        uses: actions/cache@v3
        with:
          path: .reprovm
          key: reprovm-${{ hashFiles('manifest.txt') }}

task_hash: a3f5d9c0e1b2c3d4e5f6a7b8...
result_hash: 1f2e3d4c5b6a7980a9b8c7d6...
output hello 5e2f1a3b4c6d7e8f9a0b1c2d...
output result.txt 9c4d7a1e2f3b5c6d7e8f...

# Start TypeScript language server
tsserver --stdio

# Use with ReproVM to analyze dependencies
task analyze_deps {
  cmd = tsserver --check src/**/*.ts > deps.json
  inputs = src/index.ts, src/utils.ts
  outputs = deps.json
  deps =
}

# Run all tests
cd tests && ./test_all.sh

# Individual test suites
./test_cas.sh      # CAS functionality
./test_parallel.sh # Parallel execution
./test_manifest.sh # Manifest parsing
./test_util.sh     # Utility functions