feat: add glob pattern support to copyFiles option

Adds support for glob patterns in the postCreate.copyFiles configuration
option, allowing users to specify patterns like *.env, **/*.local.yml, and
other standard glob patterns instead of listing each file individually.

Features:
- Created glob-resolver module with pattern detection and expansion
- Support for *, **, ?, and [abc] glob patterns
- Handles literal filenames containing glob metacharacters
- Custom **/ pattern matcher for dotfiles (works around Node.js limitation)
- Excludes .git directory from recursive searches
- Full backward compatibility with exact file paths

Implementation:
- Integrated glob resolution into file-copier workflow
- Added recursiveReaddir() for walking directory trees
- Added matchesPattern() for regex-based glob matching
- Literal file paths take precedence over glob patterns
- Zero dependencies added (uses Node.js native globSync)

Testing:
- Added comprehensive test coverage (22 glob resolver tests)
- Added 12 file-copier integration tests
- Fixed attach.test.js module mocking for globSync
- All tests passing (193 tests total)

Documentation:
- Updated configuration.md with glob syntax reference and examples

Author: sleicht

docs/configuration.md

@@ -91,11 +91,11 @@ parent-directory/
 
 ### postCreate.copyFiles
 
-An array of file paths to automatically copy from the current worktree to newly created worktrees.
+An array of file paths or glob patterns to automatically copy from the current worktree to newly created worktrees.
 
 **Use Cases:**
 - Environment configuration files (`.env`, `.env.local`)
-- Local development settings
+- Local development settings across subdirectories
 - Secret files that are gitignored
 - Database configuration files
 - API keys and certificates
@@ -106,18 +106,36 @@ An array of file paths to automatically copy from the current worktree to newly
   "postCreate": {
     "copyFiles": [
       ".env",
-      ".env.local",
-      "config/database.local.yml"
+      ".env*",
+      "config/**/*.local.yml",
+      "secrets/[ab]*.json"
     ]
   }
 }
 ```
 
+**Glob Pattern Support:**
+
+Glob patterns allow you to match multiple files with a single pattern. Supported patterns:
+
+- `*` - Matches any characters except `/` (e.g., `*.env` matches `.env` but not `config/.env`)
+- `**` - Matches any characters including `/` (recursive, e.g., `**/*.yml` matches all `.yml` files in any subdirectory)
+- `?` - Matches any single character (e.g., `file?.txt` matches `file1.txt` but not `file10.txt`)
+- `[abc]` - Matches any character in the brackets (e.g., `file-[ab].txt` matches `file-a.txt` and `file-b.txt`)
+
+**Common Patterns:**
+
+- `.env*` - All files starting with `.env` (`.env`, `.env.local`, `.env.production`, etc.)
+- `*.local` - All files ending with `.local` in the root directory
+- `config/**/*.local.yml` - All `.local.yml` files anywhere under `config/` directory
+- `secrets/[ab]*.json` - All `.json` files in `secrets/` starting with `a` or `b`
+
 **Notes:**
-- Paths are relative to the repository root
-- Currently, glob patterns are not supported
-- Files must exist in the source worktree
-- Non-existent files are silently skipped
+- Paths and patterns are relative to the repository root
+- Exact file paths and glob patterns can be mixed in the same array
+- Patterns matching no files are silently skipped (no error)
+- Directories are excluded from copying (only files are copied)
+- Overlapping patterns are automatically deduplicated
 - Can be overridden with `--copy-file` command line options
 
 ### postCreate.commands

packages/core/src/worktree/attach.test.js

@@ -23,6 +23,7 @@ mock.module("./validate.ts", {
 mock.module("node:fs", {
   namedExports: {
     existsSync: existsSyncMock,
+    globSync: mock.fn(() => []),
   },
 });
 

packages/core/src/worktree/file-copier.test.js

@@ -130,4 +130,140 @@ describe("copyFiles", () => {
     );
     assert.strictEqual(copiedFile, '{"env": "local"}');
   });
+
+  test("should copy files matching wildcard pattern", async () => {
+    await writeFile(path.join(sourceDir, ".env"), "TEST=value");
+    await writeFile(path.join(sourceDir, ".env.local"), "LOCAL=value");
+    await writeFile(path.join(sourceDir, ".env.production"), "PROD=value");
+    await writeFile(path.join(sourceDir, "config.json"), '{"key": "value"}');
+
+    const result = await copyFiles(sourceDir, targetDir, [".env*"]);
+
+    assert.strictEqual(isOk(result), true);
+    if (isOk(result)) {
+      assert.strictEqual(result.value.copiedFiles.length, 3);
+      assert.ok(result.value.copiedFiles.includes(".env"));
+      assert.ok(result.value.copiedFiles.includes(".env.local"));
+      assert.ok(result.value.copiedFiles.includes(".env.production"));
+    }
+
+    const copiedEnv = await readFile(path.join(targetDir, ".env"), "utf-8");
+    assert.strictEqual(copiedEnv, "TEST=value");
+  });
+
+  test("should copy files matching recursive pattern", async () => {
+    await mkdir(path.join(sourceDir, "config", "db"), { recursive: true });
+    await mkdir(path.join(sourceDir, "config", "api"), { recursive: true });
+
+    await writeFile(
+      path.join(sourceDir, "config", "db", "database.local.yml"),
+      "db: local",
+    );
+    await writeFile(
+      path.join(sourceDir, "config", "api", "api.local.yml"),
+      "api: local",
+    );
+    await writeFile(
+      path.join(sourceDir, "config", "settings.yml"),
+      "settings: default",
+    );
+
+    const result = await copyFiles(sourceDir, targetDir, [
+      "config/**/*.local.yml",
+    ]);
+
+    assert.strictEqual(isOk(result), true);
+    if (isOk(result)) {
+      assert.strictEqual(result.value.copiedFiles.length, 2);
+      assert.ok(
+        result.value.copiedFiles.includes(
+          path.join("config", "db", "database.local.yml"),
+        ),
+      );
+      assert.ok(
+        result.value.copiedFiles.includes(
+          path.join("config", "api", "api.local.yml"),
+        ),
+      );
+    }
+
+    const copiedDb = await readFile(
+      path.join(targetDir, "config", "db", "database.local.yml"),
+      "utf-8",
+    );
+    assert.strictEqual(copiedDb, "db: local");
+  });
+
+  test("should skip patterns with no matches", async () => {
+    await writeFile(path.join(sourceDir, "file.txt"), "content");
+
+    const result = await copyFiles(sourceDir, targetDir, ["*.nonexistent"]);
+
+    assert.strictEqual(isOk(result), true);
+    if (isOk(result)) {
+      assert.deepStrictEqual(result.value.copiedFiles, []);
+      assert.deepStrictEqual(result.value.skippedFiles, []);
+    }
+  });
+
+  test("should combine glob patterns and exact paths", async () => {
+    await writeFile(path.join(sourceDir, ".env"), "TEST=value");
+    await writeFile(path.join(sourceDir, ".env.local"), "LOCAL=value");
+    await writeFile(path.join(sourceDir, "config.json"), '{"key": "value"}');
+
+    const result = await copyFiles(sourceDir, targetDir, [
+      ".env*",
+      "config.json",
+    ]);
+
+    assert.strictEqual(isOk(result), true);
+    if (isOk(result)) {
+      assert.strictEqual(result.value.copiedFiles.length, 3);
+      assert.ok(result.value.copiedFiles.includes(".env"));
+      assert.ok(result.value.copiedFiles.includes(".env.local"));
+      assert.ok(result.value.copiedFiles.includes("config.json"));
+    }
+  });
+
+  test("should deduplicate files from overlapping patterns", async () => {
+    await writeFile(path.join(sourceDir, ".env"), "TEST=value");
+    await writeFile(path.join(sourceDir, ".env.local"), "LOCAL=value");
+
+    const result = await copyFiles(sourceDir, targetDir, [".env*", ".env"]);
+
+    assert.strictEqual(isOk(result), true);
+    if (isOk(result)) {
+      // Should only copy each file once
+      assert.strictEqual(result.value.copiedFiles.length, 2);
+      assert.strictEqual(
+        result.value.copiedFiles.filter((f) => f === ".env").length,
+        1,
+      );
+    }
+  });
+
+  test("should preserve subdirectory structure for matched files", async () => {
+    await mkdir(path.join(sourceDir, "nested"), { recursive: true });
+    await writeFile(path.join(sourceDir, "nested", "file1.txt"), "content1");
+    await writeFile(path.join(sourceDir, "nested", "file2.txt"), "content2");
+
+    const result = await copyFiles(sourceDir, targetDir, ["nested/*.txt"]);
+
+    assert.strictEqual(isOk(result), true);
+    if (isOk(result)) {
+      assert.strictEqual(result.value.copiedFiles.length, 2);
+      assert.ok(
+        result.value.copiedFiles.includes(path.join("nested", "file1.txt")),
+      );
+      assert.ok(
+        result.value.copiedFiles.includes(path.join("nested", "file2.txt")),
+      );
+    }
+
+    const copiedFile1 = await readFile(
+      path.join(targetDir, "nested", "file1.txt"),
+      "utf-8",
+    );
+    assert.strictEqual(copiedFile1, "content1");
+  });
 });

packages/core/src/worktree/file-copier.ts

@@ -1,6 +1,10 @@
 import { copyFile, mkdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { err, ok, type Result } from "@aku11i/phantom-shared";
+import { err, isErr, ok, type Result } from "@aku11i/phantom-shared";
+import {
+  type GlobResolutionError,
+  resolveGlobPatterns,
+} from "./glob-resolver.ts";
 
 export interface CopyFileResult {
   copiedFiles: string[];
@@ -21,11 +25,18 @@ export async function copyFiles(
   sourceDir: string,
   targetDir: string,
   files: string[],
-): Promise<Result<CopyFileResult, FileCopyError>> {
+): Promise<Result<CopyFileResult, FileCopyError | GlobResolutionError>> {
+  // Resolve glob patterns first
+  const resolveResult = await resolveGlobPatterns(sourceDir, files);
+  if (isErr(resolveResult)) {
+    return resolveResult;
+  }
+
+  const resolvedFiles = resolveResult.value.resolvedFiles;
   const copiedFiles: string[] = [];
   const skippedFiles: string[] = [];
 
-  for (const file of files) {
+  for (const file of resolvedFiles) {
     const sourcePath = path.join(sourceDir, file);
     const targetPath = path.join(targetDir, file);