Remove the requirement for .git to be a directory.

This is achieved by somewhat costly, but still cost-minimized handling
of the Git repository itself.

Author: Byron

crates/but-api/src/commands/claude.rs

@@ -72,10 +72,11 @@ pub async fn claude_get_session_details(
     let session_id = uuid::Uuid::parse_str(&session_id).map_err(anyhow::Error::from)?;
     let session = but_claude::db::get_session_by_id(&mut ctx, session_id)?
         .context("Could not find session")?;
-    let current_id = Transcript::current_valid_session_id(&project.path, &session).await?;
+    let current_id =
+        Transcript::current_valid_session_id(&project.worktree_dir(), &session).await?;
     if let Some(current_id) = current_id {
         let transcript_path =
-            but_claude::Transcript::get_transcript_path(&project.path, current_id)?;
+            but_claude::Transcript::get_transcript_path(&project.worktree_dir(), current_id)?;
         let transcript = but_claude::Transcript::from_file(&transcript_path)?;
         Ok(but_claude::ClaudeSessionDetails {
             summary: transcript.summary(),
@@ -204,8 +205,8 @@ pub fn claude_maybe_create_prompt_dir(project_id: ProjectId, path: String) -> Re
 #[instrument(err(Debug))]
 pub async fn claude_get_mcp_config(project_id: ProjectId) -> Result<McpConfig, Error> {
     let project = gitbutler_project::get(project_id)?;
-    let settings = ClaudeSettings::open(&project.path).await;
-    let mcp_config = ClaudeMcpConfig::open(&settings, &project.path).await;
+    let settings = ClaudeSettings::open(&project.worktree_dir()).await;
+    let mcp_config = ClaudeMcpConfig::open(&settings, &project.worktree_dir()).await;
     Ok(mcp_config.mcp_servers())
 }
 
@@ -215,7 +216,8 @@ pub async fn claude_get_sub_agents(
     project_id: ProjectId,
 ) -> Result<Vec<but_claude::SubAgent>, Error> {
     let project = gitbutler_project::get(project_id)?;
-    let sub_agents = but_claude::claude_sub_agents::read_claude_sub_agents(&project.path).await;
+    let sub_agents =
+        but_claude::claude_sub_agents::read_claude_sub_agents(&project.worktree_dir()).await;
     Ok(sub_agents)
 }
 
@@ -229,7 +231,7 @@ pub async fn claude_verify_path(project_id: ProjectId, path: String) -> Result<b
         std::path::PathBuf::from(&path)
     } else {
         // If relative, make it relative to project path
-        project.path.join(&path)
+        project.worktree_dir().join(&path)
     };
 
     // Check if the path exists and is a directory

crates/but-api/src/commands/config.rs

@@ -12,7 +12,7 @@ use crate::error::Error;
 #[cfg_attr(feature = "tauri", tauri::command(async))]
 #[instrument(err(Debug))]
 pub fn get_gb_config(project_id: ProjectId) -> Result<GitConfigSettings, Error> {
-    but_core::open_repo(gitbutler_project::get(project_id)?.path)?
+    but_core::open_repo(gitbutler_project::get(project_id)?.worktree_dir())?
         .git_settings()
         .map(Into::into)
         .map_err(Into::into)
@@ -22,7 +22,7 @@ pub fn get_gb_config(project_id: ProjectId) -> Result<GitConfigSettings, Error>
 #[cfg_attr(feature = "tauri", tauri::command(async))]
 #[instrument(err(Debug))]
 pub fn set_gb_config(project_id: ProjectId, config: GitConfigSettings) -> Result<(), Error> {
-    but_core::open_repo(gitbutler_project::get(project_id)?.path)?
+    but_core::open_repo(gitbutler_project::get(project_id)?.worktree_dir())?
         .set_git_settings(&config.into())
         .map_err(Into::into)
 }
@@ -35,7 +35,7 @@ pub fn store_author_globally_if_unset(
     name: String,
     email: String,
 ) -> Result<(), Error> {
-    let repo = but_core::open_repo(gitbutler_project::get(project_id)?.path)?;
+    let repo = but_core::open_repo(gitbutler_project::get(project_id)?.worktree_dir())?;
     but_rebase::commit::save_author_if_unset_in_repo(
         &repo,
         gix::config::Source::User,
@@ -61,7 +61,7 @@ pub struct AuthorInfo {
 #[instrument(err(Debug))]
 /// Return the Git author information as the project repository would see it.
 pub fn get_author_info(project_id: ProjectId) -> Result<AuthorInfo, Error> {
-    let repo = but_core::open_repo(gitbutler_project::get(project_id)?.path)?;
+    let repo = but_core::open_repo(gitbutler_project::get(project_id)?.worktree_dir())?;
     let (name, email) = repo
         .author()
         .transpose()

crates/but-api/src/commands/diff.rs

@@ -32,7 +32,7 @@ pub fn tree_change_diffs(
     let change: but_core::TreeChange = change.into();
     let project = gitbutler_project::get(project_id)?;
     let app_settings = AppSettings::load_from_default_path_creating()?;
-    let repo = gix::open(project.path).map_err(anyhow::Error::from)?;
+    let repo = gix::open(project.worktree_dir()).map_err(anyhow::Error::from)?;
     Ok(change.unified_diff(&repo, app_settings.context_lines)?)
 }
 
@@ -53,7 +53,7 @@ pub fn commit_details(
     commit_id: HexHash,
 ) -> anyhow::Result<CommitDetails, Error> {
     let project = gitbutler_project::get(project_id)?;
-    let repo = &gix::open(&project.path).context("Failed to open repo")?;
+    let repo = &gix::open(project.worktree_dir()).context("Failed to open repo")?;
     let commit = repo
         .find_commit(commit_id)
         .context("Failed for find commit")?;
@@ -121,7 +121,7 @@ pub fn changes_in_worktree(project_id: ProjectId) -> anyhow::Result<WorktreeChan
 
     let dependencies = hunk_dependencies_for_workspace_changes_by_worktree_dir(
         ctx,
-        &ctx.project().path,
+        &ctx.project().worktree_dir(),
         &ctx.project().gb_dir(),
         Some(changes.changes.clone()),
     );

crates/but-api/src/commands/forge.rs

@@ -18,7 +18,7 @@ use crate::error::Error;
 #[instrument(err(Debug))]
 pub fn pr_templates(project_id: ProjectId, forge: ForgeName) -> Result<Vec<String>, Error> {
     let project = gitbutler_project::get_validated(project_id)?;
-    Ok(available_review_templates(&project.path, &forge))
+    Ok(available_review_templates(&project.worktree_dir(), &forge))
 }
 
 #[api_cmd]
@@ -39,7 +39,7 @@ pub fn pr_template(
     if !is_valid_review_template_path(&relative_path) {
         return Err(anyhow::format_err!(
             "Invalid review template path: {:?}",
-            Path::join(&project.path, &relative_path)
+            Path::join(&project.worktree_dir(), &relative_path)
         )
         .into());
     }

crates/but-api/src/commands/virtual_branches.rs

@@ -257,7 +257,7 @@ pub fn unapply_stack(project_id: ProjectId, stack_id: StackId) -> Result<(), Err
     let (assignments, _) = but_hunk_assignment::assignments_with_fallback(
         ctx,
         false,
-        Some(but_core::diff::ui::worktree_changes_by_worktree_dir(project.path)?.changes),
+        Some(but_core::diff::ui::worktree_changes_by_worktree_dir(project.worktree_dir())?.changes),
         None,
     )?;
     let assigned_diffspec = but_workspace::flatten_diff_specs(

crates/but-api/src/commands/workspace.rs

@@ -329,7 +329,7 @@ pub fn amend_commit_from_worktree_changes(
 ) -> Result<commit_engine::ui::CreateCommitOutcome, Error> {
     let project = gitbutler_project::get(project_id)?;
     let mut guard = project.exclusive_worktree_access();
-    let repo = but_core::open_repo_for_merging(project.worktree_path())?;
+    let repo = but_core::open_repo_for_merging(project.worktree_dir())?;
     let app_settings = AppSettings::load_from_default_path_creating()?;
     let outcome = commit_engine::create_commit_and_update_refs_with_project(
         &repo,
@@ -364,7 +364,7 @@ pub fn discard_worktree_changes(
     worktree_changes: Vec<but_workspace::DiffSpec>,
 ) -> Result<Vec<but_workspace::DiffSpec>, Error> {
     let project = gitbutler_project::get(project_id)?;
-    let repo = but_core::open_repo(project.worktree_path())?;
+    let repo = but_core::open_repo(project.worktree_dir())?;
     let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
     let mut guard = project.exclusive_worktree_access();
 

crates/but-claude/src/bridge.rs

@@ -253,7 +253,7 @@ impl Claudes {
             writer,
             write_stderr,
             session,
-            project.path.clone(),
+            project.worktree_dir(),
             ctx.clone(),
             user_params,
             summary_to_resume,

crates/but-claude/src/compact.rs

@@ -234,7 +234,7 @@ pub async fn generate_summary(
     let app_settings = ctx.lock().await.app_settings().clone();
     let claude_executable = app_settings.claude.executable.clone();
     let session_id =
-        Transcript::current_valid_session_id(&ctx.lock().await.project().path, session)
+        Transcript::current_valid_session_id(&ctx.lock().await.project().worktree_dir(), session)
             .await?
             .context("Cant find current session id")?;
 
@@ -248,7 +248,7 @@ pub async fn generate_summary(
         command.creation_flags(CREATE_NO_WINDOW);
     }
 
-    command.current_dir(&ctx.lock().await.project().path);
+    command.current_dir(ctx.lock().await.project().worktree_dir());
     command.args(["--resume", &format!("{session_id}")]);
     command.arg("-p");
     command.arg(SUMMARY_PROMPT);

crates/but-claude/src/hooks/mod.rs

@@ -104,7 +104,8 @@ pub async fn handle_stop() -> anyhow::Result<ClaudeHookOutput> {
     )?;
 
     let changes =
-        but_core::diff::ui::worktree_changes_by_worktree_dir(project.clone().path)?.changes;
+        but_core::diff::ui::worktree_changes_by_worktree_dir(project.clone().worktree_dir())?
+            .changes;
 
     // This is a naive way of handling this case.
     // If the user simply asks a question and there are no changes, we don't need to create a stack
@@ -328,7 +329,7 @@ pub fn handle_pre_tool_call() -> anyhow::Result<ClaudeHookOutput> {
             .ok_or(anyhow!("No worktree found for repo"))?,
     )?;
     let relative_file_path = std::path::PathBuf::from(&input.tool_input.file_path)
-        .strip_prefix(project.path.clone())?
+        .strip_prefix(project.worktree_dir())?
         .to_string_lossy()
         .to_string();
     input.tool_input.file_path = relative_file_path;
@@ -374,7 +375,7 @@ pub fn handle_post_tool_call() -> anyhow::Result<ClaudeHookOutput> {
     )?;
 
     let relative_file_path = std::path::PathBuf::from(&input.tool_response.file_path)
-        .strip_prefix(project.path.clone())?
+        .strip_prefix(project.worktree_dir())?
         .to_string_lossy()
         .to_string();
     input.tool_response.file_path = relative_file_path.clone();
@@ -404,7 +405,7 @@ pub fn handle_post_tool_call() -> anyhow::Result<ClaudeHookOutput> {
     let stack_id = get_or_create_session(defer.ctx, &session_id, stacks, vb_state)?;
 
     let changes =
-        but_core::diff::ui::worktree_changes_by_worktree_dir(project.path.clone())?.changes;
+        but_core::diff::ui::worktree_changes_by_worktree_dir(project.worktree_dir())?.changes;
     let (assignments, _assignments_error) = but_hunk_assignment::assignments_with_fallback(
         defer.ctx,
         true,

crates/but-claude/src/prompt_templates.rs

@@ -42,10 +42,10 @@ pub struct PromptDir {
 
 /// Fetch the directories where we look up the user provided templates.
 ///
-/// We want the precidence to be Global < Project < Project Local
+/// We want the precedence to be Global < Project < Project Local
 ///
-/// As such, items last in the array take precidence, and filters last in the
-/// filters list also take precidence over earlier ones.
+/// As such, items last in the array take precedence, and filters last in the
+/// filters list also take precedence over earlier ones.
 ///
 /// The point of labeling these dirs is so we can also display where to find
 /// these directories in the frontend.
@@ -58,7 +58,7 @@ pub fn prompt_dirs(project: &Project) -> Result<Vec<PromptDir>> {
         },
         PromptDir {
             label: "Project".into(),
-            path: project.path.join(".gitbutler/prompt-templates"),
+            path: project.gb_dir().join("prompt-templates"),
             filters: vec![".md".into(), ".local.md".into()],
         },
     ])
@@ -124,7 +124,7 @@ pub fn maybe_create_dir(project: &Project, path: &str) -> Result<()> {
     let path = if path.is_absolute() {
         path
     } else {
-        &project.path.join(path)
+        &project.worktree_dir().join(path)
     };
 
     if path.try_exists()? {