Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows
Simplify picker tab and temporary index handling (#3875)
Maximilian Roosd8ad8f17ce46
diff --git a/src/commands/list/collect/tasks.rs b/src/commands/list/collect/tasks.rsindex 0e192a9e8..e892093ab 100644--- a/src/commands/list/collect/tasks.rs+++ b/src/commands/list/collect/tasks.rs@@ -8,7 +8,6 @@ use std::time::Duration;use std::sync::Arc;-use anyhow::Context;use worktrunk::git::{ErrorExt, IntegrationTargets, LineDiff, RefSnapshot, Repository, select_comparison_base,};@@ -739,17 +738,8 @@ impl Task for WorkingTreeConflictsTask {// Stage all dirty + untracked entries into a temp index so// `write-tree` produces a tree representing the full working// state. Real index untouched. See `WorkingTree::temp_index`.- let idx = wt.temp_index().map_err(|e| ctx.error(Self::KIND, &e))?;- idx.git(["add", "-A"])- .run()- .context("Failed to stage working tree changes")- .map_err(|e| ctx.error(Self::KIND, &e))?;- let output = idx- .git(["write-tree"])- .run()- .context("Failed to write tree from temporary index")- .map_err(|e| ctx.error(Self::KIND, &e))?;- String::from_utf8_lossy(&output.stdout).trim().to_string()+ wt.write_worktree_tree()+ .map_err(|e| ctx.error(Self::KIND, &e))?} else {wt.run_command(&["write-tree"]).map(|s| s.trim().to_string())diff --git a/src/commands/picker/items.rs b/src/commands/picker/items.rsindex 04d818d84..40947b3d8 100644--- a/src/commands/picker/items.rs+++ b/src/commands/picker/items.rs@@ -742,46 +742,6 @@ impl LocalContent {}}-/// The local-checkout-backed preview tabs — present for a row with a local-/// worktree, absent for a listed PR/MR row (`--prs`), which has no local copy.-/// Grouping them names *why* they're empty on a `--prs` row (no checkout), so-/// the difference reads as a data fact rather than a row-type policy.-#[derive(Debug, Clone, Copy, Default)]-struct LocalTabs {- unified_diff: bool,- working_tree: bool,- branch_diff: bool,- upstream: bool,- summary: bool,-}--impl LocalTabs {- /// A local row. The subsidiary diff tabs (`working_tree`, `branch_diff`,- /// `upstream`) follow the live [`LocalContent`] signals — available while- /// loading, dim once their diff is known empty; `unified_diff` dims only- /// when both component signals are empty because their net changes can- /// cancel. `upstream` also requires the- /// synchronous `has_upstream` floor (no tracking ref → dim with no loading- /// window). `summary` requires the process-wide `[commit.generation]` flag- /// *and* something to summarize: its pane is generated from the combined diff- /// (`crate::summary::compute_combined_diff` = commits ahead of the comparison- /// base + tracked working-tree changes), so it uses `branch_diff` and the- /// tracked-only `summary_working_tree` signal — dimming in concert with its- /// actual input rather than the untracked-inclusive working pane.- fn worktree(content: LocalContent, has_upstream: bool, summaries_enabled: bool) -> Self {- let working_tree = content.working_tree.unwrap_or(true);- let summary_working_tree = content.summary_working_tree.unwrap_or(true);- let branch_diff = content.branch_diff.unwrap_or(true);- Self {- unified_diff: working_tree || branch_diff,- working_tree,- branch_diff,- upstream: has_upstream && content.upstream_diverged.unwrap_or(true),- summary: summaries_enabled && (summary_working_tree || branch_diff),- }- }-}-/// Which preview tabs have renderable content for the selected row.////// Empty tabs are de-emphasized in the bar (number dimmed). Skim computes a@@ -789,9 +749,9 @@ impl LocalTabs {/// `loading_placeholder`). Two genuine axes drive availability, and `--prs`/// touches neither — it only decides whether a PR row is *listed* at all:///-/// - The local-checkout tabs ([`LocalTabs`]): the three subsidiary diff tabs-/// (`working_tree` / `branch_diff` / `upstream`) follow the row's live-/// [`LocalContent`] exactly; `unified_diff` uses their conservative union,+/// - The local-checkout tabs: the three subsidiary diff tabs (`working_tree` /+/// `branch_diff` / `upstream`) follow the row's live [`LocalContent`]+/// exactly; `unified_diff` uses the first two's conservative union,/// since opposing working and committed changes can cancel only after its/// net diff is computed. Tabs stay available while loading and dim once/// known empty, the same shape as the `pr` tab. `upstream` also@@ -800,8 +760,8 @@ impl LocalTabs {/// `summary` requires the process-wide `[commit.generation]` flag *and* a/// non-empty combined diff — its pane's content source — so it uses the/// `branch_diff` plus tracked-working signals and dims alongside the "no-/// changes to summarize" pane, not only when summaries are disabled. A `--prs` row has-/// no local checkout, so all five local tabs are empty.+/// changes to summarize" pane, not only when summaries are disabled. A+/// `--prs` row has no local checkout, so all five local tabs are empty./// - The PR-backed tabs: `pr` and `comments` are available together, gated by/// `has_pr`. On a worktree row that's the live status slot (primed from the CI/// cache, then refreshed by the `CiStatus` task — see@@ -816,49 +776,33 @@ impl LocalTabs {/// `--prs` row).#[derive(Debug, Clone, Copy)]pub(super) struct TabAvailability {- unified_diff: bool,working_tree: bool,- log: bool,branch_diff: bool,upstream: bool,summary: bool,pr: bool,- comments: bool,}impl TabAvailability {- /// Build from the two genuine axes: which local-checkout tabs the row has,- /// and whether it has a PR. Centralizing the mapping pins the invariants the- /// task depends on — `log` is always present, and the PR-backed tabs (`pr`,- /// `comments`) both follow `has_pr` — so they can't drift between a worktree- /// row and a listed-PR row.- fn from_axes(local: LocalTabs, has_pr: bool) -> Self {- Self {- unified_diff: local.unified_diff,- working_tree: local.working_tree,- log: true,- branch_diff: local.branch_diff,- upstream: local.upstream,- summary: local.summary,- pr: has_pr,- comments: has_pr,- }- }-- /// A worktree-backed row: the local-checkout tabs follow [`LocalTabs`]- /// (diff tabs gated by the live [`LocalContent`] + the `has_upstream` floor);- /// the PR-backed tabs follow the live PR status (see- /// [`pr_tab_available`]).+ /// A worktree-backed row: diff tabs follow the live [`LocalContent`] plus+ /// the `has_upstream` floor; PR-backed tabs follow the live PR status (see+ /// [`pr_tab_available`]). Derived tabs are handled by [`Self::contains`].pub(super) fn worktree(content: LocalContent,has_upstream: bool,summaries_enabled: bool,has_pr: bool,) -> Self {- Self::from_axes(- LocalTabs::worktree(content, has_upstream, summaries_enabled),- has_pr,- )+ let working_tree = content.working_tree.unwrap_or(true);+ let summary_working_tree = content.summary_working_tree.unwrap_or(true);+ let branch_diff = content.branch_diff.unwrap_or(true);+ Self {+ working_tree,+ branch_diff,+ upstream: has_upstream && content.upstream_diverged.unwrap_or(true),+ summary: summaries_enabled && (summary_working_tree || branch_diff),+ pr: has_pr,+ }}/// A listed PR/MR row (`--prs`): no local checkout, so the local-checkout@@ -867,21 +811,26 @@ impl TabAvailability {/// `prs::compute_pr_log`). The differences from a worktree row are only the/// genuine data ones — no local checkout, and a PR that's always present.pub(super) fn listed_pr() -> Self {- Self::from_axes(LocalTabs::default(), true)+ Self {+ working_tree: false,+ branch_diff: false,+ upstream: false,+ summary: false,+ pr: true,+ }}/// Whether `mode` has content for this row. Empty tabs remain directly/// selectable with Alt-N, but sequential cycling skips them.fn contains(self, mode: PreviewMode) -> bool {match mode {- PreviewMode::UnifiedDiff => self.unified_diff,+ PreviewMode::UnifiedDiff => self.working_tree || self.branch_diff,PreviewMode::WorkingTree => self.working_tree,PreviewMode::BranchDiff => self.branch_diff,- PreviewMode::Log => self.log,+ PreviewMode::Log => true,PreviewMode::UpstreamDiff => self.upstream,PreviewMode::Summary => self.summary,- PreviewMode::Pr => self.pr,- PreviewMode::Comments => self.comments,+ PreviewMode::Pr | PreviewMode::Comments => self.pr,}}@@ -943,55 +892,21 @@ pub(super) fn render_preview_tabs(let reset = Reset;let tabs = [- Tab {- number: 1,- label: "diff",- is_active: mode == PreviewMode::UnifiedDiff,- has_content: avail.unified_diff,- },- Tab {- number: 2,- label: "working",- is_active: mode == PreviewMode::WorkingTree,- has_content: avail.working_tree,- },- Tab {- number: 3,- label: "committed",- is_active: mode == PreviewMode::BranchDiff,- has_content: avail.branch_diff,- },- Tab {- number: 4,- label: "log",- is_active: mode == PreviewMode::Log,- has_content: avail.log,- },- Tab {- number: 5,- label: "remote⇅",- is_active: mode == PreviewMode::UpstreamDiff,- has_content: avail.upstream,- },- Tab {- number: 6,- label: "summary",- is_active: mode == PreviewMode::Summary,- has_content: avail.summary,- },- Tab {- number: 7,- label: "pr",- is_active: mode == PreviewMode::Pr,- has_content: avail.pr,- },- Tab {- number: 8,- label: "comments",- is_active: mode == PreviewMode::Comments,- has_content: avail.comments,- },- ];+ (1, "diff", PreviewMode::UnifiedDiff),+ (2, "working", PreviewMode::WorkingTree),+ (3, "committed", PreviewMode::BranchDiff),+ (4, "log", PreviewMode::Log),+ (5, "remote⇅", PreviewMode::UpstreamDiff),+ (6, "summary", PreviewMode::Summary),+ (7, "pr", PreviewMode::Pr),+ (8, "comments", PreviewMode::Comments),+ ]+ .map(|(number, label, tab_mode)| Tab {+ number,+ label,+ is_active: mode == tab_mode,+ has_content: avail.contains(tab_mode),+ });// Prefer the full bar; fall back to compact only when it would overflow the// pane (`visual_width` measures the styled string with ANSI stripped).@@ -2203,10 +2118,10 @@ mod tests {fn diff_tabs_dim_only_once_known_empty() {let has = |avail: TabAvailability| {(- avail.unified_diff,- avail.working_tree,- avail.branch_diff,- avail.upstream,+ avail.contains(PreviewMode::UnifiedDiff),+ avail.contains(PreviewMode::WorkingTree),+ avail.contains(PreviewMode::BranchDiff),+ avail.contains(PreviewMode::UpstreamDiff),)};@@ -2252,7 +2167,8 @@ mod tests {#[test]fn summary_tab_tracks_combined_diff_content() {let summary = |content, summaries_enabled| {- TabAvailability::worktree(content, true, summaries_enabled, false).summary+ TabAvailability::worktree(content, true, summaries_enabled, false)+ .contains(PreviewMode::Summary)};// Summaries disabled dims the tab regardless of content.diff --git a/src/commands/step/commit.rs b/src/commands/step/commit.rsindex 4389015c8..d7987e2c5 100644--- a/src/commands/step/commit.rs+++ b/src/commands/step/commit.rs@@ -1,11 +1,8 @@//! `wt step commit` — commit working tree changes.-use std::path::Path;-use anyhow::Context;use worktrunk::HookType;use worktrunk::config::UserConfig;-use worktrunk::git::{Repository, TempIndex};use worktrunk::styling::println;use super::super::command_approval::{approve_or_skip, resolve_template_for_preview};@@ -82,16 +79,19 @@ fn preview_commit(stage: Option<StageMode>, dry_run: bool, yes: bool) -> anyhow:// For --dry-run, stage to a copy of the index so the preview reflects what a real// run would send. --show-prompt skips this — it's the cheap "what's already staged"// path. StageMode::None has nothing to stage, so we use the existing index as-is.+ let stage_mode = stage.unwrap_or(env.resolved().commit.stage());let temp_index = if dry_run {- stage- .unwrap_or(env.resolved().commit.stage())- .add_args()- .map(|args| stage_to_temp_index(&env.repo, args))+ (stage_mode != StageMode::None)+ .then(|| {+ let temp = env.repo.current_worktree().temp_index()?;+ temp.stage(stage_mode)?;+ Ok::<_, anyhow::Error>(temp)+ }).transpose()?} else {None};- let index_override = temp_index.as_ref().map(|temp| Path::new(temp.path()));+ let index_override = temp_index.as_ref().map(|temp| temp.path());let ctx = env.context(yes);let project_append = resolve_template_for_preview(&ctx, &commit_config, dry_run)?;@@ -109,42 +109,3 @@ fn preview_commit(stage: Option<StageMode>, dry_run: bool, yes: bool) -> anyhow:)?;print_dry_run(&prompt, &commit_config, &message)}--/// Stage into the worktree's shared temporary-index abstraction.-///-/// Returning [`TempIndex`] keeps the copied index alive while the caller builds-/// the prompt, then removes it on drop without touching the user's real index.-fn stage_to_temp_index(repo: &Repository, add_args: &[&str]) -> anyhow::Result<TempIndex> {- let temp = repo.current_worktree().temp_index()?;- let output = temp- .git(add_args.iter().copied())- .run()- .context("Failed to stage changes into temp index")?;- if !output.status.success() {- return Err(- worktrunk::git::CommandError::from_failed_output("git", add_args, &output).into(),- );- }- Ok(temp)-}--#[cfg(test)]-mod tests {- use worktrunk::git::{CommandError, Repository};- use worktrunk::testing::TestRepo;-- /// A failing `git add` into the temp index (here: an invalid pathspec)- /// must surface as a typed `CommandError`.- #[test]- fn stage_to_temp_index_failure_is_command_error() {- let test = TestRepo::with_initial_commit();- let repo = Repository::at(test.root_path()).unwrap();-- let err = match super::stage_to_temp_index(&repo, &["add", "--", ":(bad"]) {- Ok(_) => panic!("invalid pathspec should fail"),- Err(err) => err,- };- let cmd_err = CommandError::find_in(&err).expect("error should carry a CommandError");- assert_eq!(cmd_err.command_string(), "git add -- :(bad");- }-}diff --git a/src/git/repository/diff.rs b/src/git/repository/diff.rsindex 7d14316ab..7c7e0f6ee 100644--- a/src/git/repository/diff.rs+++ b/src/git/repository/diff.rs@@ -61,7 +61,7 @@ impl<'repo> PreparedDiff<'repo> {.current_dir(path).context(path_to_logging_context(path)),),- DiffSource::TempIndex(index) => index.git(args.iter().cloned()),+ DiffSource::TempIndex(index) => index.command(args.iter().cloned()),}}diff --git a/src/git/repository/working_tree.rs b/src/git/repository/working_tree.rsindex beeda5d10..8d5ac370b 100644--- a/src/git/repository/working_tree.rs+++ b/src/git/repository/working_tree.rs@@ -791,14 +791,7 @@ impl<'a> WorkingTree<'a> {"--pathspec-from-file=-","--pathspec-file-nul",];- let add_output = idx- .git(add_args)- .stdin_bytes(output.stdout)- .run()- .context("Failed to stage untracked files")?;- if !add_output.status.success() {- return Err(CommandError::from_failed_output("git", &add_args, &add_output).into());- }+ idx.run_command_with_input(add_args, output.stdout)?;let mut args = vec!["diff".to_string(),@@ -808,16 +801,10 @@ impl<'a> WorkingTree<'a> {"--".to_string(),];args.extend(paths);- let output = idx- .git(&args)- .run()- .context("Failed to compute untracked diff stats")?;- if !output.status.success() {- return Err(CommandError::from_failed_output("git", &args, &output).into());- }+ let output = idx.run_command(&args)?;let mut stats = LineDiff::default();- for line in String::from_utf8_lossy(&output.stdout).lines() {+ for line in output.lines() {if let Some((added, deleted)) = parse_numstat_line(line) {stats.added += added;stats.deleted += deleted;@@ -859,9 +846,6 @@ impl<'a> WorkingTree<'a> {// Windows: deleting a still-open file leaves the name pending.std::fs::remove_file(&temp).context("Failed to clear temporary index")?;}- // Validate UTF-8 once so `TempIndex::path` is infallible.- temp.to_str()- .context("Temporary index path is not valid UTF-8")?;Ok(TempIndex {temp,@@ -873,6 +857,18 @@ impl<'a> WorkingTree<'a> {})}+ /// Write a tree containing the index plus every working-tree change.+ ///+ /// A temporary index keeps the user's staging state unchanged. `--sparse`+ /// is intentional here: this is a complete worktree snapshot for conflict+ /// detection, so untracked files outside a sparse-checkout definition must+ /// participate too.+ pub fn write_worktree_tree(&self) -> anyhow::Result<String> {+ let index = self.temp_index()?;+ index.stage_worktree_snapshot()?;+ index.write_tree()+ }+/// Determine whether there are staged changes in the index.////// Returns `Ok(true)` when staged changes are present, `Ok(false)` otherwise.@@ -986,9 +982,50 @@ pub struct TempIndex {}impl TempIndex {- /// UTF-8 path to the temp index file. Validated at construction.- pub fn path(&self) -> &str {- self.temp.to_str().expect("validated in temp_index()")+ /// Path to the temporary index file.+ pub fn path(&self) -> &Path {+ &self.temp+ }++ /// Stage the paths selected by `mode` into this temporary index.+ ///+ /// Uses the same `git add` mode as [`WorkingTree::stage`], minus its+ /// unmerged-paths gate. All-files mode also scopes the add to the worktree+ /// root (`-- .`) and, when the system temp directory sits inside the+ /// worktree, excludes Worktrunk's own temporary indexes.+ ///+ /// [`StageMode`]: crate::config::StageMode+ pub fn stage(&self, mode: crate::config::StageMode) -> anyhow::Result<()> {+ let Some(add_args) = mode.add_args() else {+ return Ok(());+ };+ let mut args: Vec<String> = add_args.iter().map(|arg| (*arg).to_string()).collect();+ if mode == crate::config::StageMode::All {+ args.extend(["--".to_string(), ".".to_string()]);+ self.append_temp_index_exclusion(&mut args)?;+ }+ self.run_command(args)?;+ Ok(())+ }++ /// Stage a complete working-tree snapshot, crossing sparse boundaries.+ fn stage_worktree_snapshot(&self) -> anyhow::Result<()> {+ let mut args = vec![+ "add".to_string(),+ "-A".to_string(),+ "--sparse".to_string(),+ "--".to_string(),+ ".".to_string(),+ ];+ self.append_temp_index_exclusion(&mut args)?;+ self.run_command(args)?;+ Ok(())+ }++ /// Write the temporary index as a tree and return its object id.+ fn write_tree(&self) -> anyhow::Result<String> {+ self.run_command(["write-tree"])+ .map(|output| output.trim().to_string())}/// Register untracked files in the temporary index without adding their@@ -1010,6 +1047,12 @@ impl TempIndex {"--".to_string(),".".to_string(),];+ self.append_temp_index_exclusion(&mut args)?;+ self.run_command(args)?;+ Ok(())+ }++ fn append_temp_index_exclusion(&self, args: &mut Vec<String>) -> anyhow::Result<()> {let temp_dir = canonicalize_with_parents(self.temp.parent()@@ -1023,14 +1066,33 @@ impl TempIndex {":(top,exclude,glob){relative}{separator}{TEMP_INDEX_PREFIX}*"));}- let output = self- .git(&args)+ Ok(())+ }++ fn run_command(+ &self,+ args: impl IntoIterator<Item = impl Into<String>>,+ ) -> anyhow::Result<String> {+ self.run_command_with_input(args, Vec::new())+ }++ fn run_command_with_input(+ &self,+ args: impl IntoIterator<Item = impl Into<String>>,+ stdin: Vec<u8>,+ ) -> anyhow::Result<String> {+ let args: Vec<String> = args.into_iter().map(Into::into).collect();+ let mut command = self.command(args.iter().cloned());+ if !stdin.is_empty() {+ command = command.stdin_bytes(stdin);+ }+ let output = command.run()- .context("Failed to register untracked files")?;+ .with_context(|| format!("Failed to execute: git {}", args.join(" ")))?;if !output.status.success() {return Err(CommandError::from_failed_output("git", &args, &output).into());}- Ok(())+ Ok(String::from_utf8_lossy(&output.stdout).into_owned())}/// Build a `git` command pointed at this temp index.@@ -1038,7 +1100,7 @@ impl TempIndex {/// Wires `current_dir` to the worktree root, the worktree's logging/// context, and `GIT_INDEX_FILE`. The caller adds the subcommand and/// chooses `.run()` / `.stream()`.- pub fn git<I, S>(&self, args: I) -> Cmd+ pub(super) fn command<I, S>(&self, args: I) -> CmdwhereI: IntoIterator<Item = S>,S: Into<String>,@@ -1301,8 +1363,7 @@ mod tests {);}- #[test]- fn untracked_diff_stats_crosses_sparse_checkout_boundary() {+ fn sparse_checkout_with_untracked_file() -> TestRepo {let test = TestRepo::with_initial_commit();std::fs::create_dir_all(test.root_path().join("visible")).unwrap();std::fs::create_dir_all(test.root_path().join("hidden")).unwrap();@@ -1316,12 +1377,51 @@ mod tests {std::fs::create_dir_all(test.root_path().join("hidden")).unwrap();std::fs::write(test.root_path().join("hidden/loose.txt"), "loose\n").unwrap();+ test+ }++ #[test]+ fn untracked_diff_stats_crosses_sparse_checkout_boundary() {+ let test = sparse_checkout_with_untracked_file();+let repo = Repository::at(test.root_path()).unwrap();let stats = repo.current_worktree().untracked_diff_stats().unwrap();assert_eq!(stats.added, 1);assert_eq!(stats.deleted, 0);}+ #[test]+ fn temp_index_stage_all_preserves_sparse_checkout_boundary() {+ let test = sparse_checkout_with_untracked_file();++ let repo = Repository::at(test.root_path()).unwrap();+ let idx = repo.current_worktree().temp_index().unwrap();+ let err = idx+ .stage(crate::config::StageMode::All)+ .expect_err("temporary staging must mirror real git add -A");+ let cmd_err = crate::git::CommandError::find_in(&err)+ .expect("sparse-boundary refusal should remain a CommandError");+ assert_eq!(cmd_err.command_string(), "git add -A -- .");+ }++ #[test]+ fn write_worktree_tree_crosses_sparse_checkout_boundary() {+ let test = sparse_checkout_with_untracked_file();++ let repo = Repository::at(test.root_path()).unwrap();+ let tree = repo.current_worktree().write_worktree_tree().unwrap();+ let files = test.git_output(&["ls-tree", "-r", "--name-only", &tree]);+ assert_eq!(+ files.lines().collect::<Vec<_>>(),+ [+ "file.txt",+ "hidden/loose.txt",+ "hidden/tracked.txt",+ "visible/tracked.txt",+ ]+ );+ }+#[test]fn untracked_diff_stats_unborn_head_is_command_error() {// With an unborn HEAD the untracked files stage fine into the temp@@ -1365,11 +1465,8 @@ mod tests {// (b) git add -A against the resulting temp index produces a tree// containing the working-tree files.- idx.git(["add", "-A"]).run().unwrap();- let write_tree = idx.git(["write-tree"]).run().unwrap();- let tree_sha = String::from_utf8_lossy(&write_tree.stdout)- .trim()- .to_string();+ idx.stage(crate::config::StageMode::All).unwrap();+ let tree_sha = idx.write_tree().unwrap();let ls_tree = Cmd::new("git").args(["ls-tree", "-r", "--name-only", &tree_sha]).current_dir(test.root_path())diff --git a/tests/integration_tests/list.rs b/tests/integration_tests/list.rsindex b12bfbf39..57565d359 100644--- a/tests/integration_tests/list.rs+++ b/tests/integration_tests/list.rs@@ -3369,6 +3369,52 @@ fn test_list_working_tree_conflicts(mut repo: TestRepo) {});}+/// A dirty worktree may contain untracked files outside its sparse-checkout+/// definition. The temporary-index snapshot must still include the visible+/// tracked change and produce the working-tree conflict result.+#[rstest]+fn test_list_working_tree_conflicts_cross_sparse_checkout_boundary(mut repo: TestRepo) {+ repo.write_test_config("[list]\njson-schema = 2\n");++ std::fs::create_dir_all(repo.root_path().join("visible")).unwrap();+ std::fs::create_dir_all(repo.root_path().join("hidden")).unwrap();+ std::fs::write(repo.root_path().join("visible/shared.txt"), "base\n").unwrap();+ std::fs::write(repo.root_path().join("hidden/tracked.txt"), "base\n").unwrap();+ repo.run_git(&["add", "."]);+ repo.commit("Add sparse fixture");++ let feature = repo.add_worktree("feature");+ std::fs::write(repo.root_path().join("visible/shared.txt"), "main\n").unwrap();+ repo.commit("Change shared file on main");++ repo.run_git_in(&feature, &["sparse-checkout", "init", "--cone"]);+ repo.run_git_in(&feature, &["sparse-checkout", "set", "visible"]);+ std::fs::write(feature.join("visible/shared.txt"), "feature\n").unwrap();+ std::fs::create_dir_all(feature.join("hidden")).unwrap();+ std::fs::write(feature.join("hidden/loose.txt"), "loose\n").unwrap();++ let output = repo+ .wt_command()+ .args(["list", "--format=json"])+ .current_dir(repo.root_path())+ .output()+ .unwrap();+ assert!(+ output.status.success(),+ "wt list should succeed; stderr:\n{}",+ String::from_utf8_lossy(&output.stderr)+ );++ let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();+ let feature = json["items"]+ .as_array()+ .unwrap()+ .iter()+ .find(|item| item["branch"] == "feature")+ .expect("feature row");+ assert_eq!(feature["default_branch"]["merge_conflicts"], true);+}+////// Even with --full, if the working tree is clean, we skip the working-tree check/// and just use the commit-level conflict detection.diff --git a/tests/integration_tests/merge.rs b/tests/integration_tests/merge.rsindex 17b59f5ee..169f4d038 100644--- a/tests/integration_tests/merge.rs+++ b/tests/integration_tests/merge.rs@@ -2865,6 +2865,9 @@ command = "cat >/dev/null && echo 'feat: add untracked'"fs::write(repo.test_config_path(), worktrunk_config).unwrap();let output = make_snapshot_cmd(&repo, "step", &["commit", "--dry-run"], None)+ // The worktree-root case exercises the empty relative path in the+ // temporary-index exclusion.+ .env("TMPDIR", repo.root_path()).output().expect("wt step commit --dry-run failed");let stdout = String::from_utf8(output.stdout).unwrap();@@ -2873,6 +2876,10 @@ command = "cat >/dev/null && echo 'feat: add untracked'""--dry-run with default --stage=all should include untracked files in the prompt; \got stdout:\n{stdout}");+ assert!(+ !stdout.contains("worktrunk-temp-index-"),+ "--dry-run must exclude its temporary index artifacts; got stdout:\n{stdout}"+ );// The user's real index must not have absorbed the untracked file.let status = repo@@ -3026,7 +3033,7 @@ command = "cat >/dev/null && echo 'feat: combined feature work'"/// `GIT_INDEX_FILE` pointed at the copy. If that `git add` exits non-zero, the/// error must propagate (not silently feed an empty diff to the LLM). We/// reproduce a non-zero exit by replacing `.git/index` with garbage — the temp-/// copy succeeds, but `git add -A` rejects the corrupt index.+/// copy succeeds, but the all-files `git add` rejects the corrupt index.#[rstest]fn test_step_commit_dry_run_propagates_git_add_failure(repo: TestRepo) {fs::write(repo.root_path().join("new.txt"), "x").expect("Failed to write file");@@ -3045,8 +3052,8 @@ fn test_step_commit_dry_run_propagates_git_add_failure(repo: TestRepo) {);let stderr = String::from_utf8_lossy(&output.stderr);assert!(- stderr.contains("git add -A failed"),- "expected bail! to surface 'git add -A failed'; got stderr:\n{stderr}"+ stderr.contains("git add -A -- . failed"),+ "expected the failing git add command; got stderr:\n{stderr}");}