Add support for copying .env files and running setup steps in git worktree operations

Co-authored-by: pelikhan <4175913+pelikhan@users.noreply.github.com>

Author: Copilot

docs/src/content/docs/reference/git.mdx

@@ -20,23 +20,35 @@ Git worktrees allow you to check out multiple branches of the same repository si
 Creates a new worktree at the specified path.
 
 ```typescript
-await git.worktreeAdd(path: string, commitish?: string): Promise<string>
+await git.worktreeAdd(path: string, commitish?: string, options?: {
+    copyEnv?: boolean
+    setupSteps?: boolean
+}): Promise<string>
 ```
 
 **Parameters:**
 - `path` - Path where the new worktree will be created
 - `commitish` - Optional commit, branch, or tag to checkout in the new worktree
+- `options` - Optional configuration object with:
+  - `copyEnv` - Copy .env files from source directory to new worktree (default: false)
+  - `setupSteps` - Run setup steps (e.g., npm install) in the new worktree (default: false)
 
 **Example:**
 ```javascript
-// Create a worktree for the main branch
+// Create a basic worktree for the main branch
 await git.worktreeAdd("/path/to/feature-worktree")
 
 // Create a worktree and checkout a specific branch
 await git.worktreeAdd("/path/to/feature-worktree", "feature-branch")
 
 // Create a worktree from a specific commit
 await git.worktreeAdd("/path/to/hotfix-worktree", "abc123")
+
+// Create a worktree with .env files copied and setup steps run
+await git.worktreeAdd("/path/to/dev-worktree", "develop", {
+    copyEnv: true,
+    setupSteps: true
+})
 ```
 
 #### worktreeList
@@ -134,18 +146,22 @@ Lists all worktrees in a human-readable format.
 
 #### git_worktree_add
 
-Creates a new worktree with optional branch specification.
+Creates a new worktree with optional branch specification, environment copying, and setup steps.
 
 **Parameters:**
 - `path` (required) - Path where the new worktree will be created
 - `commitish` (optional) - Commit, branch, or tag to checkout
+- `copyEnv` (optional) - Copy .env files from source directory to new worktree (default: false)
+- `setupSteps` (optional) - Run setup steps (e.g., npm install) in the new worktree (default: false)
 
 **Usage:**
 ```javascript
 // The LLM can create worktrees based on conversation context
 // Examples:
 // - "Create a worktree at /tmp/feature for the feature-branch"
 // - "Set up a worktree for testing the hotfix commit abc123"
+// - "Create a development worktree with environment files and run npm install"
+// - "Set up a complete development environment in a new worktree"
 ```
 
 #### git_worktree_remove

packages/cli/genaisrc/system.git_worktree.genai.mts

@@ -49,12 +49,25 @@ export default function (ctx: ChatGenerationContext) {
                     type: "string",
                     description: "Optional commit, branch, or tag to checkout in the new worktree",
                 },
+                copyEnv: {
+                    type: "boolean",
+                    description: "Copy .env files from source directory to new worktree",
+                    default: false,
+                },
+                setupSteps: {
+                    type: "boolean",
+                    description: "Run setup steps (e.g., npm install) in the new worktree",
+                    default: false,
+                },
             },
             required: ["path"],
         },
         async (args) => {
-            const { context, path, commitish } = args
-            const result = await client.worktreeAdd(path, commitish)
+            const { context, path, commitish, copyEnv, setupSteps } = args
+            const result = await client.worktreeAdd(path, commitish, {
+                copyEnv,
+                setupSteps,
+            })
             context.debug(result)
             return result
         }

packages/core/src/git.test.ts

@@ -154,4 +154,120 @@ bare
             client.exec = originalExec
         })
     })
+    
+    describe("worktreeAdd with options", () => {
+        test("calls basic worktreeAdd without options", async () => {
+            const client = new GitClient(".")
+            let capturedArgs: string[] = []
+            
+            // Mock exec to capture arguments
+            const originalExec = client.exec
+            client.exec = async (args: string[]) => {
+                capturedArgs = args
+                return "Mock response"
+            }
+            
+            await client.worktreeAdd("/path/to/worktree")
+            assert.deepEqual(capturedArgs, ["worktree", "add", "/path/to/worktree"])
+            
+            // Restore original exec
+            client.exec = originalExec
+        })
+        
+        test("calls worktreeAdd with commitish", async () => {
+            const client = new GitClient(".")
+            let capturedArgs: string[] = []
+            
+            // Mock exec to capture arguments
+            const originalExec = client.exec
+            client.exec = async (args: string[]) => {
+                capturedArgs = args
+                return "Mock response"
+            }
+            
+            await client.worktreeAdd("/path/to/worktree", "feature-branch")
+            assert.deepEqual(capturedArgs, ["worktree", "add", "/path/to/worktree", "feature-branch"])
+            
+            // Restore original exec
+            client.exec = originalExec
+        })
+        
+        test("handles copyEnv and setupSteps options", async () => {
+            const client = new GitClient(".")
+            let capturedArgs: string[] = []
+            let copyEnvCalled = false
+            let setupStepsCalled = false
+            
+            // Mock exec to capture arguments
+            const originalExec = client.exec
+            client.exec = async (args: string[]) => {
+                capturedArgs = args
+                return "Mock response"
+            }
+            
+            // Mock the private methods by replacing them on the prototype
+            const originalCopyEnvFiles = (client as any).copyEnvFiles
+            const originalRunSetupSteps = (client as any).runSetupSteps
+            
+            ;(client as any).copyEnvFiles = async () => {
+                copyEnvCalled = true
+            }
+            ;(client as any).runSetupSteps = async () => {
+                setupStepsCalled = true
+            }
+            
+            await client.worktreeAdd("/path/to/worktree", "feature-branch", {
+                copyEnv: true,
+                setupSteps: true
+            })
+            
+            assert.deepEqual(capturedArgs, ["worktree", "add", "/path/to/worktree", "feature-branch"])
+            assert.equal(copyEnvCalled, true)
+            assert.equal(setupStepsCalled, true)
+            
+            // Restore original methods
+            client.exec = originalExec
+            ;(client as any).copyEnvFiles = originalCopyEnvFiles
+            ;(client as any).runSetupSteps = originalRunSetupSteps
+        })
+        
+        test("skips copyEnv and setupSteps when options are false", async () => {
+            const client = new GitClient(".")
+            let capturedArgs: string[] = []
+            let copyEnvCalled = false
+            let setupStepsCalled = false
+            
+            // Mock exec to capture arguments
+            const originalExec = client.exec
+            client.exec = async (args: string[]) => {
+                capturedArgs = args
+                return "Mock response"
+            }
+            
+            // Mock the private methods by replacing them on the prototype
+            const originalCopyEnvFiles = (client as any).copyEnvFiles
+            const originalRunSetupSteps = (client as any).runSetupSteps
+            
+            ;(client as any).copyEnvFiles = async () => {
+                copyEnvCalled = true
+            }
+            ;(client as any).runSetupSteps = async () => {
+                setupStepsCalled = true
+            }
+            
+            await client.worktreeAdd("/path/to/worktree", "feature-branch", {
+                copyEnv: false,
+                setupSteps: false
+            })
+            
+            assert.deepEqual(capturedArgs, ["worktree", "add", "/path/to/worktree", "feature-branch"])
+            assert.equal(copyEnvCalled, false)
+            assert.equal(setupStepsCalled, false)
+            
+            // Restore original methods
+            client.exec = originalExec
+            ;(client as any).copyEnvFiles = originalCopyEnvFiles
+            ;(client as any).runSetupSteps = originalRunSetupSteps
+        })
+    })
 })

packages/core/src/git.ts

@@ -9,15 +9,16 @@ import {
 } from "./constants"
 import { llmifyDiff } from "./llmdiff"
 import { resolveFileContents } from "./file"
-import { tryReadText, tryStat } from "./fs"
+import { tryReadText, tryStat, fileExists } from "./fs"
 import { runtimeHost } from "./host"
 import { shellParse, shellQuote } from "./shell"
 import { arrayify, ellipse, logVerbose } from "./util"
 import { approximateTokens } from "./tokens"
 import { underscore } from "inflection"
-import { rm } from "node:fs/promises"
+import { rm, copyFile, readdir } from "node:fs/promises"
 import { packageResolveInstall } from "./packagemanagers"
 import { normalizeInt } from "./cleaners"
+import { join, basename } from "node:path"
 import { dotGenaiscriptPath } from "./workdir"
 import { join } from "node:path"
 import { genaiscriptDebug } from "./debug"
@@ -595,15 +596,37 @@ ${await this.diff({ ...options, nameOnly: true })}
      * Add a new worktree
      * @param path path to the new worktree
      * @param commitish optional commit, branch, or tag to checkout
+     * @param options optional configuration for worktree creation
      */
-    async worktreeAdd(path: string, commitish?: string): Promise<string> {
+    async worktreeAdd(path: string, commitish?: string, options?: {
+        /**
+         * Copy .env files from source directory to new worktree
+         */
+        copyEnv?: boolean
+        /**
+         * Run setup steps (e.g., npm install) in the new worktree
+         */
+        setupSteps?: boolean
+    }): Promise<string> {
         dbg(`adding worktree: ${path}`)
         const args = ["worktree", "add"]
         args.push(path)
         if (commitish) {
             args.push(commitish)
         }
-        return await this.exec(args)
+        const result = await this.exec(args)
+        
+        // Copy .env files if requested
+        if (options?.copyEnv) {
+            await this.copyEnvFiles(path)
+        }
+        
+        // Run setup steps if requested
+        if (options?.setupSteps) {
+            await this.runSetupSteps(path)
+        }
+        
+        return result
     }
 
     /**
@@ -669,6 +692,67 @@ ${await this.diff({ ...options, nameOnly: true })}
         return await this.exec(args)
     }
 
+    /**
+     * Copy .env files from source directory to target worktree
+     * @param targetPath path to the new worktree
+     */
+    private async copyEnvFiles(targetPath: string): Promise<void> {
+        dbg(`copying .env files to worktree: ${targetPath}`)
+        
+        try {
+            const sourceDir = this.cwd || process.cwd()
+            const files = await readdir(sourceDir)
+            const envFiles = files.filter(file => file.startsWith('.env'))
+            
+            for (const envFile of envFiles) {
+                const sourcePath = join(sourceDir, envFile)
+                const destPath = join(targetPath, envFile)
+                
+                if (await fileExists(sourcePath)) {
+                    dbg(`copying ${envFile} to worktree`)
+                    await copyFile(sourcePath, destPath)
+                }
+            }
+            
+            if (envFiles.length > 0) {
+                dbg(`copied ${envFiles.length} .env file(s) to worktree`)
+            }
+        } catch (error) {
+            dbg(`error copying .env files: ${error}`)
+            // Don't fail the worktree creation if .env copying fails
+            logVerbose(`Warning: Failed to copy .env files to worktree: ${error}`)
+        }
+    }
+
+    /**
+     * Run setup steps in the new worktree
+     * @param targetPath path to the new worktree
+     */
+    private async runSetupSteps(targetPath: string): Promise<void> {
+        dbg(`running setup steps in worktree: ${targetPath}`)
+        
+        try {
+            const { command, args } = await packageResolveInstall(targetPath)
+            if (command) {
+                dbg(`running setup command: ${command} ${args?.join(' ') || ''}`)
+                const res = await runtimeHost.exec(undefined, command, args, {
+                    cwd: targetPath,
+                })
+                if (res.exitCode !== 0) {
+                    logVerbose(`Warning: Setup command failed with exit code ${res.exitCode}: ${res.stderr}`)
+                } else {
+                    dbg(`setup steps completed successfully`)
+                }
+            } else {
+                dbg(`no package manager detected, skipping setup steps`)
+            }
+        } catch (error) {
+            dbg(`error running setup steps: ${error}`)
+            // Don't fail the worktree creation if setup fails
+            logVerbose(`Warning: Failed to run setup steps in worktree: ${error}`)
+        }
+    }
+
     client(cwd: string) {
         return new GitClient(cwd)
     }

packages/core/src/types/prompt_template.d.ts

@@ -3305,8 +3305,18 @@ interface Git {
      * Add a new worktree
      * @param path path to the new worktree
      * @param commitish optional commit, branch, or tag to checkout
+     * @param options optional configuration for worktree creation
      */
-    worktreeAdd(path: string, commitish?: string): Promise<string>
+    worktreeAdd(path: string, commitish?: string, options?: {
+        /**
+         * Copy .env files from source directory to new worktree
+         */
+        copyEnv?: boolean
+        /**
+         * Run setup steps (e.g., npm install) in the new worktree
+         */
+        setupSteps?: boolean
+    }): Promise<string>
 
     /**
      * List all worktrees