Turborepo

Turborepo リファレンス

Turborepo — JavaScript / TypeScript モノレポ向け高性能ビルドシステム。 turbo.json の設定、タスク管理、キャッシュ、各種ツール統合時に参照する。

ディレクトリ構成

skills/turborepo/
  SKILL.md
  references/
    getting-started/
      README.md
      installation.md
      add-to-existing.md
    core-concepts/
      README.md
      package-and-task-graph.md
      package-types.md
      remote-caching.md
    crafting-your-repository/
      README.md
      structuring.md
      dependencies.md
      internal-packages.md
      tasks.md
      running-tasks.md
      caching.md
      environment-variables.md
      developing.md
      ci.md
      upgrading.md
      understanding-your-repository.md
    guides/
      README.md
      ai.md
      generating-code.md
      handling-platforms.md
      microfrontends.md
      migrating-from-nx.md
      multi-language.md
      publishing-libraries.md
      single-package-workspaces.md
      skipping-tasks.md
    guides-frameworks/
      README.md
      framework-bindings.md
      nextjs.md
      nuxt.md
      sveltekit.md
      vite.md
    guides-ci-vendors/
      README.md
      buildkite.md
      circleci.md
      github-actions.md
      gitlab-ci.md
      travis-ci.md
      vercel.md
    guides-tools/
      README.md
      biome.md
      docker.md
      eslint.md
      jest.md
      oxc.md
      playwright.md
      prisma.md
      shadcn-ui.md
      storybook.md
      tailwind.md
      typescript.md
      vitest.md
    configuration/
      README.md
      globs.md
      package-configurations.md
      system-environment-variables.md
      turbo-json.md
    cli/
      README.md
      boundaries.md
      gen.md
      other-commands.md
      prune.md
      query.md
      run.md
      watch.md
  samples/
    README.md
    ci-github-actions.md
    code-generation.md
    dev-workflow.md
    environment-variables.md
    filtering-tasks.md
    internal-packages.md
    monorepo-setup.md
    publishing-packages.md
    remote-caching.md
    task-pipeline.md
  scripts/
    README.md
    build-deploy.md
    cache.md
    cli.md
    dev.md
    generate.md
    inspect.md
    install.md
    migrate.md

探索手順

タスクからカテゴリを引き、カテゴリの README.md で目的のページを特定する:

1. 下記マッピング表でタスクに対応するカテゴリを探す 2. そのカテゴリの references/{category}/README.md を参照して目的のページを特定する 3. 該当ページの .md を Read して詳細を確認する

タスク → カテゴリ マッピング

turbo boundaries

ワークスペース間の依存関係違反を検査する実験的機能。

turbo boundaries

検出する違反

1. パッケージディレクトリ外のファイルインポート 2. package.json の dependencies に未宣言のパッケージのインポート

タグ設定

各パッケージの turbo.json でタグを付与:

{ "tags": ["internal"] }

ルール設定（ルートの turbo.json）

allow ルール

{
  "boundaries": {
    "tags": {
      "public": { "dependencies": { "allow": ["public"] } }
    }
  }
}

deny ルール

{
  "boundaries": {
    "tags": {
      "public": { "dependencies": { "deny": ["internal"] } }
    }
  }
}

dependents ルール

{
  "boundaries": {
    "tags": {
      "private": { "dependents": { "deny": ["public"] } }
    }
  }
}

ルールは依存チェーンを通じて推移的に適用される。パッケージ名も使用可能。

turbo gen

turbo gen [subcommand] [options]

エイリアス: turbo generate

turbo gen workspace

turbo gen workspace [options]

turbo gen run

turbo gen run [generator-name] [options]

@turbo/gen の型定義

import type { PlopTypes } from "@turbo/gen";

export default function generator(plop: PlopTypes.NodePlopAPI): void {
  plop.setGenerator("name", {
    description: "description",
    prompts: [],
    actions: [],
  });
}

その他のコマンド

turbo ls

turbo ls [package(s)] [flags]

turbo scan

非推奨: turbo scan は将来のメジャーバージョンで削除予定。実行すると非推奨警告が表示される。

パフォーマンス最適化を設定するインタラクティブコマンド。Git FS Monitor、Remote Caching、バージョンチェック等を設定。

turbo info

デバッグ情報を表示（バージョン、パス、デーモン状態、パッケージマネージャー、プラットフォーム詳細）。

turbo devtools

パッケージグラフをブラウザで可視化。

turbo login / logout / link / unlink

turbo login          # Vercel 認証（デフォルトプロバイダー）
turbo login --manual # マニュアルトークン入力
turbo login --api=https://acme.com/api    # カスタム API エンドポイント
turbo login --sso-team=slug              # SSO チームでログイン
turbo logout         # Remote Cache プロバイダーからログアウト
turbo link           # リモートキャッシュにリンク
turbo link --yes     # 確認プロンプトをスキップ
turbo link --scope=your-team  # スコープ（Vercel ではチームスラッグ）
turbo unlink         # リンク解除

create-turbo

npx create-turbo@latest [options]

eslint-config-turbo / eslint-plugin-turbo

turbo.json のハッシュ設定に宣言されていない環境変数をコード内で検出する。

ルール: turbo/no-undeclared-env-vars

{
  "rules": {
    "turbo/no-undeclared-env-vars": ["error", { "allowList": ["^ENV_[A-Z]+$"] }]
  }
}

turbo telemetry

匿名使用データの収集を管理する。

turbo telemetry status   # 現在のテレメトリ設定を確認
turbo telemetry enable   # テレメトリを有効化
turbo telemetry disable  # テレメトリを無効化

turbo bin

turbo 実行バイナリのファイルシステムパスを取得する。グローバルインストールかローカルインストールかの確認に使用。

turbo bin

turbo docs

ターミナルから Turborepo ドキュメントを検索する（最低バージョン: 2.7.5）。

turbo docs "caching"                              # キーワード検索
turbo docs "task dependencies" --docs-version 2.8.0  # 特定バージョンのドキュメントを検索

@turbo/codemod

npx @turbo/codemod migrate

非推奨機能の自動移行。--dry でプレビュー可能。

turbo-ignore（非推奨）

非推奨: turbo-ignore は更新を終了。代わりに turbo query affected を使用する。turbo query affected はタスクレベルの変更検知で精度が高い。

turbo prune

特定パッケージとその依存関係のみを含む部分的なモノレポを生成する。Docker デプロイのレイヤーキャッシュ最適化に有用。

turbo prune [package] [options]

オプション

--docker フラグの出力構造

out/
├── json/          # package.json のみ（依存インストール用）
├── full/          # 完全なソースコード（ビルド用）
└── pnpm-lock.yaml # プルーニング済みロックファイル

Dockerfile での使用例

FROM node:alpine AS installer
COPY out/json/ .
RUN npm install

FROM node:alpine AS builder
COPY --from=installer /app/node_modules ./node_modules
COPY out/full/ .
RUN turbo run build

注意点

• pnpm deploy と異なり、モノレポ構造を維持
• globalDependencies で参照されるファイルはデフォルトではコピーされない

turbo query

モノレポに対して GraphQL クエリを実行し、パッケージ依存関係やタスク関係を分析する。

turbo query [query|file.gql]

使用方法

turbo query                              # インタラクティブモード
turbo query "query { packages { items { name } } }"  # 直接実行
turbo query query.gql                    # ファイルから

オプション

turbo query ls

パッケージ一覧表示のショートハンド。

turbo query ls              # 全パッケージ
turbo query ls web          # 特定パッケージの詳細
turbo query ls --affected   # 変更のあるパッケージのみ
turbo query ls --filter=web... --output json

turbo query affected

変更の影響を受けるパッケージ・タスクを特定する。

turbo query affected [flags]

cli

turbo run

turbo run <task> [options]

主要オプション

フィルタリング

キャッシュ制御

実行制御

出力・デバッグ

フィルタ構文

パッケージ名

turbo run build --filter=ui
turbo run build --filter=@acme/ui

ディレクトリ

turbo run build --filter=./apps/*

Git ベース

turbo run build --filter=[HEAD^1]
turbo run build --filter=[origin/main]

マイクロシンタックス演算子

よく使う組み合わせ

turbo run build --affected                         # 変更パッケージのみ
turbo run build --dry=json                         # ドライラン
turbo run test --continue=always                   # エラーでも続行
turbo run build --cache=local:r,remote:rw          # ローカル読み込みのみ
turbo run test --filter=...@acme/ui                # 依存元すべて
turbo run web#lint                                 # 特定タスク

turbo watch

turbo watch [tasks]

コードの変更をもとにタスクを再実行する。

動作レベル

• デフォルト: パッケージレベル。ファイルが1つでも変わると全タスク再実行
• `futureFlags.watchUsingTaskInputs` 有効化: タスクの inputs グロブに基づいてフィルタリング

persistent タスクとの関係

persistent タスクは turbo watch に無視される。

制限事項

• キャッシュ: 現在実験的（--experimental-write-cache で使用可能）
• ソース管理下のファイルへ書き込むタスクは無限ループの恐れあり

ファイルグロブ仕様

基本パターン

実用例

dist/**          # dist 配下の全ファイル
dist/            # dist ディレクトリとその中身すべて
!dist            # dist ディレクトリを完全に除外
dist/*.js        # dist 直下の JS ファイルのみ
dist/**/*.js     # dist 配下の任意の深さの JS ファイル
../scripts/**    # 1つ上の scripts ディレクトリ内のファイル

否定パターン

! による否定は末尾に /** が自動付与され、ディレクトリツリー全体の除外が簡略化される。

パッケージ固有 turbo.json

extends

ルートの turbo.json 設定を継承する。パッケージレベルの turbo.json にのみ使用。

{
  "extends": ["//"],
  "tasks": {
    "build": {
      "outputs": ["dist/**"]
    }
  }
}

"extends": ["//"] はルートワークスペースを意味する。

パッケージレベルでのオーバーライド

パッケージの turbo.json ではルートの同名タスクの設定を上書きできる:

• outputs, inputs, env, passThroughEnv は上書き
• dependsOn はルート設定とマージ

使用例

apps/web/turbo.json      ← Next.js 用の outputs を定義
packages/ui/turbo.json   ← UI ライブラリ用の outputs を定義

Configuration

システム環境変数

設定系

CI / プラットフォーム系

キャッシュ・パフォーマンス系

認証系

ログ・UI 系

ソース管理系

タスク実行時に自動提供される変数

その他

turbo.json 設定

グローバル設定

futureFlags

タスク定義（tasks 配下）

inputs の特殊値

• $TURBO_DEFAULT$: デフォルト挙動を維持しつつ追加・除外
• $TURBO_ROOT$: リポジトリルートからの相対パス
• $TURBO_EXTENDS$: 継承した値に追記

完成例

{
  "$schema": "https://turborepo.com/schema.json",
  "globalDependencies": [".env"],
  "globalEnv": ["NODE_ENV"],
  "globalPassThroughEnv": ["CI"],
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "inputs": ["src/**", "package.json", "tsconfig.json"],
      "outputs": ["dist/**"],
      "env": ["MY_API_URL"]
    },
    "test": {
      "dependsOn": ["build"],
      "inputs": ["src/**", "test/**"]
    },
    "lint": {},
    "dev": {
      "dependsOn": ["^build"],
      "cache": false,
      "persistent": true
    }
  }
}

Package and Task Graph

パッケージグラフ

パッケージマネージャーが作成するモノレポの基盤構造。内部パッケージ同士がインストールされると、Turborepo が自動的に依存関係を識別する。

タスクグラフ

turbo.json で定義するタスク同士の関係。データ構造は有向非巡回グラフ（DAG）。

• ノード = タスク
• エッジ = タスクの依存関係
• Task A → Task B のエッジは「A は B に依存する」を意味する

{
  "tasks": {
    "build": {
      "dependsOn": ["^build"]
    }
  }
}

トランジットノード

タスクの実装を持たないパッケージでも、依存先がそのタスクを持つ場合、タスクグラフに含まれる。ui に build タスクがなくても、ui が依存する core に build タスクがある場合、ui は「トランジットノード」として扱われる（自身では何も実行しないが、グラフ上は存在する）。

"dependsOn": ["^test"] のような設定があれば、build タスクを持たないパッケージでも、依存先のビルドがトリガーされる。

Package Types

Application Packages

ワークスペースから直接デプロイするために設計されたパッケージ。

• 通常 ./apps ディレクトリに配置
• Next.js、Svelte、Vite、CLI アプリなど
• パッケージグラフの「終端ノード」として機能
• 通常は他のパッケージの依存関係としてインストールしない

Library Packages

ワークスペース全体で共有されるコードを含むパッケージ。

• 単独ではデプロイ不可
• 「Internal Packages」とも呼ばれる
• 公式ドキュメントでは internal-packages として独立ページ化（/docs/core-concepts/internal-packages）

Internal Packages の3つのコンパイル戦略

1. Just-in-Time（JIT）パッケージ

アプリケーションのバンドラーが TypeScript ソースファイルを直接コンパイル。

• 設定が最小限で済む
• ビルドステップ不要
• 制限: トランスパイル可能なコンシューマーでのみ動作、TypeScript の paths 使用不可、Turborepo のビルドキャッシュ不可

2. Compiled Packages

tsc 等でコンパイル。Turborepo がビルド出力をキャッシュ可能。

{
  "exports": {
    "./add": {
      "types": "./dist/add.d.ts",
      "default": "./dist/add.js"
    }
  }
}

3. Publishable Packages

npm レジストリへの配布を準備したパッケージ。changesets の使用を推奨。

インストール構文

Core Concepts

Remote Caching

概要

タスクのキャッシュアーティファクトをマシンや CI システム間で共有する機能。入力が同一の場合、重複作業を防止する。

解決する問題

標準の Turborepo キャッシュはローカルに存在するため、開発者・チームメンバー・CI システムがそれぞれ別々に同じタスクを再実行してしまう。

実装オプション

セットアップ手順

# Step 1: 認証
turbo login

# SSO の場合
npx turbo login --sso-team=team-name

# Step 2: リンク
turbo link

# Step 3: 動作確認
rm -rf ./.turbo/cache
turbo run build

アーティファクト署名検証

HMAC-SHA256 署名による検証をサポート。

{
  "remoteCache": {
    "signature": true
  }
}

環境変数 TURBO_REMOTE_CACHE_SIGNATURE_KEY に秘密鍵を設定する。

キャッシュ

ハッシュ計算の仕組み

タスクごとに2種類のハッシュを計算し、両方が一致するときのみキャッシュヒット。

グローバルハッシュ（全タスク共通）

• turbo.json 設定変更
• ルートの package.json ロックファイル更新
• globalDependencies のファイル内容変更
• globalEnv の環境変数値変更
• -- 以降の passthrough 引数

パッケージハッシュ（タスク個別）

• パッケージ固有の turbo.json 変更
• パッケージの package.json 変更
• ファイルの変更（デフォルト: 全ファイル。inputs で設定可能）

キャッシュされる内容

• outputs に定義したファイル/ディレクトリ
• ターミナルログ（常にキャッシュ）

キャッシュ制御

デバッグ

turbo build --dry       # 実行せずにタスク計画を確認
turbo build --summarize # 入出力の詳細サマリーを JSON で生成

Git Worktree のキャッシュ共有

メインのワークツリーとリンクされたワークツリー間でローカルキャッシュを自動共有。cacheDir を明示的に指定するとこの機能は無効。

キャッシュが効果を発揮しにくいケース

• タスクの実行速度がネットワーク遅延より速い
• 出力アーティファクトが非常に大きい
• スクリプト自体が内部キャッシュ機構を持っている

CI の構築

環境変数

影響を受けるパッケージのみ実行

# シンプルな方法
turbo run build --affected

# JSON で影響パッケージを確認
turbo query affected --packages web

# バイナリチェック（変更あり: 終了コード 1）
turbo query affected --packages web --exit-code

典型的なワークフロー

# 品質チェックは全パッケージで
turbo run lint check-types test

# ビルドは特定パッケージのみ
turbo build --filter=web

注意点

• シャロークローンの制限: Git 履歴がない場合、ソース管理変更によるフィルタリングは使えない
• GitHub Actions の自動検出: PR の base/head ブランチ間の差分を自動検出
• グローバル turbo のバージョン固定を推奨
• turbo run <task> を明示的に使う（将来のサブコマンドとの名前衝突防止）
• outputs、env、globalEnv を正しく設定しないとキャッシュミスやビルド失敗が発生

依存関係の管理

内部パッケージの依存宣言

pnpm / bun: "@repo/ui": "workspace:*" npm / yarn: "@repo/ui": "*"

複数パッケージへの一括インストール

# pnpm
pnpm add jest --save-dev --recursive --filter=web --filter=@repo/ui

# npm
npm install jest --workspace=web --workspace=@repo/ui --save-dev

# yarn (2+)
yarn workspaces foreach -R --from '{web,@repo/ui}' add jest --dev

ベストプラクティス

• 使う場所にインストール: 依存関係は使用するパッケージの package.json に直接書く
• ルートには管理ツールのみ: turbo / husky / lint-staged 等
• Turborepo は依存関係の管理自体には関与しない（パッケージマネージャーの仕事）

バージョン統一ツール

• syncpack, manypkg, sherif 等の専用ツール
• pnpm v9.5+ の catalogs 機能

アプリケーション開発

dev タスク設定

{
  "tasks": {
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

• "cache": false: 頻繁に変化する開発コードにはキャッシュ不要
• "persistent": true: 終了しないタスクに誤って依存するのを防ぐ

セットアップスクリプト付き dev

{
  "tasks": {
    "dev": {
      "cache": false,
      "persistent": true,
      "dependsOn": ["//#dev:setup"]
    },
    "//#dev:setup": {
      "outputs": [".codegen/**"]
    }
  }
}

コマンド

turbo dev                      # 全 dev タスクを実行
turbo dev --filter=web         # web とその依存パッケージのみ
turbo watch dev lint           # ウォッチモード

ターミナル UI キーバインド

Watch Mode

turbo watch はパッケージ A を変更すると、それに依存するパッケージ B のタスクも自動的に再実行する。

制限事項

ティアダウンタスク: Turborepo はティアダウンスクリプトを自動実行できない。turbo dev:teardown で手動実行する。

環境変数の使用

4種類のキーの違い

設定例

{
  "globalEnv": ["NODE_ENV"],
  "globalPassThroughEnv": ["AWS_ACCESS_KEY_ID"],
  "tasks": {
    "build": {
      "env": ["MY_API_URL", "MY_API_KEY"],
      "passThroughEnv": ["CI"]
    }
  }
}

Strict Mode vs Loose Mode

• strict（デフォルト）: 宣言されていない環境変数はタスクに渡されない
• loose: プロセスの全環境変数がタスクに渡される

フレームワーク自動推論

Next.js の NEXT_PUBLIC_*、Vite の VITE_* 等は自動的にハッシュに含まれる。

無効化: turbo build --framework-inference=false

.env ファイルの扱い

Turborepo は .env ファイルを自動ロードしない。inputs に追加してハッシュに含める:

{
  "globalDependencies": [".env"],
  "tasks": {
    "build": {
      "inputs": ["$TURBO_DEFAULT$", ".env*"]
    }
  }
}

ベストプラクティス

• .env ファイルはルートではなくアプリパッケージに置く
• eslint-config-turbo でハッシュに含まれていない変数を検出
• トラブルシューティング: turbo build --summarize

内部パッケージの作成

1パッケージ1責務の設計が推奨。

作成手順

1. ディレクトリを作成

packages/math/
  src/
    add.ts
    subtract.ts
  package.json
  tsconfig.json

2. package.json

{
  "name": "@repo/math",
  "type": "module",
  "exports": {
    "./add": { "types": "./dist/add.d.ts", "default": "./dist/add.js" },
    "./subtract": { "types": "./dist/subtract.d.ts", "default": "./dist/subtract.js" }
  },
  "scripts": {
    "dev": "tsc --watch",
    "build": "tsc"
  },
  "devDependencies": {
    "typescript": "latest",
    "@repo/typescript-config": "workspace:*"
  }
}

3. tsconfig.json

{
  "extends": "@repo/typescript-config/base.json",
  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
  "include": ["src"],
  "exclude": ["node_modules", "dist"]
}

include / exclude はベース設定から継承されないので必ず明記する。

4. アプリへの組み込み

{ "dependencies": { "@repo/math": "workspace:*" } }

5. キャッシュ設定

{
  "tasks": {
    "build": {
      "outputs": [".next/**", "!.next/cache/**", "dist/**"]
    }
  }
}

Crafting Your Repository

タスクの実行

3つの実行方法

1. package.json スクリプト（頻繁に使うタスク） 2. グローバル turbo CLI（オンデマンド） 3. --filter でスコープを絞る

package.json スクリプト

{
  "scripts": {
    "dev": "turbo run dev",
    "build": "turbo run build",
    "test": "turbo run test",
    "lint": "turbo run lint"
  }
}

複数タスクの同時実行

turbo run build test lint check-types

自動並列化される。

フィルタリング

複数フィルターは OR（和集合）として動作。

ショートハンド構文（v2.2.4+）

turbo run web#build docs#lint

注意点

• turbo コマンドはルートの package.json にのみ書く（パッケージ内に書くと再帰実行）
• タスク実行順序は CLI 引数の順ではなく turbo.json の設定で制御

リポジトリの構造化

推奨ディレクトリ構成

apps/       # アプリケーション・サービス
packages/   # ライブラリ・ツール設定
turbo.json
package.json

最低限必要なもの

1. パッケージマネージャーのワークスペース定義 2. ロックファイル 3. ルート package.json 4. ルート turbo.json 5. 各パッケージの package.json

ワークスペース定義

pnpm (pnpm-workspace.yaml):

packages:
  - "apps/*"
  - "packages/*"

npm / yarn / bun (ルート package.json):

{
  "workspaces": ["apps/*", "packages/*"]
}

exports フィールド

{
  "exports": {
    ".": "./src/constants.ts",
    "./add": "./src/add.ts",
    "./subtract": "./src/subtract.ts"
  }
}

バレルファイルを避け、条件付きエクスポートが可能。IDE の自動補完が効く。

制約

• ネストしたパッケージは非対応（apps/** は不可）
• ロックファイル必須
• パッケージ名には名前空間プレフィックス推奨（例: @acme/name）
• パッケージ間を相対パス（../）でアクセスしない

タスクの設定

dependsOn（依存関係）

^ トポロジカル依存

{ "build": { "dependsOn": ["^build"] } }

全依存パッケージの build を先に実行。

同一パッケージ依存

{ "test": { "dependsOn": ["build"] } }

同じパッケージ内の build を先に実行。

package#task 構文

{ "lint": { "dependsOn": ["utils#build"] } }

特定パッケージの特定タスクへの依存を明示。

依存なし（並列実行）

dependsOn を省略するか空配列にする。

outputs（キャッシュ対象）

{ "build": { "outputs": [".next/**", "!.next/cache/**", "dist/**"] } }

outputs を定義しないとファイルキャッシュなし（ログのみ）。

inputs（ハッシュ対象ファイル）

{ "spell-check": { "inputs": ["**/*.md", "**/*.mdx"] } }

特殊値:

• $TURBO_DEFAULT$: デフォルト挙動を維持しつつ追加・除外
• $TURBO_ROOT$: リポジトリルートからの相対パス
• $TURBO_EXTENDS$: 継承した値に追記

ルートタスク

{ "//#lint:root": {} }

ワークスペースルートの package.json スクリプトを実行。

cache: false（副作用タスク）

{ "deploy": { "dependsOn": ["^build"], "cache": false } }

persistent + with（長時間実行タスク）

{
  "dev": {
    "with": ["api#dev"],
    "persistent": true,
    "cache": false
  }
}

リポジトリの把握

turbo devtools

ブラウザベースのパッケージグラフ可視化ツール。タスクグラフの問題診断に使う。

turbo devtools

turbo ls

パッケージとそのディレクトリ位置を一覧表示。turbo run と同じフィルタリングオプションが使用できる。

turbo ls
turbo ls --filter ...ui

turbo run（引数なし）

タスクを指定せずに turbo run を実行すると、モノレポ内で利用可能な全タスクとそれが定義されているパッケージを表示する。

turbo run

turbo query（v2.2.0+）

GraphQL インターフェースでリポジトリを深く調査できる。

使用例

# build タスクを持つパッケージを検索
turbo query "query { packages(filter: { has: { field: TASK_NAME, value: \"build\"}}) { items { name } } }"

# 10以上のパッケージから依存されているパッケージを検索
turbo query "query { packages(filter: { greaterThan: { field: DIRECT_DEPENDENT_COUNT, value: 10 } }) { items { name } } }"

# 直近の変更で影響を受けたパッケージと理由を確認
turbo query "query { affectedPackages(base: \"HEAD^\", head: \"HEAD\") { items { reason { __typename } } } }"

主なユースケース

• キャッシュミスの多発パッケージ（頻繁にインポートされるパッケージ）の特定
• --affected フラグ使用時の影響範囲の把握
• 肥大化パッケージの分割判断

Related

• running-tasks
• caching
• cli/query

アップグレード

codemod による自動移行

# pnpm
pnpm dlx @turbo/codemod migrate

# yarn
yarn dlx @turbo/codemod migrate

# npm
npx @turbo/codemod migrate

# bun
bunx @turbo/codemod migrate

turbo.json の自動更新と、ワークスペース package.json への name フィールド追加を行う。

v2.0 での主な変更点

packageManager フィールドの必須化

ルート package.json に packageManager フィールドを追加する:

{
  "packageManager": "pnpm@9.2.0"
}

環境変数モードの変更

Strict Mode がデフォルトになった。段階的移行には --env-mode=loose フラグか、turbo.json の envMode キーを使う。

削除されたフラグ

フィルタリングの変更

• 名前空間の自動推論が削除された
• マッチしないパッケージ指定はエラーになる
• --only はパッケージ依存ではなくタスク依存を制限するようになった

キャッシュハッシュの変更

ルート package.json の engines フィールドがキャッシュハッシュに含まれるようになった。

eslint-config-turbo の更新

eslint-config-turbo を使用している場合、メジャーバージョンを合わせて更新する。

Related

• configuring-tasks
• environment-variables

既存リポジトリへの追加

対応するリポジトリタイプ

導入手順

Step 1: Turborepo のインストール

pnpm add turbo --global
pnpm add turbo --save-dev --workspace-root

Step 2: turbo.json の作成

{
  "$schema": "https://turborepo.dev/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "!.next/cache/**"]
    },
    "check-types": {
      "dependsOn": ["^check-types"]
    },
    "dev": {
      "persistent": true,
      "cache": false
    }
  }
}

Step 3: .gitignore への追加

.turbo

Step 4: packageManager フィールドの追加

{
  "packageManager": "pnpm@10.0.0"
}

Step 5: ワークスペース構造の設定（モノレポのみ）

# pnpm-workspace.yaml
packages:
  - "apps/*"
  - "packages/*"

Step 6: タスクの実行

turbo build check-types

キャッシュの効果確認

再実行時の期待される出力:

Cached: 2 cached, 2 total
Time: 185ms >>> FULL TURBO

Installation

新規プロジェクト作成（クイックスタート）

スターターには2つのアプリケーションと3つの共有ライブラリが含まれる。

グローバルインストール

pnpm add turbo --global
npm install turbo --global

用途:

• turbo build — 依存グラフに沿ってビルド
• turbo build --filter=docs --dry — ドライラン
• turbo generate — コード生成
• cd apps/docs && turbo build — 特定パッケージのビルド

リポジトリへのインストール（devDependency）

npm install turbo --save-dev

チーム間でバージョンを統一するため、ルートの devDependency にも追加する。

ローカルバージョンへの委譲

グローバルの turbo はリポジトリにローカルバージョンが存在する場合、自動的にそちらに委譲する。ワークフローの利便性を保ちつつチーム全体のバージョン一貫性を維持できる。

getting-started

Buildkite

.buildkite/pipeline.yml 設定例

steps:
  - label: ":test_tube: Test"
    command: |
      npm install
      npm test
  - label: ":hammer: Build"
    command: |
      npm install
      npm run build

Remote Cache 設定

secrets プラグインで環境変数を注入:

steps:
  - label: ":test_tube: Test"
    command: |
      npm install
      npm test
    plugins:
      - secrets:
          variables:
            TURBO_TOKEN: TURBO_TOKEN
            TURBO_TEAM: TURBO_TEAM

CircleCI

重要: CircleCI は TTY を使用するため、`TURBO_UI: "false"` が全 run ステップで必須。

.circleci/config.yml 設定例（pnpm）

version: 2.1
orbs:
  node: circleci/node@5.0.2
workflows:
  test:
    jobs:
      - test
jobs:
  test:
    docker:
      - image: cimg/node:lts
    steps:
      - checkout
      - node/install-packages
      - run:
          command: npm i -g pnpm
          environment:
            TURBO_UI: "false"
      - run:
          command: pnpm build
          environment:
            TURBO_UI: "false"
      - run:
          command: pnpm test
          environment:
            TURBO_UI: "false"

Remote Cache 設定

CircleCI プロジェクト設定の「環境変数」タブで TURBO_TOKEN と TURBO_TEAM を登録。環境変数は自動でロードされるため CI ファイルの変更は不要。

GitHub Actions

ワークフロー設定例（pnpm）

name: CI
on:
  push:
    branches: ["main"]
  pull_request:
    types: [opened, synchronize]

jobs:
  build:
    name: Build and Test
    timeout-minutes: 15
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 2
      - uses: pnpm/action-setup@v3
        with:
          version: 8
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: 'pnpm'
      - run: pnpm install
      - run: pnpm build
      - run: pnpm test

Remote Cache 設定

1. Vercel でスコープ付きアクセストークンを作成 2. GitHub Secrets に TURBO_TOKEN を登録 3. GitHub Variables に TURBO_TEAM を登録 4. ワークフロー YAML に環境変数を追加:

env:
  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
  TURBO_TEAM: ${{ vars.TURBO_TEAM }}

actions/cache によるローカルキャッシング

- uses: actions/cache@v4
  with:
    path: .turbo
    key: ${{ runner.os }}-turbo-${{ github.sha }}
    restore-keys: |
      ${{ runner.os }}-turbo-

GitLab CI

.gitlab-ci.yml 設定例（pnpm）

image: node:latest
stages:
  - build
build:
  stage: build
  before_script:
    - curl -f https://get.pnpm.io/v6.16.js | node - add --global pnpm@6.32.2
    - pnpm config set store-dir .pnpm-store
  script:
    - pnpm install
    - pnpm build
    - pnpm test
  cache:
    key:
      files:
        - pnpm-lock.yaml
    paths:
      - .pnpm-store

Remote Cache 設定

1. Vercel でスコープ付きアクセストークンを作成 2. GitLab「リポジトリ設定 → CI/CD → Variables」で TURBO_TOKEN と TURBO_TEAM を登録

Guides CI Vendors

Travis CI

.travis.yml 設定例（pnpm）

language: node_js
node_js:
  - lts/*
cache:
  npm: false
  directories:
    - "~/.pnpm-store"
before_install:
  - curl -f https://get.pnpm.io/v6.16.js | node - add --global pnpm@6.32.2
  - pnpm config set store-dir ~/.pnpm-store
install:
  - pnpm install
script:
  - pnpm build
  - pnpm test

pnpm を使う場合、npm: false でデフォルトの npm キャッシュを無効化し、~/.pnpm-store を別途キャッシュする。

Remote Cache 設定

Travis リポジトリ設定の環境変数セクションで TURBO_TOKEN と TURBO_TEAM を登録。環境変数は自動でロードされるため CI ファイルの変更は不要。

Vercel

Turborepo と Vercel の統合はゼロコンフィグ。Vercel が自動的にモノレポ構造を認識し、Remote Cache も自動で構成される。

デプロイ手順

1. https://vercel.com/new でプロジェクトを新規作成 2. コードをインポート 3. Vercel が自動的に Turborepo を検出し、正しい設定を適用

TURBO_TOKEN / TURBO_TEAM の手動設定は不要。

ライブラリのフレームワークバインディング

ライブラリパッケージ内でフレームワーク API を使う際に、peerDependencies として宣言する手法。

peerDependencies の設定

{
  "name": "@repo/ui",
  "peerDependencies": {
    "next": "*"
  }
}

消費者側がインストールしたフレームワークのバージョンがライブラリ内でも解決される。バージョンは範囲指定を推奨（例: ">=15"）。

実装例

import { ComponentProps } from "react";
import { Link } from "next/link";

type CustomLinkProps = ComponentProps<typeof Link>;

export function CustomLink({ children, ...props }: CustomLinkProps) {
  return (
    <Link className="text-underline hover:text-green-400" {...props}>
      {children}
    </Link>
  );
}

エントリーポイント分割（複数フレームワーク対応）

{
  "exports": {
    "./link": "./dist/link.js",
    "./next-js/link": "./dist/next-js/link.js"
  },
  "peerDependencies": {
    "next": "*"
  }
}

• ./link — フレームワーク非依存の汎用 Link
• ./next-js/link — Next.js 専用の Link

Next.js

クイックスタート

pnpm dlx create-turbo@latest        # デフォルトテンプレート
pnpm dlx create-next-app@latest apps/my-app  # 既存リポジトリに追加

内部パッケージの参照

// pnpm / bun
"@repo/ui": "workspace:*"

// yarn / npm
"@repo/ui": "*"

タスクのカスタマイズ

デフォルトではルートの turbo.json のタスクが使用される。アプリ固有の設定は Package Configurations で上書き可能。

マイクロフロントエンド設定

// apps/docs/next.config.ts
const nextConfig: NextConfig = {
  basePath: "/docs",
};
export default nextConfig;

basePath の設定を忘れるとアセットのルーティングが壊れる。

Nuxt

クイックスタート

pnpm dlx create-turbo@latest -e with-vue-nuxt
pnpm dlx nuxi@latest init apps/my-app  # 既存リポジトリに追加

内部パッケージの参照

// pnpm / bun
"@repo/ui": "workspace:*"

// yarn / npm
"@repo/ui": "*"

マイクロフロントエンド設定

Nuxt は内部的に Vite を使用するため、vite.config.ts で base を設定:

export default defineConfig({
  base: "/admin",
});

guides-frameworks

SvelteKit

クイックスタート

pnpm dlx create-turbo@latest -e with-svelte
pnpm dlx sv create apps/my-app  # 既存リポジトリに追加

内部パッケージの参照

// pnpm / bun
"@repo/ui": "workspace:*"

// yarn / npm
"@repo/ui": "*"

マイクロフロントエンド設定

SvelteKit も Vite ベースのため、vite.config.ts で base を設定:

export default defineConfig({
  base: "/admin",
});

Vite

クイックスタート

pnpm dlx create-turbo@latest -e with-vite

内部パッケージの参照

// pnpm / bun
"@repo/ui": "workspace:*"

// yarn / npm
"@repo/ui": "*"

マイクロフロントエンド設定

export default defineConfig({
  base: "/admin",
});

base を設定しないと画像や CSS が正しくルーティングされない。

Module Federation

ランタイムでのモジュール共有には with-vite-module-federation テンプレートを使う:

pnpm dlx create-turbo@latest -e with-vite-module-federation

複数の Vite アプリ・パッケージ間で React / Vue / Svelte コンポーネントや依存関係をランタイム共有できる。

Module Federation 使用時の turbo.json 設定:

• dev タスク: "cache": false、"persistent": true、"dependsOn": ["^build"]（共有パッケージのビルドを先に実行）

Biome

高速フォーマッター兼リンター。ルートタスクとして運用が推奨。

設定

{
  "scripts": {
    "format-and-lint": "biome check .",
    "format-and-lint:fix": "biome check . --write"
  }
}

{
  "tasks": {
    "//#format-and-lint": {},
    "//#format-and-lint:fix": { "cache": false }
  }
}

注意

ルートタスクのため、バージョンアップや設定変更時に全タスクのキャッシュミスが発生する。

Docker

問題

モノレポでは package-lock.json がリポジトリ全体で共有されるため、無関係な変更が全アプリの再ビルドを引き起こす。

解決策: turbo prune

turbo prune api --docker

出力構造:

• ./out/json — 依存インストール用の package.json のみ
• ./out/full — 完全なソースファイルと設定

Dockerfile 実装例

FROM base AS prepare
RUN yarn global add turbo@^2
RUN turbo prune web --docker

FROM base AS builder
COPY --from=prepare /app/out/json/ .
RUN yarn install
COPY --from=prepare /app/out/full/ .
RUN yarn turbo build

Remote Cache との連携

docker build -f apps/web/Dockerfile . \
  --build-arg TURBO_TEAM="your-team-name" \
  --build-arg TURBO_TOKEN="your-token" \
  --no-cache

ESLint

ESLint v9（Flat Config）— 推奨

設定パッケージ構成:

packages/eslint-config/
  package.json
  base.js
  next.js
  react-internal.js

ESLint プラグインや依存関係を @repo/eslint-config パッケージに一元管理する。

lint タスク設定

{ "tasks": { "lint": { "dependsOn": ["^lint"] } } }

^lint により設定パッケージ変更時に依存パッケージのキャッシュが自動無効化される。

注意

ESLint v8 は 2024年10月5日に EOL。新規プロジェクトでは必ず v9 Flat Config を使用する。

Jest

基本設定

{ "scripts": { "test": "jest" } }

{ "tasks": { "test": {} } }

ウォッチモードの分離（重要）

{
  "scripts": { "test": "jest", "test:watch": "jest --watch" }
}

{
  "tasks": {
    "test:watch": { "cache": false, "persistent": true }
  }
}

VS Code Jest 拡張機能

{
  "jest.jestCommandLine": "turbo run test --log-prefix=none --"
}

Oxc (oxlint / oxfmt)

Rust 製の超高速 JavaScript / TypeScript ツールスイート。

oxlint

{
  "scripts": { "lint": "oxlint .", "lint:fix": "oxlint . --fix" }
}

{
  "tasks": {
    "//#lint": {},
    "//#lint:fix": { "cache": false }
  }
}

oxfmt（アルファ版）

{
  "scripts": { "format": "oxfmt --check .", "format:fix": "oxfmt ." }
}

注意点

• type-aware lint を有効にする場合、Compiled Package は事前にビルドが必要
• oxfmt はアルファ版のため本番採用には注意
• 統合ワークフロー: 検証は並列、修正は逐次実行（ファイル書き込み競合防止）

Playwright

環境変数の設定（Strict Mode 対応）

{
  "tasks": {
    "e2e": { "passThroughEnv": ["PLAYWRIGHT_*"] }
  }
}

またはグローバル:

{ "globalPassThroughEnv": ["PLAYWRIGHT_*"] }

タスクグラフの設計

{ "tasks": { "e2e": { "dependsOn": ["^build"] } } }

上流ビルドをスキップする場合:

turbo run e2e --filter=@repo/playwright-myapp --only

共有ユーティリティパッケージ

Playwright を重複インストールしないよう peerDependencies を使用:

{
  "name": "@repo/playwright-utilities",
  "peerDependencies": { "playwright": "workspace:*" }
}

Prisma

DB クライアントをモノレポ内の共有内部パッケージとして構成する。

クイックスタート

npx create-turbo@latest -e with-prisma

主要な統合ポイント

• Prisma Client の初期化
• Internal Package パターンに従った構造化
• マイグレーション（prisma migrate）
• ローカル開発ワークフロー
• 本番デプロイ戦略

詳細は Prisma 公式ガイドを参照。

guides-tools

shadcn/ui

セットアップ

モノレポ用の canary バージョンを使用:

pnpm dlx shadcn@canary init

セットアップウィザードで monorepo オプションを選択。

コンポーネントの追加

pnpm dlx shadcn@canary add [COMPONENT]

注意点

• モノレポサポートは @canary バージョンが必須
• npm パッケージではなくファイルが直接コピーされる
• Tailwind CSS が前提条件

Storybook

テンプレートから開始

pnpm dlx create-turbo@latest -e design-system

キャッシュ設定

{ "tasks": { "build": { "outputs": ["storybook-static/**"] } } }

.gitignore に storybook-static を追加。

Co-Located Stories パターン

大規模デザインシステムで推奨。ストーリーをソースパッケージ内に配置:

1. .storybook/main.ts でストーリーのパスをソースパッケージへ向ける 2. ストーリーファイルを本番ビルドの inputs から除外してキャッシュを維持

スタイルの統合

CSS は .storybook/preview.ts で手動インポートが必要。

Tailwind CSS

クイックスタート

pnpm dlx create-turbo@latest -e with-tailwind

アーキテクチャ

共有 Tailwind 設定パッケージ

/* packages/tailwind-config/shared-styles.css */
@import "tailwindcss";

@theme {
  --color-brand: #3b82f6;
}

UI パッケージ

ui: プレフィックスを付けてスタイル優先度の競合を防ぐ:

<button class="ui:bg-blue-500 ui:text-white">Button</button>

ベストプラクティス

スタイルビルドとコンポーネントビルドを別タスクに分離し、並列実行しつつ依存関係を正しく管理する。

TypeScript

設定共有 — @repo/typescript-config

packages/typescript-config/
  base.json
  nextjs.json
  react-library.json

// base.json の代表的なオプション
{ "compilerOptions": { "target": "es2022", "module": "NodeNext", "strict": true, "isolatedModules": true } }

exports フィールド

{
  "exports": {
    "./*": { "types": "./src/*.ts", "default": "./dist/*.js" }
  }
}

型チェック

{ "scripts": { "check-types": "tsc --noEmit" } }

ベストプラクティス

• bundler ではなく tsc を使う
• declaration: true と declarationMap: true を有効にする
• TypeScript の paths より Node.js の subpath imports を使う（TS 5.4+）
• ルートの tsconfig.json は作成しない
• TypeScript Project References は使わない（設定が複雑になりキャッシュ効率も悪化）
• ワークスペース全体で TypeScript のバージョンを統一する

Vitest

アプローチ 1: パッケージ単位（推奨）

{
  "scripts": { "test": "vitest run", "test:watch": "vitest --watch" }
}

{
  "tasks": {
    "test": { "dependsOn": ["^test"] },
    "test:watch": { "cache": false, "persistent": true }
  }
}

カバレッジマージ: nyc merge → nyc report

アプローチ 2: Vitest Projects（ルート一元管理）

export default defineConfig({
  projects: [
    { name: "web", root: "./apps/web", test: { include: ["src/**/*.test.ts"] } },
  ],
});

{ "tasks": { "//#test": { "outputs": ["coverage/**"] } } }

デメリット: どのパッケージを変更しても全体キャッシュミスが発生。

アプローチ 3: ハイブリッド

共有設定パッケージ @repo/vitest-config を作成し、各パッケージがインポート。

注意

• workspaces は非推奨。projects を使う
• サンプル: npx create-turbo@latest --example with-vitest

AI との連携

Agent Skills

npx skills add vercel/turborepo

Turborepo のベストプラクティス・パターン・アンチパターンをエージェントに教える。

Git Worktrees による並列エージェント実行

turbo run build
git branch feature-branch && git worktree add ../agent-2-worktree feature-branch
cd ../agent-2-worktree && turbo run build  # キャッシュが再利用される

Turborepo はワークツリー間でローカルキャッシュを自動共有する。

Task Descriptions

{
  "tasks": {
    "build": {
      "description": "Compiles TypeScript and bundles the application",
      "dependsOn": ["^build"],
      "outputs": ["dist/**"]
    },
    "test": {
      "description": "Runs the test suite with coverage",
      "dependsOn": ["build"]
    }
  }
}

AI がタスクの目的を理解しやすくなる。

ターミナルドキュメント検索

AI エージェントがシェルコマンドを実行できる場合、turbo docs でバージョン付きドキュメントを直接検索できる:

turbo docs [クエリ]

機械可読ドキュメント

コード生成

ビルトイン生成コマンド

turbo gen workspace              # 空のパッケージを追加
turbo gen workspace --copy       # 既存パッケージをテンプレートとして複製
turbo gen workspace --copy https://github.com/...  # リモートから複製

カスタムジェネレーター

内部的に Plop の設定形式を使用。設定ファイルの配置場所:

• モノレポルート: turbo/generators/config.ts
• 任意のワークスペース内: {workspace}/turbo/generators/config.ts

import type { PlopTypes } from "@turbo/gen";

export default function generator(plop: PlopTypes.NodePlopAPI): void {
  plop.setGenerator("Generator name", {
    description: "Generator description",
    prompts: [
      { type: "input", name: "name", message: "What is the name?" },
    ],
    actions: [
      { type: "add", path: "src/{{name}}.ts", templateFile: "templates/component.hbs" },
    ],
  });
}

実行方法

turbo gen [generator-name]
turbo gen [generator-name] --args answer1 answer2

注意点

• ESM 依存関係は現在非対応
• TypeScript 使用時は @turbo/gen を devDependency としてインストール

プラットフォーム対応

Node.js バージョン対応

package.json の engines キーで自動検出:

{ "engines": { "node": ">=18.0.0" } }

OS・アーキテクチャ対応

Step 1: キャッシュキー生成スクリプト

const { writeFileSync } = require("fs");
const { platform, arch } = process;
writeFileSync("turbo-cache-key.json", JSON.stringify({ platform, arch }));

Step 2: .gitignore に追加

turbo-cache-key.json

Step 3: inputs に登録

{
  "tasks": {
    "build-for-platforms": {
      "inputs": ["$TURBO_DEFAULT$", "turbo-cache-key.json"]
    }
  }
}

または全タスクに適用:

{ "globalDependencies": ["turbo-cache-key.json"] }

Step 4: Turborepo 実行前にスクリプトを実行

{
  "scripts": {
    "build-for-platforms": "node ./scripts/create-turbo-cache-key.js && turbo run build"
  }
}

ファイル生成は Turborepo 実行前に行う必要がある。

マイクロフロントエンド

Turborepo はローカル開発用のプロキシサーバーをビルトインで提供。複数アプリを単一エントリーポイント（デフォルト: http://localhost:3024）で統合できる。

microfrontends.json

{
  "$schema": "https://turborepo.dev/microfrontends/schema.json",
  "options": { "localProxyPort": 3024 },
  "applications": {
    "web": {
      "development": { "local": { "port": 3000 } }
    },
    "docs": {
      "packageName": "documentation",
      "development": {
        "local": { "port": 3001 },
        "fallback": "example.com"
      },
      "routing": [
        { "group": "documentation", "paths": ["/docs", "/docs/:path*"] }
      ]
    }
  }
}

ポート設定

{ "scripts": { "dev": "next dev --port $(turbo get-mfe-port)" } }

Vite: TURBO_MFE_PORT 環境変数を使用。

フレームワーク別ベースパス設定

ルーティングパスパターン

パスは大文字・小文字を区別する。

本番環境

Turborepo のプロキシはローカル開発専用。Vercel の場合は @vercel/microfrontends で本番対応。

Nx からの移行

移行の動機

• エコシステム標準への準拠（JS パッケージマネージャーのワークスペースをそのまま活用）
• 設定量の削減（約15行 vs 40行以上）

移行手順

1. .gitignore に .turbo を追加 2. ワークスペース定義を作成 3. 各アプリに package.json を追加 4. Nx プラグインを設定から削除 5. packageManager フィールドを指定 6. パッケージマネージャーの install を実行 7. Turborepo をインストール 8. turbo.json を作成 9. turbo build で動作確認 10. リモートキャッシュを有効化

設定対応表

CLI 対応表

段階的移行

タスク単位・パッケージ単位で1つずつ移行する。移行中は Nx と Turborepo を並行して使用可能。

多言語サポート

Turborepo はスクリプトの実行内容には関与しない設計のため、Rust や Go 等も統合可能。

ワークスペース定義への追加

# pnpm-workspace.yaml
packages:
  - "apps/*"
  - "packages/*"
  - "cli"

package.json によるラッピング

{
  "name": "@repo/rust-cli",
  "scripts": { "build": "cargo build --release" }
}

キャッシング設定

{ "tasks": { "build": { "outputs": ["target/release/**"] } } }

依存関係の定義

{ "dependencies": { "@repo/rust-cli": "workspace:*" } }

非 JS ツールチェーン（Rust, Go 等）は別途インストール済みである必要がある。

ライブラリの公開

ビルド設定（tsup）

{ "scripts": { "build": "tsup src/index.ts --format cjs,esm --dts" } }

キャッシュ設定

{ "tasks": { "build": { "outputs": ["dist/**"] } } }

パッケージエントリーポイント

{
  "main": "./dist/index.js",
  "module": "./dist/index.mjs",
  "types": "./dist/index.d.ts"
}

バージョン管理と公開（Changesets）

{
  "scripts": {
    "publish-packages": "turbo run build lint test && changeset version && changeset publish"
  }
}

スクリプト名を publish ではなく publish-packages にして npm ビルトインとの競合を防ぐ。

代替ツール

• intuit/auto — PR ラベルに基づいたリリース生成
• microsoft/beachball — セマンティックバージョン管理

Guides

単一パッケージワークスペース

create-next-app や npm create vite で生成される単一アプリケーション構造でも Turborepo を活用できる。

利用可能な機能

• ローカルキャッシング
• リモートキャッシング
• タスクの並列化

利用不可能な機能

• パッケージ間タスク（app#build のような指定）

シナリオ 1: タスクの順次実行

{
  "tasks": {
    "dev": { "dependsOn": ["db:seed"], "persistent": true },
    "db:seed": { "dependsOn": ["db:push"] },
    "db:push": {}
  }
}

実行順序: db:push → db:seed → dev

シナリオ 2: タスクの並列実行

turbo check-types lint format

シナリオ 3: キャッシュ入力の最適化

{
  "tasks": {
    "check-types": { "inputs": ["**/*.{ts,tsx}"] }
  }
}

タスクのスキップ

キャッシュヒットを超えた最適化として、コード変更がないワークスペースの CI タスクを完全にスキップする。

主要コマンド

turbo query affected --packages web
turbo query affected --tasks test --packages web
turbo query affected --packages web --base main --head HEAD

--exit-code フラグ

turbo query affected --packages web --exit-code

シェルスクリプトでの使用例

#!/bin/bash
AFFECTED=$(turbo query affected --packages web)
COUNT=$(echo "$AFFECTED" | jq '.data.affectedPackages.length')
if [ "$COUNT" -eq 0 ]; then
  echo "No affected packages, skipping tasks"
  exit 0
fi
turbo run test --filter=web

Git 履歴の注意点

シャロークローンでは全パッケージが変更済みとして扱われる場合がある。適切な履歴取得には以下を推奨:

git fetch --filter=blob:none --depth=0

重要

turbo-ignore は非推奨。turbo query affected への移行を推奨。

CI with GitHub Actions

Run Turborepo tasks in GitHub Actions with Remote Cache and affected-package detection.

.github/workflows/ci.yml:

name: CI
on:
  push:
    branches: ["main"]
  pull_request:
    types: [opened, synchronize]

env:
  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
  TURBO_TEAM: ${{ vars.TURBO_TEAM }}

jobs:
  build:
    name: Build and Test
    timeout-minutes: 15
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 2
      - uses: pnpm/action-setup@v3
        with:
          version: 8
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: "pnpm"
      - run: pnpm install
      - run: pnpm turbo run lint check-types test
      - run: pnpm turbo run build --affected

Optional local cache persistence between runs (alternative to Remote Cache):

- uses: actions/cache@v4
  with:
    path: .turbo
    key: ${{ runner.os }}-turbo-${{ github.sha }}
    restore-keys: |
      ${{ runner.os }}-turbo-

Notes

• fetch-depth: 2 is required for --affected to detect changes between commits; without Git history, source-diff filtering is unavailable
• GitHub Actions automatically detects the PR base/head branches for --affected comparisons
• TURBO_TOKEN is a Vercel scoped access token; TURBO_TEAM is the Vercel team slug
• Use turbo run <task> explicitly (not bare turbo <task>) to avoid future subcommand name conflicts

Code Generation

Scaffold new packages or files using turbo gen with built-in or custom generators.

Built-in workspace generator:

# Add a new empty package
turbo gen workspace

# Copy an existing package as a template
turbo gen workspace --copy

# Copy from a remote repository
turbo gen workspace --copy https://github.com/org/repo

Custom generator — turbo/generators/config.ts at the monorepo root:

import type { PlopTypes } from "@turbo/gen";

export default function generator(plop: PlopTypes.NodePlopAPI): void {
  plop.setGenerator("react-component", {
    description: "Add a new React component",
    prompts: [
      { type: "input", name: "name", message: "Component name?" },
    ],
    actions: [
      {
        type: "add",
        path: "src/components/{{pascalCase name}}.tsx",
        templateFile: "templates/component.hbs",
      },
    ],
  });
}

Run a custom generator:

turbo gen react-component

# Pass answers directly (non-interactive)
turbo gen react-component --args MyButton

Notes

• Generators use Plop configuration format internally
• Place generator configs either at the monorepo root (turbo/generators/config.ts) or inside any workspace ({workspace}/turbo/generators/config.ts)
• Install @turbo/gen as a devDependency when using TypeScript configs
• ESM-only dependencies are not currently supported inside generator configs

Development Workflow

Run persistent development servers across all packages with watch mode support.

turbo.json:

{
  "tasks": {
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

With a setup script that runs before dev servers start:

{
  "tasks": {
    "dev": {
      "cache": false,
      "persistent": true,
      "dependsOn": ["//#dev:setup"]
    },
    "//#dev:setup": {
      "outputs": [".codegen/**"]
    }
  }
}

Common commands:

# Start all dev tasks across the monorepo
turbo dev

# Start dev only for the web app and its dependencies
turbo dev --filter=web

# Watch mode — reruns dependent tasks when a package changes
turbo watch dev lint

Run two persistent tasks in parallel using with:

{
  "tasks": {
    "dev": {
      "with": ["api#dev"],
      "persistent": true,
      "cache": false
    }
  }
}

Notes

• "cache": false is required for dev tasks — source changes are continuous and caching would cause stale output
• "persistent": true prevents other tasks from incorrectly depending on a long-running process
• turbo watch reruns tasks in dependent packages automatically when upstream packages change
• Teardown scripts (e.g. database cleanup) must be triggered manually: turbo run dev:teardown

Environment Variables

Declare environment variables so Turborepo includes them in cache hash computation.

{
  "$schema": "https://turborepo.com/schema.json",
  "globalEnv": ["NODE_ENV"],
  "globalPassThroughEnv": ["AWS_ACCESS_KEY_ID"],
  "tasks": {
    "build": {
      "env": ["MY_API_URL", "MY_API_KEY"],
      "passThroughEnv": ["CI"]
    }
  }
}

Include .env files in the hash so cache invalidates when secrets change:

{
  "globalDependencies": [".env"],
  "tasks": {
    "build": {
      "inputs": ["$TURBO_DEFAULT$", ".env*"]
    }
  }
}

Debug which variables are (or are not) affecting the cache:

turbo build --summarize

Notes

• env and globalEnv: variable value is hashed — a change triggers a cache miss
• passThroughEnv and globalPassThroughEnv: variable is available at runtime but does not affect the hash
• In strict mode (default), undeclared variables are not passed to tasks at all; use loose mode only when migrating
• Framework-specific prefixes (NEXT_PUBLIC_*, VITE_*, etc.) are inferred automatically and included in the hash
• Place .env files inside the app package, not the repo root, for tighter scoping

Filtering Tasks

Run tasks only for specific packages using --filter.

# By package name
turbo run build --filter=@acme/web

# By directory glob
turbo run lint --filter="./packages/*"

# Include all packages that depend on ui (upstream)
turbo run build --filter=...ui

# Include ui and all packages it depends on (downstream)
turbo run dev --filter=web...

# Only packages changed since last commit
turbo run build --affected

# Only packages changed relative to a branch
turbo run build --filter=[origin/main]

# Combine multiple filters (union)
turbo run test --filter=@acme/web --filter=@acme/api

# Exclude a package
turbo run lint --filter=!@acme/docs

# Shorthand: run specific package#task pairs (v2.2.4+)
turbo run web#build docs#lint

Root package.json scripts for common workflows:

{
  "scripts": {
    "build": "turbo run build",
    "dev": "turbo run dev",
    "test": "turbo run test",
    "lint": "turbo run lint"
  }
}

Notes

• Multiple --filter flags are combined as OR (union)
• ...pkg means "pkg and all packages that depend on it"; pkg... means "pkg and all packages it depends on"
• ^ in filter syntax (e.g. ^...ui) excludes the matched package itself and includes only its relatives
• Do not write turbo commands inside individual package package.json scripts — only in the root

Internal Packages

Create a shared TypeScript package consumed by apps inside the monorepo.

Directory layout:

packages/math/
  src/
    add.ts
    subtract.ts
  package.json
  tsconfig.json

packages/math/package.json:

{
  "name": "@repo/math",
  "type": "module",
  "exports": {
    "./add": { "types": "./dist/add.d.ts", "default": "./dist/add.js" },
    "./subtract": { "types": "./dist/subtract.d.ts", "default": "./dist/subtract.js" }
  },
  "scripts": {
    "dev": "tsc --watch",
    "build": "tsc"
  },
  "devDependencies": {
    "typescript": "latest",
    "@repo/typescript-config": "workspace:*"
  }
}

packages/math/tsconfig.json:

{
  "extends": "@repo/typescript-config/base.json",
  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
  "include": ["src"],
  "exclude": ["node_modules", "dist"]
}

Declare the dependency in any consuming app (pnpm / bun):

{ "dependencies": { "@repo/math": "workspace:*" } }

For npm / yarn:

{ "dependencies": { "@repo/math": "*" } }

Cache build output in root turbo.json:

{
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**"]
    }
  }
}

Notes

• include and exclude in tsconfig.json are not inherited from the base config — always declare them explicitly
• Use exports instead of a barrel index.ts to enable tree-shaking and IDE auto-completion per entry point
• workspace:* (pnpm/bun) or "*" (npm/yarn) tells the package manager to resolve the package from the local workspace

Monorepo Setup

Bootstrap a new Turborepo monorepo with apps and shared packages.

# Create with pnpm
pnpm dlx create-turbo@latest

# Create with npm
npx create-turbo@latest

# Create with yarn
yarn dlx create-turbo@latest

Resulting structure:

apps/
  web/          # Next.js app
  docs/         # docs app
packages/
  ui/           # shared UI components
  eslint-config/
  typescript-config/
turbo.json
package.json

pnpm-workspace.yaml (or root package.json workspaces field for npm/yarn):

packages:
  - "apps/*"
  - "packages/*"

Root turbo.json:

{
  "$schema": "https://turborepo.com/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**", "!.next/cache/**"]
    },
    "lint": {},
    "test": {
      "dependsOn": ["build"]
    },
    "dev": {
      "cache": false,
      "persistent": true
    }
  }
}

Notes

• apps/ holds deployable applications; packages/ holds shared libraries and configs
• Nested packages (e.g. apps/**) are not supported — use a flat list in workspace definitions
• Add turbo to devDependencies at the root to pin the version across the team
• Use scoped package names (e.g. @acme/ui) to avoid collisions

Publishing Packages

Build and publish versioned packages from a Turborepo monorepo using Changesets.

packages/ui/package.json — build script and entry points:

{
  "name": "@acme/ui",
  "main": "./dist/index.js",
  "module": "./dist/index.mjs",
  "types": "./dist/index.d.ts",
  "scripts": {
    "build": "tsup src/index.ts --format cjs,esm --dts"
  }
}

Root turbo.json — cache built output:

{
  "tasks": {
    "build": {
      "outputs": ["dist/**"]
    }
  }
}

Root package.json — publish workflow script:

{
  "scripts": {
    "publish-packages": "turbo run build lint test && changeset version && changeset publish"
  }
}

Changeset commands:

# Create a changeset describing what changed
changeset

# Bump versions based on collected changesets
changeset version

# Build and publish to npm
changeset publish

Notes

• Name the script publish-packages rather than publish to avoid conflict with the npm built-in publish lifecycle hook
• Run turbo run build lint test before changeset publish to ensure only verified artifacts are released
• Alternative version management tools: intuit/auto (PR-label-based) and microsoft/beachball

samples

Remote Caching

Share build cache artifacts across team members and CI using Vercel Remote Cache.

# Step 1: authenticate
turbo login

# Step 2: link the repository to your Vercel account
turbo link

# Step 3: verify (clear local cache then rebuild — should hit remote)
rm -rf ./.turbo/cache
turbo run build

For CI (GitHub Actions example):

env:
  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
  TURBO_TEAM: ${{ vars.TURBO_TEAM }}

Enable HMAC-SHA256 artifact signature verification in turbo.json:

{
  "remoteCache": {
    "signature": true
  }
}

Set the signing key via environment variable:

TURBO_REMOTE_CACHE_SIGNATURE_KEY=<secret>

Notes

• Vercel Remote Cache is free on all plans; the repository does not need to be hosted on Vercel
• TURBO_TOKEN is a scoped access token created in Vercel project settings
• TURBO_TEAM is the Vercel team slug (visible in the Vercel dashboard URL)
• Self-hosting is supported via any HTTP server that implements the Turborepo Remote Cache API

Task Pipeline

Define task execution order and dependency relationships in turbo.json.

{
  "$schema": "https://turborepo.com/schema.json",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**"]
    },
    "test": {
      "dependsOn": ["build"]
    },
    "lint": {},
    "deploy": {
      "dependsOn": ["^build"],
      "cache": false
    }
  }
}

Key dependsOn patterns:

Notes

• "^build" is the most common pattern: ensures all upstream dependencies are built before the current package
• Tasks without dependsOn run in parallel automatically
• "cache": false is required for side-effectful tasks such as deploy or publish
• outputs must be declared for file artifacts to be cached and restored

Build & Deploy

ビルド・デプロイ・Docker 向け操作コマンド。

ビルドタスクの実行

turbo run build

特定パッケージのビルド

turbo run build --filter=web
turbo run build --filter=@acme/web
turbo run build --filter=./apps/web

複数タスクの並列実行

turbo run build test lint check-types

変更パッケージのみビルド

turbo run build --affected
turbo run build --filter=[HEAD^1]
turbo run build --filter=[origin/main]

Docker 向け部分モノレポの生成（turbo prune）

警告: --out-dir に既存ディレクトリを指定すると内容が上書きされる。

turbo prune <package>

Docker 向けに出力する例:

turbo prune web --docker

--docker フラグを使った場合の出力構造:

out/
├── json/          # package.json のみ（依存インストール用）
├── full/          # 完全なソースコード（ビルド用）
└── pnpm-lock.yaml # プルーニング済みロックファイル

カスタム出力先を指定:

turbo prune web --docker --out-dir=./docker-out

タスクグラフの可視化

turbo run build --graph
turbo run build --graph=graph.svg
turbo run build --graph=graph.html
turbo run build --graph=graph.mermaid

ビルド結果の確認

turbo run build --dry
turbo run build --dry=json
turbo run build --summarize

同時実行数の制御

turbo run build --concurrency=10
turbo run build --concurrency=50%    # CPU 数の 50% を使用

エラー時の続行設定

turbo run build --continue=always                   # 常に続行
turbo run build --continue=dependencies-successful  # 依存が成功したら続行
turbo run build --continue=never                    # エラーで即停止（デフォルト）

Cache

キャッシュ制御・Remote Caching のセットアップと管理コマンド。

Remote Cache 認証・接続

# Vercel に認証（デフォルト）
turbo login

# SSO チームで認証
turbo login --sso-team=slug-for-team

# 手動でトークンを入力
turbo login --manual

# カスタム API エンドポイントで認証
turbo login --api=https://acme.com/api

# ログアウト
turbo logout

リモートキャッシュへのリンク

# リポジトリを Remote Cache にリンク
turbo link

# チームスコープを指定してリンク
turbo link --scope=my-team

# 確認プロンプトをスキップ
turbo link --yes

# カスタム Remote Cache プロバイダーにリンク
turbo link --api=https://acme.com/api

# リンクを解除
turbo unlink

Remote Cache の動作確認

rm -rf ./.turbo/cache
turbo run build

再実行時に FULL TURBO が表示されれば Remote Cache が機能している。

キャッシュ制御フラグ（turbo run と組み合わせて使用）

# キャッシュを無視して強制再実行
turbo run build --force

# ローカルキャッシュ読み書き・リモートキャッシュ読み込みのみ
turbo run build --cache=local:rw,remote:r

# キャッシュディレクトリを変更
turbo run build --cache-dir="./my-cache"

# タスク計画のみ確認（実行なし）
turbo run build --dry

# 実行メタデータ（ハッシュ・入出力）を JSON で出力
turbo run build --summarize

--cache の書式: local:<r|w|rw>,remote:<r|w|rw>（例: local:r,remote:rw）

パフォーマンスデバッグ

# タスク計画の確認（JSON 形式）
turbo run build --dry=json

# パフォーマンストレースの生成
turbo run build --profile=my-profile.json

CLI

turbo CLI の主要コマンドリファレンス。

タスク実行（turbo run）

turbo run <task> [options]
turbo <task>        # run は省略可能

複数タスクを同時実行する場合:

turbo run build test lint check-types

turbo run のフィルタリング

# パッケージ名でフィルター
turbo run build --filter=web
turbo run build --filter=@acme/ui

# ディレクトリでフィルター
turbo run lint --filter="./packages/utilities/*"

# 依存元（上流）を含む
turbo run build --filter=...@acme/ui

# 依存先（下流）を含む
turbo run dev --filter=web...

# 変更のあったパッケージのみ
turbo run build --affected

# Git 差分ベース
turbo run build --filter=[HEAD^1]
turbo run build --filter=[origin/main]

# 特定タスクのショートハンド（v2.2.4+）
turbo run web#build docs#lint

# 除外
turbo run build --filter=./apps/* --filter=!./apps/admin

turbo run の主要オプション

よく使う turbo run の組み合わせ

turbo run build --affected                      # 変更パッケージのみビルド
turbo run build --dry=json                      # ドライラン（JSON 出力）
turbo run test --continue=always                # エラーでも続行
turbo run build --cache=local:r,remote:rw       # ローカル読み込みのみ
turbo run build --force                         # キャッシュを無視して再実行
turbo run build --graph=graph.svg               # タスクグラフを SVG で出力
turbo run build --summarize                     # 実行サマリーを生成
turbo run build --concurrency=50%               # CPU 数の 50% を使用

ウォッチモード（turbo watch）

turbo watch [tasks]
turbo watch dev lint

コードの変更をもとにタスクを再実行する。"persistent": true のタスクは無視される。

実験的なキャッシュ書き込み:

turbo watch your-tasks --experimental-write-cache

パッケージ一覧（turbo ls）

turbo ls                                    # 全パッケージ一覧
turbo ls web @repo/ui                       # 特定パッケージの詳細
turbo ls --affected                         # 変更パッケージのみ
turbo ls --affected --filter=web            # affected と filter の積集合
turbo ls --output=json                      # JSON 形式で出力

依存関係違反チェック（turbo boundaries）

turbo boundaries

パッケージディレクトリ外のインポートおよび package.json に未宣言のパッケージのインポートを検出する（実験的機能）。

GraphQL クエリ（turbo query）

turbo query                                              # GraphiQL インタラクティブモード
turbo query "query { packages { items { name } } }"      # 直接実行
turbo query query.gql                                    # ファイルから実行
turbo query --schema                                     # GraphQL スキーマを出力

変更影響分析:

turbo query affected
turbo query affected --tasks build test
turbo query affected --base=main --head=HEAD

デバッグ情報（turbo info）

turbo info

バージョン、パス、デーモン状態、パッケージマネージャー、プラットフォーム情報を表示する。

パッケージグラフの可視化（turbo devtools）

turbo devtools
turbo devtools --port=9876
turbo devtools --no-open

ブラウザでパッケージグラフを可視化する。

テレメトリー管理

turbo telemetry status    # テレメトリーの現在の状態を確認
turbo telemetry enable    # テレメトリーを有効化
turbo telemetry disable   # テレメトリーを無効化

グローバルフラグ

Dev

開発サーバー起動・ウォッチモードコマンド。

全パッケージの開発サーバー起動

turbo run dev
turbo dev

turbo.json で "persistent": true を設定した dev タスクが対象。

特定パッケージのみ起動

turbo run dev --filter=web
turbo dev --filter=web

依存パッケージを含めて起動

turbo dev --filter=web...

ウォッチモードで開発

turbo watch dev
turbo watch dev lint

ファイル変更を検知してタスクを自動再実行する。依存関係グラフを考慮し、変更されたパッケージの下流タスクも再実行する。

"persistent": true のタスクは turbo watch に無視される。"interruptible": true のタスクは変更検知時に再起動される。

実験的なキャッシュ書き込み付きウォッチ

turbo watch dev --experimental-write-cache

ティアダウンスクリプトの手動実行

turbo run dev:teardown

Turborepo はティアダウンスクリプトを自動実行しないため、手動で呼び出す。

ターミナル UI キーバインド

Generate

turbo gen / turbo generate によるコード生成コマンド。

新規ワークスペースの追加

turbo gen workspace
turbo generate workspace

インタラクティブプロンプトで名前・種別・配置先を設定する。

ワークスペース作成のオプション

turbo gen workspace [options]

既存ワークスペースからのコピー

turbo gen workspace --copy

リモートリポジトリからのコピー

turbo gen workspace --copy https://github.com/<owner>/<repo>

カスタムジェネレーターの実行

turbo gen run [generator-name]
turbo gen [generator-name]

turbo/generators/config.js（または config.ts）に定義したジェネレーターを実行する。

カスタムジェネレーターのオプション

turbo gen run [generator-name] [options]

プロンプトへの回答を直接渡す例

turbo gen run my-generator --args answer1 answer2

Inspect

モノレポ構造・依存関係・境界違反の検査コマンド。

パッケージ一覧の確認

turbo ls
turbo ls --output=json

特定パッケージの詳細確認

turbo ls web @repo/ui

パッケージ名、ディレクトリ、内部依存関係、タスク一覧を表示する。

変更パッケージの確認

turbo ls --affected
TURBO_SCM_BASE=development turbo ls --affected

変更パッケージのフィルター付き確認

turbo ls --affected --filter=web

GraphQL によるクエリ分析

# GraphiQL インタラクティブモード
turbo query

# インラインクエリの実行
turbo query "query { packages { items { name } } }"

# ファイルからクエリを実行
turbo query query.gql

# GraphQL スキーマの出力
turbo query --schema

# クエリ変数の指定
turbo query query.gql --variables=vars.json

変更影響の分析（turbo query affected）

turbo query affected
turbo query affected --tasks build test
turbo query affected --packages @acme/ui
turbo query affected --base=main --head=HEAD
turbo query affected --exit-code

--exit-code フラグ: 変更あり=1、なし=0、エラー=2

依存関係違反の検査（turbo boundaries）

turbo boundaries

以下の違反を検出する（実験的機能）:

• パッケージディレクトリ外のファイルインポート
• package.json の dependencies に未宣言のパッケージのインポート

タスクグラフの出力

turbo run build --graph
turbo run build --graph=graph.svg
turbo run build --graph=graph.html
turbo run build --graph=graph.mermaid
turbo run build --graph=graph.dot

パッケージグラフの可視化（ブラウザ）

turbo devtools
turbo devtools --port=9876
turbo devtools --no-open

デバッグ情報の表示

turbo info

バージョン、パス、デーモン状態、パッケージマネージャー、プラットフォーム情報を表示する。

Install

Turborepo のインストールと新規プロジェクト作成コマンド。

新規プロジェクト作成（create-turbo）

# npm
npx create-turbo@latest

# pnpm
pnpm dlx create-turbo@latest

# yarn
yarn dlx create-turbo@latest

# bun
bunx create-turbo@latest

スターターには2つのアプリケーションと3つの共有パッケージが含まれる。

create-turbo のオプション

npx create-turbo@latest [options]

グローバルインストール

# npm
npm install turbo --global

# pnpm
pnpm add turbo --global

# yarn
yarn global add turbo

# bun
bun install turbo --global

グローバルの turbo はリポジトリにローカルバージョンが存在する場合、自動的にそちらに委譲する。

devDependency としてのインストール

# npm
npm install turbo --save-dev

# pnpm
pnpm add turbo --save-dev --ignore-workspace-root-check

# yarn
yarn add turbo --dev --ignore-workspace-root-check

# bun
bun install turbo --dev

チーム全体でバージョンを統一するため、ワークスペースルートの devDependency に追加する。

既存リポジトリへの追加（pnpm の例）

pnpm add turbo --global
pnpm add turbo --save-dev --ignore-workspace-root-check

Step 2 以降は turbo.json 作成、.gitignore への .turbo 追加、packageManager フィールドの設定が必要。

@turbo/gen のインストール（カスタムジェネレーター使用時）

# npm
npm install @turbo/gen --save-dev

# pnpm
pnpm add @turbo/gen --save-dev

# yarn
yarn add @turbo/gen --dev

TypeScript でカスタムジェネレーターを作成する場合に必要。

Migrate

バージョンアップグレード・移行コマンド。

@turbo/codemod による自動移行

npx @turbo/codemod migrate

非推奨機能・破壊的変更の自動移行を実行する。

ドライランで変更内容を確認してから実行

npx @turbo/codemod migrate --dry

警告: migrate は設定ファイルや package.json を書き換える。--dry で事前に変更内容を確認することを推奨。

turbo scan による最適化設定（非推奨）

turbo scan

Git FS Monitor・Remote Caching・バージョンチェック等をインタラクティブに設定する。

注記: turbo scan は非推奨（deprecated）であり、将来のバージョンで削除される予定。

Scripts