feat(code): add .worktreeinclude support

Author: adboio

apps/code/src/main/services/file-watcher/service.ts

@@ -16,7 +16,7 @@ import {
 
 const log = logger.scope("file-watcher");
 
-const IGNORE_PATTERNS = ["**/node_modules/**", "**/.git/**", "**/.jj/**"];
+const IGNORE_PATTERNS = ["node_modules", ".git", ".jj", ".posthog-code"];
 const DEBOUNCE_MS = 500;
 const BULK_THRESHOLD = 100;
 
@@ -71,7 +71,37 @@ export class FileWatcherService extends TypedEventEmitter<FileWatcherEvents> {
     if (this.watchers.has(repoPath)) return;
 
     await fs.mkdir(this.snapshotsDir, { recursive: true });
-    await this.emitChangesSinceSnapshot(repoPath);
+
+    const MAX_RETRIES = 3;
+    const RETRY_DELAY_MS = 2000;
+
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        await this.initWatcher(repoPath);
+        return;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (attempt < MAX_RETRIES && message.includes("Events were dropped")) {
+          log.warn(
+            `File watcher failed (attempt ${attempt}/${MAX_RETRIES}), retrying in ${RETRY_DELAY_MS}ms: ${message}`,
+          );
+          await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+        } else {
+          log.error(
+            `File watcher failed after ${attempt} attempt(s): ${message}`,
+          );
+          throw error;
+        }
+      }
+    }
+  }
+
+  private async initWatcher(repoPath: string): Promise<void> {
+    try {
+      await this.emitChangesSinceSnapshot(repoPath);
+    } catch (error) {
+      log.warn("Failed to emit changes since snapshot, skipping:", error);
+    }
 
     const pending: PendingChanges = {
       dirs: new Set(),

apps/code/src/renderer/features/environments/components/EnvironmentSelector.tsx

@@ -4,7 +4,7 @@ import { HardDrives, Plus } from "@phosphor-icons/react";
 import { Flex, Tooltip } from "@radix-ui/themes";
 import { useTRPC } from "@renderer/trpc/client";
 import { useQuery } from "@tanstack/react-query";
-import { useState } from "react";
+import { useEffect, useState } from "react";
 
 interface EnvironmentSelectorProps {
   repoPath: string | null;
@@ -29,6 +29,12 @@ export function EnvironmentSelector({
     enabled: !!repoPath,
   });
 
+  useEffect(() => {
+    if (value === null && environments.length > 0) {
+      onChange(environments[0].id);
+    }
+  }, [value, environments, onChange]);
+
   const selectedEnvironment = environments.find((env) => env.id === value);
   const displayText = selectedEnvironment?.name ?? "No environment";
 

packages/agent/src/adapters/claude/claude-agent.ts

@@ -87,7 +87,7 @@ import type {
   ToolUseCache,
 } from "./types";
 
-const SESSION_VALIDATION_TIMEOUT_MS = 10_000;
+const SESSION_VALIDATION_TIMEOUT_MS = 30_000;
 const MAX_TITLE_LENGTH = 256;
 const LOCAL_ONLY_COMMANDS = new Set(["/context", "/heapdump", "/extra-usage"]);
 

packages/git/src/sagas/worktree.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { GitSaga, type GitSagaInput } from "../git-saga";
 import { addToLocalExclude, branchExists, getDefaultBranch } from "../queries";
 import { safeSymlink } from "../utils";
+import { processWorktreeInclude, runPostCheckoutHook } from "../worktree";
 
 export interface CreateWorktreeInput extends GitSagaInput {
   worktreePath: string;
@@ -35,7 +36,16 @@ export class CreateWorktreeSaga extends GitSaga<
     await this.step({
       name: "create-worktree",
       execute: () =>
-        this.git.raw(["worktree", "add", "-b", branchName, worktreePath, base]),
+        this.git.raw([
+          "-c",
+          "core.hooksPath=/dev/null",
+          "worktree",
+          "add",
+          "-b",
+          branchName,
+          worktreePath,
+          base,
+        ]),
       rollback: async () => {
         try {
           await this.git.raw(["worktree", "remove", worktreePath, "--force"]);
@@ -86,6 +96,18 @@ export class CreateWorktreeSaga extends GitSaga<
       },
     });
 
+    await this.step({
+      name: "process-worktree-include",
+      execute: () => processWorktreeInclude(baseDir, worktreePath),
+      rollback: async () => {},
+    });
+
+    await this.step({
+      name: "run-post-checkout-hook",
+      execute: () => runPostCheckoutHook(baseDir, worktreePath),
+      rollback: async () => {},
+    });
+
     return { worktreePath, branchName, baseBranch: base };
   }
 }
@@ -123,7 +145,14 @@ export class CreateWorktreeForBranchSaga extends GitSaga<
     await this.step({
       name: "create-worktree",
       execute: () =>
-        this.git.raw(["worktree", "add", worktreePath, branchName]),
+        this.git.raw([
+          "-c",
+          "core.hooksPath=/dev/null",
+          "worktree",
+          "add",
+          worktreePath,
+          branchName,
+        ]),
       rollback: async () => {
         try {
           await this.git.raw(["worktree", "remove", worktreePath, "--force"]);
@@ -171,6 +200,18 @@ export class CreateWorktreeForBranchSaga extends GitSaga<
       },
     });
 
+    await this.step({
+      name: "process-worktree-include",
+      execute: () => processWorktreeInclude(baseDir, worktreePath),
+      rollback: async () => {},
+    });
+
+    await this.step({
+      name: "run-post-checkout-hook",
+      execute: () => runPostCheckoutHook(baseDir, worktreePath),
+      rollback: async () => {},
+    });
+
     return { worktreePath, branchName };
   }
 }

packages/git/src/utils.ts

@@ -1,3 +1,4 @@
+import { execFile } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -58,6 +59,54 @@ export async function safeSymlink(
   }
 }
 
+/**
+ * copy file or directory, use copy-on-write, fall back to cp
+ */
+export async function clonePath(
+  source: string,
+  destination: string,
+): Promise<boolean> {
+  try {
+    await fs.access(source);
+  } catch {
+    return false;
+  }
+
+  const parentDir = path.dirname(destination);
+  await fs.mkdir(parentDir, { recursive: true });
+
+  const platform = os.platform();
+
+  try {
+    if (platform === "darwin") {
+      await execFileAsync("cp", ["-c", "-a", source, destination]);
+    } else {
+      await execFileAsync("cp", ["--reflink=auto", "-a", source, destination]);
+    }
+    return true;
+  } catch {
+    // CoW not supported, fall back to regular copy
+  }
+
+  await fs.cp(source, destination, { recursive: true });
+  return true;
+}
+
+function execFileAsync(
+  command: string,
+  args: string[],
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
 export function parseGitHubUrl(url: string): GitHubRepo | null {
   // Trim whitespace/newlines that git commands may include
   const trimmedUrl = url.trim();