`resolve_base_dir` detects worktrees dir inside repo when it's actually not

[blizzy78]

If gtr.worktrees.dir or GTR_WORKTREES_DIR are set to .., resolve_base_dir will detect the worktrees dir "inside" the repo when it's actually not.

The culprit seems to be this conditional:

if [[ "$base_dir" == "$repo_root"/* ]]; then

where /* includes directory entries . and ..

[coderabbitai]

• 🗺️ Generate an implementation plan for this issue

[blizzy78]

@coderabbitai do it

[coderabbitai]

📋 Copy the entire block below and paste it to your AI coding agent:

Path Canonicalization Helper Function

In `lib/core.sh`, add a local helper function `canonicalize_path` inside the `resolve_base_dir` function (after line 32). The function should accept a directory path parameter and return its canonical absolute path using `( cd -P -- "$path" && pwd -P )` in a subshell. Handle non-existent directories by returning an empty string. This helper will normalize paths by resolving symlinks and removing `.` and `..` components.

📋 Copy the entire block below and paste it to your AI coding agent:

Canonicalize base_dir After Absolute Path Conversion

In `lib/core.sh` at line 56 (after the existing absolute path conversion logic), add canonicalization of `base_dir` by calling the helper function and storing the result back: `base_dir=$(canonicalize_path "$base_dir")`. Only attempt canonicalization if `base_dir` is not empty and exists; fall back to the original absolute path if canonicalization fails.

📋 Copy the entire block below and paste it to your AI coding agent:

Canonicalize repo_root Before Comparison

In `lib/core.sh` just before line 61, introduce a local variable `canonical_repo_root` and populate it by calling `canonicalize_path "$repo_root"`. This ensures the repository root path is canonicalized before the parent/child relationship check.

📋 Copy the entire block below and paste it to your AI coding agent:

Update Path Comparison Logic

In `lib/core.sh` at line 61, replace the path comparison `if [[ "$base_dir" == "$repo_root"/* ]]` with `if [[ "$base_dir" == "$canonical_repo_root"/* ]]`. Update line 62 to use `canonical_repo_root` in the relative path calculation: `local rel_path="${base_dir#$canonical_repo_root/}"`. This fixes the bug by comparing canonical paths instead of lexical strings.

📋 Copy the entire block below and paste it to your AI coding agent:

Verify Edge Cases and Backward Compatibility

Review the updated `resolve_base_dir` function to confirm: (1) non-existent worktrees directories are handled gracefully by falling back to absolute paths, (2) symlinks in repo paths are correctly resolved for comparison, (3) relative paths with `..`, `.`, etc. are properly normalized, (4) already absolute paths continue to work, and (5) the warning message displays correct information using canonical paths. Ensure no regressions in existing functionality.

Task Overview

Fix the path comparison bug in resolve_base_dir function where relative paths containing .. are incorrectly detected as being inside the repository due to lexical string matching instead of canonical path comparison.

Task Classification

• Request Type: Bug Fix
• Scope: Minor

Codebase Summary

The codebase is a git worktree management tool with core functionality in lib/core.sh. The resolve_base_dir function handles configuration resolution for the worktrees directory location, supporting three configuration sources: git config (gtr.worktrees.dir), environment variable (GTR_WORKTREES_DIR), or a default location. The function converts relative paths to absolute paths and performs validation to warn users when the worktrees directory is inside the repository. The codebase follows a bash scripting architecture with library modules in the lib/ directory and lacks custom path canonicalization utilities.

Key components relevant to this fix:

• lib/core.sh: Contains the resolve_base_dir function with path resolution and validation logic
• lib/config.sh: Provides configuration priority lookup through cfg_default function
• No existing path canonicalization utilities in the project's own codebase

Assumptions

1. Path Canonicalization Approach

   The bug requires comparing canonical paths rather than lexical paths to properly detect parent/child relationships.

   Options Considered:

   • Use realpath command: Modern GNU/BSD utility that resolves symlinks and normalizes paths
   • Use readlink -f: GNU coreutils approach to follow symlinks to their ultimate target
   • Use cd && pwd -P pattern: Shell-based approach that changes to directory and prints canonical path

   Chosen Approach:
   Use cd && pwd -P pattern for path canonicalization. This approach is the most portable solution that works across Linux, macOS, and BSD systems without requiring external utilities that may not be available. The -P flag to pwd resolves symlinks and provides a canonical path. This pattern is already used in the codebase's dependencies (git-core scripts), indicating it's a well-established approach. The solution only needs to work for directories (not files), making this approach ideal since cd only works with directories. This avoids introducing dependencies on realpath (not available on older systems) or readlink -f (BSD readlink doesn't support -f flag).

Implementation

Task 1: Add Path Canonicalization Helper

Goals & Expectations:
Create a local helper function within resolve_base_dir that canonicalizes directory paths by resolving symlinks and normalizing . and .. components. This helper should use the portable cd && pwd -P pattern to ensure compatibility across different Unix-like systems.

Design

Add an internal bash function that takes a directory path as input and returns its canonical absolute path. The function should handle edge cases like non-existent directories and use subshell execution to avoid side effects from directory changes.

Implementation Details

The resolve_base_dir function in lib/core.sh currently performs path operations without canonicalization. This task adds a helper function to normalize paths before comparison.

Implementation steps:

1. Define canonicalization helper function (insert near the beginning of resolve_base_dir, after line 32):

   • Create a local function named canonicalize_path that accepts a single directory path parameter
   • Use a subshell ( cd -P -- "$path" && pwd -P ) to avoid affecting the current shell's working directory
   • The -P flags resolve all symbolic links to their targets
   • The -- prevents path arguments starting with - from being interpreted as options
   • Return the canonicalized path via stdout
   • Handle error case: if the directory doesn't exist or cd fails, the function should return empty string and the caller should handle the error appropriately

2. Add error handling for non-existent paths:

   • Wrap the subshell command in a conditional to check if cd succeeds
   • If canonicalization fails (directory doesn't exist), decide on appropriate behavior: either skip canonicalization and use the original path, or treat it as an error condition
   • Given that the worktrees directory may not exist yet at validation time, the function should gracefully handle non-existent paths by falling back to the non-canonicalized absolute path

3. Function placement: Insert this helper function immediately after the function declaration of resolve_base_dir and before the configuration lookup logic (before line 39 where cfg_default is called)

---

Task 2: Canonicalize Paths Before Comparison

Goals & Expectations:
Modify the path comparison logic to use canonical paths instead of lexical string matching. This ensures that paths containing .., ., or symlinks are correctly evaluated for parent/child relationships.

Design

Update the conditional check that determines whether the worktrees directory is inside the repository to first canonicalize both paths before performing the string prefix match. This prevents false positives when relative path components are present in the configured path.

Implementation Details

The buggy comparison at line 61 in lib/core.sh needs to be updated to use canonical paths. The current logic performs relative-to-absolute conversion (lines 47-56) but doesn't normalize the resulting path.

Implementation steps:

1. Canonicalize base_dir after absolute path conversion (insert after line 56, before the empty path check):

   • After the existing logic that converts relative paths to absolute paths (the cd "$repo_root" && cd "$base_dir" && pwd block)
   • Call the canonicalize_path helper function on base_dir
   • Store the result back in base_dir variable: base_dir=$(canonicalize_path "$base_dir")
   • Only attempt canonicalization if base_dir is not empty and the directory exists
   • If canonicalization fails (returns empty), preserve the original absolute path to avoid breaking existing functionality

2. Canonicalize repo_root before comparison (insert just before line 61):

   • Introduce a local variable canonical_repo_root to store the canonical version of repo_root
   • Call canonicalize_path "$repo_root" and store in this variable
   • The repo_root parameter should always exist (since it's the current repository), so no fallback handling is needed

3. Update the comparison conditional (modify line 61):

   • Change if [[ "$base_dir" == "$repo_root"/* ]]; then to if [[ "$base_dir" == "$canonical_repo_root"/* ]]; then
   • This ensures both sides of the comparison use canonical paths, eliminating the bug where .. components cause false matches
   • The pattern match still uses /* suffix to check if base_dir is a child of repo_root, but now with normalized paths

4. Update subsequent references (line 62):

   • The rel_path calculation should continue to use the canonical paths: local rel_path="${base_dir#$canonical_repo_root/}"
   • This ensures the warning message displays the correct relative path

---

Task 3: Verify Edge Cases

Goals & Expectations:
Ensure the fix handles various edge cases correctly including symlinks in the repository path, worktrees directory that doesn't exist yet, and different relative path configurations.

Design

Review the updated logic to confirm it maintains backward compatibility and doesn't introduce regressions for existing configurations while fixing the .. path bug.

Implementation Details

After implementing the canonicalization changes, the function should be reviewed for correctness with various input scenarios:

Edge cases to consider:

1. Non-existent worktrees directory: When base_dir points to a directory that doesn't exist yet (common scenario where user is setting up worktrees for the first time), the canonicalization should gracefully fail and fall back to using the absolute path as-is. The comparison will still work correctly because even though the path isn't fully canonical, it won't contain .. after the absolute path conversion.

2. Symlinks in repository path: If repo_root itself contains symlinks or is a symlink, canonicalizing it ensures consistent comparisons. For example, if the repo is at /home/user/projects/my-repo but /home/user is a symlink to /data/users/user, the canonical path should be used for comparison.

3. Relative path configurations other than ..: Paths like ., ../other-dir, ../../parent-dir should all be correctly converted to absolute then canonicalized, eliminating false positives.

4. Already absolute paths: If the user configures an absolute path directly, the existing logic should continue to work - canonicalization will simply resolve any symlinks and normalize the path.

5. Special characters in paths: The -- in the cd command prevents paths starting with - from being misinterpreted as options.

Verification approach:

• Review the control flow to ensure empty base_dir is still handled correctly (line 58-60)
• Confirm that the default worktrees directory creation logic (after line 74) isn't affected by the canonicalization
• Ensure the warning message (lines 63-71) displays correct information using the canonical paths

---