Remove some unused shit and write tests for coverage

utils/path.go

@@ -3,7 +3,6 @@ package utils
 import (
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 
 	logger "git.site.quack-lab.dev/dave/cylogger"
@@ -12,93 +11,69 @@ import (
 // pathLogger is a scoped logger for the utils/path package.
 var pathLogger = logger.Default.WithPrefix("utils/path")
 
-// ResolvePath resolves a file path by:
-// 1. Expanding ~ to the user's home directory
-// 2. Making the path absolute if it's relative
-// 3. Normalizing path separators to forward slashes
-// 4. Cleaning the path
+// ResolvePath resolves a path to an absolute path, handling ~ expansion and cleaning
 func ResolvePath(path string) string {
 	resolvePathLogger := pathLogger.WithPrefix("ResolvePath").WithField("inputPath", path)
-	resolvePathLogger.Debug("Resolving path")
+	resolvePathLogger.Trace("Resolving path: %q", path)
 
+	// Handle empty path
 	if path == "" {
-		resolvePathLogger.Warning("Empty path provided")
+		resolvePathLogger.Trace("Empty path, returning empty string")
 		return ""
 	}
 
-	// Step 1: Expand ~ to home directory
-	originalPath := path
+	// Check if path is absolute
+	if filepath.IsAbs(path) {
+		resolvePathLogger.Trace("Path is already absolute: %q", path)
+		cleaned := filepath.ToSlash(filepath.Clean(path))
+		resolvePathLogger.Trace("Cleaned absolute path: %q", cleaned)
+		return cleaned
+	}
+
+	// Handle ~ expansion
 	if strings.HasPrefix(path, "~") {
-		home := os.Getenv("HOME")
-		if home == "" {
-			// Fallback for Windows
-			if runtime.GOOS == "windows" {
-				home = os.Getenv("USERPROFILE")
-			}
-		}
-		if home != "" {
-			if path == "~" {
-				path = home
-			} else if strings.HasPrefix(path, "~/") {
-				path = filepath.Join(home, path[2:])
-			} else {
-				// Handle cases like ~username
-				// For now, just replace ~ with home directory
-				path = strings.Replace(path, "~", home, 1)
-			}
-			resolvePathLogger.Debug("Expanded tilde to home directory: home=%s, result=%s", home, path)
+		homeDir, _ := os.UserHomeDir()
+		if strings.HasPrefix(path, "~/") || strings.HasPrefix(path, "~\\") {
+			path = filepath.Join(homeDir, path[2:])
+		} else if path == "~" {
+			path = homeDir
 		} else {
-			resolvePathLogger.Warning("Could not determine home directory for tilde expansion")
+			// ~something (like ~~), treat first ~ as home expansion, rest as literal
+			path = homeDir + path[1:]
 		}
+		resolvePathLogger.Trace("Expanded ~ to home directory: %q", path)
 	}
 
-	// Step 2: Make path absolute if it's not already
+	// Make absolute if not already
 	if !filepath.IsAbs(path) {
-		cwd, err := os.Getwd()
+		absPath, err := filepath.Abs(path)
 		if err != nil {
-			resolvePathLogger.Error("Failed to get current working directory: %v", err)
-			return path // Return as-is if we can't get CWD
+			resolvePathLogger.Error("Failed to get absolute path: %v", err)
+			return filepath.ToSlash(filepath.Clean(path))
 		}
-		path = filepath.Join(cwd, path)
-		resolvePathLogger.Debug("Made relative path absolute: cwd=%s, result=%s", cwd, path)
+		resolvePathLogger.Trace("Made path absolute: %q -> %q", path, absPath)
+		path = absPath
 	}
 
-	// Step 3: Clean the path
-	path = filepath.Clean(path)
-	resolvePathLogger.Debug("Cleaned path: result=%s", path)
-
-	// Step 4: Normalize path separators to forward slashes for consistency
-	path = strings.ReplaceAll(path, "\\", "/")
-
-	resolvePathLogger.Debug("Final resolved path: original=%s, final=%s", originalPath, path)
-	return path
-}
-
-// ResolvePathForLogging is the same as ResolvePath but includes more detailed logging
-// for debugging purposes
-func ResolvePathForLogging(path string) string {
-	return ResolvePath(path)
-}
-
-// IsAbsolutePath checks if a path is absolute (including tilde expansion)
-func IsAbsolutePath(path string) bool {
-	// Check for tilde expansion first
-	if strings.HasPrefix(path, "~") {
-		return true // Tilde paths become absolute after expansion
-	}
-	return filepath.IsAbs(path)
+	// Clean the path and normalize to forward slashes for consistency
+	cleaned := filepath.ToSlash(filepath.Clean(path))
+	resolvePathLogger.Trace("Final cleaned path: %q", cleaned)
+	return cleaned
 }
 
 // GetRelativePath returns the relative path from base to target
 func GetRelativePath(base, target string) (string, error) {
-	resolvedBase := ResolvePath(base)
-	resolvedTarget := ResolvePath(target)
+	getRelativePathLogger := pathLogger.WithPrefix("GetRelativePath")
+	getRelativePathLogger.Debug("Getting relative path from %q to %q", base, target)
 
-	relPath, err := filepath.Rel(resolvedBase, resolvedTarget)
+	relPath, err := filepath.Rel(base, target)
 	if err != nil {
+		getRelativePathLogger.Error("Failed to get relative path: %v", err)
 		return "", err
 	}
 
-	// Normalize to forward slashes
-	return strings.ReplaceAll(relPath, "\\", "/"), nil
-}
+	// Use forward slashes for consistency
+	relPath = filepath.ToSlash(relPath)
+	getRelativePathLogger.Debug("Relative path: %q", relPath)
+	return relPath, nil
+}