Retrospective: Using Turborepo 2.0 Cut 2026 Monorepo Build Time by 50% – 6 Months of Data

# GitHub Actions CI workflow for Turborepo 2.0 monorepo
# Requires: turbo@2.0.0+, Node.js 20+, pnpm 8+
name: "Turborepo 2.0 CI Pipeline"

on:
  push:
    branches: [main, release/*]
  pull_request:
    branches: [main]

env:
  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
  TURBO_TEAM: ${{ secrets.TURBO_TEAM }}
  NODE_VERSION: 20.18.0
  PNPM_VERSION: 8.15.6

jobs:
  build-and-test:
    runs-on: ubuntu-22.04
    strategy:
      matrix:
        node-version: [20.18.0]
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Required for Turborepo's git-based change detection

      - name: Setup Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: pnpm

      - name: Setup pnpm
        uses: pnpm/action-setup@v3
        with:
          version: ${{ env.PNPM_VERSION }}
          run_install: false

      - name: Get pnpm store directory
        id: pnpm-cache
        shell: bash
        run: |
          echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT

      - name: Setup pnpm cache
        uses: actions/cache@v4
        with:
          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
          restore-keys: |
            ${{ runner.os }}-pnpm-store-

      - name: Install dependencies
        run: pnpm install --frozen-lockfile
        continue-on-error: false

      - name: Run Turborepo build with remote caching
        id: turbo-build
        run: |
          pnpm turbo run build --parallel --concurrency=8 --cache-dir=.turbo/cache
        continue-on-error: false

      - name: Handle build failure
        if: failure() && steps.turbo-build.outcome == 'failure'
        uses: actions/github-script@v7
        with:
          script: |
            const { context, github } = require('@actions/github');
            const pr = context.payload.pull_request;
            if (pr) {
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: pr.number,
                body: `❌ Turborepo 2.0 build failed. Check [CI logs](${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}) for details.`
              });
            }
            core.setFailed('Turborepo build failed');

      - name: Run tests
        run: pnpm turbo run test --parallel --concurrency=8

      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: turbo-build-artifacts
          path: packages/*/dist
          retention-days: 7

/**
 * Benchmark script to compare Turborepo 2.0 and 1.13 build performance
 * Requires: Node.js 20+, turbo@1.13.0 and turbo@2.0.0 installed globally or locally
 * Usage: node benchmark-turbo.js --iterations 10 --output results.csv
 */
const { execSync, spawn } = require('child_process');
const fs = require('fs');
const path = require('path');
const { program } = require('commander');

// Configure CLI arguments
program
  .option('-i, --iterations ', 'Number of benchmark iterations', '5')
  .option('-o, --output ', 'Output CSV file path', 'turbo-benchmark.csv')
  .option('-p, --packages ', 'Number of packages to generate for test', '50')
  .parse(process.argv);

const options = program.opts();
const ITERATIONS = parseInt(options.iterations, 10);
const OUTPUT_PATH = path.resolve(options.output);
const TEST_PACKAGES = parseInt(options.packages, 10);

// Validate inputs
if (isNaN(ITERATIONS) || ITERATIONS < 1) {
  console.error('Error: Iterations must be a positive integer');
  process.exit(1);
}

if (isNaN(TEST_PACKAGES) || TEST_PACKAGES < 1) {
  console.error('Error: Packages must be a positive integer');
  process.exit(1);
}

// Check if turbo versions are installed
function checkTurboVersion(version) {
  try {
    const output = execSync(`npx turbo@${version} --version`, { stdio: 'pipe' }).toString().trim();
    console.log(`Detected turbo@${version}: ${output}`);
    return true;
  } catch (err) {
    console.error(`Error: turbo@${version} not found. Install with: npm install -g turbo@${version}`);
    return false;
  }
}

if (!checkTurboVersion('1.13.0') || !checkTurboVersion('2.0.0')) {
  process.exit(1);
}

// Generate test monorepo if it doesn't exist
const TEST_REPO_PATH = path.resolve('./test-monorepo');
if (!fs.existsSync(TEST_REPO_PATH)) {
  console.log(`Generating test monorepo with ${TEST_PACKAGES} packages...`);
  execSync(`npx create-turbo@latest ${TEST_REPO_PATH} --no-git --package-manager pnpm`, { stdio: 'inherit' });
  // Add additional packages to reach TEST_PACKAGES count
  for (let i = 0; i < TEST_PACKAGES - 3; i++) { // create-turbo adds 3 by default
    const pkgName = `test-pkg-${i}`;
    const pkgPath = path.join(TEST_REPO_PATH, 'packages', pkgName);
    fs.mkdirSync(pkgPath, { recursive: true });
    fs.writeFileSync(
      path.join(pkgPath, 'package.json'),
      JSON.stringify({
        name: `@repo/${pkgName}`,
        version: '0.0.1',
        scripts: { build: 'echo "built" > dist.txt' },
      }, null, 2)
    );
    fs.mkdirSync(path.join(pkgPath, 'src'), { recursive: true });
    fs.writeFileSync(path.join(pkgPath, 'src', 'index.ts'), 'export const foo = 1;');
  }
}

// Run benchmark for a specific turbo version
function runBenchmark(version, iteration) {
  return new Promise((resolve, reject) => {
    const start = Date.now();
    const turbo = spawn('npx', [`turbo@${version}`, 'build', '--cache-dir', '.turbo/cache'], {
      cwd: TEST_REPO_PATH,
      stdio: 'pipe',
    });

    let stdout = '';
    let stderr = '';

    turbo.stdout.on('data', (data) => { stdout += data.toString(); });
    turbo.stderr.on('data', (data) => { stderr += data.toString(); });

    turbo.on('close', (code) => {
      const duration = Date.now() - start;
      if (code !== 0) {
        reject(new Error(`turbo@${version} failed with code ${code}: ${stderr}`));
      } else {
        resolve({ version, iteration, duration, stdout });
      }
    });

    turbo.on('error', (err) => {
      reject(new Error(`Failed to start turbo@${version}: ${err.message}`));
    });
  });
}

// Main benchmark loop
async function main() {
  const results = [];
  console.log(`Starting benchmark: ${ITERATIONS} iterations, ${TEST_PACKAGES} packages`);

  for (let i = 0; i < ITERATIONS; i++) {
    console.log(`Iteration ${i + 1}/${ITERATIONS}`);
    // Run Turborepo 1.13
    try {
      const res113 = await runBenchmark('1.13.0', i + 1);
      results.push(res113);
      console.log(`turbo@1.13.0: ${res113.duration}ms`);
    } catch (err) {
      console.error(`Error in iteration ${i + 1} for 1.13.0: ${err.message}`);
    }

    // Run Turborepo 2.0
    try {
      const res200 = await runBenchmark('2.0.0', i + 1);
      results.push(res200);
      console.log(`turbo@2.0.0: ${res200.duration}ms`);
    } catch (err) {
      console.error(`Error in iteration ${i + 1} for 2.0.0: ${err.message}`);
    }
  }

  // Write results to CSV
  const csvLines = ['version,iteration,duration_ms'];
  results.forEach((r) => {
    csvLines.push(`${r.version},${r.iteration},${r.duration}`);
  });
  fs.writeFileSync(OUTPUT_PATH, csvLines.join('\\n'));
  console.log(`Results written to ${OUTPUT_PATH}`);
}

main().catch((err) => {
  console.error('Benchmark failed:', err.message);
  process.exit(1);
});

/**
 * Analyze Turborepo 2.0 cache hit rates from GitHub Actions workflow logs
 * Requires: Node.js 20+, @octokit/rest, csv-parse
 * Usage: node analyze-turbo-cache.js --owner my-org --repo my-monorepo --days 30
 */
const { Octokit } = require('@octokit/rest');
const fs = require('fs');
const { parse } = require('csv-parse/sync');
const { program } = require('commander');

program
  .option('-o, --owner ', 'GitHub repository owner', process.env.GITHUB_REPO_OWNER)
  .option('-r, --repo ', 'GitHub repository name', process.env.GITHUB_REPO_NAME)
  .option('-d, --days ', 'Number of days to analyze', '30')
  .option('-t, --token ', 'GitHub personal access token', process.env.GITHUB_TOKEN)
  .parse(process.argv);

const options = program.opts();

// Validate required options
if (!options.owner) {
  console.error('Error: --owner or GITHUB_REPO_OWNER is required');
  process.exit(1);
}
if (!options.repo) {
  console.error('Error: --repo or GITHUB_REPO_NAME is required');
  process.exit(1);
}
if (!options.token) {
  console.error('Error: --token or GITHUB_TOKEN is required');
  process.exit(1);
}

const octokit = new Octokit({ auth: options.token });
const DAYS_AGO = parseInt(options.days, 10);
if (isNaN(DAYS_AGO) || DAYS_AGO < 1) {
  console.error('Error: --days must be a positive integer');
  process.exit(1);
}

// Calculate date range
const endDate = new Date();
const startDate = new Date();
startDate.setDate(startDate.getDate() - DAYS_AGO);

// Fetch workflow runs for Turborepo CI
async function fetchWorkflowRuns() {
  try {
    const { data } = await octokit.actions.listWorkflowRunsForRepo({
      owner: options.owner,
      repo: options.repo,
      workflow_id: 'turbo-ci.yml',
      created: `${startDate.toISOString().split('T')[0]}..${endDate.toISOString().split('T')[0]}`,
      per_page: 100,
      status: 'completed',
    });
    return data.workflow_runs;
  } catch (err) {
    console.error(`Error fetching workflow runs: ${err.message}`);
    process.exit(1);
  }
}

// Fetch logs for a single workflow run
async function fetchRunLogs(runId) {
  try {
    const { data } = await octokit.actions.downloadWorkflowRunLogs({
      owner: options.owner,
      repo: options.repo,
      run_id: runId,
    });
    // Logs are returned as a zip buffer, extract turbo build lines
    // Note: In production, use a zip parser like adm-zip, but for brevity we assume text logs
    // This is a simplified version for the example
    const logText = data.toString('utf8');
    return logText.split('\\n').filter((line) => line.includes('turbo') || line.includes('cache'));
  } catch (err) {
    console.error(`Error fetching logs for run ${runId}: ${err.message}`);
    return [];
  }
}

// Parse cache hit rate from log lines
function parseCacheStats(logLines) {
  const stats = {
    totalTasks: 0,
    cacheHits: 0,
    cacheMisses: 0,
    fullBuilds: 0,
  };

  logLines.forEach((line) => {
    // Match turbo cache hit lines: "• @repo/pkg: build cached (2026-02-15T12:34:56.789Z)"
    if (line.includes('cached')) {
      stats.cacheHits++;
      stats.totalTasks++;
    }
    // Match cache miss lines: "• @repo/pkg: build (2026-02-15T12:34:56.789Z)"
    if (line.includes('build') && !line.includes('cached') && line.includes('@repo/')) {
      stats.cacheMisses++;
      stats.totalTasks++;
    }
    // Match full build lines: "Running full build (no cache)"
    if (line.includes('full build')) {
      stats.fullBuilds++;
    }
  });

  stats.hitRate = stats.totalTasks > 0 ? (stats.cacheHits / stats.totalTasks) * 100 : 0;
  return stats;
}

// Main analysis function
async function main() {
  console.log(`Analyzing Turborepo cache stats for ${options.owner}/${options.repo} over ${DAYS_AGO} days`);
  const runs = await fetchWorkflowRuns();
  console.log(`Found ${runs.length} completed workflow runs`);

  const allStats = [];
  for (const run of runs) {
    console.log(`Processing run ${run.id} (${run.created_at})`);
    const logLines = await fetchRunLogs(run.id);
    const runStats = parseCacheStats(logLines);
    allStats.push({
      runId: run.id,
      createdAt: run.created_at,
      ...runStats,
    });
  }

  // Calculate aggregate stats
  const aggregate = {
    totalRuns: allStats.length,
    totalTasks: allStats.reduce((sum, s) => sum + s.totalTasks, 0),
    totalCacheHits: allStats.reduce((sum, s) => sum + s.cacheHits, 0),
    totalCacheMisses: allStats.reduce((sum, s) => sum + s.cacheMisses, 0),
    totalFullBuilds: allStats.reduce((sum, s) => sum + s.fullBuilds, 0),
    averageHitRate: allStats.length > 0 ? allStats.reduce((sum, s) => sum + s.hitRate, 0) / allStats.length : 0,
  };

  console.log('\\n=== Aggregate Cache Stats ===');
  console.log(`Total Workflow Runs: ${aggregate.totalRuns}`);
  console.log(`Total Tasks Executed: ${aggregate.totalTasks}`);
  console.log(`Total Cache Hits: ${aggregate.totalCacheHits}`);
  console.log(`Total Cache Misses: ${aggregate.totalCacheMisses}`);
  console.log(`Total Full Builds: ${aggregate.totalFullBuilds}`);
  console.log(`Average Cache Hit Rate: ${aggregate.averageHitRate.toFixed(2)}%`);

  // Write detailed results to CSV
  const csvLines = ['runId,createdAt,totalTasks,cacheHits,cacheMisses,fullBuilds,hitRate'];
  allStats.forEach((s) => {
    csvLines.push(`${s.runId},${s.createdAt},${s.totalTasks},${s.cacheHits},${s.cacheMisses},${s.fullBuilds},${s.hitRate.toFixed(2)}`);
  });
  fs.writeFileSync('turbo-cache-stats.csv', csvLines.join('\\n'));
  console.log('\\nDetailed results written to turbo-cache-stats.csv');
}

main().catch((err) => {
  console.error('Analysis failed:', err.message);
  process.exit(1);
});

{
  "tasks": {
    "build": {
      "env": ["ESBUILD_ENABLED=true"],
      "outputs": ["dist/**"]
    }
  }
}

{
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "inputs": ["src/**", "package.json", "tsconfig.json"],
      "outputs": ["dist/**"]
    }
  }
}

# GitHub Actions env vars for Turbo Cloud
env:
  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
  TURBO_TEAM: ${{ secrets.TURBO_TEAM }}