File size: 5,154 Bytes
94e1b2f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | import type { CodePatch, CodePatchSet } from './types'
function stripCodeFence(text: string): string {
return text
.replace(/^```(?:json|text)?\s*/i, '')
.replace(/\s*```$/i, '')
.trim()
}
function trimPatchBoundary(text: string): string {
return text
.replace(/^\s*\r?\n/, '')
.replace(/\r?\n\s*$/, '')
.replace(/\r\n/g, '\n')
}
export function parsePatchResponse(text: string): CodePatchSet {
const normalized = stripCodeFence(text)
if (!normalized) {
throw new Error('Code retry patch response was empty')
}
if (/^\s*<!DOCTYPE\s+html/i.test(normalized) || /^\s*<html/i.test(normalized)) {
throw new Error('Code retry patch response was HTML, not patch text')
}
const hasPatchMarkers =
normalized.includes('[[PATCH]]') ||
normalized.includes('[[SEARCH]]') ||
normalized.includes('[[REPLACE]]') ||
normalized.includes('[[END]]')
if (!hasPatchMarkers) {
throw new Error('Code retry patch response did not contain any [[PATCH]] blocks')
}
const patches: CodePatch[] = []
let cursor = 0
while (true) {
const patchStart = normalized.indexOf('[[PATCH]]', cursor)
if (patchStart < 0) {
break
}
const searchStart = normalized.indexOf('[[SEARCH]]', patchStart + '[[PATCH]]'.length)
if (searchStart < 0) {
throw new Error('Code retry patch block missing [[SEARCH]] marker')
}
const replaceStart = normalized.indexOf('[[REPLACE]]', searchStart + '[[SEARCH]]'.length)
if (replaceStart < 0) {
throw new Error('Code retry patch block missing [[REPLACE]] marker')
}
const endStart = normalized.indexOf('[[END]]', replaceStart + '[[REPLACE]]'.length)
if (endStart < 0) {
throw new Error('Code retry patch block missing [[END]] marker')
}
const originalSnippet = trimPatchBoundary(
normalized.slice(searchStart + '[[SEARCH]]'.length, replaceStart)
)
const replacementSnippet = trimPatchBoundary(
normalized.slice(replaceStart + '[[REPLACE]]'.length, endStart)
)
if (!originalSnippet) {
throw new Error('Code retry patch block missing SEARCH content')
}
if (originalSnippet === replacementSnippet) {
throw new Error('Code retry patch produced no change')
}
patches.push({ originalSnippet, replacementSnippet })
cursor = endStart + '[[END]]'.length
}
if (patches.length === 0) {
throw new Error('Code retry patch response missing patches')
}
return { patches }
}
function getLineNumberAtIndex(text: string, index: number): number {
return text.slice(0, index).split('\n').length
}
export function extractTargetLine(errorMessage: string): number | undefined {
const match = errorMessage.match(/line\s+(\d+)/i) || errorMessage.match(/:(\d+)(?::\d+)?/)
if (!match) {
return undefined
}
const line = Number.parseInt(match[1], 10)
return Number.isFinite(line) && line > 0 ? line : undefined
}
export function applyPatchToCode(code: string, patch: CodePatch, targetLine?: number): string {
const matches: number[] = []
let searchIndex = 0
while (true) {
const foundAt = code.indexOf(patch.originalSnippet, searchIndex)
if (foundAt < 0) {
break
}
matches.push(foundAt)
searchIndex = foundAt + Math.max(1, patch.originalSnippet.length)
}
if (matches.length === 0) {
throw new Error('Code retry patch original_snippet not found in code')
}
const bestIndex =
typeof targetLine === 'number'
? matches.reduce((best, current) => {
const bestDistance = Math.abs(getLineNumberAtIndex(code, best) - targetLine)
const currentDistance = Math.abs(getLineNumberAtIndex(code, current) - targetLine)
return currentDistance < bestDistance ? current : best
})
: matches[0]
return `${code.slice(0, bestIndex)}${patch.replacementSnippet}${code.slice(bestIndex + patch.originalSnippet.length)}`
}
export function applyPatchSetToCode(code: string, patchSet: CodePatchSet, targetLine?: number): string {
return patchSet.patches.reduce((currentCode, patch, index) => {
const lineHint = index === 0 ? targetLine : undefined
return applyPatchToCode(currentCode, patch, lineHint)
}, code)
}
export function getErrorType(stderr: string): string {
if (!stderr) return 'Unknown'
const errorPatterns = [
{ name: 'NameError', pattern: /NameError/i },
{ name: 'SyntaxError', pattern: /SyntaxError/i },
{ name: 'AttributeError', pattern: /AttributeError/i },
{ name: 'ImportError', pattern: /ImportError/i },
{ name: 'TypeError', pattern: /TypeError/i },
{ name: 'ValueError', pattern: /ValueError/i },
{ name: 'RuntimeError', pattern: /RuntimeError/i },
{ name: 'IndentationError', pattern: /IndentationError/i }
]
for (const { name, pattern } of errorPatterns) {
if (pattern.test(stderr)) {
return name
}
}
return 'Unknown'
}
export function extractErrorMessage(stderr: string): string {
if (!stderr) return 'Unknown error'
const lines = stderr.trim().split('\n')
const lastLine = lines[lines.length - 1]?.trim()
return lastLine || stderr.slice(0, 500)
}
|