1 files changed, 303 insertions, 0 deletions
diff --git a/makima/src/daemon/storage/patch.rs b/makima/src/daemon/storage/patch.rs
index 45624b5..0da4eda 100644
--- a/makima/src/daemon/storage/patch.rs
+++ b/makima/src/daemon/storage/patch.rs
@@ -141,6 +141,223 @@ pub async fn get_parent_sha(worktree_path: &Path) -> Result<String, PatchError>
     Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
 }
 
+/// Get the current HEAD commit SHA from a worktree.
+pub async fn get_head_sha(worktree_path: &Path) -> Result<String, PatchError> {
+    let output = Command::new("git")
+        .current_dir(worktree_path)
+        .args(["rev-parse", "HEAD"])
+        .output()
+        .await
+        .map_err(|e| PatchError::GitCommand(format!("Failed to get HEAD SHA: {}", e)))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(PatchError::GitCommand(format!(
+            "git rev-parse HEAD failed: {}",
+            stderr
+        )));
+    }
+
+    Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
+}
+
+/// Result of creating an export patch.
+#[derive(Debug, Clone)]
+pub struct ExportPatchResult {
+    /// The uncompressed, human-readable patch content.
+    pub patch_content: String,
+    /// Number of files changed in the patch.
+    pub files_count: usize,
+    /// Number of lines added.
+    pub lines_added: usize,
+    /// Number of lines removed.
+    pub lines_removed: usize,
+    /// The base commit SHA that the patch is diffed against.
+    pub base_commit_sha: String,
+}
+
+/// Create an uncompressed git diff patch for export.
+///
+/// This creates a human-readable patch that can be applied manually or
+/// shared as a file. Unlike `create_patch`, this version is not compressed
+/// and is suitable for display or export.
+///
+/// If `base_sha` is provided, the diff is between that commit and HEAD.
+/// If `base_sha` is None, it attempts to find the merge-base with the default branch
+/// or falls back to diffing uncommitted changes against HEAD.
+pub async fn create_export_patch(
+    worktree_path: &Path,
+    base_sha: Option<&str>,
+) -> Result<ExportPatchResult, PatchError> {
+    // Determine the base SHA to diff against
+    let resolved_base_sha = match base_sha {
+        Some(sha) => sha.to_string(),
+        None => {
+            // Try to find the merge-base with the default branch
+            // First, try to get the upstream tracking branch
+            let upstream_result = Command::new("git")
+                .current_dir(worktree_path)
+                .args(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"])
+                .output()
+                .await;
+
+            let base = if let Ok(output) = upstream_result {
+                if output.status.success() {
+                    let upstream = String::from_utf8_lossy(&output.stdout).trim().to_string();
+                    // Get merge-base with upstream
+                    let merge_base = Command::new("git")
+                        .current_dir(worktree_path)
+                        .args(["merge-base", "HEAD", &upstream])
+                        .output()
+                        .await;
+
+                    if let Ok(mb_output) = merge_base {
+                        if mb_output.status.success() {
+                            Some(String::from_utf8_lossy(&mb_output.stdout).trim().to_string())
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            // If we couldn't find upstream, try common default branches
+            let base = if base.is_none() {
+                let default_branches = ["origin/main", "origin/master", "main", "master"];
+                let mut found_base = None;
+
+                for branch in default_branches {
+                    let merge_base = Command::new("git")
+                        .current_dir(worktree_path)
+                        .args(["merge-base", "HEAD", branch])
+                        .output()
+                        .await;
+
+                    if let Ok(output) = merge_base {
+                        if output.status.success() {
+                            found_base = Some(String::from_utf8_lossy(&output.stdout).trim().to_string());
+                            break;
+                        }
+                    }
+                }
+                found_base
+            } else {
+                base
+            };
+
+            // If still nothing, get the first commit or use HEAD~1
+            base.unwrap_or_else(|| {
+                // This will be used, but if HEAD~1 doesn't exist (only one commit),
+                // git diff will handle it gracefully
+                "HEAD~1".to_string()
+            })
+        }
+    };
+
+    // Get diff stats using --stat
+    let stat_output = Command::new("git")
+        .current_dir(worktree_path)
+        .args(["diff", "--stat", &resolved_base_sha, "HEAD"])
+        .output()
+        .await
+        .map_err(|e| PatchError::GitCommand(format!("Failed to run git diff --stat: {}", e)))?;
+
+    // Parse the stat output to get line counts
+    let (lines_added, lines_removed) = if stat_output.status.success() {
+        parse_diff_stat(&String::from_utf8_lossy(&stat_output.stdout))
+    } else {
+        (0, 0)
+    };
+
+    // Get the actual diff content
+    let diff_output = Command::new("git")
+        .current_dir(worktree_path)
+        .args(["diff", &resolved_base_sha, "HEAD"])
+        .output()
+        .await
+        .map_err(|e| PatchError::GitCommand(format!("Failed to run git diff: {}", e)))?;
+
+    if !diff_output.status.success() {
+        let stderr = String::from_utf8_lossy(&diff_output.stderr);
+        return Err(PatchError::GitCommand(format!("git diff failed: {}", stderr)));
+    }
+
+    let patch_content = String::from_utf8_lossy(&diff_output.stdout).to_string();
+
+    // Check for empty patch
+    if patch_content.trim().is_empty() {
+        return Err(PatchError::EmptyPatch);
+    }
+
+    // Count files changed
+    let files_output = Command::new("git")
+        .current_dir(worktree_path)
+        .args(["diff", "--name-only", &resolved_base_sha, "HEAD"])
+        .output()
+        .await
+        .map_err(|e| PatchError::GitCommand(format!("Failed to count files: {}", e)))?;
+
+    let files_count = if files_output.status.success() {
+        String::from_utf8_lossy(&files_output.stdout)
+            .lines()
+            .filter(|l| !l.is_empty())
+            .count()
+    } else {
+        0
+    };
+
+    Ok(ExportPatchResult {
+        patch_content,
+        files_count,
+        lines_added,
+        lines_removed,
+        base_commit_sha: resolved_base_sha,
+    })
+}
+
+/// Parse git diff --stat output to extract lines added and removed.
+/// The last line typically looks like: " 3 files changed, 45 insertions(+), 12 deletions(-)"
+fn parse_diff_stat(stat_output: &str) -> (usize, usize) {
+    let mut lines_added = 0;
+    let mut lines_removed = 0;
+
+    // Look for the summary line at the end
+    for line in stat_output.lines().rev() {
+        let line = line.trim();
+        if line.contains("changed") || line.contains("insertion") || line.contains("deletion") {
+            // Parse insertions
+            if let Some(idx) = line.find("insertion") {
+                let before = &line[..idx];
+                if let Some(num_str) = before.split_whitespace().last() {
+                    if let Ok(num) = num_str.parse::<usize>() {
+                        lines_added = num;
+                    }
+                }
+            }
+            // Parse deletions
+            if let Some(idx) = line.find("deletion") {
+                let before = &line[..idx];
+                if let Some(num_str) = before.split(',').last() {
+                    if let Some(num_str) = num_str.trim().split_whitespace().next() {
+                        if let Ok(num) = num_str.parse::<usize>() {
+                            lines_removed = num;
+                        }
+                    }
+                }
+            }
+            break;
+        }
+    }
+
+    (lines_added, lines_removed)
+}
+
 /// Checkout a specific commit in the worktree.
 pub async fn checkout_commit(worktree_path: &Path, sha: &str) -> Result<(), PatchError> {
     let output = Command::new("git")
@@ -290,4 +507,90 @@ mod tests {
         let result = create_patch(path, &head_sha).await;
         assert!(matches!(result, Err(PatchError::EmptyPatch)));
     }
+
+    #[tokio::test]
+    async fn test_create_export_patch() {
+        let dir = setup_test_repo().await;
+        let path = dir.path();
+
+        // Get the initial commit SHA before making changes
+        let initial_sha = get_head_sha(path).await.unwrap();
+
+        // Make some changes and commit
+        fs::write(path.join("file.txt"), "modified content").unwrap();
+        fs::write(path.join("new_file.txt"), "new file content").unwrap();
+        Command::new("git")
+            .current_dir(path)
+            .args(["add", "."])
+            .output()
+            .await
+            .unwrap();
+        Command::new("git")
+            .current_dir(path)
+            .args(["commit", "-m", "changes for export"])
+            .output()
+            .await
+            .unwrap();
+
+        // Create export patch with explicit base
+        let result = create_export_patch(path, Some(&initial_sha)).await.unwrap();
+
+        // Verify the result
+        assert!(!result.patch_content.is_empty());
+        assert_eq!(result.files_count, 2); // file.txt and new_file.txt
+        assert!(result.lines_added > 0);
+        assert_eq!(result.base_commit_sha, initial_sha);
+
+        // The patch should contain diff headers
+        assert!(result.patch_content.contains("diff --git"));
+        assert!(result.patch_content.contains("new_file.txt"));
+    }
+
+    #[tokio::test]
+    async fn test_create_export_patch_no_base() {
+        let dir = setup_test_repo().await;
+        let path = dir.path();
+
+        // Make a second commit so we have something to diff
+        fs::write(path.join("file.txt"), "modified").unwrap();
+        Command::new("git")
+            .current_dir(path)
+            .args(["add", "."])
+            .output()
+            .await
+            .unwrap();
+        Command::new("git")
+            .current_dir(path)
+            .args(["commit", "-m", "second commit"])
+            .output()
+            .await
+            .unwrap();
+
+        // Create export patch without explicit base (will use HEAD~1)
+        let result = create_export_patch(path, None).await.unwrap();
+
+        // Verify the result
+        assert!(!result.patch_content.is_empty());
+        assert_eq!(result.files_count, 1);
+        assert!(result.patch_content.contains("diff --git"));
+    }
+
+    #[tokio::test]
+    async fn test_parse_diff_stat() {
+        // Test the parse_diff_stat function with various formats
+        let stat1 = " 3 files changed, 45 insertions(+), 12 deletions(-)";
+        let (added, removed) = parse_diff_stat(stat1);
+        assert_eq!(added, 45);
+        assert_eq!(removed, 12);
+
+        let stat2 = " 1 file changed, 10 insertions(+)";
+        let (added, removed) = parse_diff_stat(stat2);
+        assert_eq!(added, 10);
+        assert_eq!(removed, 0);
+
+        let stat3 = " 2 files changed, 5 deletions(-)";
+        let (added, removed) = parse_diff_stat(stat3);
+        assert_eq!(added, 0);
+        assert_eq!(removed, 5);
+    }
 }