Add a simple trim to lua

It was fucked because we were removing the static path and then cramming
that into assications

.gitignore

@@ -1,2 +1,3 @@
 *.exe
 .qodo
+*.sqlite

.vscode/launch.json

@@ -18,6 +18,19 @@
 				"*.yml",
 			]
 		},
+		{
+			"name": "Launch Package (Payday 2)",
+			"type": "go",
+			"request": "launch",
+			"mode": "auto",
+			"program": "${workspaceFolder}",
+			"cwd": "C:/Users/Administrator/Seafile/Games-Payday2",
+			"args": [
+				"-loglevel",
+				"trace",
+				"*.yml",
+			]
+		},
 		{
 			"name": "Launch Package (Barotrauma cookfile)",
 			"type": "go",

glob_test.go

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

go.mod

@@ -3,7 +3,7 @@ module cook
 go 1.24.2
 
 require (
-	git.site.quack-lab.dev/dave/cylogger v1.1.1
+	git.site.quack-lab.dev/dave/cylogger v1.2.2
 	github.com/bmatcuk/doublestar/v4 v4.8.1
 	github.com/stretchr/testify v1.10.0
 	github.com/yuin/gopher-lua v1.1.1
@@ -21,7 +21,10 @@ require (
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/go-git/go-billy/v5 v5.6.2 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/kevinburke/ssh_config v1.2.0 // indirect
+	github.com/mattn/go-sqlite3 v1.14.22 // indirect
 	github.com/pjbgf/sha1cd v0.3.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
@@ -29,11 +32,15 @@ require (
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	golang.org/x/crypto v0.35.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
+	gorm.io/gorm v1.30.0 // indirect
 )
 
 require (
+	git.site.quack-lab.dev/dave/cyutils v1.0.0
 	github.com/go-git/go-git/v5 v5.14.0
 	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
 	golang.org/x/net v0.35.0 // indirect
+	gorm.io/driver/sqlite v1.6.0
 )

go.sum

@@ -1,7 +1,9 @@
 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.2.2 h1:4xUXASEBlG9NiGxh7f57xHh9imW4unHzakIEpQoKC5E=
-git.site.quack-lab.dev/dave/cylogger v1.1.1/go.mod h1:VS9MI4Y/cwjCBZgel7dSfCQlwtAgHmfvixOoBgBhtKg=
+git.site.quack-lab.dev/dave/cylogger v1.2.2/go.mod h1:VS9MI4Y/cwjCBZgel7dSfCQlwtAgHmfvixOoBgBhtKg=
+git.site.quack-lab.dev/dave/cyutils v1.0.0 h1:yp/jkM2M7UZ+UIQuy+vPI7yDvTUdpbEdFL8h0lzUTvA=
+git.site.quack-lab.dev/dave/cyutils v1.0.0/go.mod h1:luGNFimplFhkpRLebhkVTNjG2wYfPAs+pu+UIMhBYbE=
 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=
@@ -40,6 +42,10 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
 github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -49,6 +55,8 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
+github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k=
 github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY=
 github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4=
@@ -106,3 +114,7 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/driver/sqlite v1.6.0 h1:WHRRrIiulaPiPFmDcod6prc4l2VGVWHz80KspNsxSfQ=
+gorm.io/driver/sqlite v1.6.0/go.mod h1:AO9V1qIQddBESngQUKWL9yoH93HIeA1X6V633rBwyT8=
+gorm.io/gorm v1.30.0 h1:qbT5aPv1UH8gI99OsRlvDToLxW5zR7FzS9acZDOZcgs=
+gorm.io/gorm v1.30.0/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=

main.go

@@ -11,7 +11,7 @@ import (
 	"cook/processor"
 	"cook/utils"
 
-	"github.com/go-git/go-git/v5"
+	"gopkg.in/yaml.v3"
 
 	logger "git.site.quack-lab.dev/dave/cylogger"
 )
@@ -25,9 +25,7 @@ type GlobalStats struct {
 }
 
 var (
-	repo     *git.Repository
+	stats GlobalStats = GlobalStats{
-	worktree *git.Worktree
-	stats    GlobalStats = GlobalStats{
 		ModificationsPerCommand: sync.Map{},
 	}
 )
@@ -36,8 +34,6 @@ func main() {
 	flag.Usage = func() {
 		fmt.Fprintf(os.Stderr, "Usage: %s [options] <pattern> <lua_expression> <...files_or_globs>\n", os.Args[0])
 		fmt.Fprintf(os.Stderr, "\nOptions:\n")
-		fmt.Fprintf(os.Stderr, "  -git\n")
-		fmt.Fprintf(os.Stderr, "        Use git to manage files\n")
 		fmt.Fprintf(os.Stderr, "  -reset\n")
 		fmt.Fprintf(os.Stderr, "        Reset files to their original state\n")
 		fmt.Fprintf(os.Stderr, "  -loglevel string\n")
@@ -57,15 +53,30 @@ func main() {
 	flag.Parse()
 	args := flag.Args()
 
-	level := logger.ParseLevel(*utils.LogLevel)
+	logger.InitFlag()
-	logger.Init(level)
+	logger.Info("Initializing with log level: %s", logger.GetLevel().String())
-	logger.Info("Initializing with log level: %s", level.String())
+
+	db, err := utils.GetDB()
+	if err != nil {
+		logger.Error("Failed to get database: %v", err)
+		return
+	}
+
+	workdone, err := HandleSpecialArgs(args, err, db)
+	if err != nil {
+		logger.Error("Failed to handle special args: %v", err)
+		return
+	}
+	if workdone {
+		return
+	}
 
 	// The plan is:
 	// Load all commands
 	commands, err := utils.LoadCommands(args)
-	if err != nil {
+	if err != nil || len(commands) == 0 {
 		logger.Error("Failed to load commands: %v", err)
+		CreateExampleConfig()
 		flag.Usage()
 		return
 	}
@@ -85,7 +96,6 @@ func main() {
 		logger.Trace("Regex: %s", command.Regex)
 		logger.Trace("Files: %v", command.Files)
 		logger.Trace("Lua: %s", command.Lua)
-		logger.Trace("Git: %t", command.Git)
 		logger.Trace("Reset: %t", command.Reset)
 		logger.Trace("Isolate: %t", command.Isolate)
 		logger.Trace("LogLevel: %s", command.LogLevel)
@@ -110,6 +120,12 @@ func main() {
 		return
 	}
 
+	err = utils.ResetWhereNecessary(associations, db)
+	if err != nil {
+		logger.Error("Failed to reset files where necessary: %v", err)
+		return
+	}
+
 	// Then for each file run all commands associated with the file
 	workers := make(chan struct{}, *utils.ParallelFiles)
 	wg := sync.WaitGroup{}
@@ -142,19 +158,16 @@ func main() {
 		logger.Debug("Created logger for command %q with log level %s", cmdName, cmdLogLevel.String())
 	}
 
-	// This aggregation is great but what if one modification replaces the whole entire file?
-	// Shit......
-	// TODO: Add "Isolate" field to modifications which makes them run alone
 	for file, association := range associations {
 		workers <- struct{}{}
 		wg.Add(1)
 		logger.SafeGoWithArgs(func(args ...interface{}) {
 			defer func() { <-workers }()
 			defer wg.Done()
-
 			// Track per-file processing time
 			fileStartTime := time.Now()
 
+			logger.Debug("Reading file %q", file)
 			fileData, err := os.ReadFile(file)
 			if err != nil {
 				logger.Error("Failed to read file %q: %v", file, err)
@@ -162,18 +175,28 @@ func main() {
 			}
 			fileDataStr := string(fileData)
 
+			logger.Debug("Saving file %q to database", file)
+			err = db.SaveFile(file, fileData)
+			if err != nil {
+				logger.Error("Failed to save file %q to database: %v", file, err)
+				return
+			}
+
+			logger.Debug("Running isolate commands for file %q", file)
 			fileDataStr, err = RunIsolateCommands(association, file, fileDataStr, &fileMutex)
 			if err != nil {
 				logger.Error("Failed to run isolate commands for file %q: %v", file, err)
 				return
 			}
 
+			logger.Debug("Running other commands for file %q", file)
 			fileDataStr, err = RunOtherCommands(file, fileDataStr, association, &fileMutex, commandLoggers)
 			if err != nil {
 				logger.Error("Failed to run other commands for file %q: %v", file, err)
 				return
 			}
 
+			logger.Debug("Writing file %q", file)
 			err = os.WriteFile(file, []byte(fileDataStr), 0644)
 			if err != nil {
 				logger.Error("Failed to write file %q: %v", file, err)
@@ -254,6 +277,70 @@ func main() {
 	}
 }
 
+func HandleSpecialArgs(args []string, err error, db utils.DB) (bool, error) {
+	switch args[0] {
+	case "reset":
+		err = utils.ResetAllFiles(db)
+		if err != nil {
+			logger.Error("Failed to reset all files: %v", err)
+			return true, err
+		}
+		logger.Info("All files reset")
+		return true, nil
+	case "dump":
+		err = db.RemoveAllFiles()
+		if err != nil {
+			logger.Error("Failed to remove all files from database: %v", err)
+			return true, err
+		}
+		logger.Info("All files removed from database")
+		return true, nil
+	}
+	return false, nil
+}
+
+func CreateExampleConfig() {
+	commands := []utils.ModifyCommand{
+		{
+			Name:     "DoubleNumericValues",
+			Regex:    "<value>(\\d+)</value>",
+			Lua:      "v1 * 2",
+			Files:    []string{"data/*.xml"},
+			LogLevel: "INFO",
+		},
+		{
+			Name:     "UpdatePrices",
+			Regex:    "price=\"(\\d+)\"",
+			Lua:      "if num(v1) < 100 then return v1 * 1.5 else return v1 end",
+			Files:    []string{"items/*.xml", "shop/*.xml"},
+			LogLevel: "DEBUG",
+		},
+		{
+			Name:     "IsolatedTagUpdate",
+			Regex:    "<tag>(.*?)</tag>",
+			Lua:      "string.upper(s1)",
+			Files:    []string{"config.xml"},
+			Isolate:  true,
+			NoDedup:  true,
+			LogLevel: "TRACE",
+		},
+	}
+
+	data, err := yaml.Marshal(commands)
+	if err != nil {
+		logger.Error("Failed to marshal example config: %v", err)
+		return
+	}
+
+	err = os.WriteFile("example_cook.yml", data, 0644)
+	if err != nil {
+		logger.Error("Failed to write example_cook.yml: %v", err)
+		return
+	}
+
+	logger.Info("Wrote example_cook.yml")
+}
+
 func RunOtherCommands(file string, fileDataStr string, association utils.FileCommandAssociation, fileMutex *sync.Mutex, commandLoggers map[string]*logger.Logger) (string, error) {
 	// Aggregate all the modifications and execute them
 	modifications := []utils.ReplaceCommand{}

processor/processor.go

@@ -179,6 +179,7 @@ function ceil(x) return math.ceil(x) end
 function upper(s) return string.upper(s) end
 function lower(s) return string.lower(s) end
 function format(s, ...) return string.format(s, ...) end
+function trim(s) return string.gsub(s, "^%s*(.-)%s*$", "%1") end
 
 -- String split helper
 function strsplit(inputstr, sep)

utils/db.go

@@ -0,0 +1,120 @@
+package utils
+
+import (
+	"fmt"
+	"path/filepath"
+	"time"
+
+	"git.site.quack-lab.dev/dave/cylogger"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+type DB interface {
+	DB() *gorm.DB
+	Raw(sql string, args ...any) *gorm.DB
+	SaveFile(filePath string, fileData []byte) error
+	GetFile(filePath string) ([]byte, error)
+	GetAllFiles() ([]FileSnapshot, error)
+	RemoveAllFiles() error
+}
+
+type FileSnapshot struct {
+	Date     time.Time `gorm:"primaryKey"`
+	FilePath string    `gorm:"primaryKey"`
+	FileData []byte    `gorm:"type:blob"`
+}
+
+type DBWrapper struct {
+	db *gorm.DB
+}
+
+var db *DBWrapper
+
+func GetDB() (DB, error) {
+	var err error
+
+	dbFile := filepath.Join("data.sqlite")
+	db, err := gorm.Open(sqlite.Open(dbFile), &gorm.Config{
+		// SkipDefaultTransaction: true,
+		PrepareStmt: true,
+		// Logger:      gormlogger.Default.LogMode(gormlogger.Silent),
+	})
+	if err != nil {
+		return nil, err
+	}
+	db.AutoMigrate(&FileSnapshot{})
+
+	return &DBWrapper{db: db}, nil
+}
+
+// Just a wrapper
+func (db *DBWrapper) Raw(sql string, args ...any) *gorm.DB {
+	return db.db.Raw(sql, args...)
+}
+
+func (db *DBWrapper) DB() *gorm.DB {
+	return db.db
+}
+
+func (db *DBWrapper) FileExists(filePath string) (bool, error) {
+	var count int64
+	err := db.db.Model(&FileSnapshot{}).Where("file_path = ?", filePath).Count(&count).Error
+	return count > 0, err
+}
+
+func (db *DBWrapper) SaveFile(filePath string, fileData []byte) error {
+	log := cylogger.Default.WithPrefix(fmt.Sprintf("SaveFile: %q", filePath))
+	exists, err := db.FileExists(filePath)
+	if err != nil {
+		log.Error("Error checking if file exists: %v", err)
+		return err
+	}
+	log.Debug("File exists: %t", exists)
+	// Nothing to do, file already exists
+	if exists {
+		log.Debug("File already exists, skipping save")
+		return nil
+	}
+	log.Debug("Saving file to database")
+	return db.db.Create(&FileSnapshot{
+		Date:     time.Now(),
+		FilePath: filePath,
+		FileData: fileData,
+	}).Error
+}
+
+func (db *DBWrapper) GetFile(filePath string) ([]byte, error) {
+	log := cylogger.Default.WithPrefix(fmt.Sprintf("GetFile: %q", filePath))
+	log.Debug("Getting file from database")
+	var fileSnapshot FileSnapshot
+	err := db.db.Model(&FileSnapshot{}).Where("file_path = ?", filePath).First(&fileSnapshot).Error
+	if err != nil {
+		return nil, err
+	}
+	log.Debug("File found in database")
+	return fileSnapshot.FileData, nil
+}
+
+func (db *DBWrapper) GetAllFiles() ([]FileSnapshot, error) {
+	log := cylogger.Default.WithPrefix("GetAllFiles")
+	log.Debug("Getting all files from database")
+	var fileSnapshots []FileSnapshot
+	err := db.db.Model(&FileSnapshot{}).Find(&fileSnapshots).Error
+	if err != nil {
+		return nil, err
+	}
+	log.Debug("Found %d files in database", len(fileSnapshots))
+	return fileSnapshots, nil
+}
+
+func (db *DBWrapper) RemoveAllFiles() error {
+	log := cylogger.Default.WithPrefix("RemoveAllFiles")
+	log.Debug("Removing all files from database")
+	err := db.db.Exec("DELETE FROM file_snapshots").Error
+	if err != nil {
+		return err
+	}
+	log.Debug("All files removed from database")
+	return nil
+}

utils/file.go

@@ -1,24 +1,95 @@
 package utils
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
+
+	"git.site.quack-lab.dev/dave/cylogger"
 )
 
 func CleanPath(path string) string {
+	log := cylogger.Default.WithPrefix(fmt.Sprintf("CleanPath: %q", path))
+	log.Trace("Start")
 	path = filepath.Clean(path)
 	path = strings.ReplaceAll(path, "\\", "/")
+	log.Trace("Done: %q", path)
 	return path
 }
 
 func ToAbs(path string) string {
+	log := cylogger.Default.WithPrefix(fmt.Sprintf("ToAbs: %q", path))
+	log.Trace("Start")
 	if filepath.IsAbs(path) {
+		log.Trace("Path is already absolute: %q", path)
 		return CleanPath(path)
 	}
 	cwd, err := os.Getwd()
 	if err != nil {
+		log.Error("Error getting cwd: %v", err)
 		return CleanPath(path)
 	}
+	log.Trace("Cwd: %q", cwd)
 	return CleanPath(filepath.Join(cwd, path))
 }
+
+func ResetWhereNecessary(associations map[string]FileCommandAssociation, db DB) error {
+	log := cylogger.Default.WithPrefix("ResetWhereNecessary")
+	log.Debug("Start")
+	dirtyFiles := make(map[string]struct{})
+	for _, association := range associations {
+		for _, command := range association.Commands {
+			log.Debug("Checking command %q for file %q", command.Name, association.File)
+			if command.Reset {
+				log.Debug("Command %q requires reset for file %q", command.Name, association.File)
+				dirtyFiles[association.File] = struct{}{}
+			}
+		}
+		for _, command := range association.IsolateCommands {
+			log.Debug("Checking isolate command %q for file %q", command.Name, association.File)
+			if command.Reset {
+				log.Debug("Isolate command %q requires reset for file %q", command.Name, association.File)
+				dirtyFiles[association.File] = struct{}{}
+			}
+		}
+	}
+	log.Debug("Dirty files: %v", dirtyFiles)
+	for file := range dirtyFiles {
+		log.Debug("Resetting file %q", file)
+		fileData, err := db.GetFile(file)
+		if err != nil {
+			log.Warning("Failed to get file %q: %v", file, err)
+			continue
+		}
+		log.Debug("Writing file %q to disk", file)
+		err = os.WriteFile(file, fileData, 0644)
+		if err != nil {
+			log.Warning("Failed to write file %q: %v", file, err)
+			continue
+		}
+		log.Debug("File %q written to disk", file)
+	}
+	log.Debug("Done")
+	return nil
+}
+
+func ResetAllFiles(db DB) error {
+	log := cylogger.Default.WithPrefix("ResetAllFiles")
+	log.Debug("Start")
+	fileSnapshots, err := db.GetAllFiles()
+	if err != nil {
+		return err
+	}
+	log.Debug("Found %d files in database", len(fileSnapshots))
+	for _, fileSnapshot := range fileSnapshots {
+		log.Debug("Resetting file %q", fileSnapshot.FilePath)
+		err = os.WriteFile(fileSnapshot.FilePath, fileSnapshot.FileData, 0644)
+		if err != nil {
+			return err
+		}
+		log.Debug("File %q written to disk", fileSnapshot.FilePath)
+	}
+	log.Debug("Done")
+	return nil
+}

utils/flags.go

@@ -5,11 +5,6 @@ import (
 )
 
 var (
-	// Deprecated
-	GitFlag       = flag.Bool("git", false, "Use git to manage files")
-	// 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")
 	ParallelFiles = flag.Int("P", 100, "Number of files to process in parallel")
-	Filter        = flag.String("filter", "", "Filter commands before running them")
+	Filter        = flag.String("f", "", "Filter commands before running them")
 )

utils/git.go

@@ -1,97 +0,0 @@
-package utils
-
-import (
-	"fmt"
-	"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"
-)
-
-var (
-	Repo     *git.Repository
-	Worktree *git.Worktree
-)
-
-func SetupGit() error {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return fmt.Errorf("failed to get current working directory: %w", err)
-	}
-	logger.Debug("Current working directory obtained: %s", cwd)
-
-	logger.Debug("Attempting to open git repository at %s", cwd)
-	Repo, err = git.PlainOpen(cwd)
-	if err != nil {
-		logger.Debug("No existing git repository found at %s, attempting to initialize a new git repository.", cwd)
-		Repo, err = git.PlainInit(cwd, false)
-		if err != nil {
-			return fmt.Errorf("failed to initialize a new git repository at %s: %w", cwd, err)
-		}
-		logger.Info("Successfully initialized a new git repository at %s", cwd)
-	} else {
-		logger.Info("Successfully opened existing git repository at %s", cwd)
-	}
-
-	logger.Debug("Attempting to obtain worktree for repository at %s", cwd)
-	Worktree, err = Repo.Worktree()
-	if err != nil {
-		return fmt.Errorf("failed to obtain worktree for repository at %s: %w", cwd, err)
-	}
-	logger.Debug("Successfully obtained worktree for repository at %s", cwd)
-	return nil
-}
-
-func CleanupGitFiles(files []string) error {
-	for _, file := range files {
-		logger.Debug("Checking git status for file: %s", file)
-		status, err := Worktree.Status()
-		if err != nil {
-			logger.Error("Error getting worktree status: %v", err)
-			fmt.Fprintf(os.Stderr, "Error getting worktree status: %v\n", err)
-			return fmt.Errorf("error getting worktree status: %w", err)
-		}
-		if status.IsUntracked(file) {
-			logger.Info("Detected untracked file: %s. Adding to git index.", file)
-			_, err = Worktree.Add(file)
-			if err != nil {
-				logger.Error("Error adding file to git: %v", err)
-				fmt.Fprintf(os.Stderr, "Error adding file to git: %v\n", err)
-				return fmt.Errorf("error adding file to git: %w", err)
-			}
-
-			filename := filepath.Base(file)
-			logger.Info("File %s added successfully. Committing with message: 'Track %s'", filename, filename)
-			_, err = Worktree.Commit("Track "+filename, &git.CommitOptions{
-				Author: &object.Signature{
-					Name:  "Big Chef",
-					Email: "bigchef@bigchef.com",
-					When:  time.Now(),
-				},
-			})
-			if err != nil {
-				logger.Error("Error committing file: %v", err)
-				fmt.Fprintf(os.Stderr, "Error committing file: %v\n", err)
-				return fmt.Errorf("error committing file: %w", err)
-			}
-			logger.Info("Successfully committed file: %s", filename)
-		} else {
-			logger.Info("File %s is already tracked. Restoring it to the working tree.", file)
-			err := Worktree.Restore(&git.RestoreOptions{
-				Files:    []string{file},
-				Staged:   true,
-				Worktree: true,
-			})
-			if err != nil {
-				logger.Error("Error restoring file: %v", err)
-				fmt.Fprintf(os.Stderr, "Error restoring file: %v\n", err)
-				return fmt.Errorf("error restoring file: %w", err)
-			}
-			logger.Info("File %s restored successfully", file)
-		}
-	}
-	return nil
-}

utils/modifycommand.go

@@ -16,11 +16,11 @@ type ModifyCommand struct {
 	Regex    string   `yaml:"regex"`
 	Lua      string   `yaml:"lua"`
 	Files    []string `yaml:"files"`
-	Git      bool     `yaml:"git"`
 	Reset    bool     `yaml:"reset"`
 	LogLevel string   `yaml:"loglevel"`
 	Isolate  bool     `yaml:"isolate"`
 	NoDedup  bool     `yaml:"nodedup"`
+	Disabled bool     `yaml:"disable"`
 }
 type CookFile []ModifyCommand
 
@@ -86,6 +86,7 @@ func AssociateFilesWithCommands(files []string, commands []ModifyCommand) (map[s
 	fileCommands := make(map[string]FileCommandAssociation)
 
 	for _, file := range files {
+		file = strings.ReplaceAll(file, "\\", "/")
 		fileCommands[file] = FileCommandAssociation{
 			File:            file,
 			IsolateCommands: []ModifyCommand{},
@@ -94,9 +95,8 @@ func AssociateFilesWithCommands(files []string, commands []ModifyCommand) (map[s
 		for _, command := range commands {
 			for _, glob := range command.Files {
 				static, pattern := SplitPattern(glob)
-				file = strings.ReplaceAll(file, "\\", "/")
+				patternFile := strings.Replace(file, static+`/`, "", 1)
-				file = strings.Replace(file, static+`/`, "", 1)
+				matches, err := Matches(patternFile, pattern)
-				matches, err := Matches(file, pattern)
 				if err != nil {
 					logger.Trace("Failed to match glob %s with file %s: %v", glob, file, err)
 					continue
@@ -185,12 +185,18 @@ func LoadCommands(args []string) ([]ModifyCommand, error) {
 		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))
+		logger.Info("Successfully loaded %d commands from cook files", len(newcommands))
-		commands = append(commands, newcommands...)
+		for _, cmd := range newcommands {
+			if cmd.Disabled {
+				logger.Info("Skipping disabled command: %s", cmd.Name)
+				continue
+			}
+			commands = append(commands, cmd)
+		}
 		logger.Info("Now total commands: %d", len(commands))
 	}
 
-	logger.Info("Loaded %d commands from all cook f", len(commands))
+	logger.Info("Loaded %d commands from all cook file", len(commands))
 	return commands, nil
 }