feat: copy .gitignore-d files into new session worktrees (#26)

## 概要

セッションを新しく立ち上げるときの git worktree は、**git 追跡対象のファイルしか引き継ぎません**。そのため
`.gitignore` された `node_modules/` や `.env`
などはコピーされず、各セッションで依存の再インストールや環境変数の再設定が必要でした。

この PR で、worktree 作成時にリポジトリルートの **ignore された未追跡ファイルを複製**するようにします（既定で有効）。

## 変更点

- **`ignoredCopyEntries()`（純関数・新規）**: `git ls-files --others --ignored
--exclude-standard --directory` の出力をパースし、コピー対象エントリを返す。
- `--directory` によりディレクトリ全体が ignore されている場合は末尾 `/` 付きの1エントリに畳まれる →
`node_modules/` を数万ファイル列挙せず1エントリで扱える。
  - `.codiva/`（worktree 群を再帰コピーしてしまう）と `.git`（内部状態破壊）は必ず除外。
- **`WorktreeManager.copyIgnoredFiles()`**: `fs.cp`
でエントリ単位のベストエフォート複製。1件の失敗で worktree 作成全体を止めない。
- **`add()`**: `copyIgnored` が有効なら worktree 作成後にコピーを実行。
- **config**: `copyIgnored`（既定 `true`）を追加。`toConfig()`
で検証。`"copyIgnored": false` で無効化可能。
- **docs**: README の設定セクション + ARCHITECTURE の WorktreeManager 記述を更新。

> 未ステージのファイル（作業途中の tracked 変更）は git worktree の仕様上そのまま引き継がれないため対象外です。この
PR は「ignore されたファイルの複製」にフォーカスしています。

## 設計判断

- 純粋ロジック（コピー対象の決定）と I/O（コピー実行）を分離（`ignoredCopyEntries`
は純関数、テーブルドリブンでテスト）。
- パフォーマンス配慮で `--directory` を使い、大量ファイルの列挙を回避。
- 破壊を避けるため `.codiva/` / `.git` を確実に除外。

## テスト計画

- [x] `ignoredCopyEntries` の純関数テスト（`.codiva/`・`.git` 除外、空入力）
- [x] 実 git リポジトリで `node_modules/` と `.env` が worktree に複製されることを検証
- [x] `.codiva/` が複製されないことを検証
- [x] `copyIgnored: false` で複製がスキップされることを検証
- [x] `toConfig()` の `copyIgnored` 検証（boolean 受理・不正値ドロップ・全キー結合）
- [x] `npm test`（479 passed） / `npm run typecheck` / `npm run
lint`（変更ファイルは警告0）

Author: takecchi

README.md

@@ -58,11 +58,13 @@ codiva
 
 ```json
 {
-  "language": "auto"
+  "language": "auto",
+  "copyIgnored": true
 }
 ```
 
 - `language`: `"ja"` / `"en"` / `"auto"`（OS ロケール準拠）。環境変数 `CODIVA_LANG`（`ja` / `en`）が最優先です。
+- `copyIgnored`: セッション用 worktree を作るとき、`.gitignore` された未追跡ファイル（`node_modules/` や `.env` など）をリポジトリルートから複製するか。既定 `true`。git worktree は追跡対象しか引き継がないため、これにより依存の再インストールや環境変数の再設定なしにセッションを即実行できます（`false` で無効化）。
 
 ## 開発
 

docs/ARCHITECTURE.md

@@ -158,6 +158,7 @@ interface SessionState {
 - 前提チェック: Gitリポジトリか、HEAD が存在するか（コミット0のリポジトリでは worktree を作れない）。
 - `add(slug)`: `git worktree add .codiva/worktrees/<slug> -b codiva/<slug>` を現在の HEAD から作成。slug 衝突時は `-2`, `-3` を付与。
 - `.git/info/exclude` に `.codiva/` を自動追記（初回のみ）。
+- ignore 済みファイルの複製: `copyIgnored`（既定 true）が有効なら、`git ls-files --others --ignored --exclude-standard --directory` で列挙した `.gitignore` 対象（`node_modules/`・`.env` など）をリポジトリルートから worktree へ `fs.cp` で複製する。git worktree は追跡対象しか引き継がないため、これで依存の再インストールや環境変数の再設定なしにセッションが即実行できる。列挙結果のフィルタは純関数 `ignoredCopyEntries()` に切り出し（`.codiva/`・`.git` は再帰・内部状態破壊を避けるため必ず除外）、コピー自体はエントリ単位のベストエフォート（1件の失敗で worktree 作成を止めない）。
 - `diffStat(session)`: `git -C <worktree> diff <base>...HEAD --stat` 相当。未コミット変更がある場合はその旨も返す。
 - `merge(session)`: セッションブランチをベースブランチへマージ（squash はしない。コンフリクト時はエラーを返し、手動解決を促すメッセージを表示するのみ）。
 - `remove(session, { force })`: `git worktree remove` + `git branch -D`。

src/core/config.spec.ts

@@ -80,6 +80,17 @@ describe('toConfig', () => {
     expect(toConfig({ notifications })).toEqual({});
   });
 
+  it.each([
+    [true, true],
+    [false, false],
+  ])('keeps boolean copyIgnored %o', (input, expected) => {
+    expect(toConfig({ copyIgnored: input })).toEqual({ copyIgnored: expected });
+  });
+
+  it.each([['yes'], [1], [null]])('drops invalid copyIgnored: %o', (copyIgnored) => {
+    expect(toConfig({ copyIgnored })).toEqual({});
+  });
+
   it('collects all valid keys together', () => {
     expect(
       toConfig({
@@ -89,6 +100,7 @@ describe('toConfig', () => {
         permissionMode: 'acceptEdits',
         maxBudgetUsd: 2.5,
         notifications: false,
+        copyIgnored: false,
       }),
     ).toEqual({
       language: 'en',
@@ -97,6 +109,7 @@ describe('toConfig', () => {
       permissionMode: 'acceptEdits',
       maxBudgetUsd: 2.5,
       notifications: false,
+      copyIgnored: false,
     });
   });
 });

src/core/config.ts

@@ -24,6 +24,13 @@ export interface CodivaConfig {
    * 有効中は端末のテキスト選択が通常ドラッグでできない（Shift+ドラッグは可）。
    */
   mouse?: boolean;
+  /**
+   * セッション用 worktree 作成時に `.gitignore` された未追跡ファイル
+   * （`node_modules/`・`.env` など）をリポジトリルートから複製するか。未設定は有効（true）。
+   * git worktree は追跡対象しか引き継がないため、無効化すると依存や環境変数を
+   * セッション側で用意し直す必要がある。
+   */
+  copyIgnored?: boolean;
 }
 
 /** SDK 由来 union の実行時検証用リテラル。型が変われば型エラーで気付ける。 */
@@ -46,6 +53,7 @@ interface CodivaConfigJson {
   maxBudgetUsd?: unknown;
   notifications?: unknown;
   mouse?: unknown;
+  copyIgnored?: unknown;
 }
 
 function toLangSetting(value: unknown): Lang | 'auto' | undefined {
@@ -111,5 +119,9 @@ export function toConfig(json: unknown): CodivaConfig {
   if (mouse !== undefined) {
     config.mouse = mouse;
   }
+  const copyIgnored = toBoolean(raw.copyIgnored);
+  if (copyIgnored !== undefined) {
+    config.copyIgnored = copyIgnored;
+  }
   return config;
 }

src/core/worktree.spec.ts

@@ -1,11 +1,11 @@
 import { execFile } from 'node:child_process';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { uniqueSlug } from '@/core/slug';
-import { WorktreeManager } from '@/core/worktree';
+import { ignoredCopyEntries, WorktreeManager } from '@/core/worktree';
 
 const execFileAsync = promisify(execFile);
 const g = (cwd: string, ...args: string[]) => execFileAsync('git', args, { cwd });
@@ -127,6 +127,51 @@ describe('WorktreeManager', () => {
     });
   });
 
+  describe('ignoredCopyEntries', () => {
+    it('keeps ignored files and dirs but drops .codiva and .git', () => {
+      const raw = ['.codiva/', '.env', '.env.local', '.git/', 'node_modules/', ''].join('\n');
+      expect(ignoredCopyEntries(raw)).toEqual(['.env', '.env.local', 'node_modules/']);
+    });
+
+    it('returns an empty list for empty output', () => {
+      expect(ignoredCopyEntries('')).toEqual([]);
+    });
+  });
+
+  describe('copying .gitignore-d files into a new worktree', () => {
+    beforeEach(async () => {
+      repo = await makeRepo(true);
+      // ignore node_modules/ and .env, then leave them untracked on disk
+      await writeFile(join(repo, '.gitignore'), 'node_modules/\n.env\n.codiva/\n');
+      await g(repo, 'add', '.gitignore');
+      await g(repo, 'commit', '-m', 'add gitignore');
+      await mkdir(join(repo, 'node_modules', 'dep'), { recursive: true });
+      await writeFile(join(repo, 'node_modules', 'dep', 'index.js'), 'module.exports = 1\n');
+      await writeFile(join(repo, '.env'), 'SECRET=1\n');
+    });
+
+    it('copies ignored files/dirs from the repo root by default', async () => {
+      const wm = new WorktreeManager(repo);
+      const wt = await wm.add('with-ignored');
+      expect(await readFile(join(wt.path, '.env'), 'utf8')).toBe('SECRET=1\n');
+      expect(await readFile(join(wt.path, 'node_modules', 'dep', 'index.js'), 'utf8')).toBe(
+        'module.exports = 1\n',
+      );
+    });
+
+    it('does not copy .codiva (would recurse into worktrees)', async () => {
+      const wm = new WorktreeManager(repo);
+      const wt = await wm.add('no-codiva');
+      await expect(readFile(join(wt.path, '.codiva', 'state.json'), 'utf8')).rejects.toBeTruthy();
+    });
+
+    it('skips copying when copyIgnored is false', async () => {
+      const wm = new WorktreeManager(repo, { copyIgnored: false });
+      const wt = await wm.add('bare');
+      await expect(readFile(join(wt.path, '.env'), 'utf8')).rejects.toBeTruthy();
+    });
+  });
+
   describe('slug collision handling', () => {
     it('avoids reusing an existing codiva branch slug', async () => {
       repo = await makeRepo(true);

src/core/worktree.ts

@@ -1,11 +1,22 @@
-import { appendFile, mkdir, readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { appendFile, cp, mkdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 import { GitError, git } from '@/utils';
 
 const CODIVA_DIR = '.codiva';
 const WORKTREES_SUBDIR = join(CODIVA_DIR, 'worktrees');
 const EXCLUDE_MARKER = '# codiva';
 
+/**
+ * `git worktree add` が引き継ぐのは追跡対象ファイルだけなので、`.gitignore` された
+ * `node_modules/` や `.env` などは新しい worktree に現れない。これらをリポジトリ
+ * ルートから複製すると、セッションが即座にビルド/実行できる（依存や環境変数を
+ * 手で用意し直さなくてよい）。既定で有効。
+ */
+export interface WorktreeOptions {
+  /** `.gitignore` された未追跡ファイルを新しい worktree へコピーするか。未設定は true。 */
+  copyIgnored?: boolean;
+}
+
 export interface Worktree {
   slug: string;
   branch: string;
@@ -19,14 +30,41 @@ export interface DiffStat {
   uncommitted: string[];
 }
 
+/**
+ * `git ls-files --others --ignored --exclude-standard --directory` の生出力から、
+ * 新しい worktree へコピーすべき ignore 済みエントリだけを取り出す純関数。
+ *
+ * `--directory` によりディレクトリ全体が ignore されている場合は末尾 `/` 付きの
+ * 1エントリに畳まれる（`node_modules/` を数万ファイル列挙せずに済む）。codiva 自身の
+ * 作業ディレクトリ（`.codiva/`）と `.git` は、worktree 群を再帰コピーしたり内部状態を
+ * 壊したりするため必ず除外する。
+ */
+export function ignoredCopyEntries(raw: string): string[] {
+  return raw
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .filter((entry) => {
+      const normalized = entry.replace(/\/$/, '');
+      return normalized !== CODIVA_DIR && normalized !== '.git';
+    });
+}
+
 /**
  * Creates and tears down git worktrees for sessions. Every worktree lives under
  * `.codiva/worktrees/<slug>` on branch `codiva/<slug>`, branched from the repo's
  * current HEAD. The repo's own files are never modified except a one-time
  * `.git/info/exclude` entry for `.codiva/`.
  */
 export class WorktreeManager {
-  constructor(private readonly repoRoot: string) {}
+  private readonly copyIgnored: boolean;
+
+  constructor(
+    private readonly repoRoot: string,
+    options: WorktreeOptions = {},
+  ) {
+    this.copyIgnored = options.copyIgnored !== false;
+  }
 
   /** The base branch worktrees are cut from and merged back into. */
   async baseBranch(): Promise<string> {
@@ -89,7 +127,39 @@ export class WorktreeManager {
     const relPath = join(WORKTREES_SUBDIR, slug);
     const branch = `codiva/${slug}`;
     await git(this.repoRoot, ['worktree', 'add', relPath, '-b', branch]);
-    return { slug, branch, path: join(this.repoRoot, relPath) };
+    const worktreePath = join(this.repoRoot, relPath);
+    if (this.copyIgnored) {
+      await this.copyIgnoredFiles(worktreePath);
+    }
+    return { slug, branch, path: worktreePath };
+  }
+
+  /**
+   * `.gitignore` された未追跡ファイル（`node_modules/`・`.env` など）をリポジトリ
+   * ルートから新しい worktree へ複製する。git worktree は追跡対象しか引き継がないため、
+   * これがないとセッション側で依存の再インストールや環境変数の再設定が必要になる。
+   *
+   * ベストエフォート: 個々のコピー失敗（競合・権限等）は worktree 作成を巻き込まず
+   * スキップする（環境ファイルが1つ欠けても致命ではない）。
+   */
+  private async copyIgnoredFiles(worktreePath: string): Promise<void> {
+    const raw = await git(this.repoRoot, [
+      'ls-files',
+      '--others',
+      '--ignored',
+      '--exclude-standard',
+      '--directory',
+    ]).catch(() => '');
+    for (const entry of ignoredCopyEntries(raw)) {
+      const from = join(this.repoRoot, entry);
+      const to = join(worktreePath, entry);
+      try {
+        await mkdir(dirname(to), { recursive: true });
+        await cp(from, to, { recursive: true, force: true, errorOnExist: false });
+      } catch {
+        // best-effort: 1エントリの失敗で worktree 作成全体を止めない
+      }
+    }
   }
 
   /** Committed diff stat vs. the base branch plus any uncommitted paths. */

src/index.tsx

@@ -38,7 +38,9 @@ async function main(): Promise<void> {
   const t = messages[lang];
 
   const repoRoot = process.cwd();
-  const worktrees = new WorktreeManager(repoRoot);
+  // `.gitignore` された node_modules/.env 等は git worktree に引き継がれないため、
+  // 既定でリポジトリルートから複製する（`"copyIgnored": false` で無効化）。
+  const worktrees = new WorktreeManager(repoRoot, { copyIgnored: config.copyIgnored !== false });
 
   try {
     await worktrees.preflight();