support syncing changes from user

* new `environment_sync_from_user` tool: applies user's unstaged changes
  to the env, commits, syncs the env back to the user (bidirectional)
* `git reset --hard` is now done after creating a refless stash, so the
  user can bring everything back if something goes wrong
* add `Environment.ApplyPatch`, which currently depends on `patch` being
  available in the environment
* clean up all the git code that wasn't using helpers

Signed-off-by: Alex Suraci <suraci.alex@gmail.com>

Author: vito

environment/filesystem.go

@@ -114,14 +114,18 @@ func (env *Environment) FileSearchReplace(ctx context.Context, explanation, targ
 
 	// Apply the changes using `patch` so we don't have to spit out the entire
 	// contents
-	err = env.apply(ctx, env.container().
+	return env.ApplyPatch(ctx, godiffpatch.GeneratePatch(targetFile, contents, newContents))
+}
+
+func (env *Environment) ApplyPatch(ctx context.Context, patch string) error {
+	err := env.apply(ctx, env.container().
 		WithExec([]string{"patch", "-p1"}, dagger.ContainerWithExecOpts{
-			Stdin: godiffpatch.GeneratePatch(targetFile, contents, newContents),
+			Stdin: patch,
 		}))
 	if err != nil {
 		return fmt.Errorf("failed applying file edit, skipping git propagation: %w", err)
 	}
-	env.Notes.Add("Edit %s", targetFile)
+	env.Notes.Add("Apply patch")
 	return nil
 }
 

mcpserver/tools.go

@@ -10,6 +10,7 @@ import (
 	"log/slog"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 
 	"dagger.io/dagger"
@@ -143,6 +144,8 @@ func init() {
 		EnvironmentAddServiceTool,
 
 		EnvironmentCheckpointTool,
+
+		EnvironmentSyncFromUserTool,
 	)
 }
 
@@ -824,3 +827,44 @@ Supported schemas are:
 		return mcp.NewToolResultText(fmt.Sprintf("Service added and started successfully: %s", string(output))), nil
 	},
 }
+
+var EnvironmentSyncFromUserTool = &Tool{
+	Definition: newEnvironmentTool(
+		"environment_sync_from_user",
+		"Apply the user's unstaged changes to the environment and apply the environment's to the user's local worktree. ONLY RUN WHEN EXPLICITLY REQUESTED BY THE USER.",
+	),
+	Handler: func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+		repo, env, err := openEnvironment(ctx, request)
+		if err != nil {
+			return nil, err
+		}
+
+		// Use a string builder to capture output
+		patch, err := repo.DiffUserLocalChanges(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("failed to generate patch: %w", err)
+		}
+		if len(patch) == 0 {
+			return mcp.NewToolResultText("No unstaged changes to pull."), nil
+		}
+
+		if err := env.ApplyPatch(ctx, patch); err != nil {
+			return nil, fmt.Errorf("failed to pull changes to environment: %w", err)
+		}
+
+		if err := repo.Update(ctx, env, request.GetString("explanation", "")); err != nil {
+			return nil, fmt.Errorf("unable to update the environment: %w", err)
+		}
+
+		if err := repo.ResetUserLocalChanges(ctx); err != nil {
+			return nil, fmt.Errorf("unable to reset user's worktree: %w", err)
+		}
+
+		var buf strings.Builder
+		if err := repo.Apply(ctx, env.ID, &buf); err != nil {
+			return nil, fmt.Errorf("unable to apply changes to user's worktree: %w\n\nlogs:\n%s", err, buf.String())
+		}
+
+		return mcp.NewToolResultText("Patch applied successfully to the environment:\n\n```patch\n" + string(patch) + "\n```"), nil
+	},
+}

repository/repository.go

@@ -11,7 +11,6 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
-	"time"
 
 	"dagger.io/dagger"
 	"github.com/dagger/container-use/environment"
@@ -415,68 +414,39 @@ func (r *Repository) Merge(ctx context.Context, id string, w io.Writer) error {
 	return RunInteractiveGitCommand(ctx, r.userRepoPath, w, "merge", "--no-ff", "--autostash", "-m", "Merge environment "+envInfo.ID, "--", "container-use/"+envInfo.ID)
 }
 
-func (r *Repository) Apply(ctx context.Context, id string, w io.Writer) error {
+func (r *Repository) Apply(ctx context.Context, id string, w io.Writer) (rerr error) {
 	envInfo, err := r.Info(ctx, id)
 	if err != nil {
 		return err
 	}
 
-	// Create patch directory if it doesn't exist
-	configPath := os.ExpandEnv("$HOME/.config/container-use")
-	patchDir := filepath.Join(configPath, "patches")
-	if err := os.MkdirAll(patchDir, 0755); err != nil {
-		return fmt.Errorf("failed to create patch directory: %w", err)
-	}
-
-	// Create a unique patch filename using timestamp and environment ID
-	patchFile := filepath.Join(patchDir, fmt.Sprintf("user-changes-%s-%d.patch", envInfo.ID, time.Now().Unix()))
-
-	// Check if there are any unstaged changes
-	diffCmd := exec.CommandContext(ctx, "git", "diff")
-	diffCmd.Dir = r.userRepoPath
-	diffOutput, err := diffCmd.Output()
+	diffOutput, err := r.DiffUserLocalChanges(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to check for unstaged changes: %w", err)
 	}
 
 	hasUnstagedChanges := len(diffOutput) > 0
 
-	if hasUnstagedChanges {
-		// Create a patch of only unstaged changes
-		fmt.Fprintf(w, "Saving unstaged user changes to %s...\n", patchFile)
-
-		// Create the patch from unstaged changes only
-		patchCmd := exec.CommandContext(ctx, "git", "diff")
-		patchCmd.Dir = r.userRepoPath
-		patchOutput, err := patchCmd.Output()
-		if err != nil {
-			return fmt.Errorf("failed to create patch: %w", err)
-		}
-
-		// Write patch to file
-		if err := os.WriteFile(patchFile, patchOutput, 0644); err != nil {
-			return fmt.Errorf("failed to write patch file: %w", err)
+	fmt.Fprintf(w, "Creating virtual stash as backup...\n")
+	stashID, err := RunGitCommand(ctx, r.userRepoPath, "stash", "create")
+	if err != nil {
+		return fmt.Errorf("failed to stash changes: %w", err)
+	}
+	defer func() {
+		if rerr != nil {
+			fmt.Fprintf(w, "ERROR: %s\n", rerr)
+			fmt.Fprintf(w, "Your prior changes can be restored with `git stash apply %s`\n", stashID)
 		}
+	}()
 
-		// Reset to clean state
-		fmt.Fprintf(w, "Resetting to clean state...\n")
-		if err := RunInteractiveGitCommand(ctx, r.userRepoPath, w, "reset", "--hard", "HEAD"); err != nil {
-			return fmt.Errorf("failed to reset: %w", err)
-		}
+	// Reset to clean state
+	if err := RunInteractiveGitCommand(ctx, r.userRepoPath, w, "reset", "--hard", "HEAD"); err != nil {
+		return fmt.Errorf("failed to reset: %w", err)
 	}
 
 	// Apply the merge without autostash
 	fmt.Fprintf(w, "Applying environment changes...\n")
 	if err := RunInteractiveGitCommand(ctx, r.userRepoPath, w, "merge", "--squash", "--", "container-use/"+envInfo.ID); err != nil {
-		// If merge fails, try to restore user changes
-		if hasUnstagedChanges {
-			fmt.Fprintf(w, "Merge failed, restoring user changes...\n")
-			applyCmd := exec.CommandContext(ctx, "git", "apply", patchFile)
-			applyCmd.Dir = r.userRepoPath
-			applyCmd.Stdout = w
-			applyCmd.Stderr = w
-			applyCmd.Run() // Ignore error as patch might partially apply
-		}
 		return fmt.Errorf("failed to merge: %w", err)
 	}
 
@@ -485,46 +455,48 @@ func (r *Repository) Apply(ctx context.Context, id string, w io.Writer) error {
 		fmt.Fprintf(w, "Restoring user changes...\n")
 
 		// 1. Temporarily commit the agent's changes
-		commitCmd := exec.CommandContext(ctx, "git", "commit", "-m", "temp: agent changes")
-		commitCmd.Dir = r.userRepoPath
-		if err := commitCmd.Run(); err != nil {
-			fmt.Fprintf(w, "Warning: Failed to commit agent changes: %v\n", err)
-			return nil
+		if err := RunInteractiveGitCommand(ctx, r.userRepoPath, w, "commit", "-m", "temp: agent changes"); err != nil {
+			return fmt.Errorf("failed to commit agent changes: %w", err)
 		}
 
 		// 2. Apply the user's patch
-		applyCmd := exec.CommandContext(ctx, "git", "apply", patchFile)
+		applyCmd := exec.CommandContext(ctx, "git", "apply", "-")
 		applyCmd.Dir = r.userRepoPath
+		applyCmd.Stdin = strings.NewReader(diffOutput)
 		applyCmd.Stdout = w
 		applyCmd.Stderr = w
 		if err := applyCmd.Run(); err != nil {
-			fmt.Fprintf(w, "Warning: Failed to apply some user changes. Patch saved at: %s\n", patchFile)
-			fmt.Fprintf(w, "You can manually apply it with: git apply %s\n", patchFile)
-			// Try to recover by doing soft reset
-			resetCmd := exec.CommandContext(ctx, "git", "reset", "--soft", "HEAD~1")
-			resetCmd.Dir = r.userRepoPath
-			resetCmd.Run()
-			return nil
+			return fmt.Errorf("failed to apply user changes: %w", err)
 		}
 
-		// 3. Reset to unstage everything
-		resetCmd := exec.CommandContext(ctx, "git", "reset")
-		resetCmd.Dir = r.userRepoPath
-		if err := resetCmd.Run(); err != nil {
+		// 3. Reset to unstage the user's changes
+		if err := RunInteractiveGitCommand(ctx, r.userRepoPath, w, "reset"); err != nil {
 			fmt.Fprintf(w, "Warning: Failed to reset: %v\n", err)
 		}
 
 		// 4. Soft reset to bring agent changes back to staging
-		softResetCmd := exec.CommandContext(ctx, "git", "reset", "--soft", "HEAD~1")
-		softResetCmd.Dir = r.userRepoPath
-		if err := softResetCmd.Run(); err != nil {
+		if err := RunInteractiveGitCommand(ctx, r.userRepoPath, w, "reset", "--soft", "HEAD~1"); err != nil {
 			fmt.Fprintf(w, "Warning: Failed to restore agent changes to staging: %v\n", err)
 		}
 
 		// Clean up patch file on successful application
-		os.Remove(patchFile)
 		fmt.Fprintf(w, "User changes successfully restored as unstaged changes.\n")
 	}
 
 	return nil
 }
+
+func (r *Repository) DiffUserLocalChanges(ctx context.Context) (string, error) {
+	diff, err := RunGitCommand(ctx, r.userRepoPath, "diff")
+	if err != nil {
+		return "", fmt.Errorf("failed to get user diff: %w", err)
+	}
+	return diff, nil
+}
+
+func (r *Repository) ResetUserLocalChanges(ctx context.Context) error {
+	if _, err := RunGitCommand(ctx, r.userRepoPath, "restore", "."); err != nil {
+		return fmt.Errorf("failed to reset unstaged changes: %w", err)
+	}
+	return nil
+}