Hallucinate actual json fucking thing

processor/json.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	logger "git.site.quack-lab.dev/dave/cylogger"
+	"github.com/tidwall/sjson"
 	lua "github.com/yuin/gopher-lua"
 )
 
@@ -85,26 +86,216 @@ func ProcessJSON(content string, command utils.ModifyCommand, filename string) (
 		return commands, fmt.Errorf("failed to convert Lua table back to Go: %v", err)
 	}
 
-	// Marshal back to JSON
-	modifiedJSON, err := json.MarshalIndent(goData, "", "  ")
+	// Use surgical JSON editing instead of full replacement
+	commands, err = applySurgicalJSONChanges(content, jsonData, goData)
 	if err != nil {
-		processJsonLogger.Error("Failed to marshal modified data to JSON: %v", err)
-		return commands, fmt.Errorf("failed to marshal modified data to JSON: %v", err)
+		processJsonLogger.Error("Failed to apply surgical JSON changes: %v", err)
+		return commands, fmt.Errorf("failed to apply surgical JSON changes: %v", err)
 	}
 
-	// Create replacement command for the entire file
-	// For JSON mode, we always replace the entire content
-	commands = append(commands, utils.ReplaceCommand{
-		From: 0,
-		To:   len(content),
-		With: string(modifiedJSON),
-	})
-
 	processJsonLogger.Debug("Total JSON processing time: %v", time.Since(startTime))
 	processJsonLogger.Debug("Generated %d total modifications", len(commands))
 	return commands, nil
 }
 
+// applySurgicalJSONChanges compares original and modified data and applies changes surgically
+func applySurgicalJSONChanges(content string, originalData, modifiedData interface{}) ([]utils.ReplaceCommand, error) {
+	var commands []utils.ReplaceCommand
+	
+	// Convert both to JSON for comparison
+	originalJSON, err := json.Marshal(originalData)
+	if err != nil {
+		return commands, fmt.Errorf("failed to marshal original data: %v", err)
+	}
+	
+	modifiedJSON, err := json.Marshal(modifiedData)
+	if err != nil {
+		return commands, fmt.Errorf("failed to marshal modified data: %v", err)
+	}
+	
+	// If no changes, return empty commands
+	if string(originalJSON) == string(modifiedJSON) {
+		return commands, nil
+	}
+	
+	// Try true surgical approach that preserves formatting
+	surgicalCommands, err := applyTrueSurgicalChanges(content, originalData, modifiedData)
+	if err == nil && len(surgicalCommands) > 0 {
+		return surgicalCommands, nil
+	}
+	
+	// Fall back to full replacement with proper formatting
+	modifiedJSONIndented, err := json.MarshalIndent(modifiedData, "", "  ")
+	if err != nil {
+		return commands, fmt.Errorf("failed to marshal modified data with indentation: %v", err)
+	}
+	
+	commands = append(commands, utils.ReplaceCommand{
+		From: 0,
+		To:   len(content),
+		With: string(modifiedJSONIndented),
+	})
+	
+	return commands, nil
+}
+
+// applyTrueSurgicalChanges attempts to make surgical changes while preserving exact formatting
+func applyTrueSurgicalChanges(content string, originalData, modifiedData interface{}) ([]utils.ReplaceCommand, error) {
+	var commands []utils.ReplaceCommand
+	
+	// Find changes by comparing the data structures
+	changes := findDeepChanges("", originalData, modifiedData)
+	
+	if len(changes) == 0 {
+		return commands, nil
+	}
+	
+	// Apply changes surgically using sjson.Set() to preserve formatting
+	modifiedContent := content
+	for path, newValue := range changes {
+		var err error
+		modifiedContent, err = sjson.Set(modifiedContent, path, newValue)
+		if err != nil {
+			return nil, fmt.Errorf("failed to apply surgical change at path %s: %v", path, err)
+		}
+	}
+	
+	// If we successfully made changes, create a replacement command
+	if modifiedContent != content {
+		commands = append(commands, utils.ReplaceCommand{
+			From: 0,
+			To:   len(content),
+			With: modifiedContent,
+		})
+	}
+	
+	return commands, nil
+}
+
+// findDeepChanges recursively finds all paths that need to be changed
+func findDeepChanges(basePath string, original, modified interface{}) map[string]interface{} {
+	changes := make(map[string]interface{})
+	
+	switch orig := original.(type) {
+	case map[string]interface{}:
+		if mod, ok := modified.(map[string]interface{}); ok {
+			// Check each key in the modified data
+			for key, modValue := range mod {
+				var currentPath string
+				if basePath == "" {
+					currentPath = key
+				} else {
+					currentPath = basePath + "." + key
+				}
+				
+				if origValue, exists := orig[key]; exists {
+					// Key exists in both, check if value changed
+					if !deepEqual(origValue, modValue) {
+						// If it's a nested object/array, recurse
+						switch modValue.(type) {
+						case map[string]interface{}, []interface{}:
+							nestedChanges := findDeepChanges(currentPath, origValue, modValue)
+							for nestedPath, nestedValue := range nestedChanges {
+								changes[nestedPath] = nestedValue
+							}
+						default:
+							// Primitive value changed
+							changes[currentPath] = modValue
+						}
+					}
+				} else {
+					// New key added
+					changes[currentPath] = modValue
+				}
+			}
+		}
+	case []interface{}:
+		if mod, ok := modified.([]interface{}); ok {
+			// For arrays, check each index
+			for i, modValue := range mod {
+				var currentPath string
+				if basePath == "" {
+					currentPath = fmt.Sprintf("%d", i)
+				} else {
+					currentPath = fmt.Sprintf("%s.%d", basePath, i)
+				}
+				
+				if i < len(orig) {
+					// Index exists in both, check if value changed
+					if !deepEqual(orig[i], modValue) {
+						// If it's a nested object/array, recurse
+						switch modValue.(type) {
+						case map[string]interface{}, []interface{}:
+							nestedChanges := findDeepChanges(currentPath, orig[i], modValue)
+							for nestedPath, nestedValue := range nestedChanges {
+								changes[nestedPath] = nestedValue
+							}
+						default:
+							// Primitive value changed
+							changes[currentPath] = modValue
+						}
+					}
+				} else {
+					// New array element added
+					changes[currentPath] = modValue
+				}
+			}
+		}
+	default:
+		// For primitive types, compare directly
+		if !deepEqual(original, modified) {
+			if basePath == "" {
+				changes[""] = modified
+			} else {
+				changes[basePath] = modified
+			}
+		}
+	}
+	
+	return changes
+}
+
+// deepEqual performs deep comparison of two values
+func deepEqual(a, b interface{}) bool {
+	if a == nil && b == nil {
+		return true
+	}
+	if a == nil || b == nil {
+		return false
+	}
+
+	switch av := a.(type) {
+	case map[string]interface{}:
+		if bv, ok := b.(map[string]interface{}); ok {
+			if len(av) != len(bv) {
+				return false
+			}
+			for k, v := range av {
+				if !deepEqual(v, bv[k]) {
+					return false
+				}
+			}
+			return true
+		}
+		return false
+	case []interface{}:
+		if bv, ok := b.([]interface{}); ok {
+			if len(av) != len(bv) {
+				return false
+			}
+			for i, v := range av {
+				if !deepEqual(v, bv[i]) {
+					return false
+				}
+			}
+			return true
+		}
+		return false
+	default:
+		return a == b
+	}
+}
+
 // ToLuaTable converts a Go interface{} to a Lua table recursively
 func ToLuaTable(L *lua.LState, data interface{}) (*lua.LTable, error) {
 	toLuaTableLogger := jsonLogger.WithPrefix("ToLuaTable")