This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

166 lines
4.9 KiB
Go

// Package utils provides utility functions for issue ID parsing and path handling.
package utils
import (
"os"
"path/filepath"
"runtime"
"strings"
)
// ResolveForWrite returns the path to write to, resolving symlinks.
// If path is a symlink, returns the resolved target path.
// If path doesn't exist, returns path unchanged (new file).
func ResolveForWrite(path string) (string, error) {
info, err := os.Lstat(path)
if err != nil {
if os.IsNotExist(err) {
return path, nil
}
return "", err
}
if info.Mode()&os.ModeSymlink != 0 {
return filepath.EvalSymlinks(path)
}
return path, nil
}
// CanonicalizePath converts a path to its canonical form by:
// 1. Converting to absolute path
// 2. Resolving symlinks
// 3. On macOS/Windows, resolving the true filesystem case (GH#880)
//
// If any step fails, it falls back to the best available form:
// - If case resolution fails, returns symlink-resolved path
// - If symlink resolution fails, returns absolute path
// - If absolute path conversion fails, returns original path
//
// This function is used to ensure consistent path handling across the codebase,
// particularly for BEADS_DIR environment variable processing and git worktree
// paths which require exact case matching.
func CanonicalizePath(path string) string {
// Try to get absolute path
absPath, err := filepath.Abs(path)
if err != nil {
// If we can't get absolute path, return original
return path
}
// Try to resolve symlinks
canonical, err := filepath.EvalSymlinks(absPath)
if err != nil {
// If we can't resolve symlinks, return absolute path
return absPath
}
// On case-insensitive filesystems, resolve to true filesystem case (GH#880)
// This is critical for git operations which string-compare paths exactly.
if runtime.GOOS == "darwin" || runtime.GOOS == "windows" {
if resolved := resolveCanonicalCase(canonical); resolved != "" {
return resolved
}
}
return canonical
}
// resolveCanonicalCase resolves a path to its true filesystem case.
// On macOS, walks each path component and matches against actual directory
// entries to recover the correct case (HFS+/APFS are case-insensitive).
// Returns empty string if resolution fails.
func resolveCanonicalCase(path string) string {
if runtime.GOOS != "darwin" {
// Windows: filepath.EvalSymlinks already handles case
return ""
}
// Walk the path component-by-component, resolving each to its true case
// by listing the parent directory and matching case-insensitively.
parts := strings.Split(filepath.Clean(path), string(filepath.Separator))
if len(parts) == 0 {
return ""
}
// Start from root
resolved := string(filepath.Separator)
for _, part := range parts {
if part == "" {
continue
}
entries, err := os.ReadDir(resolved)
if err != nil {
return "" // can't read directory, fall back
}
found := false
for _, entry := range entries {
if strings.EqualFold(entry.Name(), part) {
resolved = filepath.Join(resolved, entry.Name())
found = true
break
}
}
if !found {
return "" // component not found, fall back
}
}
return resolved
}
// NormalizePathForComparison returns a normalized path suitable for comparison.
// It resolves symlinks and handles case-insensitive filesystems (macOS, Windows).
//
// On case-insensitive filesystems (darwin, windows), the path is lowercased
// to ensure that /Users/foo/Desktop and /Users/foo/desktop compare as equal.
//
// This function should be used whenever comparing workspace paths, not for
// storing or displaying paths (preserve original case for those purposes).
func NormalizePathForComparison(path string) string {
if path == "" {
return ""
}
// Try to get absolute path first
absPath, err := filepath.Abs(path)
if err != nil {
absPath = path
}
// Try to resolve symlinks
canonical, err := filepath.EvalSymlinks(absPath)
if err != nil {
// If symlink resolution fails (e.g., path doesn't exist), use absolute path
canonical = absPath
}
// On case-insensitive filesystems, lowercase for comparison
if runtime.GOOS == "darwin" || runtime.GOOS == "windows" {
canonical = strings.ToLower(canonical)
}
return canonical
}
// PathsEqual compares two paths for equality, handling case-insensitive
// filesystems and symlinks.
func PathsEqual(path1, path2 string) bool {
return NormalizePathForComparison(path1) == NormalizePathForComparison(path2)
}
// CanonicalizeIfRelative ensures a path is absolute for filepath.Rel() compatibility.
// If the path is non-empty and relative, it is canonicalized using CanonicalizePath.
// Absolute paths and empty strings are returned unchanged.
//
// This guards against code paths that might set paths to relative values,
// which would cause filepath.Rel() to fail or produce incorrect results.
//
// See GH#959 for root cause analysis of the original autoflush bug.
func CanonicalizeIfRelative(path string) string {
if path != "" && !filepath.IsAbs(path) {
return CanonicalizePath(path)
}
return path
}