Trim regex to work with yaml pipe

Fuck windows and its path fuck windows

.vscode/launch.json

@@ -32,28 +32,6 @@
 				"cookassistant.yml",
 			]
 		},
-		{
-			"name": "Launch Package (Quasimorph cookfile)",
-			"type": "go",
-			"request": "launch",
-			"mode": "auto",
-			"program": "${workspaceFolder}",
-			"cwd": "C:/Users/Administrator/Seafile/Games-Quasimorph",
-			"args": [
-				"cook.yml",
-			]
-		},
-		{
-			"name": "Launch Package (Rimworld cookfile)",
-			"type": "go",
-			"request": "launch",
-			"mode": "auto",
-			"program": "${workspaceFolder}",
-			"cwd": "C:/Users/Administrator/Seafile/Games-Rimworld/294100",
-			"args": [
-				"cookVehicles.yml",
-			]
-		},
 		{
 			"name": "Launch Package (Workspace)",
 			"type": "go",
@@ -61,7 +39,10 @@
 			"mode": "auto",
 			"program": "${workspaceFolder}",
 			"args": [
-				"tester.yml",
+				"-loglevel",
+				"trace",
+				"-cook",
+				"cookscoop.yml",
 			]
 		}
 	]

cmd/log_format_test/main.go

@@ -1,9 +1,8 @@
 package main
 
 import (
+	"modify/logger"
 	"time"
-
-	logger "git.site.quack-lab.dev/dave/cylogger"
 )
 
 func main() {

glob_test.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"cook/utils"
+	"modify/utils"
 	"os"
 	"path/filepath"
 	"testing"

go.mod

@@ -1,9 +1,8 @@
-module cook
+module modify
 
-go 1.24.2
+go 1.24.1
 
 require (
-	git.site.quack-lab.dev/dave/cylogger v1.1.1
 	github.com/bmatcuk/doublestar/v4 v4.8.1
 	github.com/stretchr/testify v1.10.0
 	github.com/yuin/gopher-lua v1.1.1

go.sum

@@ -1,7 +1,5 @@
 dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
 dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
-git.site.quack-lab.dev/dave/cylogger v1.1.1 h1:LQZaigVKUo07hGbS/ZTKiR+l7j4Z2eNf13zsljednNU=
-git.site.quack-lab.dev/dave/cylogger v1.1.1/go.mod h1:VS9MI4Y/cwjCBZgel7dSfCQlwtAgHmfvixOoBgBhtKg=
 github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
 github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
 github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=

logger/logger.go

@@ -0,0 +1,465 @@
+package logger
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+// LogLevel defines the severity of log messages
+type LogLevel int
+
+const (
+	// LevelError is for critical errors that should always be displayed
+	LevelError LogLevel = iota
+	// LevelWarning is for important warnings
+	LevelWarning
+	// LevelInfo is for informational messages
+	LevelInfo
+	// LevelDebug is for detailed debugging information
+	LevelDebug
+	// LevelTrace is for very detailed tracing information
+	LevelTrace
+	// LevelLua is specifically for output from Lua scripts
+	LevelLua
+)
+
+var levelNames = map[LogLevel]string{
+	LevelError:   "ERROR",
+	LevelWarning: "WARNING",
+	LevelInfo:    "INFO",
+	LevelDebug:   "DEBUG",
+	LevelTrace:   "TRACE",
+	LevelLua:     "LUA",
+}
+
+var levelColors = map[LogLevel]string{
+	LevelError:   "\033[1;31m", // Bold Red
+	LevelWarning: "\033[1;33m", // Bold Yellow
+	LevelInfo:    "\033[1;32m", // Bold Green
+	LevelDebug:   "\033[1;36m", // Bold Cyan
+	LevelTrace:   "\033[1;35m", // Bold Magenta
+	LevelLua:     "\033[1;34m", // Bold Blue
+}
+
+// ResetColor is the ANSI code to reset text color
+const ResetColor = "\033[0m"
+
+// Logger is our custom logger with level support
+type Logger struct {
+	mu            sync.Mutex
+	out           io.Writer
+	currentLevel  LogLevel
+	prefix        string
+	flag          int
+	useColors     bool
+	callerOffset  int
+	defaultFields map[string]interface{}
+	showGoroutine bool
+}
+
+var (
+	// DefaultLogger is the global logger instance
+	DefaultLogger *Logger
+	// defaultLogLevel is the default log level if not specified
+	defaultLogLevel = LevelInfo
+	// Global mutex for DefaultLogger initialization
+	initMutex sync.Mutex
+)
+
+// ParseLevel converts a string log level to LogLevel
+func ParseLevel(levelStr string) LogLevel {
+	switch strings.ToUpper(levelStr) {
+	case "ERROR":
+		return LevelError
+	case "WARNING", "WARN":
+		return LevelWarning
+	case "INFO":
+		return LevelInfo
+	case "DEBUG":
+		return LevelDebug
+	case "TRACE":
+		return LevelTrace
+	case "LUA":
+		return LevelLua
+	default:
+		return defaultLogLevel
+	}
+}
+
+// String returns the string representation of the log level
+func (l LogLevel) String() string {
+	if name, ok := levelNames[l]; ok {
+		return name
+	}
+	return fmt.Sprintf("Level(%d)", l)
+}
+
+// New creates a new Logger instance
+func New(out io.Writer, prefix string, flag int) *Logger {
+	return &Logger{
+		out:           out,
+		currentLevel:  defaultLogLevel,
+		prefix:        prefix,
+		flag:          flag,
+		useColors:     true,
+		callerOffset:  0,
+		defaultFields: make(map[string]interface{}),
+		showGoroutine: true,
+	}
+}
+
+// Init initializes the DefaultLogger
+func Init(level LogLevel) {
+	initMutex.Lock()
+	defer initMutex.Unlock()
+
+	if DefaultLogger == nil {
+		DefaultLogger = New(os.Stdout, "", log.Lmicroseconds|log.Lshortfile)
+	}
+	DefaultLogger.SetLevel(level)
+}
+
+// SetLevel sets the current log level
+func (l *Logger) SetLevel(level LogLevel) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.currentLevel = level
+}
+
+// GetLevel returns the current log level
+func (l *Logger) GetLevel() LogLevel {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.currentLevel
+}
+
+// SetCallerOffset sets the caller offset for correct file and line reporting
+func (l *Logger) SetCallerOffset(offset int) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.callerOffset = offset
+}
+
+// SetShowGoroutine sets whether to include goroutine ID in log messages
+func (l *Logger) SetShowGoroutine(show bool) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.showGoroutine = show
+}
+
+// ShowGoroutine returns whether goroutine ID is included in log messages
+func (l *Logger) ShowGoroutine() bool {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.showGoroutine
+}
+
+// WithField adds a field to the logger's context
+func (l *Logger) WithField(key string, value interface{}) *Logger {
+	newLogger := &Logger{
+		out:           l.out,
+		currentLevel:  l.currentLevel,
+		prefix:        l.prefix,
+		flag:          l.flag,
+		useColors:     l.useColors,
+		callerOffset:  l.callerOffset,
+		defaultFields: make(map[string]interface{}),
+		showGoroutine: l.showGoroutine,
+	}
+
+	// Copy existing fields
+	for k, v := range l.defaultFields {
+		newLogger.defaultFields[k] = v
+	}
+
+	// Add new field
+	newLogger.defaultFields[key] = value
+	return newLogger
+}
+
+// WithFields adds multiple fields to the logger's context
+func (l *Logger) WithFields(fields map[string]interface{}) *Logger {
+	newLogger := &Logger{
+		out:           l.out,
+		currentLevel:  l.currentLevel,
+		prefix:        l.prefix,
+		flag:          l.flag,
+		useColors:     l.useColors,
+		callerOffset:  l.callerOffset,
+		defaultFields: make(map[string]interface{}),
+		showGoroutine: l.showGoroutine,
+	}
+
+	// Copy existing fields
+	for k, v := range l.defaultFields {
+		newLogger.defaultFields[k] = v
+	}
+
+	// Add new fields
+	for k, v := range fields {
+		newLogger.defaultFields[k] = v
+	}
+	return newLogger
+}
+
+// GetGoroutineID extracts the goroutine ID from the runtime stack
+func GetGoroutineID() string {
+	buf := make([]byte, 64)
+	n := runtime.Stack(buf, false)
+	// Format of first line is "goroutine N [state]:"
+	// We only need the N part
+	buf = buf[:n]
+	idField := bytes.Fields(bytes.Split(buf, []byte{':'})[0])[1]
+	return string(idField)
+}
+
+// formatMessage formats a log message with level, time, file, and line information
+func (l *Logger) formatMessage(level LogLevel, format string, args ...interface{}) string {
+	var msg string
+	if len(args) > 0 {
+		msg = fmt.Sprintf(format, args...)
+	} else {
+		msg = format
+	}
+
+	// Format default fields if any
+	var fields string
+	if len(l.defaultFields) > 0 {
+		var pairs []string
+		for k, v := range l.defaultFields {
+			pairs = append(pairs, fmt.Sprintf("%s=%v", k, v))
+		}
+		fields = " " + strings.Join(pairs, " ")
+	}
+
+	var levelColor, resetColor string
+	if l.useColors {
+		levelColor = levelColors[level]
+		resetColor = ResetColor
+	}
+
+	var caller string
+	if l.flag&log.Lshortfile != 0 || l.flag&log.Llongfile != 0 {
+		// Find the actual caller by scanning up the stack
+		// until we find a function outside the logger package
+		var file string
+		var line int
+		var ok bool
+
+		// Start at a reasonable depth and scan up to 10 frames
+		for depth := 4; depth < 15; depth++ {
+			_, file, line, ok = runtime.Caller(depth)
+			if !ok {
+				break
+			}
+
+			// If the caller is not in the logger package, we found our caller
+			if !strings.Contains(file, "logger/logger.go") {
+				break
+			}
+		}
+
+		if !ok {
+			file = "???"
+			line = 0
+		}
+
+		if l.flag&log.Lshortfile != 0 {
+			file = filepath.Base(file)
+		}
+		caller = fmt.Sprintf("%-25s ", file+":"+strconv.Itoa(line))
+	}
+
+	// Format the timestamp with fixed width
+	var timeStr string
+	if l.flag&(log.Ldate|log.Ltime|log.Lmicroseconds) != 0 {
+		t := time.Now()
+		if l.flag&log.Ldate != 0 {
+			timeStr += fmt.Sprintf("%04d/%02d/%02d ", t.Year(), t.Month(), t.Day())
+		}
+		if l.flag&(log.Ltime|log.Lmicroseconds) != 0 {
+			timeStr += fmt.Sprintf("%02d:%02d:%02d", t.Hour(), t.Minute(), t.Second())
+			if l.flag&log.Lmicroseconds != 0 {
+				timeStr += fmt.Sprintf(".%06d", t.Nanosecond()/1000)
+			}
+		}
+		timeStr = fmt.Sprintf("%-15s ", timeStr)
+	}
+
+	// Add goroutine ID if enabled, with fixed width
+	var goroutineStr string
+	if l.showGoroutine {
+		goroutineID := GetGoroutineID()
+		goroutineStr = fmt.Sprintf("[g:%-4s] ", goroutineID)
+	}
+
+	// Create a colored level indicator with both brackets colored
+	levelStr := fmt.Sprintf("%s[%s]%s", levelColor, levelNames[level], levelColor)
+	// Add a space after the level and before the reset color
+	levelColumn := fmt.Sprintf("%s %s", levelStr, resetColor)
+
+	return fmt.Sprintf("%s%s%s%s%s%s%s\n",
+		l.prefix, timeStr, caller, goroutineStr, levelColumn, msg, fields)
+}
+
+// log logs a message at the specified level
+func (l *Logger) log(level LogLevel, format string, args ...interface{}) {
+	// Always show LUA level logs regardless of the current log level
+	if level != LevelLua && level > l.currentLevel {
+		return
+	}
+
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	msg := l.formatMessage(level, format, args...)
+	fmt.Fprint(l.out, msg)
+}
+
+// Error logs an error message
+func (l *Logger) Error(format string, args ...interface{}) {
+	l.log(LevelError, format, args...)
+}
+
+// Warning logs a warning message
+func (l *Logger) Warning(format string, args ...interface{}) {
+	l.log(LevelWarning, format, args...)
+}
+
+// Info logs an informational message
+func (l *Logger) Info(format string, args ...interface{}) {
+	l.log(LevelInfo, format, args...)
+}
+
+// Debug logs a debug message
+func (l *Logger) Debug(format string, args ...interface{}) {
+	l.log(LevelDebug, format, args...)
+}
+
+// Trace logs a trace message
+func (l *Logger) Trace(format string, args ...interface{}) {
+	l.log(LevelTrace, format, args...)
+}
+
+// Lua logs a Lua message
+func (l *Logger) Lua(format string, args ...interface{}) {
+	l.log(LevelLua, format, args...)
+}
+
+// Global log functions that use DefaultLogger
+
+// Error logs an error message using the default logger
+func Error(format string, args ...interface{}) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	DefaultLogger.Error(format, args...)
+}
+
+// Warning logs a warning message using the default logger
+func Warning(format string, args ...interface{}) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	DefaultLogger.Warning(format, args...)
+}
+
+// Info logs an informational message using the default logger
+func Info(format string, args ...interface{}) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	DefaultLogger.Info(format, args...)
+}
+
+// Debug logs a debug message using the default logger
+func Debug(format string, args ...interface{}) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	DefaultLogger.Debug(format, args...)
+}
+
+// Trace logs a trace message using the default logger
+func Trace(format string, args ...interface{}) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	DefaultLogger.Trace(format, args...)
+}
+
+// Lua logs a Lua message using the default logger
+func Lua(format string, args ...interface{}) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	DefaultLogger.Lua(format, args...)
+}
+
+// LogPanic logs a panic error and its stack trace
+func LogPanic(r interface{}) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	stack := make([]byte, 4096)
+	n := runtime.Stack(stack, false)
+	DefaultLogger.Error("PANIC: %v\n%s", r, stack[:n])
+}
+
+// SetLevel sets the log level for the default logger
+func SetLevel(level LogLevel) {
+	if DefaultLogger == nil {
+		Init(level)
+		return
+	}
+	DefaultLogger.SetLevel(level)
+}
+
+// GetLevel gets the log level for the default logger
+func GetLevel() LogLevel {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	return DefaultLogger.GetLevel()
+}
+
+// WithField returns a new logger with the field added to the default logger's context
+func WithField(key string, value interface{}) *Logger {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	return DefaultLogger.WithField(key, value)
+}
+
+// WithFields returns a new logger with the fields added to the default logger's context
+func WithFields(fields map[string]interface{}) *Logger {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	return DefaultLogger.WithFields(fields)
+}
+
+// SetShowGoroutine enables or disables goroutine ID display in the default logger
+func SetShowGoroutine(show bool) {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	DefaultLogger.SetShowGoroutine(show)
+}
+
+// ShowGoroutine returns whether goroutine ID is included in default logger's messages
+func ShowGoroutine() bool {
+	if DefaultLogger == nil {
+		Init(defaultLogLevel)
+	}
+	return DefaultLogger.ShowGoroutine()
+}

logger/panic_handler.go

@@ -0,0 +1,49 @@
+package logger
+
+import (
+	"fmt"
+	"runtime/debug"
+)
+
+// PanicHandler handles a panic and logs it
+func PanicHandler() {
+	if r := recover(); r != nil {
+		goroutineID := GetGoroutineID()
+		stackTrace := debug.Stack()
+		Error("PANIC in goroutine %s: %v\n%s", goroutineID, r, stackTrace)
+	}
+}
+
+// SafeGo launches a goroutine with panic recovery
+// Usage: logger.SafeGo(func() { ... your code ... })
+func SafeGo(f func()) {
+	go func() {
+		defer PanicHandler()
+		f()
+	}()
+}
+
+// SafeGoWithArgs launches a goroutine with panic recovery and passes arguments
+// Usage: logger.SafeGoWithArgs(func(arg1, arg2 interface{}) { ... }, "value1", 42)
+func SafeGoWithArgs(f func(...interface{}), args ...interface{}) {
+	go func() {
+		defer PanicHandler()
+		f(args...)
+	}()
+}
+
+// SafeExec executes a function with panic recovery
+// Useful for code that should not panic
+func SafeExec(f func()) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			goroutineID := GetGoroutineID()
+			stackTrace := debug.Stack()
+			Error("PANIC in goroutine %s: %v\n%s", goroutineID, r, stackTrace)
+			err = fmt.Errorf("panic recovered: %v", r)
+		}
+	}()
+
+	f()
+	return nil
+}

main.go

@@ -8,12 +8,12 @@ import (
 	"sync"
 	"time"
 
-	"cook/processor"
-	"cook/utils"
+	"modify/processor"
+	"modify/utils"
 
 	"github.com/go-git/go-git/v5"
 
-	logger "git.site.quack-lab.dev/dave/cylogger"
+	"modify/logger"
 )
 
 type GlobalStats struct {
@@ -259,7 +259,7 @@ func RunOtherCommands(file string, fileDataStr string, association utils.FileCom
 	modifications := []utils.ReplaceCommand{}
 	for _, command := range association.Commands {
 		// Use command-specific logger if available, otherwise fall back to default logger
-		cmdLogger := logger.Default
+		cmdLogger := logger.DefaultLogger
 		if cmdLog, ok := commandLoggers[command.Name]; ok {
 			cmdLogger = cmdLog
 		}

processor/processor.go

@@ -2,12 +2,11 @@ package processor
 
 import (
 	"fmt"
-	"io"
-	"net/http"
 	"strings"
 
-	logger "git.site.quack-lab.dev/dave/cylogger"
 	lua "github.com/yuin/gopher-lua"
+
+	"modify/logger"
 )
 
 // Maybe we make this an interface again for the shits and giggles
@@ -250,7 +249,6 @@ modified = false
 
 	logger.Debug("Setting up Lua print function to Go")
 	L.SetGlobal("print", L.NewFunction(printToGo))
-	L.SetGlobal("fetch", L.NewFunction(fetch))
 	return nil
 }
 
@@ -326,90 +324,3 @@ func printToGo(L *lua.LState) int {
 	logger.Lua("%s", message)
 	return 0
 }
-
-func fetch(L *lua.LState) int {
-	// Get URL from first argument
-	url := L.ToString(1)
-	if url == "" {
-		L.Push(lua.LNil)
-		L.Push(lua.LString("URL is required"))
-		return 2
-	}
-
-	// Get options from second argument if provided
-	var method string = "GET"
-	var headers map[string]string = make(map[string]string)
-	var body string = ""
-
-	if L.GetTop() > 1 {
-		options := L.ToTable(2)
-		if options != nil {
-			// Get method
-			if methodVal := options.RawGetString("method"); methodVal != lua.LNil {
-				method = methodVal.String()
-			}
-
-			// Get headers
-			if headersVal := options.RawGetString("headers"); headersVal != lua.LNil {
-				if headersTable, ok := headersVal.(*lua.LTable); ok {
-					headersTable.ForEach(func(key lua.LValue, value lua.LValue) {
-						headers[key.String()] = value.String()
-					})
-				}
-			}
-
-			// Get body
-			if bodyVal := options.RawGetString("body"); bodyVal != lua.LNil {
-				body = bodyVal.String()
-			}
-		}
-	}
-
-	// Create HTTP request
-	req, err := http.NewRequest(method, url, strings.NewReader(body))
-	if err != nil {
-		L.Push(lua.LNil)
-		L.Push(lua.LString(fmt.Sprintf("Error creating request: %v", err)))
-		return 2
-	}
-
-	// Set headers
-	for key, value := range headers {
-		req.Header.Set(key, value)
-	}
-
-	// Make request
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		L.Push(lua.LNil)
-		L.Push(lua.LString(fmt.Sprintf("Error making request: %v", err)))
-		return 2
-	}
-	defer resp.Body.Close()
-
-	// Read response body
-	bodyBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		L.Push(lua.LNil)
-		L.Push(lua.LString(fmt.Sprintf("Error reading response: %v", err)))
-		return 2
-	}
-
-	// Create response table
-	responseTable := L.NewTable()
-	responseTable.RawSetString("status", lua.LNumber(resp.StatusCode))
-	responseTable.RawSetString("statusText", lua.LString(resp.Status))
-	responseTable.RawSetString("ok", lua.LBool(resp.StatusCode >= 200 && resp.StatusCode < 300))
-	responseTable.RawSetString("body", lua.LString(string(bodyBytes)))
-
-	// Set headers in response
-	headersTable := L.NewTable()
-	for key, values := range resp.Header {
-		headersTable.RawSetString(key, lua.LString(values[0]))
-	}
-	responseTable.RawSetString("headers", headersTable)
-
-	L.Push(responseTable)
-	return 1
-}

processor/regex.go

@@ -1,15 +1,16 @@
 package processor
 
 import (
-	"cook/utils"
 	"fmt"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
-	logger "git.site.quack-lab.dev/dave/cylogger"
 	lua "github.com/yuin/gopher-lua"
+
+	"modify/logger"
+	"modify/utils"
 )
 
 type CaptureGroup struct {

processor/regex_test.go

@@ -2,8 +2,8 @@ package processor
 
 import (
 	"bytes"
-	"cook/utils"
 	"io"
+	"modify/utils"
 	"os"
 	"regexp"
 	"strings"

processor/test_helper.go

@@ -2,9 +2,8 @@ package processor
 
 import (
 	"io"
+	"modify/logger"
 	"os"
-
-	logger "git.site.quack-lab.dev/dave/cylogger"
 )
 
 func init() {
@@ -21,7 +20,7 @@ func init() {
 		if disableTestLogs {
 			// Create a new logger that writes to nowhere
 			silentLogger := logger.New(io.Discard, "", 0)
-			logger.Default = silentLogger
+			logger.DefaultLogger = silentLogger
 		}
 	}
 }

regression/regression_test.go

@@ -1,8 +1,8 @@
 package regression
 
 import (
-	"cook/processor"
-	"cook/utils"
+	"modify/processor"
+	"modify/utils"
 	"os"
 	"path/filepath"
 	"testing"

utils/file.go

@@ -1,24 +0,0 @@
-package utils
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func CleanPath(path string) string {
-	path = filepath.Clean(path)
-	path = strings.ReplaceAll(path, "\\", "/")
-	return path
-}
-
-func ToAbs(path string) string {
-	if filepath.IsAbs(path) {
-		return CleanPath(path)
-	}
-	cwd, err := os.Getwd()
-	if err != nil {
-		return CleanPath(path)
-	}
-	return CleanPath(filepath.Join(cwd, path))
-}

utils/flags.go

@@ -10,6 +10,7 @@ var (
 	// Deprecated
 	ResetFlag     = flag.Bool("reset", false, "Reset files to their original state")
 	LogLevel      = flag.String("loglevel", "INFO", "Set log level: ERROR, WARNING, INFO, DEBUG, TRACE")
+	Cookfile      = flag.String("cook", "**/cook.yml", "Path to cook config files, can be globbed")
 	ParallelFiles = flag.Int("P", 100, "Number of files to process in parallel")
 	Filter        = flag.String("filter", "", "Filter commands before running them")
 )

utils/git.go

@@ -2,13 +2,13 @@ package utils
 
 import (
 	"fmt"
+	"modify/logger"
 	"os"
 	"path/filepath"
 	"time"
 
-	logger "git.site.quack-lab.dev/dave/cylogger"
-	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/go-git/go-git/v5"
 )
 
 var (
@@ -94,4 +94,4 @@ func CleanupGitFiles(files []string) error {
 		}
 	}
 	return nil
-}
+}

utils/modifycommand.go

@@ -2,11 +2,11 @@ package utils
 
 import (
 	"fmt"
+	"modify/logger"
 	"os"
 	"path/filepath"
 	"strings"
 
-	logger "git.site.quack-lab.dev/dave/cylogger"
 	"github.com/bmatcuk/doublestar/v4"
 	"gopkg.in/yaml.v3"
 )
@@ -57,24 +57,6 @@ func Matches(path string, glob string) (bool, error) {
 	return matches, nil
 }
 
-func SplitPattern(pattern string) (string, string) {
-	static, pattern := doublestar.SplitPattern(pattern)
-
-	cwd, err := os.Getwd()
-	if err != nil {
-		return "", ""
-	}
-	if static == "" {
-		static = cwd
-	}
-	if !filepath.IsAbs(static) {
-		static = filepath.Join(cwd, static)
-		static = filepath.Clean(static)
-	}
-	static = strings.ReplaceAll(static, "\\", "/")
-	return static, pattern
-}
-
 type FileCommandAssociation struct {
 	File            string
 	IsolateCommands []ModifyCommand
@@ -93,9 +75,14 @@ func AssociateFilesWithCommands(files []string, commands []ModifyCommand) (map[s
 		}
 		for _, command := range commands {
 			for _, glob := range command.Files {
-				static, pattern := SplitPattern(glob)
+				_, pattern, err := FigureOutGlobRoot(glob)
+				if err != nil {
+					logger.Trace("Failed to figure out glob root for %s: %v", glob, err)
+					continue
+				}
+				file = filepath.Clean(file)
 				file = strings.ReplaceAll(file, "\\", "/")
-				file = strings.Replace(file, static+`/`, "", 1)
+
 				matches, err := Matches(file, pattern)
 				if err != nil {
 					logger.Trace("Failed to match glob %s with file %s: %v", glob, file, err)
@@ -132,7 +119,7 @@ func AggregateGlobs(commands []ModifyCommand) map[string]struct{} {
 	globs := make(map[string]struct{})
 	for _, command := range commands {
 		for _, glob := range command.Files {
-			glob = strings.Replace(glob, "~", os.Getenv("HOME"), 1)
+			glob = strings.ReplaceAll(glob, "~", os.Getenv("USERPROFILE"))
 			glob = strings.ReplaceAll(glob, "\\", "/")
 			globs[glob] = struct{}{}
 		}
@@ -141,23 +128,87 @@ func AggregateGlobs(commands []ModifyCommand) map[string]struct{} {
 	return globs
 }
 
+func FigureOutGlobRoot(inputPattern string) (root, pattern string, err error) {
+	logger.Debug("Starting to figure out glob root for input pattern: %s", inputPattern)
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		logger.Error("Failed to get current working directory: %v", err)
+		return "", inputPattern, fmt.Errorf("failed to get current working directory: %w", err)
+	}
+	logger.Trace("Current working directory: %s", cwd)
+
+	root = inputPattern
+	if !filepath.IsAbs(inputPattern) {
+		root = filepath.Join(cwd, inputPattern)
+		logger.Info("Input pattern is not absolute. Using combined path: %s", root)
+	}
+	root = filepath.Clean(root)
+	logger.Debug("Cleaned root path: %s", root)
+
+	// In either case (whatever our root may be), we have to figure out
+	// Where to start, what our FS will be
+	// The best place would be the last sure entry
+	// That is to say the final directory that is not a wildcard
+
+	finalroot := ""
+	// TODO: This will probably explode on linux because oooooooooo we have to be clever oooooooooo / on linux \\ on windows ooooooooooo
+	parts := strings.Split(root, "\\")
+	lastIndex := len(parts) - 1
+	logger.Debug("Split root into parts: %v", parts)
+
+	// In the case our pattern ends with a file (and many of them do)
+	// Look for only the folders, we cannot mount a file as a FS
+	// In any case we have to match files so they have to be the last part
+	for i := 0; i < len(parts)-1; i++ {
+		part := parts[i]
+		logger.Trace("Processing part: %s", part)
+		if part == "*" || part == "**" || part == "?" || part == "[" {
+			lastIndex = i
+			logger.Debug("Found wildcard part: %s, updating lastIndex to: %d", part, lastIndex)
+			break
+		}
+		// We can't use join here because it joins C: and Users as C:Users
+		// Instead of C:/Users/
+		// God damn it
+		if finalroot != "" {
+			finalroot = finalroot + "/" + part
+		} else {
+			finalroot = finalroot + part
+		}
+	}
+	finalroot = filepath.Clean(finalroot)
+	logger.Debug("Final root after processing: %s", finalroot)
+
+	// After all this juggling our pattern is whatever is left after the finalroot
+	// Which is, in "worst" case, only a file
+	pattern = strings.Join(parts[lastIndex:], "/")
+	logger.Info("Determined pattern: %s", pattern)
+
+	return finalroot, pattern, nil
+}
+
 func ExpandGLobs(patterns map[string]struct{}) ([]string, error) {
 	var files []string
 	filesMap := make(map[string]bool)
 
-	cwd, err := os.Getwd()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current working directory: %w", err)
-	}
-
-	logger.Debug("Expanding patterns from directory: %s", cwd)
 	for pattern := range patterns {
+		root, pattern, err := FigureOutGlobRoot(pattern)
+		if err != nil {
+			return nil, fmt.Errorf("failed to figure out glob root: %w", err)
+		}
+
 		logger.Trace("Processing pattern: %s", pattern)
-		static, pattern := SplitPattern(pattern)
-		matches, _ := doublestar.Glob(os.DirFS(static), pattern)
+		matches, err := doublestar.Glob(os.DirFS(root), pattern)
+		if err != nil {
+			return nil, fmt.Errorf("failed to glob pattern %s: %w", pattern, err)
+		}
 		logger.Debug("Found %d matches for pattern %s", len(matches), pattern)
 		for _, m := range matches {
-			m = filepath.Join(static, m)
+			m = filepath.Join(root, m)
+			m = filepath.Clean(m)
+			m = strings.ReplaceAll(m, "\\", "/")
+
 			info, err := os.Stat(m)
 			if err != nil {
 				logger.Warning("Error getting file info for %s: %v", m, err)
@@ -179,35 +230,69 @@ func ExpandGLobs(patterns map[string]struct{}) ([]string, error) {
 func LoadCommands(args []string) ([]ModifyCommand, error) {
 	commands := []ModifyCommand{}
 
-	logger.Info("Loading commands from cook files: %s", args)
-	for _, arg := range args {
-		newcommands, err := LoadCommandsFromCookFiles(arg)
-		if err != nil {
-			return nil, fmt.Errorf("failed to load commands from cook files: %w", err)
-		}
-		logger.Info("Successfully loaded %d commands from cook iles", len(newcommands))
-		commands = append(commands, newcommands...)
-		logger.Info("Now total commands: %d", len(commands))
+	logger.Info("Loading commands from cook files: %s", *Cookfile)
+	newcommands, err := LoadCommandsFromCookFiles(*Cookfile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load commands from cook files: %w", err)
 	}
+	logger.Info("Successfully loaded %d commands from cook files", len(newcommands))
+	commands = append(commands, newcommands...)
+	logger.Info("Now total commands: %d", len(commands))
+
+	logger.Info("Loading commands from arguments: %v", args)
+	newcommands, err = LoadCommandFromArgs(args)
+	if err != nil {
+		if len(commands) == 0 {
+			return nil, fmt.Errorf("failed to load commands from args: %w", err)
+		}
+		logger.Warning("Failed to load commands from args: %v", err)
+	}
+	logger.Info("Successfully loaded %d commands from args", len(newcommands))
+	commands = append(commands, newcommands...)
+	logger.Info("Now total commands: %d", len(commands))
 
-	logger.Info("Loaded %d commands from all cook f", len(commands))
 	return commands, nil
 }
 
-func LoadCommandsFromCookFiles(pattern string) ([]ModifyCommand, error) {
-	static, pattern := SplitPattern(pattern)
+func LoadCommandFromArgs(args []string) ([]ModifyCommand, error) {
+	// Cannot reset without git, right?
+	if *ResetFlag {
+		*GitFlag = true
+	}
+
+	if len(args) < 3 {
+		return nil, fmt.Errorf("at least %d arguments are required", 3)
+	}
+
+	command := ModifyCommand{
+		Regex:    args[0],
+		Lua:      args[1],
+		Files:    args[2:],
+		Git:      *GitFlag,
+		Reset:    *ResetFlag,
+		LogLevel: *LogLevel,
+	}
+
+	if err := command.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid command: %w", err)
+	}
+
+	return []ModifyCommand{command}, nil
+}
+
+func LoadCommandsFromCookFiles(s string) ([]ModifyCommand, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get current working directory: %w", err)
+	}
+
 	commands := []ModifyCommand{}
-	cookFiles, err := doublestar.Glob(os.DirFS(static), pattern)
+	cookFiles, err := doublestar.Glob(os.DirFS(cwd), *Cookfile)
 	if err != nil {
 		return nil, fmt.Errorf("failed to glob cook files: %w", err)
 	}
 
 	for _, cookFile := range cookFiles {
-		cookFile = filepath.Join(static, cookFile)
-		cookFile = filepath.Clean(cookFile)
-		cookFile = strings.ReplaceAll(cookFile, "\\", "/")
-		logger.Info("Loading commands from cook file: %s", cookFile)
-
 		cookFileData, err := os.ReadFile(cookFile)
 		if err != nil {
 			return nil, fmt.Errorf("failed to read cook file: %w", err)

utils/modifycommand_test.go

@@ -3,6 +3,7 @@ package utils
 import (
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -269,6 +270,128 @@ func TestAggregateGlobs(t *testing.T) {
 	}
 }
 
+func TestLoadCommandFromArgs(t *testing.T) {
+	// Save original flags
+	origGitFlag := *GitFlag
+	origResetFlag := *ResetFlag
+	origLogLevel := *LogLevel
+
+	// Restore original flags after test
+	defer func() {
+		*GitFlag = origGitFlag
+		*ResetFlag = origResetFlag
+		*LogLevel = origLogLevel
+	}()
+
+	// Test cases
+	tests := []struct {
+		name        string
+		args        []string
+		gitFlag     bool
+		resetFlag   bool
+		logLevel    string
+		shouldError bool
+	}{
+		{
+			name:        "Valid command",
+			args:        []string{"pattern", "expr", "file1", "file2"},
+			gitFlag:     false,
+			resetFlag:   false,
+			logLevel:    "INFO",
+			shouldError: false,
+		},
+		{
+			name:        "Not enough args",
+			args:        []string{"pattern", "expr"},
+			gitFlag:     false,
+			resetFlag:   false,
+			logLevel:    "INFO",
+			shouldError: true,
+		},
+		{
+			name:        "With git flag",
+			args:        []string{"pattern", "expr", "file1"},
+			gitFlag:     true,
+			resetFlag:   false,
+			logLevel:    "INFO",
+			shouldError: false,
+		},
+		{
+			name:        "With reset flag (forces git flag)",
+			args:        []string{"pattern", "expr", "file1"},
+			gitFlag:     false,
+			resetFlag:   true,
+			logLevel:    "INFO",
+			shouldError: false,
+		},
+		{
+			name:        "With custom log level",
+			args:        []string{"pattern", "expr", "file1"},
+			gitFlag:     false,
+			resetFlag:   false,
+			logLevel:    "DEBUG",
+			shouldError: false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// Set flags for this test case
+			*GitFlag = tc.gitFlag
+			*ResetFlag = tc.resetFlag
+			*LogLevel = tc.logLevel
+
+			commands, err := LoadCommandFromArgs(tc.args)
+
+			if tc.shouldError {
+				if err == nil {
+					t.Errorf("Expected an error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+
+			if len(commands) != 1 {
+				t.Errorf("Expected 1 command, got %d", len(commands))
+				return
+			}
+
+			cmd := commands[0]
+
+			// Check command properties
+			if cmd.Regex != tc.args[0] {
+				t.Errorf("Expected pattern %q, got %q", tc.args[0], cmd.Regex)
+			}
+
+			if cmd.Lua != tc.args[1] {
+				t.Errorf("Expected LuaExpr %q, got %q", tc.args[1], cmd.Lua)
+			}
+
+			if len(cmd.Files) != len(tc.args)-2 {
+				t.Errorf("Expected %d files, got %d", len(tc.args)-2, len(cmd.Files))
+			}
+
+			// When reset is true, git should be true regardless of what was set
+			expectedGit := tc.gitFlag || tc.resetFlag
+			if cmd.Git != expectedGit {
+				t.Errorf("Expected Git flag %v, got %v", expectedGit, cmd.Git)
+			}
+
+			if cmd.Reset != tc.resetFlag {
+				t.Errorf("Expected Reset flag %v, got %v", tc.resetFlag, cmd.Reset)
+			}
+
+			if cmd.LogLevel != tc.logLevel {
+				t.Errorf("Expected LogLevel %q, got %q", tc.logLevel, cmd.LogLevel)
+			}
+		})
+	}
+}
+
 // Successfully unmarshal valid YAML data into ModifyCommand slice
 func TestLoadCommandsFromCookFileSuccess(t *testing.T) {
 	// Arrange
@@ -434,6 +557,155 @@ func TestLoadCommandsFromCookFileLegitExample(t *testing.T) {
 	assert.Equal(t, "crewlayabout", commands[0].Name)
 }
 
+// Valid command with minimum 3 arguments returns a ModifyCommand slice with correct values
+func TestLoadCommandFromArgsWithValidArguments(t *testing.T) {
+	// Setup
+	oldGitFlag := GitFlag
+	oldResetFlag := ResetFlag
+	oldLogLevel := LogLevel
+
+	gitValue := true
+	resetValue := false
+	logLevelValue := "info"
+
+	GitFlag = &gitValue
+	ResetFlag = &resetValue
+	LogLevel = &logLevelValue
+
+	defer func() {
+		GitFlag = oldGitFlag
+		ResetFlag = oldResetFlag
+		LogLevel = oldLogLevel
+	}()
+
+	args := []string{"*.go", "return x", "file1.go", "file2.go"}
+
+	// Execute
+	commands, err := LoadCommandFromArgs(args)
+
+	// Assert
+	assert.NoError(t, err)
+	assert.Len(t, commands, 1)
+	assert.Equal(t, "*.go", commands[0].Regex)
+	assert.Equal(t, "return x", commands[0].Lua)
+	assert.Equal(t, []string{"file1.go", "file2.go"}, commands[0].Files)
+	assert.Equal(t, true, commands[0].Git)
+	assert.Equal(t, false, commands[0].Reset)
+	assert.Equal(t, "info", commands[0].LogLevel)
+}
+
+// Less than 3 arguments returns an error with appropriate message
+func TestLoadCommandFromArgsWithInsufficientArguments(t *testing.T) {
+	// Setup
+	oldGitFlag := GitFlag
+	oldResetFlag := ResetFlag
+	oldLogLevel := LogLevel
+
+	gitValue := false
+	resetValue := false
+	logLevelValue := "info"
+
+	GitFlag = &gitValue
+	ResetFlag = &resetValue
+	LogLevel = &logLevelValue
+
+	defer func() {
+		GitFlag = oldGitFlag
+		ResetFlag = oldResetFlag
+		LogLevel = oldLogLevel
+	}()
+
+	testCases := []struct {
+		name string
+		args []string
+	}{
+		{"empty args", []string{}},
+		{"one arg", []string{"*.go"}},
+		{"two args", []string{"*.go", "return x"}},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Execute
+			commands, err := LoadCommandFromArgs(tc.args)
+
+			// Assert
+			assert.Error(t, err)
+			assert.Nil(t, commands)
+			assert.Contains(t, err.Error(), "at least 3 arguments are required")
+		})
+	}
+}
+
+// Pattern, Lua, and Files fields are correctly populated from args
+func TestLoadCommandFromArgsPopulatesFieldsCorrectly(t *testing.T) {
+	// Setup
+	oldGitFlag := GitFlag
+	oldResetFlag := ResetFlag
+	oldLogLevel := LogLevel
+
+	gitValue := false
+	resetValue := false
+	logLevelValue := "debug"
+
+	GitFlag = &gitValue
+	ResetFlag = &resetValue
+	LogLevel = &logLevelValue
+
+	defer func() {
+		GitFlag = oldGitFlag
+		ResetFlag = oldResetFlag
+		LogLevel = oldLogLevel
+	}()
+
+	args := []string{"*.txt", "print('Hello')", "file1.txt", "file2.txt"}
+
+	// Execute
+	commands, err := LoadCommandFromArgs(args)
+
+	// Assert
+	assert.NoError(t, err)
+	assert.Len(t, commands, 1)
+	assert.Equal(t, "*.txt", commands[0].Regex)
+	assert.Equal(t, "print('Hello')", commands[0].Lua)
+	assert.Equal(t, []string{"file1.txt", "file2.txt"}, commands[0].Files)
+	assert.Equal(t, false, commands[0].Git)
+	assert.Equal(t, false, commands[0].Reset)
+	assert.Equal(t, "debug", commands[0].LogLevel)
+}
+
+// Git flag is set to true when ResetFlag is true
+func TestLoadCommandFromArgsSetsGitFlagWhenResetFlagIsTrue(t *testing.T) {
+	// Setup
+	oldGitFlag := GitFlag
+	oldResetFlag := ResetFlag
+	oldLogLevel := LogLevel
+
+	gitValue := false
+	resetValue := true
+	logLevelValue := "info"
+
+	GitFlag = &gitValue
+	ResetFlag = &resetValue
+	LogLevel = &logLevelValue
+
+	defer func() {
+		GitFlag = oldGitFlag
+		ResetFlag = oldResetFlag
+		LogLevel = oldLogLevel
+	}()
+
+	args := []string{"*.go", "return x", "file1.go", "file2.go"}
+
+	// Execute
+	commands, err := LoadCommandFromArgs(args)
+
+	// Assert
+	assert.NoError(t, err)
+	assert.Len(t, commands, 1)
+	assert.Equal(t, true, commands[0].Git)
+}
+
 // TODO: Figure out how to mock shit
 // Can't be asked doing that right now...
 // Successfully loads commands from multiple YAML files in the current directory
@@ -998,3 +1270,164 @@ func TestLoadCommandsFromCookFilesNoYamlFiles(t *testing.T) {
 // 		t.Errorf("Expected 0 commands, got: %d", len(commands))
 // 	}
 // }
+
+// Absolute path without wildcards returns correct root and pattern
+func TestFigureOutGlobRootWithAbsolutePathNoWildcards(t *testing.T) {
+	// Setup
+	absPath := filepath.Join("C:\\Users", "test", "documents", "file.txt")
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(absPath)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(filepath.Join("C:\\Users", "test", "documents"))
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "file.txt", pattern)
+}
+
+// Empty input pattern handling - we expect our "Patter", such as it is, to be a folder
+func TestFigureOutGlobRootWithEmptyPattern(t *testing.T) {
+	// Setup
+	emptyPattern := ""
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(emptyPattern)
+
+	// Assert
+	assert.NoError(t, err)
+	cwd, _ := os.Getwd()
+	cwdParts := strings.Split(filepath.Clean(cwd), "\\")
+	expectedRoot := strings.Join(cwdParts[:len(cwdParts)-1], "\\")
+	expectedPattern := cwdParts[len(cwdParts)-1]
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, expectedPattern, pattern)
+}
+
+// Relative path is correctly joined with current working directory
+func TestFigureOutGlobRootWithRelativePath(t *testing.T) {
+	// Setup
+	cwd, err := os.Getwd()
+	assert.NoError(t, err)
+	relPath := "test/documents/file.txt"
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(relPath)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(filepath.Join(cwd, "test/documents"))
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "file.txt", pattern)
+}
+
+// Path with wildcards correctly identifies the last non-wildcard directory as root
+func TestFigureOutGlobRootWithWildcards(t *testing.T) {
+	// Setup
+	inputPattern := filepath.Join("C:\\Users", "test", "documents", "*", "file.txt")
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(inputPattern)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(filepath.Join("C:\\Users", "test", "documents"))
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "*/file.txt", pattern)
+}
+
+// Windows-style paths are properly handled and converted
+func TestFigureOutGlobRootWithRelativePathAndWildcards(t *testing.T) {
+	// Setup
+	inputPattern := "documents\\*\\file?.txt"
+	cwd, _ := os.Getwd()
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(inputPattern)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(filepath.Join(cwd, "documents"))
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "*/file?.txt", pattern)
+}
+
+// Path with only wildcards (e.g., "*" or "**")
+func TestFigureOutGlobRootWithOnlyWildcards(t *testing.T) {
+	// Setup
+	wildcardPattern := "*"
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(wildcardPattern)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot, _ := os.Getwd()
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "*", pattern)
+}
+
+// Multiple path segments are correctly processed and joined
+func TestFigureOutGlobRootWithRelativePathAndWildcards2(t *testing.T) {
+	// Setup
+	cwd, err := os.Getwd()
+	assert.NoError(t, err)
+	relPath := filepath.Join("test", "data", "*", "file?.txt")
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(relPath)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(filepath.Join(cwd, "test", "data"))
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "*/file?.txt", pattern)
+}
+
+// Path with mixed forward and backward slashes
+func TestFigureOutGlobRootWithMixedSlashes(t *testing.T) {
+	// Setup
+	mixedPath := "C:\\Users/test\\documents\\file.txt"
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(mixedPath)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(filepath.Join("C:\\Users", "test", "documents"))
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "file.txt", pattern)
+}
+
+// Path with wildcards in the first segment
+func TestFigureOutGlobRootWithWildcardInFirstSegment(t *testing.T) {
+	// Setup
+	inputPattern := "*\\Users\\test\\documents\\file.txt"
+	cwd, _ := os.Getwd()
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(inputPattern)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(cwd)
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "*/Users/test/documents/file.txt", pattern)
+}
+
+// Handling of relative paths with ".." or "." components
+func TestFigureOutGlobRootWithRelativePathAndDotComponents(t *testing.T) {
+	// Setup
+	cwd, err := os.Getwd()
+	assert.NoError(t, err)
+	relPath := filepath.Join("..", ".", "test", "documents", "file.txt")
+
+	// Execute
+	root, pattern, err := FigureOutGlobRoot(relPath)
+
+	// Assert
+	assert.NoError(t, err)
+	expectedRoot := filepath.Clean(filepath.Join(cwd, "..", "test", "documents"))
+	assert.Equal(t, expectedRoot, root)
+	assert.Equal(t, "file.txt", pattern)
+}

utils/replacecommand.go

@@ -2,9 +2,8 @@ package utils
 
 import (
 	"fmt"
+	"modify/logger"
 	"sort"
-
-	logger "git.site.quack-lab.dev/dave/cylogger"
 )
 
 type ReplaceCommand struct {