Rework regex grouping to avoid changing the same area twice

Add replaceCommands to avoid index suicide
Add a regression test
2025-03-26 22:24:19 +01:00 · 2025-03-26 21:55:34 +01:00 · 2025-03-26 21:55:17 +01:00 · 2025-03-26 18:30:21 +01:00 · 2025-03-26 14:04:39 +01:00 · 2025-03-26 13:37:39 +01:00
22 changed files with 8719 additions and 1580 deletions
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -9,8 +9,13 @@
 			"type": "go",
 			"request": "launch",
 			"mode": "auto",
-			"program": "${fileDirname}",
-			"args": []
+			"program": "${workspaceFolder}",
+			"args": [
+				"-mode=json",
+				"$..name",
+				"v='pero'",
+				"test.json"
+			]
 		}
 	]
 }
--- a/README.md
+++ b/README.md
@@ -0,0 +1,116 @@
+# Big Chef
+
+A Go-based tool for modifying XML, JSON, and text documents using XPath/JSONPath/Regex expressions and Lua transformations.
+
+## Features
+
+- **Multi-Format Processing**:
+  - XML (XPath)
+  - JSON (JSONPath) 
+  - Text (Regex)
+- **Node Value Modification**: Update text values in XML elements, JSON properties or text matches
+- **Attribute Manipulation**: Modify XML attributes, JSON object keys or regex capture groups
+- **Conditional Logic**: Apply transformations based on document content
+- **Complex Operations**: 
+  - Mathematical calculations
+  - String manipulations
+  - Date conversions
+  - Structural changes
+  - Whole ass Lua environment
+- **Error Handling**: Comprehensive error detection for:
+  - Invalid XML/JSON
+  - Malformed XPath/JSONPath
+  - Lua syntax errors
+
+## Usage Examples
+
+### 1. Basic field modification
+```xml
+<!-- Input -->
+<price>44.95</price>
+
+<!-- Command -->
+chef -xml "//price" "v=v*2" input.xml
+
+<!-- Output -->
+<price>89.9</price>
+```
+
+### 2. Supports glob patterns
+```xml
+chef -xml "//price" "v=v*2" data/**.xml
+```
+
+### 3. Attribute Update
+```xml
+<!-- Input -->
+<item price="10.50"/>
+
+<!-- Command -->
+chef -xml "//item/@price" "v=v*2" input.xml
+
+<!-- Output --> 
+<item price="21"/>
+```
+
+### 3. JSONPath Transformation
+```json
+// Input
+{
+  "products": [
+    {"name": "Widget", "price": 19.99},
+    {"name": "Gadget", "price": 29.99}
+  ]
+}
+
+// Command
+chef -json "$.products[*].price" "v=v*0.75" input.json
+
+// Output
+{
+  "products": [
+    {"name": "Widget", "price": 14.99},
+    {"name": "Gadget", "price": 22.49}
+  ]
+}
+```
+
+### 4. Regex Text Replacement
+Regex works slightly differently, up to 12 match groups are provided as v1..v12 and s1..s12 for numbers and strings respectively.
+A special shorthand "!num" is also provided that simply expands to `(\d*\.?\d+)`.
+```xml
+<!-- Input -->
+<description>Price: $15.00 Special Offer</description>
+
+<!-- Command -->
+chef "Price: $!num Special Offer" "v1 = v1 * 0.92" input.xml
+
+<!-- Output -->
+<description>Price: $13.80 Special Offer</description>
+```
+
+### 5. Conditional Transformation
+```xml
+<!-- Input -->
+<item stock="5" price="10.00"/>
+
+<!-- Command -->
+chef -xml "//item" "if tonumber(v.stock) > 0 then v.price = v.price * 0.8 end" input.xml
+
+<!-- Output -->
+<item stock="5" price="8.00"/>
+```
+
+## Installation
+
+```bash
+go build -o chef main.go
+```
+
+```bash
+# Process XML file
+./chef -xml "//price" "v=v*1.2" input.xml
+
+# Process JSON file 
+./chef -json "$.prices[*]" "v=v*0.9" input.json
+```
--- a/go.mod
+++ b/go.mod
@@ -2,9 +2,38 @@ module modify

 go 1.24.1

-require github.com/Knetic/govaluate v3.0.0+incompatible
+require (
+	github.com/PaesslerAG/jsonpath v0.1.1
+	github.com/antchfx/xmlquery v1.4.4
+	github.com/bmatcuk/doublestar/v4 v4.8.1
+	github.com/yuin/gopher-lua v1.1.1
+)

 require (
-	github.com/bmatcuk/doublestar/v4 v4.8.1 // indirect
-	github.com/yuin/gopher-lua v1.1.1 // indirect
+	dario.cat/mergo v1.0.0 // indirect
+	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/ProtonMail/go-crypto v1.1.5 // indirect
+	github.com/cloudflare/circl v1.6.0 // indirect
+	github.com/cyphar/filepath-securejoin v0.4.1 // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
+	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/kevinburke/ssh_config v1.2.0 // indirect
+	github.com/pjbgf/sha1cd v0.3.2 // indirect
+	github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
+	github.com/skeema/knownhosts v1.3.1 // indirect
+	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
+	gopkg.in/warnings.v0 v0.1.2 // indirect
+)
+
+require (
+	github.com/PaesslerAG/gval v1.0.0 // indirect
+	github.com/antchfx/xpath v1.3.3 // indirect
+	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
+	golang.org/x/text v0.22.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,6 +1,177 @@
-github.com/Knetic/govaluate v3.0.0+incompatible h1:7o6+MAPhYTCF0+fdvoz1xDedhRb4f6s9Tn1Tt7/WTEg=
-github.com/Knetic/govaluate v3.0.0+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
+dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
+dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+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=
+github.com/PaesslerAG/gval v1.0.0 h1:GEKnRwkWDdf9dOmKcNrar9EA1bz1z9DqPIO1+iLzhd8=
+github.com/PaesslerAG/gval v1.0.0/go.mod h1:y/nm5yEyTeX6av0OfKJNp9rBNj2XrGhAf5+v24IBN1I=
+github.com/PaesslerAG/jsonpath v0.1.0/go.mod h1:4BzmtoM/PI8fPO4aQGIusjGxGir2BzcV0grWtFzq1Y8=
+github.com/PaesslerAG/jsonpath v0.1.1 h1:c1/AToHQMVsduPAa4Vh6xp2U0evy4t8SWp8imEsylIk=
+github.com/PaesslerAG/jsonpath v0.1.1/go.mod h1:lVboNxFGal/VwW6d9JzIy56bUsYAP6tH/x80vjnCseY=
+github.com/ProtonMail/go-crypto v1.1.5 h1:eoAQfK2dwL+tFSFpr7TbOaPNUbPiJj4fLYwwGE1FQO4=
+github.com/ProtonMail/go-crypto v1.1.5/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
+github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
+github.com/antchfx/xmlquery v1.4.4 h1:mxMEkdYP3pjKSftxss4nUHfjBhnMk4imGoR96FRY2dg=
+github.com/antchfx/xmlquery v1.4.4/go.mod h1:AEPEEPYE9GnA2mj5Ur2L5Q5/2PycJ0N9Fusrx9b12fc=
+github.com/antchfx/xpath v1.3.3 h1:tmuPQa1Uye0Ym1Zn65vxPgfltWb/Lxu2jeqIGteJSRs=
+github.com/antchfx/xpath v1.3.3/go.mod h1:i54GszH55fYfBmoZXapTHN8T8tkcHfRgLyVwwqzXNcs=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/bmatcuk/doublestar/v4 v4.8.1 h1:54Bopc5c2cAvhLRAzqOGCYHYyhcDHsFF4wWIR5wKP38=
 github.com/bmatcuk/doublestar/v4 v4.8.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
+github.com/cloudflare/circl v1.6.0 h1:cr5JKic4HI+LkINy2lg3W2jF8sHCVTBncJr5gIIq7qk=
+github.com/cloudflare/circl v1.6.0/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
+github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s=
+github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o=
+github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE=
+github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
+github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
+github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c=
+github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
+github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
+github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM=
+github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
+github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
+github.com/go-git/go-git/v5 v5.14.0 h1:/MD3lCrGjCen5WfEAzKg00MJJffKhC8gzS80ycmCi60=
+github.com/go-git/go-git/v5 v5.14.0/go.mod h1:Z5Xhoia5PcWA3NF8vRLURn9E5FRhSl7dGj9ItW3Wk5k=
+github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ=
+github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+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/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=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+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/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=
+github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8=
+github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4=
+github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8=
+github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
+github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
 github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.35.0 h1:b15kiHdrGCHrP6LvwaQ3c03kgNhhiMgvlhxHQhmg2Xs=
+golang.org/x/crypto v0.35.0/go.mod h1:dy7dXNW32cAb/6/PRuTNsix8T+vJAqvuIy5Bli/x0YQ=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
+golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+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=
--- a/main.go
+++ b/main.go
@@ -3,85 +3,83 @@ package main
 import (
 	"flag"
 	"fmt"
-	"io"
 	"log"
 	"os"
 	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
 	"sync"
+	"time"

 	"github.com/bmatcuk/doublestar/v4"
-	lua "github.com/yuin/gopher-lua"
+	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing/object"
+
+	"modify/processor"
 )

-var Error *log.Logger
-var Warning *log.Logger
-var Info *log.Logger
-var Success *log.Logger
-
-// ModificationRecord tracks a single value modification
-type ModificationRecord struct {
-	File      string
-	OldValue  string
-	NewValue  string
-	Operation string
-	Context   string
-}
-
-// GlobalStats tracks all modifications across files
 type GlobalStats struct {
 	TotalMatches       int
 	TotalModifications int
-	Modifications      []ModificationRecord
 	ProcessedFiles     int
 	FailedFiles        int
 }

 var stats GlobalStats
+var logger *log.Logger
+
+var (
+	jsonFlag  = flag.Bool("json", false, "Process JSON files")
+	xmlFlag   = flag.Bool("xml", false, "Process XML files")
+	gitFlag   = flag.Bool("git", false, "Use git to manage files")
+	resetFlag = flag.Bool("reset", false, "Reset files to their original state")
+	repo      *git.Repository
+	worktree  *git.Worktree
+)

 func init() {
-	// Configure standard logging to be hidden by default
 	log.SetFlags(log.Lmicroseconds | log.Lshortfile)
-	log.SetOutput(io.Discard) // Disable default logging to stdout
+	logger = log.New(os.Stdout, "", log.Lmicroseconds|log.Lshortfile)

-	// Set up custom loggers with different severity levels
-	Error = log.New(io.MultiWriter(os.Stderr, os.Stdout),
-		fmt.Sprintf("%sERROR:%s ", "\033[0;101m", "\033[0m"),
-		log.Lmicroseconds|log.Lshortfile)
-
-	Warning = log.New(os.Stdout,
-		fmt.Sprintf("%sWarning:%s ", "\033[0;93m", "\033[0m"),
-		log.Lmicroseconds|log.Lshortfile)
-
-	Info = log.New(os.Stdout,
-		fmt.Sprintf("%sInfo:%s ", "\033[0;94m", "\033[0m"),
-		log.Lmicroseconds|log.Lshortfile)
-
-	Success = log.New(os.Stdout,
-		fmt.Sprintf("%s✨ SUCCESS:%s ", "\033[0;92m", "\033[0m"),
-		log.Lmicroseconds|log.Lshortfile)
-
-	// Initialize global stats
-	stats = GlobalStats{
-		Modifications: make([]ModificationRecord, 0),
-	}
+	stats = GlobalStats{}
 }

 func main() {
-	// Define flags
+	// TODO: Implement some sort of git integration
+	// Maybe use go-git
+	// Specify a -git flag
+	// If we are operating with git then:
+	// Inmitialize a repo if one doesn't exist (try to open right?)
+	// For each file matched by glob first figure out if it's already tracked
+	// If not tracked then track it and commit (either it alone or maybe multiple together somehow)
+	// Then reset the file (to undo previous modifications)
+	// THEN change the file
+	// In addition add a -undo flag that will ONLY reset the files without changing them
+	// Only for the ones matched by glob
+	// ^ important because binary files would fuck us up
 	flag.Usage = func() {
-		fmt.Fprintf(os.Stderr, "Usage: %s <regex_with_capture_groups> <lua_expression> <...files_or_globs>\n", os.Args[0])
+		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, "  -json\n")
+		fmt.Fprintf(os.Stderr, "        Process JSON files\n")
+		fmt.Fprintf(os.Stderr, "  -xml\n")
+		fmt.Fprintf(os.Stderr, "        Process XML files\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, "  -mode string\n")
+		fmt.Fprintf(os.Stderr, "        Processing mode: regex, xml, json (default \"regex\")\n")
 		fmt.Fprintf(os.Stderr, "\nExamples:\n")
-		fmt.Fprintf(os.Stderr, "  %s \"<value>(\\d+)</value>\" \"*1.5\" data.xml\n", os.Args[0])
-		fmt.Fprintf(os.Stderr, "  %s \"<value>(\\d+)</value>\" \"*1.5\" \"*.xml\"\n", os.Args[0])
-		fmt.Fprintf(os.Stderr, "  %s \"<value>(\\d+)</value>,(\\d+)\" \"v1 * 1.5 * v2\" data.xml\n", os.Args[0])
-		fmt.Fprintf(os.Stderr, "  %s \"<value>(\\d+)</value>\" \"=0\" data.xml\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "  Regex mode (default):\n")
+		fmt.Fprintf(os.Stderr, "    %s \"<value>(\\d+)</value>\" \"*1.5\" data.xml\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "  XML mode:\n")
+		fmt.Fprintf(os.Stderr, "    %s -xml \"//value\" \"*1.5\" data.xml\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "  JSON mode:\n")
+		fmt.Fprintf(os.Stderr, "    %s -json \"$.items[*].value\" \"*1.5\" data.json\n", os.Args[0])
 		fmt.Fprintf(os.Stderr, "\nNote: v1, v2, etc. are used to refer to capture groups as numbers.\n")
 		fmt.Fprintf(os.Stderr, "      s1, s2, etc. are used to refer to capture groups as strings.\n")
 		fmt.Fprintf(os.Stderr, "      Helper functions: num(str) converts string to number, str(num) converts number to string\n")
 		fmt.Fprintf(os.Stderr, "      is_number(str) checks if a string is numeric\n")
+		fmt.Fprintf(os.Stderr, "      For XML and JSON, the captured values are exposed as 'v', which can be of any type we capture (string, number, table).\n")
 		fmt.Fprintf(os.Stderr, "      If expression starts with an operator like *, /, +, -, =, etc., v1 is automatically prepended\n")
 		fmt.Fprintf(os.Stderr, "      You can use any valid Lua code, including if statements, loops, etc.\n")
 		fmt.Fprintf(os.Stderr, "      Glob patterns are supported for file selection (*.xml, data/**.xml, etc.)\n")
@@ -89,440 +87,141 @@ func main() {

 	flag.Parse()
 	args := flag.Args()
+	if *resetFlag {
+		*gitFlag = true
+	}
+
 	if len(args) < 3 {
-		Error.Println("Insufficient arguments - need regex pattern, lua expression, and at least one file or glob pattern")
+		log.Printf("At least %d arguments are required", 3)
 		flag.Usage()
 		return
 	}

-	regexPattern := args[0]
-	luaExpr := args[1]
-	filePatterns := args[2:]
+	// Get the appropriate pattern and expression based on mode
+	var pattern, luaExpr string
+	var filePatterns []string
+
+	pattern = args[0]
+	luaExpr = args[1]
+	filePatterns = args[2:]
+
+	// Prepare the Lua expression
+	originalLuaExpr := luaExpr
+	luaExpr = processor.BuildLuaScript(luaExpr)
+	if originalLuaExpr != luaExpr {
+		logger.Printf("Transformed Lua expression from %q to %q", originalLuaExpr, luaExpr)
+	}
+
+	if *gitFlag {
+		err := setupGit()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error setting up git: %v\n", err)
+			return
+		}
+	}

 	// Expand file patterns with glob support
 	files, err := expandFilePatterns(filePatterns)
 	if err != nil {
-		Error.Printf("Error expanding file patterns: %v", err)
+		fmt.Fprintf(os.Stderr, "Error expanding file patterns: %v\n", err)
 		return
 	}

 	if len(files) == 0 {
-		Error.Println("No files found matching the specified patterns")
+		fmt.Fprintf(os.Stderr, "No files found matching the specified patterns\n")
 		return
 	}

-	Info.Printf("Starting modifier with pattern '%s', expression '%s' on %d files", regexPattern, luaExpr, len(files))
-
-	// Prepare the Lua expression
-	originalLuaExpr := luaExpr
-	luaExpr = buildLuaScript(luaExpr)
-	if originalLuaExpr != luaExpr {
-		Info.Printf("Transformed Lua expression from '%s' to '%s'", originalLuaExpr, luaExpr)
+	if *gitFlag {
+		err := cleanupGitFiles(files)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error cleaning up git files: %v\n", err)
+			return
+		}
 	}
-
-	// Handle special pattern modifications
-	originalPattern := regexPattern
-	patternModified := false
-
-	if strings.Contains(regexPattern, "!num") {
-		regexPattern = strings.ReplaceAll(regexPattern, "!num", "(-?\\d*\\.?\\d+)")
-		patternModified = true
-	}
-
-	// Make sure the regex can match across multiple lines by adding (?s) flag
-	if !strings.HasPrefix(regexPattern, "(?s)") {
-		regexPattern = "(?s)" + regexPattern
-		patternModified = true
-	}
-
-	if patternModified {
-		Info.Printf("Modified regex pattern from '%s' to '%s'", originalPattern, regexPattern)
-	}
-
-	// Compile the pattern for file processing
-	pattern, err := regexp.Compile(regexPattern)
-	if err != nil {
-		Error.Printf("Invalid regex pattern '%s': %v", regexPattern, err)
+	if *resetFlag {
+		log.Printf("Files reset to their original state, nothing more to do")
 		return
 	}

+	// Create the processor based on mode
+	var proc processor.Processor
+	switch {
+	case *xmlFlag:
+		proc = &processor.XMLProcessor{}
+		logger.Printf("Starting XML modifier with XPath %q, expression %q on %d files",
+			pattern, luaExpr, len(files))
+	case *jsonFlag:
+		proc = &processor.JSONProcessor{}
+		logger.Printf("Starting JSON modifier with JSONPath %q, expression %q on %d files",
+			pattern, luaExpr, len(files))
+	default:
+		proc = &processor.RegexProcessor{}
+		logger.Printf("Starting regex modifier with pattern %q, expression %q on %d files",
+			pattern, luaExpr, len(files))
+	}
+
 	var wg sync.WaitGroup
 	// Process each file
 	for _, file := range files {
 		wg.Add(1)
 		go func(file string) {
 			defer wg.Done()
-			Info.Printf("🔄 Processing file: %s", file)
-			err := processFile(file, pattern, luaExpr, originalLuaExpr)
+			logger.Printf("Processing file: %s", file)
+
+			// It's a bit fucked, maybe I could do better to call it from proc... But it'll do for now
+			modCount, matchCount, err := processor.Process(proc, file, pattern, luaExpr)
 			if err != nil {
-				Error.Printf("❌ Failed to process file %s: %v", file, err)
+				fmt.Fprintf(os.Stderr, "Failed to process file %s: %v\n", file, err)
 				stats.FailedFiles++
 			} else {
-				Info.Printf("✅ Successfully processed file: %s", file)
+				logger.Printf("Successfully processed file: %s", file)
 				stats.ProcessedFiles++
+				stats.TotalMatches += matchCount
+				stats.TotalModifications += modCount
 			}
 		}(file)
 	}
 	wg.Wait()

-	// Print summary of all modifications
-	printSummary(originalLuaExpr)
-}
-
-// printSummary outputs a formatted summary of all modifications made
-func printSummary(operation string) {
+	// Print summary
 	if stats.TotalModifications == 0 {
-		Warning.Printf("No modifications were made in any files")
-		return
+		fmt.Fprintf(os.Stderr, "No modifications were made in any files\n")
+	} else {
+		fmt.Printf("Operation complete! Modified %d values in %d/%d files\n",
+			stats.TotalModifications, stats.ProcessedFiles, stats.ProcessedFiles+stats.FailedFiles)
 	}
+}

-	Success.Printf("Operation complete! Modified %d values in %d/%d files using '%s'",
-		stats.TotalModifications, stats.ProcessedFiles, stats.ProcessedFiles+stats.FailedFiles, operation)
-
-	// Group modifications by file for better readability
-	fileGroups := make(map[string][]ModificationRecord)
-	for _, mod := range stats.Modifications {
-		fileGroups[mod.File] = append(fileGroups[mod.File], mod)
+func setupGit() error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return fmt.Errorf("failed to get current working directory: %w", err)
 	}
+	logger.Printf("Current working directory obtained: %s", cwd)

-	// Print modifications by file
-	for file, mods := range fileGroups {
-		Success.Printf("📄 %s: %d modifications", file, len(mods))
-
-		// Show some sample modifications (max 5 per file to avoid overwhelming output)
-		maxSamples := 5
-		if len(mods) > maxSamples {
-			for i := 0; i < maxSamples; i++ {
-				mod := mods[i]
-				Success.Printf("   %d. '%s' → '%s' %s",
-					i+1, limitString(mod.OldValue, 20), limitString(mod.NewValue, 20), mod.Context)
-			}
-			Success.Printf("   ... and %d more modifications", len(mods)-maxSamples)
-		} else {
-			for i, mod := range mods {
-				Success.Printf("   %d. '%s' → '%s' %s",
-					i+1, limitString(mod.OldValue, 20), limitString(mod.NewValue, 20), mod.Context)
-			}
+	logger.Printf("Attempting to open git repository at %s", cwd)
+	repo, err = git.PlainOpen(cwd)
+	if err != nil {
+		logger.Printf("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.Printf("Successfully initialized a new git repository at %s", cwd)
+	} else {
+		logger.Printf("Successfully opened existing git repository at %s", cwd)
 	}

-	// Print a nice visual indicator of success
-	if stats.TotalModifications > 0 {
-		Success.Printf("🎉 All done! Modified %d values successfully!", stats.TotalModifications)
-	}
-}
-
-// buildLuaScript creates a complete Lua script from the expression
-func buildLuaScript(luaExpr string) string {
-	// Track if we modified the expression
-	modified := false
-	original := luaExpr
-
-	// Auto-prepend v1 for expressions starting with operators
-	if strings.HasPrefix(luaExpr, "*") ||
-		strings.HasPrefix(luaExpr, "/") ||
-		strings.HasPrefix(luaExpr, "+") ||
-		strings.HasPrefix(luaExpr, "-") ||
-		strings.HasPrefix(luaExpr, "^") ||
-		strings.HasPrefix(luaExpr, "%") {
-		luaExpr = "v1 = v1" + luaExpr
-		modified = true
-	} else if strings.HasPrefix(luaExpr, "=") {
-		// Handle direct assignment with = operator
-		luaExpr = "v1 " + luaExpr
-		modified = true
-	}
-
-	// Add assignment if needed
-	if !strings.Contains(luaExpr, "=") {
-		luaExpr = "v1 = " + luaExpr
-		modified = true
-	}
-
-	// Replace shorthand v[] and s[] with their direct variable names
-	newExpr := strings.ReplaceAll(luaExpr, "v[1]", "v1")
-	newExpr = strings.ReplaceAll(newExpr, "v[2]", "v2")
-	newExpr = strings.ReplaceAll(newExpr, "s[1]", "s1")
-	newExpr = strings.ReplaceAll(newExpr, "s[2]", "s2")
-
-	if newExpr != luaExpr {
-		luaExpr = newExpr
-		modified = true
-	}
-
-	if modified {
-		Info.Printf("Transformed Lua expression: '%s' → '%s'", original, luaExpr)
-	}
-
-	return luaExpr
-}
-
-func processFile(filename string, pattern *regexp.Regexp, luaExpr string, originalExpr string) error {
-	fullPath := filepath.Join(".", filename)
-
-	// Read file content
-	content, err := os.ReadFile(fullPath)
+	logger.Printf("Attempting to obtain worktree for repository at %s", cwd)
+	worktree, err = repo.Worktree()
 	if err != nil {
-		Error.Printf("Cannot read file %s: %v", fullPath, err)
-		return fmt.Errorf("error reading file: %v", err)
+		return fmt.Errorf("failed to obtain worktree for repository at %s: %w", cwd, err)
 	}
-
-	fileContent := string(content)
-	Info.Printf("File %s loaded: %d bytes", fullPath, len(content))
-
-	// Process the content
-	result, modificationCount, matchCount, err := process(fileContent, pattern, luaExpr, filename, originalExpr)
-	if err != nil {
-		Error.Printf("Processing failed for %s: %v", fullPath, err)
-		return err
-	}
-
-	// Update global stats
-	stats.TotalMatches += matchCount
-	stats.TotalModifications += modificationCount
-
-	if modificationCount == 0 {
-		Warning.Printf("No modifications made to %s - pattern didn't match any content", fullPath)
-		return nil
-	}
-
-	// Write the modified content back
-	err = os.WriteFile(fullPath, []byte(result), 0644)
-	if err != nil {
-		Error.Printf("Failed to save changes to %s: %v", fullPath, err)
-		return fmt.Errorf("error writing file: %v", err)
-	}
-
-	Info.Printf("Made %d modifications to %s and saved (%d bytes)",
-		modificationCount, fullPath, len(result))
-
+	logger.Printf("Successfully obtained worktree for repository at %s", cwd)
 	return nil
 }

-func process(data string, pattern *regexp.Regexp, luaExpr string, filename string, originalExpr string) (string, int, int, error) {
-	L := lua.NewState()
-	defer L.Close()
-
-	// Initialize Lua environment
-	modificationCount := 0
-	matchCount := 0
-
-	// Load math library
-	L.Push(L.GetGlobal("require"))
-	L.Push(lua.LString("math"))
-	if err := L.PCall(1, 1, nil); err != nil {
-		Error.Printf("Failed to load Lua math library: %v", err)
-		return data, 0, 0, fmt.Errorf("error loading Lua math library: %v", err)
-	}
-
-	// Initialize helper functions
-	helperScript := `
-- Custom Lua helpers for math operations
-function min(a, b) return math.min(a, b) end
-function max(a, b) return math.max(a, b) end
-function round(x) return math.floor(x + 0.5) end
-function floor(x) return math.floor(x) end
-function ceil(x) return math.ceil(x) end
-
-- String to number conversion helper
-function num(str)
-    return tonumber(str) or 0
-end
-
-- Number to string conversion
-function str(num)
-    return tostring(num)
-end
-
-- Check if string is numeric
-function is_number(str)
-    return tonumber(str) ~= nil
-end
-`
-	if err := L.DoString(helperScript); err != nil {
-		Error.Printf("Failed to load Lua helper functions: %v", err)
-		return data, 0, 0, fmt.Errorf("error loading helper functions: %v", err)
-	}
-
-	// Process all regex matches
-	result := pattern.ReplaceAllStringFunc(data, func(match string) string {
-		matchCount++
-		captures := pattern.FindStringSubmatch(match)
-		if len(captures) <= 1 {
-			// No capture groups, return unchanged
-			Warning.Printf("Match found but no capture groups: %s", limitString(match, 50))
-			return match
-		}
-		Info.Printf("Match found: %s", limitString(match, 50))
-
-		// Set up global variables v1, v2, etc. for the Lua context
-		captureValues := make([]string, len(captures)-1)
-		for i, capture := range captures[1:] {
-			captureValues[i] = capture
-			// Set the raw string value with s prefix
-			L.SetGlobal(fmt.Sprintf("s%d", i+1), lua.LString(capture))
-
-			// Also set numeric version with v prefix if possible
-			floatVal, err := strconv.ParseFloat(capture, 64)
-			if err == nil {
-				L.SetGlobal(fmt.Sprintf("v%d", i+1), lua.LNumber(floatVal))
-			} else {
-				// For non-numeric values, set v also to the string value
-				L.SetGlobal(fmt.Sprintf("v%d", i+1), lua.LString(capture))
-			}
-		}
-
-		// Execute the user's Lua code
-		if err := L.DoString(luaExpr); err != nil {
-			Error.Printf("Lua execution failed for match '%s': %v", limitString(match, 50), err)
-			return match // Return unchanged on error
-		}
-
-		// Get the modified values after Lua execution
-		modifications := make(map[int]string)
-		for i := 0; i < len(captures)-1 && i < 12; i++ {
-			// Check both v and s variables to see if any were modified
-			vVarName := fmt.Sprintf("v%d", i+1)
-			sVarName := fmt.Sprintf("s%d", i+1)
-
-			// First check the v-prefixed numeric variable
-			vLuaVal := L.GetGlobal(vVarName)
-			sLuaVal := L.GetGlobal(sVarName)
-
-			oldVal := captures[i+1]
-			var newVal string
-			var useModification bool
-
-			// First priority: check if the string variable was modified
-			if sLuaVal != lua.LNil {
-				if sStr, ok := sLuaVal.(lua.LString); ok {
-					newStrVal := string(sStr)
-					if newStrVal != oldVal {
-						newVal = newStrVal
-						useModification = true
-					}
-				}
-			}
-
-			// Second priority: if string wasn't modified, check numeric variable
-			if !useModification && vLuaVal != lua.LNil {
-				switch v := vLuaVal.(type) {
-				case lua.LNumber:
-					newNumVal := strconv.FormatFloat(float64(v), 'f', -1, 64)
-					if newNumVal != oldVal {
-						newVal = newNumVal
-						useModification = true
-					}
-				case lua.LString:
-					newStrVal := string(v)
-					if newStrVal != oldVal {
-						newVal = newStrVal
-						useModification = true
-					}
-				default:
-					newDefaultVal := fmt.Sprintf("%v", v)
-					if newDefaultVal != oldVal {
-						newVal = newDefaultVal
-						useModification = true
-					}
-				}
-			}
-
-			// Record the modification if anything changed
-			if useModification {
-				modifications[i] = newVal
-			}
-		}
-
-		// Apply modifications to the matched text
-		if len(modifications) == 0 {
-			return match // No changes
-		}
-
-		result := match
-		for i, newVal := range modifications {
-			oldVal := captures[i+1]
-			// Special handling for empty capture groups
-			if oldVal == "" {
-				// Find the position where the empty capture group should be
-				// by analyzing the regex pattern and current match
-				parts := pattern.SubexpNames()
-				if i+1 < len(parts) && parts[i+1] != "" {
-					// Named capture groups
-					subPattern := fmt.Sprintf("(?P<%s>)", parts[i+1])
-					emptyGroupPattern := regexp.MustCompile(subPattern)
-					if loc := emptyGroupPattern.FindStringIndex(result); loc != nil {
-						// Insert the new value at the capture group location
-						result = result[:loc[0]] + newVal + result[loc[1]:]
-					}
-				} else {
-					// For unnamed capture groups, we need to find where they would be in the regex
-					// This is a simplification that might not work for complex regex patterns
-					// but should handle the test case with <value></value>
-					tagPattern := regexp.MustCompile("<value></value>")
-					if loc := tagPattern.FindStringIndex(result); loc != nil {
-						// Replace the empty tag content with our new value
-						result = result[:loc[0]+7] + newVal + result[loc[1]-8:]
-					}
-				}
-			} else {
-				// Normal replacement for non-empty capture groups
-				result = strings.Replace(result, oldVal, newVal, 1)
-			}
-
-			// Extract a bit of context from the match for better reporting
-			contextStart := max(0, strings.Index(match, oldVal)-10)
-			contextLength := min(30, len(match)-contextStart)
-			if contextStart+contextLength > len(match) {
-				contextLength = len(match) - contextStart
-			}
-			contextStr := "..." + match[contextStart:contextStart+contextLength] + "..."
-
-			// Log the modification
-			Info.Printf("Modified value [%d]: '%s' → '%s'", i+1, limitString(oldVal, 30), limitString(newVal, 30))
-
-			// Record the modification for summary
-			stats.Modifications = append(stats.Modifications, ModificationRecord{
-				File:      filename,
-				OldValue:  oldVal,
-				NewValue:  newVal,
-				Operation: originalExpr,
-				Context:   fmt.Sprintf("(in %s)", limitString(contextStr, 30)),
-			})
-		}
-
-		modificationCount++
-		return result
-	})
-
-	return result, modificationCount, matchCount, nil
-}
-
-// limitString truncates a string to maxLen and adds "..." if truncated
-func limitString(s string, maxLen int) string {
-	s = strings.ReplaceAll(s, "\n", "\\n")
-	if len(s) <= maxLen {
-		return s
-	}
-	return s[:maxLen-3] + "..."
-}
-
-// max returns the maximum of two integers
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}
-
-// min returns the minimum of two integers
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
 func expandFilePatterns(patterns []string) ([]string, error) {
 	var files []string
 	filesMap := make(map[string]bool)
@@ -537,7 +236,54 @@ func expandFilePatterns(patterns []string) ([]string, error) {
 	}

 	if len(files) > 0 {
-		Info.Printf("Found %d files to process", len(files))
+		logger.Printf("Found %d files to process", len(files))
 	}
 	return files, nil
 }
+
+func cleanupGitFiles(files []string) error {
+	for _, file := range files {
+		logger.Printf("Checking file: %s", file)
+		status, err := worktree.Status()
+		if err != nil {
+			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.Printf("Detected untracked file: %s. Attempting to add it to the git index.", file)
+			_, err = worktree.Add(file)
+			if err != nil {
+				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.Printf("File %s added successfully. Now committing it 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 {
+				fmt.Fprintf(os.Stderr, "Error committing file: %v\n", err)
+				return fmt.Errorf("error committing file: %w", err)
+			}
+			logger.Printf("Successfully committed file: %s with message: 'Track %s'", filename, filename)
+		} else {
+			logger.Printf("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 {
+				fmt.Fprintf(os.Stderr, "Error restoring file: %v\n", err)
+				return fmt.Errorf("error restoring file: %w", err)
+			}
+			logger.Printf("File %s restored successfully.", file)
+		}
+	}
+	return nil
+}
--- a/main_test.go
+++ b/main_test.go
--- a/processor/json.go
+++ b/processor/json.go
@@ -0,0 +1,165 @@
+package processor
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"modify/processor/jsonpath"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+// JSONProcessor implements the Processor interface for JSON documents
+type JSONProcessor struct{}
+
+// ProcessContent implements the Processor interface for JSONProcessor
+func (p *JSONProcessor) ProcessContent(content string, pattern string, luaExpr string) (string, int, int, error) {
+	// Parse JSON document
+	var jsonData interface{}
+	err := json.Unmarshal([]byte(content), &jsonData)
+	if err != nil {
+		return content, 0, 0, fmt.Errorf("error parsing JSON: %v", err)
+	}
+
+	// Find nodes matching the JSONPath pattern
+	nodes, err := jsonpath.Get(jsonData, pattern)
+	if err != nil {
+		return content, 0, 0, fmt.Errorf("error getting nodes: %v", err)
+	}
+
+	matchCount := len(nodes)
+	if matchCount == 0 {
+		return content, 0, 0, nil
+	}
+
+	modCount := 0
+	for _, node := range nodes {
+		log.Printf("Processing node at path: %s with value: %v", node.Path, node.Value)
+
+		// Initialize Lua
+		L, err := NewLuaState()
+		if err != nil {
+			return content, len(nodes), 0, fmt.Errorf("error creating Lua state: %v", err)
+		}
+		defer L.Close()
+		log.Println("Lua state initialized successfully.")
+
+		err = p.ToLua(L, node.Value)
+		if err != nil {
+			return content, len(nodes), 0, fmt.Errorf("error converting to Lua: %v", err)
+		}
+		log.Printf("Converted node value to Lua: %v", node.Value)
+
+		originalScript := luaExpr
+		fullScript := BuildLuaScript(luaExpr)
+		log.Printf("Original script: %q, Full script: %q", originalScript, fullScript)
+
+		// Execute Lua script
+		log.Printf("Executing Lua script: %q", fullScript)
+		if err := L.DoString(fullScript); err != nil {
+			return content, len(nodes), 0, fmt.Errorf("error executing Lua %q: %v", fullScript, err)
+		}
+		log.Println("Lua script executed successfully.")
+
+		// Get modified value
+		result, err := p.FromLua(L)
+		if err != nil {
+			return content, len(nodes), 0, fmt.Errorf("error getting result from Lua: %v", err)
+		}
+		log.Printf("Retrieved modified value from Lua: %v", result)
+
+		modified := false
+		modified = L.GetGlobal("modified").String() == "true"
+		if !modified {
+			log.Printf("No changes made to node at path: %s", node.Path)
+			continue
+		}
+
+		// Apply the modification to the JSON data
+		err = p.updateJSONValue(jsonData, node.Path, result)
+		if err != nil {
+			return content, len(nodes), 0, fmt.Errorf("error updating JSON: %v", err)
+		}
+		log.Printf("Updated JSON at path: %s with new value: %v", node.Path, result)
+		modCount++
+	}
+
+	// Convert the modified JSON back to a string with same formatting
+	var jsonBytes []byte
+	jsonBytes, err = json.MarshalIndent(jsonData, "", "  ")
+	if err != nil {
+		return content, modCount, matchCount, fmt.Errorf("error marshalling JSON: %v", err)
+	}
+	return string(jsonBytes), modCount, matchCount, nil
+}
+
+// updateJSONValue updates a value in the JSON structure based on its JSONPath
+func (p *JSONProcessor) updateJSONValue(jsonData interface{}, path string, newValue interface{}) error {
+	// Special handling for root node
+	if path == "$" {
+		// For the root node, we'll copy the value to the jsonData reference
+		// This is a special case since we can't directly replace the interface{} variable
+
+		// We need to handle different types of root elements
+		switch rootValue := newValue.(type) {
+		case map[string]interface{}:
+			// For objects, we need to copy over all keys
+			rootMap, ok := jsonData.(map[string]interface{})
+			if !ok {
+				// If the original wasn't a map, completely replace it with the new map
+				// This is handled by the jsonpath.Set function
+				return jsonpath.Set(jsonData, path, newValue)
+			}
+
+			// Clear the original map
+			for k := range rootMap {
+				delete(rootMap, k)
+			}
+
+			// Copy all keys from the new map
+			for k, v := range rootValue {
+				rootMap[k] = v
+			}
+			return nil
+
+		case []interface{}:
+			// For arrays, we need to handle similarly
+			rootArray, ok := jsonData.([]interface{})
+			if !ok {
+				// If the original wasn't an array, use jsonpath.Set
+				return jsonpath.Set(jsonData, path, newValue)
+			}
+
+			// Clear and recreate the array
+			*&rootArray = rootValue
+			return nil
+
+		default:
+			// For other types, use jsonpath.Set
+			return jsonpath.Set(jsonData, path, newValue)
+		}
+	}
+
+	// For non-root paths, use the regular Set method
+	err := jsonpath.Set(jsonData, path, newValue)
+	if err != nil {
+		return fmt.Errorf("failed to update JSON value at path '%s': %w", path, err)
+	}
+	return nil
+}
+
+// ToLua converts JSON values to Lua variables
+func (p *JSONProcessor) ToLua(L *lua.LState, data interface{}) error {
+	table, err := ToLua(L, data)
+	if err != nil {
+		return err
+	}
+	L.SetGlobal("v", table)
+	return nil
+}
+
+// FromLua retrieves values from Lua
+func (p *JSONProcessor) FromLua(L *lua.LState) (interface{}, error) {
+	luaValue := L.GetGlobal("v")
+	return FromLua(L, luaValue)
+}
--- a/processor/json_test.go
+++ b/processor/json_test.go
--- a/processor/jsonpath/jsonpath.go
+++ b/processor/jsonpath/jsonpath.go
@@ -0,0 +1,490 @@
+package jsonpath
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// JSONStep represents a single step in a JSONPath query
+type JSONStep struct {
+	Type  StepType
+	Key   string // For Child/RecursiveDescent
+	Index int    // For Index (use -1 for wildcard "*")
+}
+
+// JSONNode represents a value in the JSON data with its path
+type JSONNode struct {
+	Value interface{} // The value found at the path
+	Path  string      // The exact JSONPath where the value was found
+}
+
+// StepType defines the types of steps in a JSONPath
+type StepType int
+
+const (
+	RootStep             StepType = iota // $ - The root element
+	ChildStep                            // .key - Direct child access
+	RecursiveDescentStep                 // ..key - Recursive search for key
+	WildcardStep                         // .* - All children of an object
+	IndexStep                            // [n] - Array index access (or [*] for all elements)
+)
+
+// TraversalMode determines how the traversal behaves
+type TraversalMode int
+
+const (
+	CollectMode     TraversalMode = iota // Just collect matched nodes
+	ModifyFirstMode                      // Modify first matching node
+	ModifyAllMode                        // Modify all matching nodes
+)
+
+// ParseJSONPath parses a JSONPath string into a sequence of steps
+func ParseJSONPath(path string) ([]JSONStep, error) {
+	if len(path) == 0 || path[0] != '$' {
+		return nil, fmt.Errorf("path must start with $; received: %q", path)
+	}
+
+	steps := []JSONStep{}
+	i := 0
+
+	for i < len(path) {
+		switch path[i] {
+		case '$':
+			steps = append(steps, JSONStep{Type: RootStep})
+			i++
+		case '.':
+			i++
+			if i < len(path) && path[i] == '.' {
+				// Recursive descent
+				i++
+				key, nextPos := readKey(path, i)
+				steps = append(steps, JSONStep{Type: RecursiveDescentStep, Key: key})
+				i = nextPos
+			} else {
+				// Child step or wildcard
+				key, nextPos := readKey(path, i)
+				if key == "*" {
+					steps = append(steps, JSONStep{Type: WildcardStep})
+				} else {
+					steps = append(steps, JSONStep{Type: ChildStep, Key: key})
+				}
+				i = nextPos
+			}
+		case '[':
+			// Index step
+			i++
+			indexStr, nextPos := readIndex(path, i)
+			if indexStr == "*" {
+				steps = append(steps, JSONStep{Type: IndexStep, Index: -1})
+			} else {
+				index, err := strconv.Atoi(indexStr)
+				if err != nil {
+					return nil, fmt.Errorf("invalid index: %s; error: %w", indexStr, err)
+				}
+				steps = append(steps, JSONStep{Type: IndexStep, Index: index})
+			}
+			i = nextPos + 1 // Skip closing ]
+		default:
+			return nil, fmt.Errorf("unexpected character: %c at position %d; path: %q", path[i], i, path)
+		}
+	}
+
+	return steps, nil
+}
+
+// readKey extracts a key name from the path
+func readKey(path string, start int) (string, int) {
+	i := start
+	for ; i < len(path); i++ {
+		if path[i] == '.' || path[i] == '[' {
+			break
+		}
+	}
+	return path[start:i], i
+}
+
+// readIndex extracts an array index or wildcard from the path
+func readIndex(path string, start int) (string, int) {
+	i := start
+	for ; i < len(path); i++ {
+		if path[i] == ']' {
+			break
+		}
+	}
+	return path[start:i], i
+}
+
+// Get retrieves values with their paths from data at the specified JSONPath
+// Each returned JSONNode contains both the value and its exact path in the data structure
+func Get(data interface{}, path string) ([]JSONNode, error) {
+	steps, err := ParseJSONPath(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse JSONPath %q: %w", path, err)
+	}
+
+	results := []JSONNode{}
+	err = traverseWithPaths(data, steps, &results, "$")
+	if err != nil {
+		return nil, fmt.Errorf("failed to traverse JSONPath %q: %w", path, err)
+	}
+	return results, nil
+}
+
+// Set updates the value at the specified JSONPath in the original data structure.
+// It only modifies the first matching node.
+func Set(data interface{}, path string, value interface{}) error {
+	steps, err := ParseJSONPath(path)
+	if err != nil {
+		return fmt.Errorf("failed to parse JSONPath %q: %w", path, err)
+	}
+
+	success := false
+	err = setWithPath(data, steps, &success, value, "$", ModifyFirstMode)
+	if err != nil {
+		return fmt.Errorf("failed to set value at JSONPath %q: %w", path, err)
+	}
+	return nil
+}
+
+// SetAll updates all matching values at the specified JSONPath.
+func SetAll(data interface{}, path string, value interface{}) error {
+	steps, err := ParseJSONPath(path)
+	if err != nil {
+		return fmt.Errorf("failed to parse JSONPath %q: %w", path, err)
+	}
+
+	success := false
+	err = setWithPath(data, steps, &success, value, "$", ModifyAllMode)
+	if err != nil {
+		return fmt.Errorf("failed to set value at JSONPath %q: %w", path, err)
+	}
+	return nil
+}
+
+// setWithPath modifies values while tracking paths
+func setWithPath(node interface{}, steps []JSONStep, success *bool, value interface{}, currentPath string, mode TraversalMode) error {
+	if node == nil || *success && mode == ModifyFirstMode {
+		return nil
+	}
+
+	// Skip root step
+	actualSteps := steps
+	if len(steps) > 0 && steps[0].Type == RootStep {
+		actualSteps = steps[1:]
+	}
+
+	// If we have no steps left, we're setting the root value
+	if len(actualSteps) == 0 {
+		// For the root node, we need to handle it differently depending on what's passed in
+		// since we can't directly replace the interface{} variable
+
+		// We'll signal success and let the JSONProcessor handle updating the root
+		*success = true
+		return nil
+	}
+
+	// Process the first step
+	step := actualSteps[0]
+	remainingSteps := actualSteps[1:]
+	isLastStep := len(remainingSteps) == 0
+
+	switch step.Type {
+	case ChildStep:
+		m, ok := node.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("node at path %q is not a map; actual type: %T", currentPath, node)
+		}
+
+		childPath := currentPath + "." + step.Key
+
+		if isLastStep {
+			// We've reached the target, set the value
+			m[step.Key] = value
+			*success = true
+			return nil
+		}
+
+		// Create intermediate nodes if necessary
+		child, exists := m[step.Key]
+		if !exists {
+			// Create missing intermediate node
+			if len(remainingSteps) > 0 && remainingSteps[0].Type == IndexStep {
+				child = []interface{}{}
+			} else {
+				child = map[string]interface{}{}
+			}
+			m[step.Key] = child
+		}
+
+		err := setWithPath(child, remainingSteps, success, value, childPath, mode)
+		if err != nil {
+			return fmt.Errorf("failed to set value at JSONPath %q: %w", childPath, err)
+		}
+
+	case IndexStep:
+		arr, ok := node.([]interface{})
+		if !ok {
+			return fmt.Errorf("node at path %q is not an array; actual type: %T", currentPath, node)
+		}
+
+		// Handle wildcard index
+		if step.Index == -1 {
+			for i, item := range arr {
+				itemPath := fmt.Sprintf("%s[%d]", currentPath, i)
+				if isLastStep {
+					arr[i] = value
+					*success = true
+					if mode == ModifyFirstMode {
+						return nil
+					}
+				} else {
+					err := setWithPath(item, remainingSteps, success, value, itemPath, mode)
+					if err != nil {
+						return fmt.Errorf("failed to set value at JSONPath %q: %w", itemPath, err)
+					}
+					if *success && mode == ModifyFirstMode {
+						return nil
+					}
+				}
+			}
+			return nil
+		}
+
+		// Handle specific index
+		if step.Index >= 0 && step.Index < len(arr) {
+			item := arr[step.Index]
+			itemPath := fmt.Sprintf("%s[%d]", currentPath, step.Index)
+			if isLastStep {
+				arr[step.Index] = value
+				*success = true
+			} else {
+				err := setWithPath(item, remainingSteps, success, value, itemPath, mode)
+				if err != nil {
+					return fmt.Errorf("failed to set value at JSONPath %q: %w", itemPath, err)
+				}
+			}
+		}
+
+	case RecursiveDescentStep:
+		// For recursive descent, first check direct match at this level
+		if m, ok := node.(map[string]interface{}); ok && step.Key != "*" {
+			if val, exists := m[step.Key]; exists {
+				directPath := currentPath + "." + step.Key
+				if isLastStep {
+					m[step.Key] = value
+					*success = true
+					if mode == ModifyFirstMode {
+						return nil
+					}
+				} else {
+					err := setWithPath(val, remainingSteps, success, value, directPath, mode)
+					if err != nil {
+						return fmt.Errorf("failed to set value at JSONPath %q: %w", directPath, err)
+					}
+					if *success && mode == ModifyFirstMode {
+						return nil
+					}
+				}
+			}
+		}
+
+		// Then continue recursion to all children
+		switch n := node.(type) {
+		case map[string]interface{}:
+			for k, v := range n {
+				childPath := currentPath + "." + k
+				// Skip keys we've already processed directly
+				if step.Key != "*" && k == step.Key {
+					continue
+				}
+				err := setWithPath(v, steps, success, value, childPath, mode)
+				if err != nil {
+					return fmt.Errorf("failed to set value at JSONPath %q: %w", childPath, err)
+				}
+				if *success && mode == ModifyFirstMode {
+					return nil
+				}
+			}
+		case []interface{}:
+			for i, v := range n {
+				childPath := fmt.Sprintf("%s[%d]", currentPath, i)
+				err := setWithPath(v, steps, success, value, childPath, mode)
+				if err != nil {
+					return fmt.Errorf("failed to set value at JSONPath %q: %w", childPath, err)
+				}
+				if *success && mode == ModifyFirstMode {
+					return nil
+				}
+			}
+		}
+
+	case WildcardStep:
+		m, ok := node.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("node at path %q is not a map; actual type: %T", currentPath, node)
+		}
+
+		for k, v := range m {
+			childPath := currentPath + "." + k
+			if isLastStep {
+				m[k] = value
+				*success = true
+				if mode == ModifyFirstMode {
+					return nil
+				}
+			} else {
+				err := setWithPath(v, remainingSteps, success, value, childPath, mode)
+				if err != nil {
+					return fmt.Errorf("failed to set value at JSONPath %q: %w", childPath, err)
+				}
+				if *success && mode == ModifyFirstMode {
+					return nil
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// traverseWithPaths tracks both nodes and their paths during traversal
+func traverseWithPaths(node interface{}, steps []JSONStep, results *[]JSONNode, currentPath string) error {
+	if len(steps) == 0 || node == nil {
+		return fmt.Errorf("cannot traverse with empty steps or nil node; steps length: %d, node: %v", len(steps), node)
+	}
+
+	// Skip root step
+	actualSteps := steps
+	if steps[0].Type == RootStep {
+		if len(steps) == 1 {
+			*results = append(*results, JSONNode{Value: node, Path: currentPath})
+			return nil
+		}
+		actualSteps = steps[1:]
+	}
+
+	// Process the first step
+	step := actualSteps[0]
+	remainingSteps := actualSteps[1:]
+	isLastStep := len(remainingSteps) == 0
+
+	switch step.Type {
+	case ChildStep:
+		m, ok := node.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("node is not a map; actual type: %T", node)
+		}
+
+		child, exists := m[step.Key]
+		if !exists {
+			return fmt.Errorf("key not found: %s in node at path: %s", step.Key, currentPath)
+		}
+
+		childPath := currentPath + "." + step.Key
+		if isLastStep {
+			*results = append(*results, JSONNode{Value: child, Path: childPath})
+		} else {
+			err := traverseWithPaths(child, remainingSteps, results, childPath)
+			if err != nil {
+				return fmt.Errorf("failed to traverse JSONPath %q: %w", childPath, err)
+			}
+		}
+
+	case IndexStep:
+		arr, ok := node.([]interface{})
+		if !ok {
+			return fmt.Errorf("node is not an array; actual type: %T", node)
+		}
+
+		// Handle wildcard index
+		if step.Index == -1 {
+			for i, item := range arr {
+				itemPath := fmt.Sprintf("%s[%d]", currentPath, i)
+				if isLastStep {
+					*results = append(*results, JSONNode{Value: item, Path: itemPath})
+				} else {
+					err := traverseWithPaths(item, remainingSteps, results, itemPath)
+					if err != nil {
+						return fmt.Errorf("failed to traverse JSONPath %q: %w", itemPath, err)
+					}
+				}
+			}
+			return nil
+		}
+
+		// Handle specific index
+		if step.Index >= 0 && step.Index < len(arr) {
+			item := arr[step.Index]
+			itemPath := fmt.Sprintf("%s[%d]", currentPath, step.Index)
+			if isLastStep {
+				*results = append(*results, JSONNode{Value: item, Path: itemPath})
+			} else {
+				err := traverseWithPaths(item, remainingSteps, results, itemPath)
+				if err != nil {
+					return fmt.Errorf("failed to traverse JSONPath %q: %w", itemPath, err)
+				}
+			}
+		} else {
+			return fmt.Errorf("index %d out of bounds for array at path: %s", step.Index, currentPath)
+		}
+
+	case RecursiveDescentStep:
+		// For recursive descent, first check direct match at this level
+		if m, ok := node.(map[string]interface{}); ok && step.Key != "*" {
+			if val, exists := m[step.Key]; exists {
+				directPath := currentPath + "." + step.Key
+				if isLastStep {
+					*results = append(*results, JSONNode{Value: val, Path: directPath})
+				} else {
+					err := traverseWithPaths(val, remainingSteps, results, directPath)
+					if err != nil {
+						return fmt.Errorf("failed to traverse JSONPath %q: %w", directPath, err)
+					}
+				}
+			}
+		}
+
+		// For wildcard, collect this node
+		if step.Key == "*" && isLastStep {
+			*results = append(*results, JSONNode{Value: node, Path: currentPath})
+		}
+
+		// Then continue recursion to all children
+		switch n := node.(type) {
+		case map[string]interface{}:
+			for k, v := range n {
+				childPath := currentPath + "." + k
+				err := traverseWithPaths(v, steps, results, childPath) // Use the same steps
+				if err != nil {
+					return fmt.Errorf("failed to traverse JSONPath %q: %w", childPath, err)
+				}
+			}
+		case []interface{}:
+			for i, v := range n {
+				childPath := fmt.Sprintf("%s[%d]", currentPath, i)
+				err := traverseWithPaths(v, steps, results, childPath) // Use the same steps
+				if err != nil {
+					return fmt.Errorf("failed to traverse JSONPath %q: %w", childPath, err)
+				}
+			}
+		}
+
+	case WildcardStep:
+		m, ok := node.(map[string]interface{})
+		if !ok {
+			return fmt.Errorf("node is not a map; actual type: %T", node)
+		}
+
+		for k, v := range m {
+			childPath := currentPath + "." + k
+			if isLastStep {
+				*results = append(*results, JSONNode{Value: v, Path: childPath})
+			} else {
+				err := traverseWithPaths(v, remainingSteps, results, childPath)
+				if err != nil {
+					return fmt.Errorf("failed to traverse JSONPath %q: %w", childPath, err)
+				}
+			}
+		}
+	}
+	return nil
+}
--- a/processor/jsonpath/jsonpath_get_set_test.go
+++ b/processor/jsonpath/jsonpath_get_set_test.go
@@ -0,0 +1,577 @@
+package jsonpath
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestGetWithPathsBasic(t *testing.T) {
+	tests := []struct {
+		name     string
+		data     map[string]interface{}
+		path     string
+		expected []JSONNode
+		error    bool
+	}{
+		{
+			name: "simple property",
+			data: map[string]interface{}{
+				"name": "John",
+				"age":  30,
+			},
+			path: "$.name",
+			expected: []JSONNode{
+				{Value: "John", Path: "$.name"},
+			},
+		},
+		{
+			name: "nested property",
+			data: map[string]interface{}{
+				"user": map[string]interface{}{
+					"name": "John",
+					"age":  30,
+				},
+			},
+			path: "$.user.name",
+			expected: []JSONNode{
+				{Value: "John", Path: "$.user.name"},
+			},
+		},
+		{
+			name: "array access",
+			data: map[string]interface{}{
+				"users": []interface{}{
+					map[string]interface{}{"name": "John", "age": 30},
+					map[string]interface{}{"name": "Jane", "age": 25},
+				},
+			},
+			path: "$.users[1].name",
+			expected: []JSONNode{
+				{Value: "Jane", Path: "$.users[1].name"},
+			},
+		},
+		{
+			name: "wildcard",
+			data: map[string]interface{}{
+				"users": []interface{}{
+					map[string]interface{}{"name": "John", "age": 30},
+					map[string]interface{}{"name": "Jane", "age": 25},
+				},
+			},
+			path: "$.users[*].name",
+			expected: []JSONNode{
+				{Value: "John", Path: "$.users[0].name"},
+				{Value: "Jane", Path: "$.users[1].name"},
+			},
+		},
+		{
+			name: "recursive descent",
+			data: map[string]interface{}{
+				"user": map[string]interface{}{
+					"name": "John",
+					"profile": map[string]interface{}{
+						"email": "john@example.com",
+					},
+				},
+				"admin": map[string]interface{}{
+					"email": "admin@example.com",
+				},
+			},
+			path: "$..email",
+			expected: []JSONNode{
+				{Value: "john@example.com", Path: "$.user.profile.email"},
+				{Value: "admin@example.com", Path: "$.admin.email"},
+			},
+		},
+		{
+			name: "nonexistent path",
+			data: map[string]interface{}{
+				"user": map[string]interface{}{
+					"name": "John",
+				},
+			},
+			path:     "$.user.email",
+			expected: []JSONNode{},
+			error:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := Get(tt.data, tt.path)
+			if err != nil {
+				if !tt.error {
+					t.Errorf("GetWithPaths() returned error: %v", err)
+				}
+				return
+			}
+
+			// For nonexistent path, we expect empty slice
+			if tt.name == "nonexistent path" {
+				if len(result) > 0 {
+					t.Errorf("GetWithPaths() returned %v, expected empty result", result)
+				}
+				return
+			}
+
+			// Check if lengths match
+			if len(result) != len(tt.expected) {
+				t.Errorf("GetWithPaths() returned %d items, expected %d", len(result), len(tt.expected))
+				return
+			}
+
+			// For wildcard results, we need to check containment rather than exact order
+			if tt.name == "wildcard" || tt.name == "recursive descent" {
+				// For each expected item, check if it exists in the results by both value and path
+				for _, expected := range tt.expected {
+					found := false
+					for _, r := range result {
+						if reflect.DeepEqual(r.Value, expected.Value) && r.Path == expected.Path {
+							found = true
+							break
+						}
+					}
+					if !found {
+						t.Errorf("GetWithPaths() missing expected value: %v with path: %s", expected.Value, expected.Path)
+					}
+				}
+			} else {
+				// Otherwise check exact equality of both values and paths
+				for i, expected := range tt.expected {
+					if !reflect.DeepEqual(result[i].Value, expected.Value) {
+						t.Errorf("GetWithPaths() value at [%d] = %v, expected %v", i, result[i].Value, expected.Value)
+					}
+					if result[i].Path != expected.Path {
+						t.Errorf("GetWithPaths() path at [%d] = %s, expected %s", i, result[i].Path, expected.Path)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestSet(t *testing.T) {
+	t.Run("simple property", func(t *testing.T) {
+		data := map[string]interface{}{
+			"name": "John",
+			"age":  30,
+		}
+		 err := Set(data, "$.name", "Jane")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		if data["name"] != "Jane" {
+			t.Errorf("Set() failed: expected name to be 'Jane', got %v", data["name"])
+		}
+	})
+
+	t.Run("nested property", func(t *testing.T) {
+		data := map[string]interface{}{
+			"user": map[string]interface{}{
+				"name": "John",
+				"age":  30,
+			},
+		}
+		err := Set(data, "$.user.name", "Jane")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		user, ok := data["user"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("User is not a map")
+		}
+		if user["name"] != "Jane" {
+			t.Errorf("Set() failed: expected user.name to be 'Jane', got %v", user["name"])
+		}
+	})
+
+	t.Run("array element", func(t *testing.T) {
+		data := map[string]interface{}{
+			"users": []interface{}{
+				map[string]interface{}{"name": "John", "age": 30},
+				map[string]interface{}{"name": "Jane", "age": 25},
+			},
+		}
+		err := Set(data, "$.users[0].name", "Bob")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+		users, ok := data["users"].([]interface{})
+		if !ok {
+			t.Fatalf("Users is not a slice")
+		}
+		user0, ok := users[0].(map[string]interface{})
+		if !ok {
+			t.Fatalf("User is not a map")
+		}
+		if user0["name"] != "Bob" {
+			t.Errorf("Set() failed: expected users[0].name to be 'Bob', got %v", user0["name"])
+		}
+	})
+
+	t.Run("complex value", func(t *testing.T) {
+		data := map[string]interface{}{
+			"user": map[string]interface{}{
+				"name": "John",
+				"profile": map[string]interface{}{
+					"email": "john@example.com",
+				},
+			},
+		}
+
+		newProfile := map[string]interface{}{
+			"email": "john.doe@example.com",
+			"phone": "123-456-7890",
+		}
+
+		err := Set(data, "$.user.profile", newProfile)
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		userMap, ok := data["user"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("User is not a map")
+		}
+
+		profile, ok := userMap["profile"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("Profile is not a map")
+		}
+
+		if profile["email"] != "john.doe@example.com" || profile["phone"] != "123-456-7890" {
+			t.Errorf("Set() failed: expected profile to be updated with new values")
+		}
+	})
+
+	t.Run("create new property", func(t *testing.T) {
+		data := map[string]interface{}{
+			"user": map[string]interface{}{
+				"name": "John",
+			},
+		}
+
+		err := Set(data, "$.user.email", "john@example.com")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+		userMap, ok := data["user"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("User is not a map")
+		}
+
+		if email, exists := userMap["email"]; !exists || email != "john@example.com" {
+			t.Errorf("Set() failed: expected user.email to be 'john@example.com', got %v", userMap["email"])
+		}
+	})
+
+	t.Run("create nested properties", func(t *testing.T) {
+		data := map[string]interface{}{
+			"user": map[string]interface{}{
+				"name": "John",
+			},
+		}
+
+		err := Set(data, "$.user.contact.email", "john@example.com")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+		userMap, ok := data["user"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("User is not a map")
+		}
+
+		contact, ok := userMap["contact"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("Contact is not a map")
+		}
+
+		if email, exists := contact["email"]; !exists || email != "john@example.com" {
+			t.Errorf("Set() failed: expected user.contact.email to be 'john@example.com', got %v", contact["email"])
+		}
+	})
+
+	t.Run("create array and element", func(t *testing.T) {
+		data := map[string]interface{}{
+			"user": map[string]interface{}{
+				"name": "John",
+			},
+		}
+
+		// This should create an empty addresses array, but won't be able to set index 0
+		// since the array is empty
+		err := Set(data, "$.user.addresses[0].street", "123 Main St")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+	})
+
+	t.Run("multiple targets (should only update first)", func(t *testing.T) {
+		data := map[string]interface{}{
+			"users": []interface{}{
+				map[string]interface{}{"active": true},
+				map[string]interface{}{"active": true},
+			},
+		}
+
+		err := Set(data, "$.users[*].active", false)
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		users, ok := data["users"].([]interface{})
+		if !ok {
+			t.Fatalf("Users is not a slice")
+		}
+
+		user0, ok := users[0].(map[string]interface{})
+		if !ok {
+			t.Fatalf("User0 is not a map")
+		}
+
+		user1, ok := users[1].(map[string]interface{})
+		if !ok {
+			t.Fatalf("User1 is not a map")
+		}
+
+		// Only the first one should be changed
+		if active, exists := user0["active"]; !exists || active != false {
+			t.Errorf("Set() failed: expected users[0].active to be false, got %v", user0["active"])
+		}
+
+		// The second one should remain unchanged
+		if active, exists := user1["active"]; !exists || active != true {
+			t.Errorf("Set() incorrectly modified users[1].active: expected true, got %v", user1["active"])
+		}
+	})
+
+	t.Run("setting on root should not fail (anymore)", func(t *testing.T) {
+		data := map[string]interface{}{
+			"name": "John",
+		}
+
+		err := Set(data, "$", "Jane")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		// Data should be unchanged
+		if data["name"] != "John" {
+			t.Errorf("Data was modified when setting on root")
+		}
+	})
+}
+
+func TestSetAll(t *testing.T) {
+	t.Run("simple property", func(t *testing.T) {
+		data := map[string]interface{}{
+			"name": "John",
+			"age":  30,
+		}
+		err := SetAll(data, "$.name", "Jane")
+		if err != nil {
+			t.Errorf("SetAll() returned error: %v", err)
+			return
+		}
+		if data["name"] != "Jane" {
+			t.Errorf("SetAll() failed: expected name to be 'Jane', got %v", data["name"])
+		}
+	})
+
+	t.Run("all array elements", func(t *testing.T) {
+		data := map[string]interface{}{
+			"users": []interface{}{
+				map[string]interface{}{"active": true},
+				map[string]interface{}{"active": true},
+			},
+		}
+
+		err := SetAll(data, "$.users[*].active", false)
+		if err != nil {
+			t.Errorf("SetAll() returned error: %v", err)
+			return
+		}
+
+		users, ok := data["users"].([]interface{})
+		if !ok {
+			t.Fatalf("Users is not a slice")
+		}
+
+		// Both elements should be updated
+		for i, user := range users {
+			userMap, ok := user.(map[string]interface{})
+			if !ok {
+				t.Fatalf("User%d is not a map", i)
+			}
+
+			if active, exists := userMap["active"]; !exists || active != false {
+				t.Errorf("SetAll() failed: expected users[%d].active to be false, got %v", i, userMap["active"])
+			}
+		}
+	})
+
+	t.Run("recursive descent", func(t *testing.T) {
+		data := map[string]interface{}{
+			"user": map[string]interface{}{
+				"profile": map[string]interface{}{
+					"active": true,
+				},
+			},
+			"admin": map[string]interface{}{
+				"profile": map[string]interface{}{
+					"active": true,
+				},
+			},
+		}
+
+		err := SetAll(data, "$..active", false)
+		if err != nil {
+			t.Errorf("SetAll() returned error: %v", err)
+			return
+		}
+
+		// Check user profile
+		userProfile, ok := data["user"].(map[string]interface{})["profile"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("Failed to access user.profile")
+		}
+		if active, exists := userProfile["active"]; !exists || active != false {
+			t.Errorf("SetAll() didn't update user.profile.active, got: %v", active)
+		}
+
+		// Check admin profile
+		adminProfile, ok := data["admin"].(map[string]interface{})["profile"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("Failed to access admin.profile")
+		}
+		if active, exists := adminProfile["active"]; !exists || active != false {
+			t.Errorf("SetAll() didn't update admin.profile.active, got: %v", active)
+		}
+	})
+}
+
+func TestGetWithPathsExtended(t *testing.T) {
+	tests := []struct {
+		name     string
+		data     map[string]interface{}
+		path     string
+		expected []JSONNode
+	}{
+		{
+			name: "simple property",
+			data: map[string]interface{}{
+				"name": "John",
+				"age":  30,
+			},
+			path: "$.name",
+			expected: []JSONNode{
+				{Value: "John", Path: "$.name"},
+			},
+		},
+		{
+			name: "nested property",
+			data: map[string]interface{}{
+				"user": map[string]interface{}{
+					"name": "John",
+					"age":  30,
+				},
+			},
+			path: "$.user.name",
+			expected: []JSONNode{
+				{Value: "John", Path: "$.user.name"},
+			},
+		},
+		{
+			name: "array access",
+			data: map[string]interface{}{
+				"users": []interface{}{
+					map[string]interface{}{"name": "John", "age": 30},
+					map[string]interface{}{"name": "Jane", "age": 25},
+				},
+			},
+			path: "$.users[1].name",
+			expected: []JSONNode{
+				{Value: "Jane", Path: "$.users[1].name"},
+			},
+		},
+		{
+			name: "wildcard",
+			data: map[string]interface{}{
+				"users": []interface{}{
+					map[string]interface{}{"name": "John", "age": 30},
+					map[string]interface{}{"name": "Jane", "age": 25},
+				},
+			},
+			path: "$.users[*].name",
+			expected: []JSONNode{
+				{Value: "John", Path: "$.users[0].name"},
+				{Value: "Jane", Path: "$.users[1].name"},
+			},
+		},
+		{
+			name: "recursive descent",
+			data: map[string]interface{}{
+				"user": map[string]interface{}{
+					"name": "John",
+					"profile": map[string]interface{}{
+						"email": "john@example.com",
+					},
+				},
+				"admin": map[string]interface{}{
+					"email": "admin@example.com",
+				},
+			},
+			path: "$..email",
+			expected: []JSONNode{
+				{Value: "john@example.com", Path: "$.user.profile.email"},
+				{Value: "admin@example.com", Path: "$.admin.email"},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := Get(tt.data, tt.path)
+			if err != nil {
+				t.Errorf("GetWithPaths() returned error: %v", err)
+				return
+			}
+
+			// Check if lengths match
+			if len(result) != len(tt.expected) {
+				t.Errorf("GetWithPaths() returned %d items, expected %d", len(result), len(tt.expected))
+				return
+			}
+
+			// For each expected item, find its match in the results and verify both value and path
+			for _, expected := range tt.expected {
+				found := false
+				for _, r := range result {
+					// Check if value matches
+					if reflect.DeepEqual(r.Value, expected.Value) {
+						found = true
+						// Check if path matches
+						if r.Path != expected.Path {
+							t.Errorf("Path mismatch for value %v: got %s, expected %s", r.Value, r.Path, expected.Path)
+						}
+						break
+					}
+				}
+				if !found {
+					t.Errorf("Expected node with value %v and path %s not found in results", expected.Value, expected.Path)
+				}
+			}
+		})
+	}
+}
--- a/processor/jsonpath/jsonpath_test.go
+++ b/processor/jsonpath/jsonpath_test.go
@@ -0,0 +1,318 @@
+package jsonpath
+
+import (
+	"reflect"
+	"testing"
+)
+
+var testData = map[string]interface{}{
+	"store": map[string]interface{}{
+		"book": []interface{}{
+			map[string]interface{}{
+				"title": "The Fellowship of the Ring",
+				"price": 22.99,
+			},
+			map[string]interface{}{
+				"title": "The Two Towers",
+				"price": 23.45,
+			},
+		},
+		"bicycle": map[string]interface{}{
+			"color": "red",
+			"price": 199.95,
+		},
+	},
+}
+
+func TestParser(t *testing.T) {
+	tests := []struct {
+		path    string
+		steps   []JSONStep
+		wantErr bool
+	}{
+		{
+			path: "$.store.bicycle.color",
+			steps: []JSONStep{
+				{Type: RootStep},
+				{Type: ChildStep, Key: "store"},
+				{Type: ChildStep, Key: "bicycle"},
+				{Type: ChildStep, Key: "color"},
+			},
+		},
+		{
+			path: "$..price",
+			steps: []JSONStep{
+				{Type: RootStep},
+				{Type: RecursiveDescentStep, Key: "price"},
+			},
+		},
+		{
+			path: "$.store.book[*].title",
+			steps: []JSONStep{
+				{Type: RootStep},
+				{Type: ChildStep, Key: "store"},
+				{Type: ChildStep, Key: "book"},
+				{Type: IndexStep, Index: -1}, // Wildcard
+				{Type: ChildStep, Key: "title"},
+			},
+		},
+		{
+			path: "$.store.book[0]",
+			steps: []JSONStep{
+				{Type: RootStep},
+				{Type: ChildStep, Key: "store"},
+				{Type: ChildStep, Key: "book"},
+				{Type: IndexStep, Index: 0},
+			},
+		},
+		{
+			path:    "invalid.path",
+			wantErr: true,
+		},
+		{
+			path:    "$.store.book[abc]",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.path, func(t *testing.T) {
+			steps, err := ParseJSONPath(tt.path)
+			if (err != nil) != tt.wantErr {
+				t.Fatalf("ParseJSONPath() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !tt.wantErr && !reflect.DeepEqual(steps, tt.steps) {
+				t.Errorf("ParseJSONPath() steps = %+v, want %+v", steps, tt.steps)
+			}
+		})
+	}
+}
+
+func TestEvaluator(t *testing.T) {
+	tests := []struct {
+		name     string
+		path     string
+		expected []JSONNode
+		error    bool
+	}{
+		{
+			name: "simple_property_access",
+			path: "$.store.bicycle.color",
+			expected: []JSONNode{
+				{Value: "red", Path: "$.store.bicycle.color"},
+			},
+		},
+		{
+			name: "array_index_access",
+			path: "$.store.book[0].title",
+			expected: []JSONNode{
+				{Value: "The Fellowship of the Ring", Path: "$.store.book[0].title"},
+			},
+		},
+		{
+			name: "wildcard_array_access",
+			path: "$.store.book[*].title",
+			expected: []JSONNode{
+				{Value: "The Fellowship of the Ring", Path: "$.store.book[0].title"},
+				{Value: "The Two Towers", Path: "$.store.book[1].title"},
+			},
+		},
+		{
+			name: "recursive_price_search",
+			path: "$..price",
+			expected: []JSONNode{
+				{Value: 22.99, Path: "$.store.book[0].price"},
+				{Value: 23.45, Path: "$.store.book[1].price"},
+				{Value: 199.95, Path: "$.store.bicycle.price"},
+			},
+		},
+		{
+			name: "wildcard_recursive",
+			path: "$..*",
+			expected: []JSONNode{
+				// These will be compared by value only, paths will be validated separately
+				{Value: testData["store"].(map[string]interface{})["book"]},
+				{Value: testData["store"].(map[string]interface{})["bicycle"]},
+				{Value: testData["store"].(map[string]interface{})["book"].([]interface{})[0]},
+				{Value: testData["store"].(map[string]interface{})["book"].([]interface{})[1]},
+				{Value: "The Fellowship of the Ring"},
+				{Value: 22.99},
+				{Value: "The Two Towers"},
+				{Value: 23.45},
+				{Value: "red"},
+				{Value: 199.95},
+			},
+		},
+		{
+			name:     "invalid_index",
+			path:     "$.store.book[5]",
+			expected: []JSONNode{},
+			error:    true,
+		},
+		{
+			name:     "nonexistent_property",
+			path:     "$.store.nonexistent",
+			expected: []JSONNode{},
+			error:    true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Use GetWithPaths directly
+			result, err := Get(testData, tt.path)
+			if err != nil {
+				if !tt.error {
+					t.Errorf("Get() returned error: %v", err)
+				}
+				return
+			}
+
+			// Special handling for wildcard recursive test
+			if tt.name == "wildcard_recursive" {
+				// Skip length check for wildcard recursive since it might vary
+				// Just verify that each expected item is in the results
+
+				// Validate values match and paths are filled in
+				for _, e := range tt.expected {
+					found := false
+					for _, r := range result {
+						if reflect.DeepEqual(r.Value, e.Value) {
+							found = true
+							break
+						}
+					}
+					if !found {
+						t.Errorf("Expected value %v not found in results", e.Value)
+					}
+				}
+				return
+			}
+
+			if len(result) != len(tt.expected) {
+				t.Errorf("Expected %d items, got %d", len(tt.expected), len(result))
+			}
+
+			// Validate both values and paths
+			for i, e := range tt.expected {
+				if i < len(result) {
+					if !reflect.DeepEqual(result[i].Value, e.Value) {
+						t.Errorf("Value at [%d]: got %v, expected %v", i, result[i].Value, e.Value)
+					}
+					if result[i].Path != e.Path {
+						t.Errorf("Path at [%d]: got %s, expected %s", i, result[i].Path, e.Path)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestEdgeCases(t *testing.T) {
+	t.Run("empty_data", func(t *testing.T) {
+		result, err := Get(nil, "$.a.b")
+		if err == nil {
+			t.Errorf("Expected error for empty data")
+			return
+		}
+		if len(result) > 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+
+	t.Run("empty_path", func(t *testing.T) {
+		_, err := ParseJSONPath("")
+		if err == nil {
+			t.Error("Expected error for empty path")
+		}
+	})
+
+	t.Run("numeric_keys", func(t *testing.T) {
+		data := map[string]interface{}{
+			"42": "answer",
+		}
+		result, err := Get(data, "$.42")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+		if len(result) == 0 || result[0].Value != "answer" {
+			t.Errorf("Expected 'answer', got %v", result)
+		}
+	})
+}
+
+func TestGetWithPaths(t *testing.T) {
+	tests := []struct {
+		name     string
+		path     string
+		expected []JSONNode
+	}{
+		{
+			name: "simple_property_access",
+			path: "$.store.bicycle.color",
+			expected: []JSONNode{
+				{Value: "red", Path: "$.store.bicycle.color"},
+			},
+		},
+		{
+			name: "array_index_access",
+			path: "$.store.book[0].title",
+			expected: []JSONNode{
+				{Value: "The Fellowship of the Ring", Path: "$.store.book[0].title"},
+			},
+		},
+		{
+			name: "wildcard_array_access",
+			path: "$.store.book[*].title",
+			expected: []JSONNode{
+				{Value: "The Fellowship of the Ring", Path: "$.store.book[0].title"},
+				{Value: "The Two Towers", Path: "$.store.book[1].title"},
+			},
+		},
+		{
+			name: "recursive_price_search",
+			path: "$..price",
+			expected: []JSONNode{
+				{Value: 22.99, Path: "$.store.book[0].price"},
+				{Value: 23.45, Path: "$.store.book[1].price"},
+				{Value: 199.95, Path: "$.store.bicycle.price"},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := Get(testData, tt.path)
+			if err != nil {
+				t.Errorf("Get() returned error: %v", err)
+				return
+			}
+
+			// Check if lengths match
+			if len(result) != len(tt.expected) {
+				t.Errorf("GetWithPaths() returned %d items, expected %d", len(result), len(tt.expected))
+				return
+			}
+
+			// For each expected item, find its match in the results and verify both value and path
+			for _, expected := range tt.expected {
+				found := false
+				for _, r := range result {
+					// First verify the value matches
+					if reflect.DeepEqual(r.Value, expected.Value) {
+						found = true
+						// Then verify the path matches
+						if r.Path != expected.Path {
+							t.Errorf("Path mismatch for value %v: got %s, expected %s", r.Value, r.Path, expected.Path)
+						}
+						break
+					}
+				}
+				if !found {
+					t.Errorf("Expected node with value %v and path %s not found in results", expected.Value, expected.Path)
+				}
+			}
+		})
+	}
+}
--- a/processor/processor.go
+++ b/processor/processor.go
@@ -0,0 +1,329 @@
+package processor
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/antchfx/xmlquery"
+	lua "github.com/yuin/gopher-lua"
+)
+
+// Processor defines the interface for all file processors
+type Processor interface {
+	// Process handles processing a file with the given pattern and Lua expression
+	// Now implemented as a base function in processor.go
+	// Process(filename string, pattern string, luaExpr string) (int, int, error)
+
+	// ProcessContent handles processing a string content directly with the given pattern and Lua expression
+	// Returns the modified content, modification count, match count, and any error
+	ProcessContent(content string, pattern string, luaExpr string) (string, int, int, error)
+
+	// ToLua converts processor-specific data to Lua variables
+	ToLua(L *lua.LState, data interface{}) error
+
+	// FromLua retrieves modified data from Lua
+	FromLua(L *lua.LState) (interface{}, error)
+}
+
+// ModificationRecord tracks a single value modification
+type ModificationRecord struct {
+	File      string
+	OldValue  string
+	NewValue  string
+	Operation string
+	Context   string
+}
+
+func NewLuaState() (*lua.LState, error) {
+	L := lua.NewState()
+	// defer L.Close()
+
+	// Load math library
+	L.Push(L.GetGlobal("require"))
+	L.Push(lua.LString("math"))
+	if err := L.PCall(1, 1, nil); err != nil {
+		return nil, fmt.Errorf("error loading Lua math library: %v", err)
+	}
+
+	// Initialize helper functions
+	if err := InitLuaHelpers(L); err != nil {
+		return nil, err
+	}
+
+	return L, nil
+}
+
+func Process(p Processor, filename string, pattern string, luaExpr string) (int, int, error) {
+	// Read file content
+	cwd, err := os.Getwd()
+	if err != nil {
+		return 0, 0, fmt.Errorf("error getting current working directory: %v", err)
+	}
+
+	fullPath := filepath.Join(cwd, filename)
+	content, err := os.ReadFile(fullPath)
+	if err != nil {
+		return 0, 0, fmt.Errorf("error reading file: %v", err)
+	}
+
+	fileContent := string(content)
+
+	// Process the content
+	modifiedContent, modCount, matchCount, err := p.ProcessContent(fileContent, pattern, luaExpr)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	// If we made modifications, save the file
+	if modCount > 0 {
+		err = os.WriteFile(fullPath, []byte(modifiedContent), 0644)
+		if err != nil {
+			return 0, 0, fmt.Errorf("error writing file: %v", err)
+		}
+	}
+
+	return modCount, matchCount, nil
+}
+
+// ToLua converts a struct or map to a Lua table recursively
+func ToLua(L *lua.LState, data interface{}) (lua.LValue, error) {
+	switch v := data.(type) {
+	case *xmlquery.Node:
+		luaTable := L.NewTable()
+		luaTable.RawSetString("text", lua.LString(v.Data))
+		// Should be a map, simple key value pairs
+		attr, err := ToLua(L, v.Attr)
+		if err != nil {
+			return nil, err
+		}
+		luaTable.RawSetString("attr", attr)
+		return luaTable, nil
+	case map[string]interface{}:
+		luaTable := L.NewTable()
+		for key, value := range v {
+			luaValue, err := ToLua(L, value)
+			if err != nil {
+				return nil, err
+			}
+			luaTable.RawSetString(key, luaValue)
+		}
+		return luaTable, nil
+	case []interface{}:
+		luaTable := L.NewTable()
+		for i, value := range v {
+			luaValue, err := ToLua(L, value)
+			if err != nil {
+				return nil, err
+			}
+			luaTable.RawSetInt(i+1, luaValue) // Lua arrays are 1-indexed
+		}
+		return luaTable, nil
+	case string:
+		return lua.LString(v), nil
+	case bool:
+		return lua.LBool(v), nil
+	case float64:
+		return lua.LNumber(v), nil
+	case nil:
+		return lua.LNil, nil
+	default:
+		return nil, fmt.Errorf("unsupported data type: %T", data)
+	}
+}
+
+// FromLua converts a Lua table to a struct or map recursively
+func FromLua(L *lua.LState, luaValue lua.LValue) (interface{}, error) {
+	switch v := luaValue.(type) {
+	// Well shit...
+	// Tables in lua are both maps and arrays
+	// As arrays they are ordered and as maps, obviously, not
+	// So when we parse them to a go map we fuck up the order for arrays
+	// We have to find a better way....
+	case *lua.LTable:
+		isArray, err := IsLuaTableArray(L, v)
+		if err != nil {
+			return nil, err
+		}
+		if isArray {
+			result := make([]interface{}, 0)
+			v.ForEach(func(key lua.LValue, value lua.LValue) {
+				converted, _ := FromLua(L, value)
+				result = append(result, converted)
+			})
+			return result, nil
+		} else {
+			result := make(map[string]interface{})
+			v.ForEach(func(key lua.LValue, value lua.LValue) {
+				converted, _ := FromLua(L, value)
+				result[key.String()] = converted
+			})
+			return result, nil
+		}
+	case lua.LString:
+		return string(v), nil
+	case lua.LBool:
+		return bool(v), nil
+	case lua.LNumber:
+		return float64(v), nil
+	default:
+		return nil, nil
+	}
+}
+
+func IsLuaTableArray(L *lua.LState, v *lua.LTable) (bool, error) {
+	L.SetGlobal("table_to_check", v)
+
+	// Use our predefined helper function from InitLuaHelpers
+	err := L.DoString(`is_array = isArray(table_to_check)`)
+	if err != nil {
+		return false, fmt.Errorf("error determining if table is array: %w", err)
+	}
+
+	// Check the result of our Lua function
+	isArray := L.GetGlobal("is_array")
+	// LVIsFalse returns true if a given LValue is a nil or false otherwise false.
+	if !lua.LVIsFalse(isArray) {
+		return true, nil
+	}
+	return false, nil
+}
+
+// InitLuaHelpers initializes common Lua helper functions
+func InitLuaHelpers(L *lua.LState) error {
+	helperScript := `
+-- Custom Lua helpers for math operations
+function min(a, b) return math.min(a, b) end
+function max(a, b) return math.max(a, b) end
+function round(x, n)
+	if n == nil then n = 0 end
+	return math.floor(x * 10^n + 0.5) / 10^n
+end
+function floor(x) return math.floor(x) end
+function ceil(x) return math.ceil(x) end
+function upper(s) return string.upper(s) end
+function lower(s) return string.lower(s) end
+
+-- String to number conversion helper
+function num(str)
+    return tonumber(str) or 0
+end
+
+-- Number to string conversion
+function str(num)
+    return tostring(num)
+end
+
+-- Check if string is numeric
+function is_number(str)
+    return tonumber(str) ~= nil
+end
+
+function isArray(t)
+    if type(t) ~= "table" then return false end
+    local max = 0
+    local count = 0
+    for k, _ in pairs(t) do
+        if type(k) ~= "number" or k < 1 or math.floor(k) ~= k then
+            return false
+        end
+        max = math.max(max, k)
+        count = count + 1
+    end
+    return max == count
+end
+
+modified = false
+`
+	if err := L.DoString(helperScript); err != nil {
+		return fmt.Errorf("error loading helper functions: %v", err)
+	}
+
+	L.SetGlobal("print", L.NewFunction(printToGo))
+	return nil
+}
+
+// Helper utility functions
+
+// LimitString truncates a string to maxLen and adds "..." if truncated
+func LimitString(s string, maxLen int) string {
+	s = strings.ReplaceAll(s, "\n", "\\n")
+	if len(s) <= maxLen {
+		return s
+	}
+	return s[:maxLen-3] + "..."
+}
+
+func PrependLuaAssignment(luaExpr string) string {
+	// Auto-prepend v1 for expressions starting with operators
+	if strings.HasPrefix(luaExpr, "*") ||
+		strings.HasPrefix(luaExpr, "/") ||
+		strings.HasPrefix(luaExpr, "+") ||
+		strings.HasPrefix(luaExpr, "-") ||
+		strings.HasPrefix(luaExpr, "^") ||
+		strings.HasPrefix(luaExpr, "%") {
+		luaExpr = "v1 = v1" + luaExpr
+	} else if strings.HasPrefix(luaExpr, "=") {
+		// Handle direct assignment with = operator
+		luaExpr = "v1 " + luaExpr
+	}
+
+	// Add assignment if needed
+	if !strings.Contains(luaExpr, "=") {
+		luaExpr = "v1 = " + luaExpr
+	}
+	return luaExpr
+}
+
+// BuildLuaScript prepares a Lua expression from shorthand notation
+func BuildLuaScript(luaExpr string) string {
+	luaExpr = PrependLuaAssignment(luaExpr)
+
+	// This allows the user to specify whether or not they modified a value
+	// If they do nothing we assume they did modify (no return at all)
+	// If they return before our return then they themselves specify what they did
+	// If nothing is returned lua assumes nil
+	// So we can say our value was modified if the return value is either nil or true
+	// If the return value is false then the user wants to keep the original
+	fullScript := fmt.Sprintf(`
+		function run()
+			%s
+		end
+		local res = run()
+		modified = res == nil or res
+	`, luaExpr)
+
+	return fullScript
+}
+
+func printToGo(L *lua.LState) int {
+	// Get the number of arguments passed to the Lua print function
+	n := L.GetTop()
+	// Create a slice to hold the arguments
+	args := make([]interface{}, n)
+	for i := 1; i <= n; i++ {
+		args[i-1] = L.Get(i) // Get the argument from Lua stack
+	}
+	// Print the arguments to Go's stdout
+	log.Print("Lua: ")
+	log.Println(args...)
+	return 0 // No return values
+}
+
+// Max returns the maximum of two integers
+func Max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// Min returns the minimum of two integers
+func Min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
--- a/processor/regex.go
+++ b/processor/regex.go
@@ -0,0 +1,285 @@
+package processor
+
+import (
+	"fmt"
+	"log"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+// RegexProcessor implements the Processor interface using regex patterns
+type RegexProcessor struct{}
+
+// ToLua sets capture groups as Lua variables (v1, v2, etc. for numeric values and s1, s2, etc. for strings)
+func (p *RegexProcessor) ToLua(L *lua.LState, data interface{}) error {
+	captureGroups, ok := data.([]*CaptureGroup)
+	if !ok {
+		return fmt.Errorf("expected []*CaptureGroup for captures, got %T", data)
+	}
+
+	groupindex := 0
+	for _, capture := range captureGroups {
+		if capture.Name == "" {
+			// We don't want to change the name of the capture group
+			// Even if it's empty
+			tempName := fmt.Sprintf("%d", groupindex+1)
+			groupindex++
+
+			L.SetGlobal("s"+tempName, lua.LString(capture.Value))
+
+			val, err := strconv.ParseFloat(capture.Value, 64)
+			if err == nil {
+				L.SetGlobal("v"+tempName, lua.LNumber(val))
+			}
+		} else {
+			val, err := strconv.ParseFloat(capture.Value, 64)
+			if err == nil {
+				L.SetGlobal(capture.Name, lua.LNumber(val))
+			} else {
+				L.SetGlobal(capture.Name, lua.LString(capture.Value))
+			}
+		}
+	}
+
+	return nil
+}
+
+func (p *RegexProcessor) FromLua(L *lua.LState) (interface{}, error) {
+	// Stub to satisfy interface
+	return nil, nil
+}
+
+// FromLua implements the Processor interface for RegexProcessor
+func (p *RegexProcessor) FromLuaCustom(L *lua.LState, captureGroups []*CaptureGroup) ([]*CaptureGroup, error) {
+	captureIndex := 0
+	for _, capture := range captureGroups {
+		if capture.Name == "" {
+			capture.Name = fmt.Sprintf("%d", captureIndex+1)
+
+			vVarName := fmt.Sprintf("v%s", capture.Name)
+			sVarName := fmt.Sprintf("s%s", capture.Name)
+			captureIndex++
+
+			vLuaVal := L.GetGlobal(vVarName)
+			sLuaVal := L.GetGlobal(sVarName)
+
+			if sLuaVal.Type() == lua.LTString {
+				capture.Updated = sLuaVal.String()
+			}
+			// Numbers have priority
+			if vLuaVal.Type() == lua.LTNumber {
+				capture.Updated = vLuaVal.String()
+			}
+		} else {
+			// Easy shit
+			capture.Updated = L.GetGlobal(capture.Name).String()
+		}
+	}
+
+	return captureGroups, nil
+}
+
+type CaptureGroup struct {
+	Name    string
+	Value   string
+	Updated string
+	Range   [2]int
+}
+type ReplaceCommand struct {
+	From int
+	To   int
+	With string
+}
+
+// ProcessContent applies regex replacement with Lua processing
+func (p *RegexProcessor) ProcessContent(content string, pattern string, luaExpr string) (string, int, int, error) {
+	pattern = ResolveRegexPlaceholders(pattern)
+	compiledPattern, err := regexp.Compile(pattern)
+	if err != nil {
+		log.Printf("Error compiling pattern: %v", err)
+		return "", 0, 0, fmt.Errorf("error compiling pattern: %v", err)
+	}
+	log.Printf("Compiled pattern successfully: %s", pattern)
+
+	previous := luaExpr
+	luaExpr = BuildLuaScript(luaExpr)
+	log.Printf("Changing Lua expression from: %s to: %s", previous, luaExpr)
+
+	// Initialize Lua environment
+	modificationCount := 0
+
+	// Process all regex matches
+	result := content
+	indices := compiledPattern.FindAllStringSubmatchIndex(content, -1)
+	log.Printf("Found %d matches in the content", len(indices))
+
+	// We walk backwards because we're replacing something with something else that might be longer
+	// And in the case it is longer than the original all indicces past that change will be fucked up
+	// By going backwards we fuck up all the indices to the end of the file that we don't care about
+	// Because there either aren't any (last match) or they're already modified (subsequent matches)
+	for i := len(indices) - 1; i >= 0; i-- {
+		L, err := NewLuaState()
+		if err != nil {
+			log.Printf("Error creating Lua state: %v", err)
+			return "", 0, 0, fmt.Errorf("error creating Lua state: %v", err)
+		}
+		// Hmm... Maybe we don't want to defer this..
+		// Maybe we want to close them every iteration
+		// We'll leave it as is for now
+		defer L.Close()
+		log.Printf("Lua state created successfully")
+
+		matchIndices := indices[i]
+		log.Printf("Processing match indices: %v", matchIndices)
+
+		// Why we're doing this whole song and dance of indices is to properly handle empty matches
+		// Plus it's a little cleaner to surgically replace our matches
+		// If we were to use string.replace and encountered an empty match there'd be nothing to replace
+		// But using indices an empty match would have its starting and ending indices be the same
+		// So when we're cutting open the array we say 0:7 + modified + 7:end
+		// As if concatenating in the middle of the array
+		// Plus it supports lookarounds
+		match := content[matchIndices[0]:matchIndices[1]]
+		log.Printf("Matched content: %s", match)
+
+		groups := matchIndices[2:]
+		if len(groups) <= 0 {
+			log.Println("No capture groups for lua to chew on")
+			continue
+		}
+		if len(groups)%2 == 1 {
+			log.Println("Odd number of indices of groups, what the fuck?")
+			continue
+		}
+		for _, index := range groups {
+			if index == -1 {
+				// return "", 0, 0, fmt.Errorf("negative indices encountered: %v. This indicates that there was an issue with the match indices, possibly due to an empty match or an unexpected pattern. Please check the regex pattern and input content.", matchIndices)
+				log.Printf("Negative indices encountered: %v. This indicates that there was an issue with the match indices, possibly due to an empty match or an unexpected pattern. This is not an error but it's possibly not what you want.", matchIndices)
+				continue
+			}
+		}
+
+		// We have to use array to preserve order
+		// Very important for the reconstruction step
+		// Because we must overwrite the values in reverse order
+		// See comments a few dozen lines above for more details
+		captureGroups := make([]*CaptureGroup, 0, len(groups)/2)
+		groupNames := compiledPattern.SubexpNames()[1:]
+		for i, name := range groupNames {
+			// if name == "" {
+			// 	continue
+			// }
+			start := groups[i*2]
+			end := groups[i*2+1]
+			if start == -1 || end == -1 {
+				continue
+			}
+
+			captureGroups = append(captureGroups, &CaptureGroup{
+				Name:  name,
+				Value: content[start:end],
+				Range: [2]int{start, end},
+			})
+		}
+
+		log.Printf("Capture groups: %v", captureGroups)
+
+		if err := p.ToLua(L, captureGroups); err != nil {
+			log.Printf("Error setting Lua variables: %v", err)
+			continue
+		}
+		log.Println("Lua variables set successfully")
+
+		if err := L.DoString(luaExpr); err != nil {
+			log.Printf("Error executing Lua code %s for groups %+v: %v", luaExpr, captureGroups, err)
+			continue
+		}
+		log.Println("Lua code executed successfully")
+
+		// Get modifications from Lua
+		captureGroups, err = p.FromLuaCustom(L, captureGroups)
+		if err != nil {
+			log.Printf("Error getting modifications: %v", err)
+			continue
+		}
+
+		replacement := ""
+		replacementVar := L.GetGlobal("replacement")
+		if replacementVar.Type() != lua.LTNil {
+			replacement = replacementVar.String()
+		}
+		if replacement == "" {
+			commands := make([]ReplaceCommand, 0, len(captureGroups))
+			// Apply the modifications to the original match
+			replacement = match
+			for _, capture := range captureGroups {
+				log.Printf("Applying modification: %s", capture.Updated)
+				// Indices of the group are relative to content
+				// To relate them to match we have to subtract the match start index
+				// replacement = replacement[:groupStart] + newVal + replacement[groupEnd:]
+				commands = append(commands, ReplaceCommand{
+					From: capture.Range[0] - matchIndices[0],
+					To:   capture.Range[1] - matchIndices[0],
+					With: capture.Updated,
+				})
+			}
+
+			sort.Slice(commands, func(i, j int) bool {
+				return commands[i].From > commands[j].From
+			})
+
+			for _, command := range commands {
+				replacement = replacement[:command.From] + command.With + replacement[command.To:]
+			}
+		}
+		modificationCount++
+		result = result[:matchIndices[0]] + replacement + result[matchIndices[1]:]
+		log.Printf("Modification count updated: %d", modificationCount)
+	}
+
+	log.Printf("Process completed with %d modifications", modificationCount)
+	return result, modificationCount, len(indices), nil
+}
+
+// The order of these replaces is important
+// This one handles !num-s inside of named capture groups
+// If it were not here our !num in a named capture group would
+// Expand to another capture group in the capture group
+// We really only want one (our named) capture group
+func ResolveRegexPlaceholders(pattern string) string {
+	// Handle special pattern modifications
+	if !strings.HasPrefix(pattern, "(?s)") {
+		pattern = "(?s)" + pattern
+		log.Printf("Pattern modified to include (?s): %s", pattern)
+	}
+
+	namedGroupNum := regexp.MustCompile(`(?:(\?<[^>]+>)(!num))`)
+	pattern = namedGroupNum.ReplaceAllStringFunc(pattern, func(match string) string {
+		parts := namedGroupNum.FindStringSubmatch(match)
+		if len(parts) != 3 {
+			return match
+		}
+		replacement := `-?\d*\.?\d+`
+		return parts[1] + replacement
+	})
+	pattern = strings.ReplaceAll(pattern, "!num", `"?(-?\d*\.?\d+)"?`)
+	pattern = strings.ReplaceAll(pattern, "!any", `.*?`)
+	repPattern := regexp.MustCompile(`!rep\(([^,]+),\s*(\d+)\)`)
+	// !rep(pattern, count) repeats the pattern n times
+	// Inserting !any between each repetition
+	pattern = repPattern.ReplaceAllStringFunc(pattern, func(match string) string {
+		parts := repPattern.FindStringSubmatch(match)
+		if len(parts) != 3 {
+			return match
+		}
+		repeatedPattern := parts[1]
+		count := parts[2]
+		repetitions, _ := strconv.Atoi(count)
+		return strings.Repeat(repeatedPattern+".*?", repetitions-1) + repeatedPattern
+	})
+	return pattern
+}
--- a/processor/regex_test.go
+++ b/processor/regex_test.go
--- a/processor/xml.go
+++ b/processor/xml.go
@@ -0,0 +1,412 @@
+package processor
+
+import (
+	"fmt"
+	"log"
+	"modify/processor/xpath"
+	"strings"
+
+	"github.com/antchfx/xmlquery"
+	lua "github.com/yuin/gopher-lua"
+)
+
+// XMLProcessor implements the Processor interface for XML documents
+type XMLProcessor struct{}
+
+// ProcessContent implements the Processor interface for XMLProcessor
+func (p *XMLProcessor) ProcessContent(content string, path string, luaExpr string) (string, int, int, error) {
+	// Parse XML document
+	// We can't really use encoding/xml here because it requires a pre defined struct
+	// And we HAVE TO parse dynamic unknown XML
+	doc, err := xmlquery.Parse(strings.NewReader(content))
+	if err != nil {
+		return content, 0, 0, fmt.Errorf("error parsing XML: %v", err)
+	}
+
+	// Find nodes matching the XPath pattern
+	nodes, err := xpath.Get(doc, path)
+	if err != nil {
+		return content, 0, 0, fmt.Errorf("error executing XPath: %v", err)
+	}
+
+	matchCount := len(nodes)
+	if matchCount == 0 {
+		return content, 0, 0, nil
+	}
+
+	// Apply modifications to each node
+	modCount := 0
+	for _, node := range nodes {
+		L, err := NewLuaState()
+		if err != nil {
+			return content, 0, 0, fmt.Errorf("error creating Lua state: %v", err)
+		}
+		defer L.Close()
+
+		err = p.ToLua(L, node)
+		if err != nil {
+			return content, modCount, matchCount, fmt.Errorf("error converting to Lua: %v", err)
+		}
+
+		err = L.DoString(BuildLuaScript(luaExpr))
+		if err != nil {
+			return content, modCount, matchCount, fmt.Errorf("error executing Lua: %v", err)
+		}
+
+		result, err := p.FromLua(L)
+		if err != nil {
+			return content, modCount, matchCount, fmt.Errorf("error getting result from Lua: %v", err)
+		}
+		log.Printf("%#v", result)
+
+		modified := false
+		modified = L.GetGlobal("modified").String() == "true"
+		if !modified {
+			log.Printf("No changes made to node at path: %s", node.Data)
+			continue
+		}
+
+		// Apply modification based on the result
+		if updatedValue, ok := result.(string); ok {
+			// If the result is a simple string, update the node value directly
+			xpath.Set(doc, path, updatedValue)
+		} else if nodeData, ok := result.(map[string]interface{}); ok {
+			// If the result is a map, apply more complex updates
+			updateNodeFromMap(node, nodeData)
+		}
+
+		modCount++
+	}
+
+	// Serialize the modified XML document to string
+	if doc.FirstChild != nil && doc.FirstChild.Type == xmlquery.DeclarationNode {
+		// If we have an XML declaration, start with it
+		declaration := doc.FirstChild.OutputXML(true)
+		// Remove the firstChild (declaration) before serializing the rest of the document
+		doc.FirstChild = doc.FirstChild.NextSibling
+		return ConvertToNamedEntities(declaration + doc.OutputXML(true)), modCount, matchCount, nil
+	}
+
+	// Convert numeric entities to named entities for better readability
+	return ConvertToNamedEntities(doc.OutputXML(true)), modCount, matchCount, nil
+}
+
+func (p *XMLProcessor) ToLua(L *lua.LState, data interface{}) error {
+	table, err := p.ToLuaTable(L, data)
+	if err != nil {
+		return err
+	}
+	L.SetGlobal("v", table)
+	return nil
+}
+
+// ToLua converts XML node values to Lua variables
+func (p *XMLProcessor) ToLuaTable(L *lua.LState, data interface{}) (lua.LValue, error) {
+	// Check if data is an xmlquery.Node
+	node, ok := data.(*xmlquery.Node)
+	if !ok {
+		return nil, fmt.Errorf("expected xmlquery.Node, got %T", data)
+	}
+
+	// Create a simple table with essential data
+	table := L.NewTable()
+
+	// For element nodes, just provide basic info
+	L.SetField(table, "type", lua.LString(nodeTypeToString(node.Type)))
+	L.SetField(table, "name", lua.LString(node.Data))
+	L.SetField(table, "value", lua.LString(node.InnerText()))
+
+	// Add children if any
+	children := L.NewTable()
+	for child := node.FirstChild; child != nil; child = child.NextSibling {
+		childTable, err := p.ToLuaTable(L, child)
+		if err == nil {
+			children.Append(childTable)
+		}
+	}
+	L.SetField(table, "children", children)
+
+	attrs := L.NewTable()
+	if len(node.Attr) > 0 {
+		for _, attr := range node.Attr {
+			L.SetField(attrs, attr.Name.Local, lua.LString(attr.Value))
+		}
+	}
+	L.SetField(table, "attr", attrs)
+
+	return table, nil
+}
+
+// FromLua gets modified values from Lua
+func (p *XMLProcessor) FromLua(L *lua.LState) (interface{}, error) {
+	luaValue := L.GetGlobal("v")
+
+	// Handle string values directly
+	if luaValue.Type() == lua.LTString {
+		return luaValue.String(), nil
+	}
+
+	// Handle tables (for attributes and more complex updates)
+	if luaValue.Type() == lua.LTTable {
+		return luaTableToMap(L, luaValue.(*lua.LTable)), nil
+	}
+
+	return luaValue.String(), nil
+}
+
+// Simple helper to convert a Lua table to a Go map
+func luaTableToMap(L *lua.LState, table *lua.LTable) map[string]interface{} {
+	result := make(map[string]interface{})
+
+	table.ForEach(func(k, v lua.LValue) {
+		if k.Type() == lua.LTString {
+			key := k.String()
+
+			if v.Type() == lua.LTTable {
+				result[key] = luaTableToMap(L, v.(*lua.LTable))
+			} else {
+				result[key] = v.String()
+			}
+		}
+	})
+
+	return result
+}
+
+// Simple helper to convert node type to string
+func nodeTypeToString(nodeType xmlquery.NodeType) string {
+	switch nodeType {
+	case xmlquery.ElementNode:
+		return "element"
+	case xmlquery.TextNode:
+		return "text"
+	case xmlquery.AttributeNode:
+		return "attribute"
+	default:
+		return "other"
+	}
+}
+
+// Helper function to update an XML node from a map
+func updateNodeFromMap(node *xmlquery.Node, data map[string]interface{}) {
+	// Update node value if present
+	if value, ok := data["value"]; ok {
+		if strValue, ok := value.(string); ok {
+			// For element nodes, replace text content
+			if node.Type == xmlquery.ElementNode {
+				// Find the first text child if it exists
+				var textNode *xmlquery.Node
+				for child := node.FirstChild; child != nil; child = child.NextSibling {
+					if child.Type == xmlquery.TextNode {
+						textNode = child
+						break
+					}
+				}
+
+				if textNode != nil {
+					// Update existing text node
+					textNode.Data = strValue
+				} else {
+					// Create new text node
+					newText := &xmlquery.Node{
+						Type:   xmlquery.TextNode,
+						Data:   strValue,
+						Parent: node,
+					}
+
+					// Insert at beginning of children
+					if node.FirstChild != nil {
+						newText.NextSibling = node.FirstChild
+						node.FirstChild.PrevSibling = newText
+						node.FirstChild = newText
+					} else {
+						node.FirstChild = newText
+						node.LastChild = newText
+					}
+				}
+			} else if node.Type == xmlquery.TextNode {
+				// Directly update text node
+				node.Data = strValue
+			} else if node.Type == xmlquery.AttributeNode {
+				// Update attribute value
+				if node.Parent != nil {
+					for i, attr := range node.Parent.Attr {
+						if attr.Name.Local == node.Data {
+							node.Parent.Attr[i].Value = strValue
+							break
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Update attributes if present
+	if attrs, ok := data["attr"].(map[string]interface{}); ok && node.Type == xmlquery.ElementNode {
+		for name, value := range attrs {
+			if strValue, ok := value.(string); ok {
+				// Look for existing attribute
+				found := false
+				for i, attr := range node.Attr {
+					if attr.Name.Local == name {
+						node.Attr[i].Value = strValue
+						found = true
+						break
+					}
+				}
+
+				// Add new attribute if not found
+				if !found {
+					node.Attr = append(node.Attr, xmlquery.Attr{
+						Name: struct {
+							Space, Local string
+						}{Local: name},
+						Value: strValue,
+					})
+				}
+			}
+		}
+	}
+}
+
+// Helper function to get a string representation of node type
+func nodeTypeName(nodeType xmlquery.NodeType) string {
+	switch nodeType {
+	case xmlquery.ElementNode:
+		return "element"
+	case xmlquery.TextNode:
+		return "text"
+	case xmlquery.AttributeNode:
+		return "attribute"
+	case xmlquery.CommentNode:
+		return "comment"
+	case xmlquery.DeclarationNode:
+		return "declaration"
+	default:
+		return "unknown"
+	}
+}
+
+// ConvertToNamedEntities replaces numeric XML entities with their named counterparts
+func ConvertToNamedEntities(xml string) string {
+	// Basic XML entities
+	replacements := map[string]string{
+		// Basic XML entities
+		"&#34;": "&quot;", // double quote
+		"&#39;": "&apos;", // single quote
+		"&#60;": "&lt;",   // less than
+		"&#62;": "&gt;",   // greater than
+		"&#38;": "&amp;",  // ampersand
+
+		// Common symbols
+		"&#160;":  "&nbsp;",   // non-breaking space
+		"&#169;":  "&copy;",   // copyright
+		"&#174;":  "&reg;",    // registered trademark
+		"&#8364;": "&euro;",   // euro
+		"&#163;":  "&pound;",  // pound
+		"&#165;":  "&yen;",    // yen
+		"&#162;":  "&cent;",   // cent
+		"&#167;":  "&sect;",   // section
+		"&#8482;": "&trade;",  // trademark
+		"&#9824;": "&spades;", // spade
+		"&#9827;": "&clubs;",  // club
+		"&#9829;": "&hearts;", // heart
+		"&#9830;": "&diams;",  // diamond
+
+		// Special characters
+		"&#161;":  "&iexcl;",  // inverted exclamation
+		"&#191;":  "&iquest;", // inverted question
+		"&#171;":  "&laquo;",  // left angle quotes
+		"&#187;":  "&raquo;",  // right angle quotes
+		"&#183;":  "&middot;", // middle dot
+		"&#8226;": "&bull;",   // bullet
+		"&#8230;": "&hellip;", // horizontal ellipsis
+		"&#8242;": "&prime;",  // prime
+		"&#8243;": "&Prime;",  // double prime
+		"&#8254;": "&oline;",  // overline
+		"&#8260;": "&frasl;",  // fraction slash
+
+		// Math symbols
+		"&#177;":  "&plusmn;", // plus-minus
+		"&#215;":  "&times;",  // multiplication
+		"&#247;":  "&divide;", // division
+		"&#8734;": "&infin;",  // infinity
+		"&#8776;": "&asymp;",  // almost equal
+		"&#8800;": "&ne;",     // not equal
+		"&#8804;": "&le;",     // less than or equal
+		"&#8805;": "&ge;",     // greater than or equal
+		"&#8721;": "&sum;",    // summation
+		"&#8730;": "&radic;",  // square root
+		"&#8747;": "&int;",    // integral
+
+		// Accented characters
+		"&#192;": "&Agrave;", // A grave
+		"&#193;": "&Aacute;", // A acute
+		"&#194;": "&Acirc;",  // A circumflex
+		"&#195;": "&Atilde;", // A tilde
+		"&#196;": "&Auml;",   // A umlaut
+		"&#197;": "&Aring;",  // A ring
+		"&#198;": "&AElig;",  // AE ligature
+		"&#199;": "&Ccedil;", // C cedilla
+		"&#200;": "&Egrave;", // E grave
+		"&#201;": "&Eacute;", // E acute
+		"&#202;": "&Ecirc;",  // E circumflex
+		"&#203;": "&Euml;",   // E umlaut
+		"&#204;": "&Igrave;", // I grave
+		"&#205;": "&Iacute;", // I acute
+		"&#206;": "&Icirc;",  // I circumflex
+		"&#207;": "&Iuml;",   // I umlaut
+		"&#208;": "&ETH;",    // Eth
+		"&#209;": "&Ntilde;", // N tilde
+		"&#210;": "&Ograve;", // O grave
+		"&#211;": "&Oacute;", // O acute
+		"&#212;": "&Ocirc;",  // O circumflex
+		"&#213;": "&Otilde;", // O tilde
+		"&#214;": "&Ouml;",   // O umlaut
+		"&#216;": "&Oslash;", // O slash
+		"&#217;": "&Ugrave;", // U grave
+		"&#218;": "&Uacute;", // U acute
+		"&#219;": "&Ucirc;",  // U circumflex
+		"&#220;": "&Uuml;",   // U umlaut
+		"&#221;": "&Yacute;", // Y acute
+		"&#222;": "&THORN;",  // Thorn
+		"&#223;": "&szlig;",  // Sharp s
+		"&#224;": "&agrave;", // a grave
+		"&#225;": "&aacute;", // a acute
+		"&#226;": "&acirc;",  // a circumflex
+		"&#227;": "&atilde;", // a tilde
+		"&#228;": "&auml;",   // a umlaut
+		"&#229;": "&aring;",  // a ring
+		"&#230;": "&aelig;",  // ae ligature
+		"&#231;": "&ccedil;", // c cedilla
+		"&#232;": "&egrave;", // e grave
+		"&#233;": "&eacute;", // e acute
+		"&#234;": "&ecirc;",  // e circumflex
+		"&#235;": "&euml;",   // e umlaut
+		"&#236;": "&igrave;", // i grave
+		"&#237;": "&iacute;", // i acute
+		"&#238;": "&icirc;",  // i circumflex
+		"&#239;": "&iuml;",   // i umlaut
+		"&#240;": "&eth;",    // eth
+		"&#241;": "&ntilde;", // n tilde
+		"&#242;": "&ograve;", // o grave
+		"&#243;": "&oacute;", // o acute
+		"&#244;": "&ocirc;",  // o circumflex
+		"&#245;": "&otilde;", // o tilde
+		"&#246;": "&ouml;",   // o umlaut
+		"&#248;": "&oslash;", // o slash
+		"&#249;": "&ugrave;", // u grave
+		"&#250;": "&uacute;", // u acute
+		"&#251;": "&ucirc;",  // u circumflex
+		"&#252;": "&uuml;",   // u umlaut
+		"&#253;": "&yacute;", // y acute
+		"&#254;": "&thorn;",  // thorn
+		"&#255;": "&yuml;",   // y umlaut
+	}
+
+	result := xml
+	for numeric, named := range replacements {
+		result = strings.ReplaceAll(result, numeric, named)
+	}
+	return result
+}
--- a/processor/xml_test.go
+++ b/processor/xml_test.go
--- a/processor/xpath/parser_manual_test.go
+++ b/processor/xpath/parser_manual_test.go
@@ -0,0 +1,4 @@
+// The package is now using github.com/antchfx/xmlquery for XPath parsing.
+// The parsing functionality tests have been removed since we're now
+// delegating XPath parsing to the xmlquery library.
+package xpath
--- a/processor/xpath/parser_test.go
+++ b/processor/xpath/parser_test.go
@@ -0,0 +1,4 @@
+// The package is now using github.com/antchfx/xmlquery for XPath parsing.
+// The parsing functionality tests have been removed since we're now
+// delegating XPath parsing to the xmlquery library.
+package xpath
--- a/processor/xpath/xpath.go
+++ b/processor/xpath/xpath.go
@@ -0,0 +1,133 @@
+package xpath
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/antchfx/xmlquery"
+)
+
+// Get retrieves nodes from XML data using an XPath expression
+func Get(node *xmlquery.Node, path string) ([]*xmlquery.Node, error) {
+	if node == nil {
+		return nil, errors.New("nil node provided")
+	}
+
+	// Execute xpath query directly
+	nodes, err := xmlquery.QueryAll(node, path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute XPath query: %v", err)
+	}
+
+	return nodes, nil
+}
+
+// Set updates a single node in the XML data using an XPath expression
+func Set(node *xmlquery.Node, path string, value interface{}) error {
+	if node == nil {
+		return errors.New("nil node provided")
+	}
+
+	// Find the node to update
+	nodes, err := xmlquery.QueryAll(node, path)
+	if err != nil {
+		return fmt.Errorf("failed to execute XPath query: %v", err)
+	}
+
+	if len(nodes) == 0 {
+		return fmt.Errorf("no nodes found for path: %s", path)
+	}
+
+	// Update the first matching node
+	updateNodeValue(nodes[0], value)
+
+	return nil
+}
+
+// SetAll updates all nodes that match the XPath expression
+func SetAll(node *xmlquery.Node, path string, value interface{}) error {
+	if node == nil {
+		return errors.New("nil node provided")
+	}
+
+	// Find all nodes to update
+	nodes, err := xmlquery.QueryAll(node, path)
+	if err != nil {
+		return fmt.Errorf("failed to execute XPath query: %v", err)
+	}
+
+	if len(nodes) == 0 {
+		return fmt.Errorf("no nodes found for path: %s", path)
+	}
+
+	// Update all matching nodes
+	for _, matchNode := range nodes {
+		updateNodeValue(matchNode, value)
+	}
+
+	return nil
+}
+
+// Helper function to update a node's value
+func updateNodeValue(node *xmlquery.Node, value interface{}) {
+	strValue := fmt.Sprintf("%v", value)
+
+	// Handle different node types
+	switch node.Type {
+	case xmlquery.AttributeNode:
+		// For attribute nodes, update the attribute value
+		parent := node.Parent
+		if parent != nil {
+			for i, attr := range parent.Attr {
+				if attr.Name.Local == node.Data {
+					parent.Attr[i].Value = strValue
+					break
+				}
+			}
+		}
+	case xmlquery.TextNode:
+		// For text nodes, update the text content
+		node.Data = strValue
+	case xmlquery.ElementNode:
+		// For element nodes, clear existing text children and add a new text node
+		// First, remove all existing text children
+		var nonTextChildren []*xmlquery.Node
+		for child := node.FirstChild; child != nil; child = child.NextSibling {
+			if child.Type != xmlquery.TextNode {
+				nonTextChildren = append(nonTextChildren, child)
+			}
+		}
+
+		// Clear all children
+		node.FirstChild = nil
+		node.LastChild = nil
+
+		// Add a new text node
+		textNode := &xmlquery.Node{
+			Type:   xmlquery.TextNode,
+			Data:   strValue,
+			Parent: node,
+		}
+
+		// Set the text node as the first child
+		node.FirstChild = textNode
+		node.LastChild = textNode
+
+		// Add back non-text children
+		for _, child := range nonTextChildren {
+			child.Parent = node
+
+			// If this is the first child being added back
+			if node.FirstChild == textNode && node.LastChild == textNode {
+				node.FirstChild.NextSibling = child
+				child.PrevSibling = node.FirstChild
+				node.LastChild = child
+			} else {
+				// Add to the end of the chain
+				node.LastChild.NextSibling = child
+				child.PrevSibling = node.LastChild
+				node.LastChild = child
+			}
+		}
+	}
+}
--- a/processor/xpath/xpath_test.go
+++ b/processor/xpath/xpath_test.go
@@ -0,0 +1,474 @@
+package xpath
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/antchfx/xmlquery"
+)
+
+// Parse test XML data once at the beginning for use in multiple tests
+func parseTestXML(t *testing.T, xmlData string) *xmlquery.Node {
+	doc, err := xmlquery.Parse(strings.NewReader(xmlData))
+	if err != nil {
+		t.Fatalf("Failed to parse test XML: %v", err)
+	}
+	return doc
+}
+
+// XML test data as a string for our tests
+var testXML = `
+<store>
+  <book category="fiction">
+    <title lang="en">The Fellowship of the Ring</title>
+    <author>J.R.R. Tolkien</author>
+    <year>1954</year>
+    <price>22.99</price>
+  </book>
+  <book category="fiction">
+    <title lang="en">The Two Towers</title>
+    <author>J.R.R. Tolkien</author>
+    <year>1954</year>
+    <price>23.45</price>
+  </book>
+  <book category="technical">
+    <title lang="en">Learning XML</title>
+    <author>Erik T. Ray</author>
+    <year>2003</year>
+    <price>39.95</price>
+  </book>
+  <bicycle>
+    <color>red</color>
+    <price>199.95</price>
+  </bicycle>
+</store>
+`
+
+func TestEvaluator(t *testing.T) {
+	// Parse the test XML data once for all test cases
+	doc := parseTestXML(t, testXML)
+
+	tests := []struct {
+		name  string
+		path  string
+		error bool
+	}{
+		{
+			name: "simple_element_access",
+			path: "/store/bicycle/color",
+		},
+		{
+			name: "recursive_element_access",
+			path: "//price",
+		},
+		{
+			name: "wildcard_element_access",
+			path: "/store/book/*",
+		},
+		{
+			name: "attribute_exists_predicate",
+			path: "//title[@lang]",
+		},
+		{
+			name: "attribute_equals_predicate",
+			path: "//title[@lang='en']",
+		},
+		{
+			name:  "value_comparison_predicate",
+			path:  "/store/book[price>35.00]/title",
+			error: true,
+		},
+		{
+			name:  "last_predicate",
+			path:  "/store/book[last()]/title",
+			error: true,
+		},
+		{
+			name:  "last_minus_predicate",
+			path:  "/store/book[last()-1]/title",
+			error: true,
+		},
+		{
+			name:  "position_predicate",
+			path:  "/store/book[position()<3]/title",
+			error: true,
+		},
+		{
+			name:  "invalid_index",
+			path:  "/store/book[10]/title",
+			error: true,
+		},
+		{
+			name: "nonexistent_element",
+			path: "/store/nonexistent",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := Get(doc, tt.path)
+
+			// Handle expected errors
+			if tt.error {
+				if err == nil && len(result) == 0 {
+					// If we expected an error but got empty results instead, that's okay
+					return
+				}
+				if err != nil {
+					// If we got an error as expected, that's okay
+					return
+				}
+			} else if err != nil {
+				// If we didn't expect an error but got one, that's a test failure
+				t.Errorf("Get(%q) returned unexpected error: %v", tt.path, err)
+				return
+			}
+
+			// Special cases where we don't care about exact matches
+			switch tt.name {
+			case "wildcard_element_access":
+				// Just check that we got some elements
+				if len(result) == 0 {
+					t.Errorf("Expected multiple elements for wildcard, got none")
+				}
+				return
+			case "attribute_exists_predicate", "attribute_equals_predicate":
+				// Just check that we got some titles
+				if len(result) == 0 {
+					t.Errorf("Expected titles with lang attribute, got none")
+				}
+				// Ensure all are title elements
+				for _, node := range result {
+					if node.Data != "title" {
+						t.Errorf("Expected title elements, got: %s", node.Data)
+					}
+				}
+				return
+			case "nonexistent_element":
+				// Just check that we got empty results
+				if len(result) != 0 {
+					t.Errorf("Expected empty results for nonexistent element, got %d items", len(result))
+				}
+				return
+			}
+
+			// For other cases, just verify we got results
+			if len(result) == 0 {
+				t.Errorf("Expected results for path %s, got none", tt.path)
+			}
+		})
+	}
+}
+
+func TestEdgeCases(t *testing.T) {
+	t.Run("nil_node", func(t *testing.T) {
+		result, err := Get(nil, "/store/book")
+		if err == nil {
+			t.Errorf("Expected error for nil node")
+			return
+		}
+		if len(result) > 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+
+	t.Run("invalid_xml", func(t *testing.T) {
+		invalidXML, err := xmlquery.Parse(strings.NewReader("<invalid>xml"))
+		if err != nil {
+			// If parsing fails, that's expected
+			return
+		}
+
+		_, err = Get(invalidXML, "/store")
+		if err == nil {
+			t.Error("Expected error for invalid XML structure")
+		}
+	})
+
+	// For these tests with the simple XML, we expect just one result
+	simpleXML := `<root><book><title lang="en">Test</title></book></root>`
+	doc := parseTestXML(t, simpleXML)
+
+	t.Run("current_node", func(t *testing.T) {
+		result, err := Get(doc, "/root/book/.")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+		if len(result) > 1 {
+			t.Errorf("Expected at most 1 result, got %d", len(result))
+		}
+		if len(result) > 0 {
+			// Verify it's the book node
+			if result[0].Data != "book" {
+				t.Errorf("Expected book node, got %v", result[0].Data)
+			}
+		}
+	})
+
+	t.Run("attributes", func(t *testing.T) {
+		result, err := Get(doc, "/root/book/title/@lang")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+		if len(result) != 1 || result[0].InnerText() != "en" {
+			t.Errorf("Expected 'en', got %v", result[0].InnerText())
+		}
+	})
+}
+
+func TestGetWithPaths(t *testing.T) {
+	// Use a simplified, well-formed XML document
+	simpleXML := `<store>
+  <book category="fiction">
+    <title lang="en">The Book Title</title>
+    <author>Author Name</author>
+    <price>19.99</price>
+  </book>
+  <bicycle>
+    <color>red</color>
+    <price>199.95</price>
+  </bicycle>
+</store>`
+
+	// Parse the XML for testing
+	doc := parseTestXML(t, simpleXML)
+
+	// Debug: Print the test XML
+	t.Logf("Test XML:\n%s", simpleXML)
+
+	tests := []struct {
+		name          string
+		path          string
+		expectedValue string
+	}{
+		{
+			name:          "simple_element_access",
+			path:          "/store/bicycle/color",
+			expectedValue: "red",
+		},
+		{
+			name:          "attribute_access",
+			path:          "/store/book/title/@lang",
+			expectedValue: "en",
+		},
+		{
+			name:          "recursive_with_attribute",
+			path:          "//title[@lang='en']",
+			expectedValue: "The Book Title",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Debug: Print the path we're looking for
+			t.Logf("Looking for path: %s", tt.path)
+
+			result, err := Get(doc, tt.path)
+			if err != nil {
+				t.Errorf("Get(%q) returned error: %v", tt.path, err)
+				return
+			}
+
+			// Debug: Print the results
+			t.Logf("Got %d results", len(result))
+			for i, r := range result {
+				t.Logf("Result %d: Node=%s, Value=%v", i, r.Data, r.InnerText())
+			}
+
+			// Check that we got results
+			if len(result) == 0 {
+				t.Errorf("Get(%q) returned no results", tt.path)
+				return
+			}
+
+			// For attribute access test, do more specific checks
+			if tt.name == "attribute_access" {
+				// Check the first result's value matches expected
+				if result[0].InnerText() != tt.expectedValue {
+					t.Errorf("Attribute value: got %v, expected %s", result[0].InnerText(), tt.expectedValue)
+				}
+			}
+
+			// For simple element access, check the text content
+			if tt.name == "simple_element_access" {
+				if text := result[0].InnerText(); text != tt.expectedValue {
+					t.Errorf("Element text: got %s, expected %s", text, tt.expectedValue)
+				}
+			}
+
+			// For recursive with attribute test, check title elements with lang="en"
+			if tt.name == "recursive_with_attribute" {
+				for _, node := range result {
+					// Check the node is a title
+					if node.Data != "title" {
+						t.Errorf("Expected title element, got %s", node.Data)
+					}
+
+					// Check text content
+					if text := node.InnerText(); text != tt.expectedValue {
+						t.Errorf("Text content: got %s, expected %s", text, tt.expectedValue)
+					}
+
+					// Check attributes - find the lang attribute
+					hasLang := false
+					for _, attr := range node.Attr {
+						if attr.Name.Local == "lang" && attr.Value == "en" {
+							hasLang = true
+							break
+						}
+					}
+					if !hasLang {
+						t.Errorf("Expected lang=\"en\" attribute, but it was not found")
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestSet(t *testing.T) {
+	t.Run("simple element", func(t *testing.T) {
+		xmlData := `<root><name>John</name></root>`
+		doc := parseTestXML(t, xmlData)
+
+		err := Set(doc, "/root/name", "Jane")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		// Verify the change
+		result, err := Get(doc, "/root/name")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+		if len(result) != 1 {
+			t.Errorf("Expected 1 result, got %d", len(result))
+			return
+		}
+
+		// Check text content
+		if text := result[0].InnerText(); text != "Jane" {
+			t.Errorf("Expected text 'Jane', got '%s'", text)
+		}
+	})
+
+	t.Run("attribute", func(t *testing.T) {
+		xmlData := `<root><element id="123"></element></root>`
+		doc := parseTestXML(t, xmlData)
+
+		err := Set(doc, "/root/element/@id", "456")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		// Verify the change
+		result, err := Get(doc, "/root/element/@id")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+		if len(result) != 1 {
+			t.Errorf("Expected 1 result, got %d", len(result))
+			return
+		}
+
+		// For attributes, check the inner text
+		if text := result[0].InnerText(); text != "456" {
+			t.Errorf("Expected attribute value '456', got '%s'", text)
+		}
+	})
+
+	t.Run("indexed element", func(t *testing.T) {
+		xmlData := `<root><items><item>first</item><item>second</item></items></root>`
+		doc := parseTestXML(t, xmlData)
+
+		err := Set(doc, "/root/items/item[1]", "changed")
+		if err != nil {
+			t.Errorf("Set() returned error: %v", err)
+			return
+		}
+
+		// Verify the change using XPath that specifically targets the first item
+		result, err := Get(doc, "/root/items/item[1]")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+
+		// Check if we have results
+		if len(result) == 0 {
+			t.Errorf("Expected at least one result for /root/items/item[1]")
+			return
+		}
+
+		// Check text content
+		if text := result[0].InnerText(); text != "changed" {
+			t.Errorf("Expected text 'changed', got '%s'", text)
+		}
+	})
+}
+
+func TestSetAll(t *testing.T) {
+	t.Run("multiple elements", func(t *testing.T) {
+		xmlData := `<root><items><item>first</item><item>second</item></items></root>`
+		doc := parseTestXML(t, xmlData)
+
+		err := SetAll(doc, "//item", "changed")
+		if err != nil {
+			t.Errorf("SetAll() returned error: %v", err)
+			return
+		}
+
+		// Verify all items are changed
+		result, err := Get(doc, "//item")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+		if len(result) != 2 {
+			t.Errorf("Expected 2 results, got %d", len(result))
+			return
+		}
+
+		// Check each node
+		for i, node := range result {
+			if text := node.InnerText(); text != "changed" {
+				t.Errorf("Item %d: expected text 'changed', got '%s'", i, text)
+			}
+		}
+	})
+
+	t.Run("attributes", func(t *testing.T) {
+		xmlData := `<root><item id="1"/><item id="2"/></root>`
+		doc := parseTestXML(t, xmlData)
+
+		err := SetAll(doc, "//item/@id", "new")
+		if err != nil {
+			t.Errorf("SetAll() returned error: %v", err)
+			return
+		}
+
+		// Verify all attributes are changed
+		result, err := Get(doc, "//item/@id")
+		if err != nil {
+			t.Errorf("Get() returned error: %v", err)
+			return
+		}
+		if len(result) != 2 {
+			t.Errorf("Expected 2 results, got %d", len(result))
+			return
+		}
+
+		// For attributes, check inner text
+		for i, node := range result {
+			if text := node.InnerText(); text != "new" {
+				t.Errorf("Attribute %d: expected value 'new', got '%s'", i, text)
+			}
+		}
+	})
+}
--- a/regression/SliceOutOfRange_test.go
+++ b/regression/SliceOutOfRange_test.go
@@ -0,0 +1,83 @@
+package regression
+
+import (
+	"modify/processor"
+	"testing"
+)
+
+func TestTalentsMechanicOutOfRange(t *testing.T) {
+	given := `<Talent identifier="quickfixer">
+    <Icon texture="Content/UI/TalentsIcons2.png" sheetindex="5,2" sheetelementsize="128,128"/>
+    <Description tag="talentdescription.quickfixer">
+      <Replace tag="[amount]" value="20" color="gui.green"/>
+      <Replace tag="[duration]" value="10" color="gui.green"/>
+    </Description>
+    <Description tag="talentdescription.repairmechanicaldevicestwiceasfast"/>
+    <AbilityGroupEffect abilityeffecttype="None">
+      <Abilities>
+        <CharacterAbilityGiveStat stattype="MechanicalRepairSpeed" value="1"/>
+      </Abilities>
+    </AbilityGroupEffect>
+    <AbilityGroupEffect abilityeffecttype="OnRepairComplete">
+      <Conditions>
+        <AbilityConditionItem tags="fabricator,door,engine,oxygengenerator,pump,turretammosource,deconstructor,medicalfabricator,ductblock"/>
+      </Conditions>
+      <Abilities>
+        <CharacterAbilityApplyStatusEffects>
+          <StatusEffects>
+            <StatusEffect type="OnAbility" target="Character" disabledeltatime="true">
+              <Affliction identifier="quickfixer" amount="10.0"/>
+            </StatusEffect>
+          </StatusEffects>
+        </CharacterAbilityApplyStatusEffects>
+      </Abilities>
+    </AbilityGroupEffect>
+  </Talent>`
+
+	actual := `<Talent identifier="quickfixer">
+    <Icon texture="Content/UI/TalentsIcons2.png" sheetindex="5,2" sheetelementsize="128,128"/>
+    <Description tag="talentdescription.quickfixer">
+      <Replace tag="[amount]" value="30" color="gui.green"/>
+      <Replace tag="[duration]" value="20" color="gui.green"/>
+    </Description>
+    <Description tag="talentdescription.repairmechanicaldevicestwiceasfast"/>
+    <AbilityGroupEffect abilityeffecttype="None">
+      <Abilities>
+        <CharacterAbilityGiveStat stattype="MechanicalRepairSpeed" value="2"/>
+      </Abilities>
+    </AbilityGroupEffect>
+    <AbilityGroupEffect abilityeffecttype="OnRepairComplete">
+      <Conditions>
+        <AbilityConditionItem tags="fabricator,door,engine,oxygengenerator,pump,turretammosource,deconstructor,medicalfabricator,ductblock"/>
+      </Conditions>
+      <Abilities>
+        <CharacterAbilityApplyStatusEffects>
+          <StatusEffects>
+            <StatusEffect type="OnAbility" target="Character" disabledeltatime="true">
+              <Affliction identifier="quickfixer" amount="20"/>
+            </StatusEffect>
+          </StatusEffects>
+        </CharacterAbilityApplyStatusEffects>
+      </Abilities>
+    </AbilityGroupEffect>
+  </Talent>`
+
+	p := &processor.RegexProcessor{}
+	result, mods, matches, err := p.ProcessContent(given, `<Talent identifier="quickfixer">!anyvalue="(?<movementspeed>!num)"!anyvalue="(?<duration>!num)"!anyvalue="(?<repairspeed>!num)"!anyamount="(?<durationv>!num)"`, "movementspeed=round(movementspeed*1.5, 2) duration=round(duration*2, 2) repairspeed=round(repairspeed*2, 2) durationv=duration")
+
+	if err != nil {
+		t.Fatalf("Error processing content: %v", err)
+	}
+
+	if matches != 1 {
+		t.Errorf("Expected 1 match, got %d", matches)
+	}
+
+	if mods != 1 {
+		t.Errorf("Expected 1 modification, got %d", mods)
+	}
+
+	if result != actual {
+		t.Errorf("expected %s, got %s", actual, result)
+	}
+}
--- a/release.sh
+++ b/release.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+
+echo "Figuring out the tag..."
+TAG=$(git describe --tags --exact-match 2>/dev/null || echo "")
+if [ -z "$TAG" ]; then
+  # Get the latest tag
+  LATEST_TAG=$(git describe --tags $(git rev-list --tags --max-count=1))
+  # Increment the patch version
+  IFS='.' read -r -a VERSION_PARTS <<< "$LATEST_TAG"
+  VERSION_PARTS[2]=$((VERSION_PARTS[2]+1))
+  TAG="${VERSION_PARTS[0]}.${VERSION_PARTS[1]}.${VERSION_PARTS[2]}"
+  # Create a new tag
+  git tag $TAG
+  git push origin $TAG
+fi
+echo "Tag: $TAG"
+
+echo "Building the thing..."
+go build -o chef.exe .
+go install .
+
+echo "Creating a release..."
+TOKEN="$GITEA_API_KEY"
+GITEA="https://git.site.quack-lab.dev"
+REPO="dave/BigChef"
+# Create a release
+RELEASE_RESPONSE=$(curl -s -X POST \
+  -H "Authorization: token $TOKEN" \
+  -H "Accept: application/json" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "tag_name": "'"$TAG"'",
+    "name": "'"$TAG"'",
+    "draft": false,
+    "prerelease": false
+  }' \
+  $GITEA/api/v1/repos/$REPO/releases)
+
+# Extract the release ID
+echo $RELEASE_RESPONSE
+RELEASE_ID=$(echo $RELEASE_RESPONSE | awk -F'"id":' '{print $2+0; exit}')
+echo "Release ID: $RELEASE_ID"
+
+echo "Uploading the things..."
+curl -X POST \
+  -H "Authorization: token $TOKEN" \
+  -F "attachment=@chef.exe" \
+  "$GITEA/api/v1/repos/$REPO/releases/${RELEASE_ID}/assets?name=chef.exe"
+rm chef.exe
Author	SHA1	Message	Date
PhatPhuckDave	d3a1f1bd96	Rework regex grouping to avoid changing the same area twice	2025-03-26 22:24:19 +01:00
PhatPhuckDave	07a5f3f1a4	Add replaceCommands to avoid index suicide	2025-03-26 21:55:34 +01:00
PhatPhuckDave	e2257e082a	Add a regression test	2025-03-26 21:55:17 +01:00
PhatPhuckDave	b3fce4244d	Fix regex for numbers to support negative numbers	2025-03-26 18:30:21 +01:00
PhatPhuckDave	bd443067b6	Add support for !num inside of named capture groups	2025-03-26 14:04:39 +01:00
PhatPhuckDave	a9b6f7f984	Implement printing from lua	2025-03-26 13:37:39 +01:00
PhatPhuckDave	10c39b02a0	Fix some regex tests	2025-03-26 13:13:53 +01:00
PhatPhuckDave	7f4392b10e	Implement "replacement" variable that simply replaces the match	2025-03-26 13:00:52 +01:00
PhatPhuckDave	7e19cf4e2c	Rework named captures to be array To comply with the whole reverse replacing	2025-03-26 12:50:55 +01:00
PhatPhuckDave	c5fb20e96a	Implement named capture groups	2025-03-26 12:28:28 +01:00
PhatPhuckDave	a8c2257f20	Add named capture group tests	2025-03-26 12:17:01 +01:00
PhatPhuckDave	b63b4d1352	Add some more shorthands for regex	2025-03-26 12:06:04 +01:00
PhatPhuckDave	6a3d44ccd0	Redo what claude removed	2025-03-26 11:42:00 +01:00
PhatPhuckDave	c22e6ff41f	Code polish	2025-03-26 11:40:23 +01:00
PhatPhuckDave	068c64d714	Fix up file reseting	2025-03-26 11:10:43 +01:00
PhatPhuckDave	2c7a4f5d97	Add a lot more logs to regex What the fuck is going on?	2025-03-26 03:30:08 +01:00
PhatPhuckDave	0d7d251e76	Implement git reset	2025-03-26 03:23:16 +01:00
PhatPhuckDave	0d8c447ff6	Add support for git ie. automatically resetting changes to ensure clean slate	2025-03-26 03:22:05 +01:00
PhatPhuckDave	bb14087598	Fix oopsie	2025-03-26 02:52:28 +01:00
PhatPhuckDave	66a522aa12	Try to include xml node children in lua table	2025-03-26 02:50:33 +01:00
PhatPhuckDave	1a4b4f76f2	Map the weird numeric escapes to textual ones	2025-03-26 02:34:21 +01:00
PhatPhuckDave	2bfd9f951e	Fix up some more xml tests and other small bugs	2025-03-26 02:17:42 +01:00
PhatPhuckDave	e5092edf53	Implement parsing xml to and from lua A lot more complex than json.........	2025-03-26 01:36:49 +01:00
PhatPhuckDave	e31c0e4e8f	Implement xpath (by calling library)	2025-03-26 01:19:41 +01:00
PhatPhuckDave	73d93367a0	Refactor some things around a little	2025-03-25 23:16:03 +01:00
PhatPhuckDave	64f690f6b4	Fix usage to reflect recent flag changes	2025-03-25 23:02:32 +01:00
PhatPhuckDave	34477b2c34	Make readme and rework the flags a little	2025-03-25 22:55:01 +01:00
PhatPhuckDave	d5c08d86f5	Code polish	2025-03-25 19:22:44 +01:00
PhatPhuckDave	68127fe453	Add more json tests To bring it in line with the xml ones	2025-03-25 19:22:07 +01:00
PhatPhuckDave	872f2dd46d	Fix another changed test for json	2025-03-25 19:16:09 +01:00
PhatPhuckDave	4eed05c7c2	Fix some more minor bugs and tests	2025-03-25 19:14:21 +01:00
PhatPhuckDave	4640281fbf	Enable root modifications Though I can not see why you would want to..... But there's no reason you would not be able to	2025-03-25 18:57:32 +01:00
PhatPhuckDave	aba10267d1	Fix more tests	2025-03-25 18:47:55 +01:00
PhatPhuckDave	fed140254b	Fix some json tests	2025-03-25 18:32:51 +01:00
PhatPhuckDave	db92033642	Rework rounding and building lua script To allow user script to specify what was modified where	2025-03-25 18:28:33 +01:00
PhatPhuckDave	1b0b198297	Add xpath tests	2025-03-25 17:56:48 +01:00
PhatPhuckDave	15ae116447	Fix up some miscellaneous shit around the project regarding lua conversions	2025-03-25 17:46:21 +01:00
PhatPhuckDave	1bcc6735ab	Improve error handling across the board	2025-03-25 17:27:20 +01:00
PhatPhuckDave	20bab894e3	Add path data to the selected nodes for reconstruction via set	2025-03-25 17:27:20 +01:00
PhatPhuckDave	396992b3d0	Implement Set and SetAll (and Get)	2025-03-25 17:27:20 +01:00
PhatPhuckDave	054dcbf835	Fix up the recursive descent Again I guess?	2025-03-25 17:27:20 +01:00
PhatPhuckDave	88887b9a12	Fix up the recursive descent	2025-03-25 17:27:20 +01:00
PhatPhuckDave	533a563dc5	Fix up parser	2025-03-25 17:27:20 +01:00
PhatPhuckDave	7fc2956b6d	Begin to implement jsonpath	2025-03-25 17:27:20 +01:00
PhatPhuckDave	6f9f3f5eae	Begin to rework the json parsing	2025-03-25 17:27:20 +01:00
PhatPhuckDave	d2419b761e	Implement a generic translator between lua and go tables (maps)	2025-03-25 17:27:20 +01:00
PhatPhuckDave	ab98800ca0	Rework regex processor to be more betterer	2025-03-25 17:27:20 +01:00
PhatPhuckDave	0f7ee521ac	Fix up lua variable writing and reading for regex	2025-03-25 17:27:20 +01:00
PhatPhuckDave	fd81861a64	Fix reading lua variables	2025-03-25 17:27:20 +01:00
PhatPhuckDave	430234dd3b	Clean up after claude	2025-03-25 17:27:20 +01:00
PhatPhuckDave	17bb3d4f71	Refactor everything to processors and implement json and xml processors such as they are	2025-03-25 17:27:20 +01:00
PhatPhuckDave	84e0a8bed6	Add xpath dependencies	2025-03-25 17:27:20 +01:00
PhatPhuckDave	bdcf096fdd	Fix up the oopsies	2025-03-25 17:27:15 +01:00
PhatPhuckDave	1a90046c89	Add release script	2025-03-25 17:26:23 +01:00