improvements to edit mode

Author: SamSaffron

cmd/edit.go

@@ -62,8 +62,8 @@ func init() {
 // FileSpec represents a file with optional line range guard
 type FileSpec struct {
 	Path      string
-	StartLine int  // 1-indexed, 0 means from beginning
-	EndLine   int  // 1-indexed, 0 means to end
+	StartLine int // 1-indexed, 0 means from beginning
+	EndLine   int // 1-indexed, 0 means to end
 	HasGuard  bool
 }
 
@@ -185,7 +185,7 @@ func runEdit(cmd *cobra.Command, args []string) error {
 
 	// Build prompts
 	systemPrompt := buildEditSystemPrompt(cfg.Edit.Instructions, specs)
-	userPrompt := buildEditUserPrompt(request, files)
+	userPrompt := buildEditUserPrompt(request, files, specs)
 
 	// Track file contents for applying edits
 	fileContents := make(map[string]string)
@@ -259,27 +259,30 @@ func processEditsConsolidated(edits []llm.EditToolCall, fileContents map[string]
 				continue
 			}
 
-			if !strings.Contains(currentContent, edit.OldString) {
-				cf.skipReasons = append(cf.skipReasons, fmt.Sprintf("old_string not found: %.40s...", edit.OldString))
-				continue
+			// Find the matching spec to check for guards
+			var matchSpec *FileSpec
+			for i := range specs {
+				if specs[i].Path == path {
+					matchSpec = &specs[i]
+					break
+				}
 			}
 
-			// Check guard
-			guardErr := ""
-			for _, spec := range specs {
-				if spec.Path == path && spec.HasGuard {
-					if err := validateGuardForReplace(currentContent, edit, spec); err != nil {
-						guardErr = err.Error()
-						break
-					}
-				}
+			var match editMatch
+			var err error
+			if matchSpec != nil && matchSpec.HasGuard {
+				// Use guard-scoped matching
+				match, err = findEditMatchWithGuard(currentContent, edit.OldString, matchSpec.StartLine, matchSpec.EndLine)
+			} else {
+				// No guard, search full content
+				match, err = findEditMatch(currentContent, edit.OldString)
 			}
-			if guardErr != "" {
-				cf.skipReasons = append(cf.skipReasons, guardErr)
+			if err != nil {
+				cf.skipReasons = append(cf.skipReasons, err.Error())
 				continue
 			}
 
-			currentContent = strings.Replace(currentContent, edit.OldString, edit.NewString, 1)
+			currentContent = applyEditMatch(currentContent, match, edit.NewString)
 			cf.editCount++
 		}
 
@@ -376,27 +379,33 @@ func processEditsIndividually(edits []llm.EditToolCall, fileContents map[string]
 			continue
 		}
 
-		if !strings.Contains(content, editCall.OldString) {
+		// Find the matching spec to check for guards
+		var matchSpec *FileSpec
+		for i := range specs {
+			if specs[i].Path == editCall.FilePath {
+				matchSpec = &specs[i]
+				break
+			}
+		}
+
+		var match editMatch
+		var err error
+		if matchSpec != nil && matchSpec.HasGuard {
+			// Use guard-scoped matching
+			match, err = findEditMatchWithGuard(content, editCall.OldString, matchSpec.StartLine, matchSpec.EndLine)
+		} else {
+			// No guard, search full content
+			match, err = findEditMatch(content, editCall.OldString)
+		}
+		if err != nil {
 			pe.skip = true
-			pe.skipReason = "old_string not found"
+			pe.skipReason = err.Error()
 			processed = append(processed, pe)
 			continue
 		}
 
-		for _, spec := range specs {
-			if spec.Path == editCall.FilePath && spec.HasGuard {
-				if err := validateGuardForReplace(content, editCall, spec); err != nil {
-					pe.skip = true
-					pe.skipReason = err.Error()
-					break
-				}
-			}
-		}
-
-		if !pe.skip {
-			pe.oldContent = content
-			pe.newContent = strings.Replace(content, editCall.OldString, editCall.NewString, 1)
-		}
+		pe.oldContent = content
+		pe.newContent = applyEditMatch(content, match, editCall.NewString)
 		processed = append(processed, pe)
 	}
 
@@ -464,27 +473,33 @@ Context:
 		base += fmt.Sprintf("\n- User Context: %s", instructions)
 	}
 
-	base += `
+	base += fmt.Sprintf(`
 
 Rules:
 1. Make minimal, focused changes
 2. Preserve existing code style
 3. Use the edit tool for each change - you can call it multiple times
 4. The edit tool does find/replace: old_string must match exactly
-5. Include enough context in old_string to be unique`
+5. You may include the literal token %s in old_string to match any sequence of characters (including newlines)
+6. Include enough context in old_string (especially around %s) to be unique`, editWildcardToken, editWildcardToken)
 
 	// Add guard info
+	hasGuards := false
 	for _, spec := range specs {
 		if spec.HasGuard {
-			base += fmt.Sprintf("\n\nIMPORTANT: For %s, only modify lines %d-%d.",
+			hasGuards = true
+			base += fmt.Sprintf("\n\nIMPORTANT: For %s, only modify lines %d-%d. The <editable-region> block shows the exact content you may edit with line numbers.",
 				spec.Path, spec.StartLine, spec.EndLine)
 		}
 	}
+	if hasGuards {
+		base += "\n\nYour old_string MUST match text within the editable region. Use the line numbers in <editable-region> to ensure your edit is within bounds."
+	}
 
 	return base
 }
 
-func buildEditUserPrompt(request string, files []input.FileContent) string {
+func buildEditUserPrompt(request string, files []input.FileContent, specs []FileSpec) string {
 	var sb strings.Builder
 
 	sb.WriteString("Files:\n\n")
@@ -497,20 +512,59 @@ func buildEditUserPrompt(request string, files []input.FileContent) string {
 		sb.WriteString("</file>\n\n")
 	}
 
+	// Add editable region blocks for guarded files
+	for _, spec := range specs {
+		if spec.HasGuard {
+			// Find the matching file content
+			for _, f := range files {
+				if f.Path == spec.Path {
+					excerpt := extractLineRange(f.Content, spec.StartLine, spec.EndLine)
+					sb.WriteString(fmt.Sprintf("<editable-region path=\"%s\" lines=\"%d-%d\">\n",
+						spec.Path, spec.StartLine, spec.EndLine))
+					sb.WriteString(excerpt)
+					if !strings.HasSuffix(excerpt, "\n") {
+						sb.WriteString("\n")
+					}
+					sb.WriteString("</editable-region>\n\n")
+					break
+				}
+			}
+		}
+	}
+
 	sb.WriteString(fmt.Sprintf("Request: %s", request))
 	return sb.String()
 }
 
-func validateGuardForReplace(content string, editCall llm.EditToolCall, spec FileSpec) error {
-	// Find where old_string appears
-	idx := strings.Index(content, editCall.OldString)
-	if idx < 0 {
-		return fmt.Errorf("old_string not found")
+// extractLineRange extracts lines startLine to endLine (1-indexed, inclusive) from content
+func extractLineRange(content string, startLine, endLine int) string {
+	lines := strings.Split(content, "\n")
+
+	// Adjust for 0-based indexing
+	start := startLine - 1
+	if start < 0 {
+		start = 0
+	}
+	end := endLine
+	if end <= 0 || end > len(lines) {
+		end = len(lines)
+	}
+	if start >= len(lines) {
+		return ""
 	}
 
+	// Build output with line numbers
+	var sb strings.Builder
+	for i := start; i < end; i++ {
+		sb.WriteString(fmt.Sprintf("%d: %s\n", i+1, lines[i]))
+	}
+	return strings.TrimSuffix(sb.String(), "\n")
+}
+
+func validateGuardForReplace(content string, match editMatch, spec FileSpec) error {
 	// Count lines before
-	lineNum := strings.Count(content[:idx], "\n") + 1
-	endLineNum := lineNum + strings.Count(editCall.OldString, "\n")
+	lineNum := strings.Count(content[:match.start], "\n") + 1
+	endLineNum := lineNum + strings.Count(match.text, "\n")
 
 	// Check if within guard
 	if spec.StartLine > 0 && lineNum < spec.StartLine {

cmd/edit_match.go

@@ -0,0 +1,173 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+)
+
+const editWildcardToken = "<<<elided>>>"
+
+type editMatch struct {
+	start int
+	end   int
+	text  string
+}
+
+func findEditMatch(content, oldString string) (editMatch, error) {
+	if oldString == "" {
+		return editMatch{}, fmt.Errorf("old_string is empty")
+	}
+
+	if !strings.Contains(oldString, editWildcardToken) {
+		idx := strings.Index(content, oldString)
+		if idx < 0 {
+			return editMatch{}, fmt.Errorf("old_string not found: %.40s...", oldString)
+		}
+		return editMatch{
+			start: idx,
+			end:   idx + len(oldString),
+			text:  oldString,
+		}, nil
+	}
+
+	segments := strings.Split(oldString, editWildcardToken)
+	foundSegment := false
+	foundFirst := false
+	start := 0
+	end := 0
+	searchFrom := 0
+
+	for _, segment := range segments {
+		if segment == "" {
+			continue
+		}
+		foundSegment = true
+		idx := strings.Index(content[searchFrom:], segment)
+		if idx < 0 {
+			return editMatch{}, fmt.Errorf("wildcard match failed: %.40s...", oldString)
+		}
+		absIdx := searchFrom + idx
+		if !foundFirst {
+			start = absIdx
+			foundFirst = true
+		}
+		searchFrom = absIdx + len(segment)
+		end = searchFrom
+	}
+
+	if !foundSegment {
+		return editMatch{}, fmt.Errorf("wildcard token used without anchors")
+	}
+
+	return editMatch{
+		start: start,
+		end:   end,
+		text:  content[start:end],
+	}, nil
+}
+
+func applyEditMatch(content string, match editMatch, newString string) string {
+	return content[:match.start] + newString + content[match.end:]
+}
+
+// lineRangeToByteRange converts 1-indexed line numbers to byte offsets
+// Returns (startOffset, endOffset) where endOffset is exclusive
+func lineRangeToByteRange(content string, startLine, endLine int) (int, int) {
+	lines := strings.Split(content, "\n")
+
+	startOffset := 0
+	endOffset := len(content)
+
+	// Calculate start offset (byte position at start of startLine)
+	if startLine > 1 {
+		lineCount := 0
+		for i, ch := range content {
+			if ch == '\n' {
+				lineCount++
+				if lineCount == startLine-1 {
+					startOffset = i + 1
+					break
+				}
+			}
+		}
+	}
+
+	// Calculate end offset (byte position after endLine, including its newline)
+	if endLine > 0 && endLine < len(lines) {
+		lineCount := 0
+		for i, ch := range content {
+			if ch == '\n' {
+				lineCount++
+				if lineCount == endLine {
+					endOffset = i + 1
+					break
+				}
+			}
+		}
+	}
+
+	return startOffset, endOffset
+}
+
+// findEditMatchWithGuard searches for oldString only within the guarded line range
+// Returns a match with offsets relative to the full content
+func findEditMatchWithGuard(content, oldString string, startLine, endLine int) (editMatch, error) {
+	if oldString == "" {
+		return editMatch{}, fmt.Errorf("old_string is empty")
+	}
+
+	guardStart, guardEnd := lineRangeToByteRange(content, startLine, endLine)
+	guardedContent := content[guardStart:guardEnd]
+
+	// Search within the guarded slice
+	if !strings.Contains(oldString, editWildcardToken) {
+		idx := strings.Index(guardedContent, oldString)
+		if idx < 0 {
+			return editMatch{}, fmt.Errorf("not found within lines %d-%d", startLine, endLine)
+		}
+		// Adjust offset back to full content
+		absStart := guardStart + idx
+		return editMatch{
+			start: absStart,
+			end:   absStart + len(oldString),
+			text:  oldString,
+		}, nil
+	}
+
+	// Wildcard matching within guarded slice
+	segments := strings.Split(oldString, editWildcardToken)
+	foundSegment := false
+	foundFirst := false
+	start := 0
+	end := 0
+	searchFrom := 0
+
+	for _, segment := range segments {
+		if segment == "" {
+			continue
+		}
+		foundSegment = true
+		idx := strings.Index(guardedContent[searchFrom:], segment)
+		if idx < 0 {
+			return editMatch{}, fmt.Errorf("wildcard match failed within lines %d-%d", startLine, endLine)
+		}
+		absIdx := searchFrom + idx
+		if !foundFirst {
+			start = absIdx
+			foundFirst = true
+		}
+		searchFrom = absIdx + len(segment)
+		end = searchFrom
+	}
+
+	if !foundSegment {
+		return editMatch{}, fmt.Errorf("wildcard token used without anchors")
+	}
+
+	// Adjust offsets back to full content
+	return editMatch{
+		start: guardStart + start,
+		end:   guardStart + end,
+		text:  guardedContent[start:end],
+	}, nil
+}