feat: PR-aware worktree merge (push to PR branch), conflict handling, worktree path in context messages

Author: Swofty-Developments

crates/tauri-app/frontend/src/components/chat/ChatArea.tsx

@@ -182,7 +182,17 @@ export function ChatArea() {
               <span class="wt-branch">{worktree()!.branch}</span>
               <span class="wt-path">{worktree()!.path}</span>
             </div>
-            <button class="wt-merge-btn" onClick={handleMergeWorktree}>Merge back to main</button>
+            <button class="wt-merge-btn" onClick={handleMergeWorktree}>
+              {(() => {
+                const proj = activeProject();
+                const tab = store.activeTab;
+                if (proj && tab) {
+                  const prMap = store.projectPrMap[proj.id];
+                  if (prMap?.[tab]) return `Push to PR #${prMap[tab]}`;
+                }
+                return "Merge back to main";
+              })()}
+            </button>
           </div>
         </Show>
 

crates/tauri-app/frontend/src/components/chat/ThreadSetup.tsx

@@ -55,10 +55,11 @@ export function ThreadSetup(props: Props) {
           }))
         );
       }
-      // Add a context message
-      const context = createWorktree
-        ? `Working on branch \`${branchName}\` in a worktree. What would you like to do?`
-        : `Working on the main branch. What would you like to do?`;
+      // Add a context message — include worktree path
+      const wt = store.worktrees[props.threadId];
+      const context = createWorktree && wt
+        ? `Working on branch \`${branchName}\` in a worktree at ${wt.path}. What would you like to do?`
+        : `Working on the main branch at ${props.repoPath}. What would you like to do?`;
       const msgId = await ipc.persistUserMessage(props.threadId, context);
       setStore("threadMessages", props.threadId, (msgs) => [
         ...(msgs || []),
@@ -102,8 +103,10 @@ export function ThreadSetup(props: Props) {
         console.error("Worktree creation failed (continuing without):", e);
       }
 
-      // Inject context
-      const context = `I'm working on PR #${pr.number}: "${pr.title}" by ${pr.author}\n\nBranch: ${pr.branch} → ${pr.base}\n+${pr.additions} -${pr.deletions} across ${pr.changed_files} files\n${pr.labels.length > 0 ? `Labels: ${pr.labels.join(", ")}\n` : ""}Help me review or continue work on this PR.`;
+      // Inject context — include worktree path so the agent knows where to work
+      const wt = store.worktrees[props.threadId];
+      const wtInfo = wt ? `\n\nWorktree: ${wt.path} (branch: ${wt.branch})` : "";
+      const context = `I'm working on PR #${pr.number}: "${pr.title}" by ${pr.author}\n\nBranch: ${pr.branch} → ${pr.base}\n+${pr.additions} -${pr.deletions} across ${pr.changed_files} files\n${pr.labels.length > 0 ? `Labels: ${pr.labels.join(", ")}\n` : ""}${wtInfo}\n\nHelp me review or continue work on this PR.`;
       const msgId = await ipc.persistUserMessage(props.threadId, context);
       setStore("threadMessages", props.threadId, (msgs) => [
         ...(msgs || []),

crates/tauri-app/src/commands/worktree.rs

@@ -141,40 +141,111 @@ pub fn merge_worktree(
         main_branch
     };
 
-    // Merge the worktree branch into main
-    let merge = Command::new("git")
-        .args(["merge", &branch, "--no-edit"])
-        .current_dir(&project_path)
-        .output()
-        .map_err(|e| format!("Failed to merge: {e}"))?;
+    // Check if this thread is linked to a PR
+    let pr_number = {
+        let db = state.db.lock().map_err(|e| format!("{e}"))?;
+        codeforge_persistence::queries::get_setting(
+            db.conn(),
+            &format!("pr:{thread_id}"),
+        )
+        .ok()
+        .flatten()
+    };
 
-    if !merge.status.success() {
-        return Err(format!(
-            "Merge failed (may have conflicts): {}",
-            String::from_utf8_lossy(&merge.stderr)
-        ));
-    }
+    if let Some(_pr_num) = &pr_number {
+        // PR mode: commit and push the worktree branch (don't merge to main)
+        // First, commit any uncommitted changes in the worktree
+        let status = Command::new("git")
+            .args(["status", "--porcelain"])
+            .current_dir(&worktree_path)
+            .output()
+            .map_err(|e| format!("Failed to check status: {e}"))?;
 
-    // Remove worktree
-    let _ = Command::new("git")
-        .args(["worktree", "remove", &worktree_path, "--force"])
-        .current_dir(&project_path)
-        .output();
+        let has_changes = !String::from_utf8_lossy(&status.stdout).trim().is_empty();
 
-    // Delete the branch
-    let _ = Command::new("git")
-        .args(["branch", "-d", &branch])
-        .current_dir(&project_path)
-        .output();
+        if has_changes {
+            let _ = Command::new("git")
+                .args(["add", "-A"])
+                .current_dir(&worktree_path)
+                .output();
 
-    // Remove setting
-    {
-        let db = state.db.lock().map_err(|e| format!("{e}"))?;
-        let _ = codeforge_persistence::queries::delete_setting(
-            db.conn(),
-            &format!("worktree:{thread_id}"),
-        );
-    }
+            let _ = Command::new("git")
+                .args(["commit", "-m", "Changes from CodeForge"])
+                .current_dir(&worktree_path)
+                .output();
+        }
+
+        // Push the branch
+        let push = Command::new("git")
+            .args(["push", "origin", &branch])
+            .current_dir(&worktree_path)
+            .output()
+            .map_err(|e| format!("Failed to push: {e}"))?;
+
+        if !push.status.success() {
+            let stderr = String::from_utf8_lossy(&push.stderr);
+            return Err(format!("Push failed: {stderr}"));
+        }
+
+        // Remove worktree but keep branch (PR is still open)
+        let _ = Command::new("git")
+            .args(["worktree", "remove", &worktree_path, "--force"])
+            .current_dir(&project_path)
+            .output();
+
+        // Remove worktree setting
+        {
+            let db = state.db.lock().map_err(|e| format!("{e}"))?;
+            let _ = codeforge_persistence::queries::delete_setting(
+                db.conn(),
+                &format!("worktree:{thread_id}"),
+            );
+        }
+
+        Ok(format!("Pushed {branch} to origin"))
+    } else {
+        // Normal mode: merge worktree branch into main
+        let merge = Command::new("git")
+            .args(["merge", &branch, "--no-edit"])
+            .current_dir(&project_path)
+            .output()
+            .map_err(|e| format!("Failed to merge: {e}"))?;
+
+        if !merge.status.success() {
+            let stderr = String::from_utf8_lossy(&merge.stderr).to_string();
+
+            // Abort the failed merge to leave repo in clean state
+            let _ = Command::new("git")
+                .args(["merge", "--abort"])
+                .current_dir(&project_path)
+                .output();
 
-    Ok(format!("Merged {branch} into {main_branch}"))
+            return Err(format!(
+                "Merge has conflicts. Resolve them manually in the worktree at {worktree_path} then try again.\n\nConflict details: {stderr}"
+            ));
+        }
+
+        // Remove worktree
+        let _ = Command::new("git")
+            .args(["worktree", "remove", &worktree_path, "--force"])
+            .current_dir(&project_path)
+            .output();
+
+        // Delete the branch
+        let _ = Command::new("git")
+            .args(["branch", "-d", &branch])
+            .current_dir(&project_path)
+            .output();
+
+        // Remove setting
+        {
+            let db = state.db.lock().map_err(|e| format!("{e}"))?;
+            let _ = codeforge_persistence::queries::delete_setting(
+                db.conn(),
+                &format!("worktree:{thread_id}"),
+            );
+        }
+
+        Ok(format!("Merged {branch} into {main_branch}"))
+    }
 }