@ottocode/sdk 0.1.265 → 0.1.266

package/src/core/src/tools/builtin/patch/indentation.ts

@@ -0,0 +1,160 @@
+import {
+	applyIndentDelta,
+	computeIndentDelta,
+	detectIndentStyle,
+	expandWhitespace,
+	getLeadingWhitespace,
+	inferTabSizeFromPairs,
+} from './normalize.ts';
+import type { PatchHunk } from './types.ts';
+
+export function adjustReplacementIndentation(
+	hunk: PatchHunk,
+	matchedFileLines: string[],
+	allFileLines?: string[],
+): string[] {
+	const result: string[] = [];
+	let expectedIdx = 0;
+	let lastDelta = 0;
+	let lastFileIndentExpanded = 0;
+	let lastPatchIndentExpanded = 0;
+	let hasDelta = false;
+	let hasStyleMismatch = false;
+	let fileIndentChar: 'tab' | 'space' = 'space';
+	const deltas: number[] = [];
+	let hasAddStyleMismatch = false;
+	let fileIndentDetected = false;
+
+	for (const fl of matchedFileLines) {
+		const ws = getLeadingWhitespace(fl);
+		if (ws.length > 0) {
+			fileIndentChar = detectIndentStyle(ws);
+			fileIndentDetected = true;
+			break;
+		}
+	}
+
+	if (!fileIndentDetected && allFileLines) {
+		for (const fl of allFileLines) {
+			const ws = getLeadingWhitespace(fl);
+			if (ws.length > 0) {
+				fileIndentChar = detectIndentStyle(ws);
+				fileIndentDetected = true;
+				break;
+			}
+		}
+	}
+
+	const patchContextLines = hunk.lines
+		.filter((l) => l.kind === 'context' || l.kind === 'remove')
+		.map((l) => l.content);
+	const tabSize = inferTabSizeFromPairs(patchContextLines, matchedFileLines);
+
+	let tempIdx = 0;
+	for (const line of hunk.lines) {
+		if (line.kind === 'context' || line.kind === 'remove') {
+			const fileLine = matchedFileLines[tempIdx];
+			if (fileLine !== undefined) {
+				const d = computeIndentDelta(line.content, fileLine, tabSize);
+				if (d !== 0) deltas.push(d);
+			}
+			tempIdx++;
+		}
+	}
+	const sortedDeltas = [...deltas].sort((a, b) => a - b);
+	const medianDelta =
+		sortedDeltas.length > 0
+			? sortedDeltas[Math.floor(sortedDeltas.length / 2)]
+			: 0;
+
+	for (const line of hunk.lines) {
+		if (line.kind === 'add' && line.content.trim() !== '') {
+			const ws = getLeadingWhitespace(line.content);
+			if (ws.length > 0 && detectIndentStyle(ws) !== fileIndentChar) {
+				hasAddStyleMismatch = true;
+				break;
+			}
+		}
+	}
+
+	for (const line of hunk.lines) {
+		if (line.kind === 'context') {
+			const fileLine = matchedFileLines[expectedIdx];
+			if (fileLine !== undefined) {
+				lastDelta = computeIndentDelta(line.content, fileLine, tabSize);
+				lastFileIndentExpanded = expandWhitespace(
+					getLeadingWhitespace(fileLine),
+					tabSize,
+				);
+				lastPatchIndentExpanded = expandWhitespace(
+					getLeadingWhitespace(line.content),
+					tabSize,
+				);
+				if (lastDelta !== 0) hasDelta = true;
+				if (
+					detectIndentStyle(getLeadingWhitespace(fileLine)) !==
+						detectIndentStyle(getLeadingWhitespace(line.content)) &&
+					getLeadingWhitespace(fileLine).length > 0
+				) {
+					hasStyleMismatch = true;
+				}
+				result.push(fileLine);
+			} else {
+				result.push(line.content);
+			}
+			expectedIdx++;
+		} else if (line.kind === 'remove') {
+			const fileLine = matchedFileLines[expectedIdx];
+			if (fileLine !== undefined) {
+				lastDelta = computeIndentDelta(line.content, fileLine, tabSize);
+				lastFileIndentExpanded = expandWhitespace(
+					getLeadingWhitespace(fileLine),
+					tabSize,
+				);
+				lastPatchIndentExpanded = expandWhitespace(
+					getLeadingWhitespace(line.content),
+					tabSize,
+				);
+				if (lastDelta !== 0) hasDelta = true;
+				if (
+					detectIndentStyle(getLeadingWhitespace(fileLine)) !==
+						detectIndentStyle(getLeadingWhitespace(line.content)) &&
+					getLeadingWhitespace(fileLine).length > 0
+				) {
+					hasStyleMismatch = true;
+				}
+			}
+			expectedIdx++;
+		} else if (line.kind === 'add') {
+			const addIndent = expandWhitespace(
+				getLeadingWhitespace(line.content),
+				tabSize,
+			);
+			const addWs = getLeadingWhitespace(line.content);
+			const addStyle =
+				addWs.length > 0 ? detectIndentStyle(addWs) : fileIndentChar;
+			const styleMismatch =
+				addStyle !== fileIndentChar && line.content.trim() !== '';
+			if (styleMismatch) {
+				const relativeOffset = addIndent - lastPatchIndentExpanded;
+				const targetIndent = lastFileIndentExpanded + relativeOffset;
+				const actualDelta = targetIndent - addIndent;
+				result.push(
+					applyIndentDelta(line.content, actualDelta, fileIndentChar, tabSize),
+				);
+			} else if (Math.abs(medianDelta) > tabSize) {
+				result.push(
+					applyIndentDelta(line.content, medianDelta, fileIndentChar, tabSize),
+				);
+			} else {
+				result.push(line.content);
+			}
+		}
+	}
+
+	if (!hasDelta && !hasStyleMismatch && !hasAddStyleMismatch) {
+		return hunk.lines.filter((l) => l.kind !== 'remove').map((l) => l.content);
+	}
+
+	return result;
+}

package/src/core/src/tools/builtin/patch/matching.ts

@@ -0,0 +1,58 @@
+import { NORMALIZATION_LEVELS, normalizeWhitespace } from './normalize.ts';
+
+export function linesMatch(
+	line: string,
+	pattern: string,
+	useFuzzy: boolean,
+): boolean {
+	if (line === pattern) return true;
+	if (!useFuzzy) return false;
+	for (const level of NORMALIZATION_LEVELS.slice(1)) {
+		if (
+			normalizeWhitespace(line, level) === normalizeWhitespace(pattern, level)
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+export function findLineIndex(
+	lines: string[],
+	pattern: string,
+	start: number,
+	useFuzzy: boolean,
+): number {
+	for (let i = Math.max(0, start); i < lines.length; i++) {
+		if (linesMatch(lines[i], pattern, useFuzzy)) return i;
+	}
+	return -1;
+}
+
+export function findSubsequence(
+	lines: string[],
+	pattern: string[],
+	startIndex: number,
+	useFuzzy: boolean,
+): number {
+	if (pattern.length === 0) return -1;
+	const start = Math.max(0, startIndex);
+	for (let i = start; i <= lines.length - pattern.length; i++) {
+		let matches = true;
+		for (let j = 0; j < pattern.length; j++) {
+			if (linesMatch(lines[i + j], pattern[j], useFuzzy)) continue;
+			matches = false;
+			break;
+		}
+		if (matches) return i;
+	}
+	return -1;
+}
+
+export function lineExists(
+	lines: string[],
+	target: string,
+	useFuzzy: boolean,
+): boolean {
+	return findLineIndex(lines, target, 0, useFuzzy) !== -1;
+}

package/src/core/src/tools/builtin/patch/parse-enveloped.ts

@@ -8,6 +8,13 @@ import {
 	PATCH_UPDATE_PREFIX,
 	PATCH_WITH_MARKER,
 } from './constants.ts';
+import { parseHunkHeader } from './hunk-header.ts';
+import {
+	createReplaceBuilder,
+	flushReplaceBuilder,
+	flushReplacePair,
+	type ReplaceBuilder,
+} from './replace-builder.ts';
 import type {
 	PatchAddOperation,
 	PatchDeleteOperation,
@@ -28,70 +35,6 @@ function parseDirectivePath(line: string, prefix: string): string {
 	return filePath;
 }
 
-function parseHunkHeader(raw: string) {
-	const match = raw.match(
-		/^@@\s*-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s*@@(?:\s*(.*))?$/,
-	);
-	if (match) {
-		const [, oldStart, oldCount, newStart, newCount, context] = match;
-		return {
-			oldStart: Number.parseInt(oldStart, 10),
-			oldLines: oldCount ? Number.parseInt(oldCount, 10) : undefined,
-			newStart: Number.parseInt(newStart, 10),
-			newLines: newCount ? Number.parseInt(newCount, 10) : undefined,
-			context: context?.trim() || undefined,
-		};
-	}
-	const context = raw.replace(/^@@/, '').trim();
-	return context ? { context } : {};
-}
-
-interface ReplaceBuilder {
-	kind: 'replace';
-	filePath: string;
-	hunks: PatchHunk[];
-	phase: 'idle' | 'find' | 'with';
-	findLines: string[];
-	withLines: string[];
-}
-
-function flushReplacePair(builder: ReplaceBuilder) {
-	if (builder.findLines.length === 0 && builder.withLines.length === 0) return;
-	if (builder.findLines.length === 0) {
-		throw new Error(
-			`Replace in ${builder.filePath}: *** Find: block is empty.`,
-		);
-	}
-	const lines: PatchHunkLine[] = [];
-	for (const line of builder.findLines) {
-		lines.push({ kind: 'remove', content: line });
-	}
-	for (const line of builder.withLines) {
-		lines.push({ kind: 'add', content: line });
-	}
-	builder.hunks.push({ header: {}, lines });
-	builder.findLines = [];
-	builder.withLines = [];
-	builder.phase = 'idle';
-}
-
-function flushReplaceBuilder(builder: ReplaceBuilder): PatchUpdateOperation {
-	flushReplacePair(builder);
-	if (builder.hunks.length === 0) {
-		throw new Error(
-			`Replace in ${builder.filePath} does not contain any *** Find:/*** With: pairs.`,
-		);
-	}
-	return {
-		kind: 'update',
-		filePath: builder.filePath,
-		hunks: builder.hunks.map((hunk) => ({
-			header: { ...hunk.header },
-			lines: hunk.lines.map((line) => ({ ...line })),
-		})),
-	};
-}
-
 export function parseEnvelopedPatch(patch: string): PatchOperation[] {
 	const normalized = patch.replace(/\r\n/g, '\n');
 	const lines = normalized.split('\n');
@@ -205,14 +148,9 @@ export function parseEnvelopedPatch(patch: string): PatchOperation[] {
 
 		if (line.startsWith(PATCH_REPLACE_PREFIX)) {
 			flushBuilder();
-			builder = {
-				kind: 'replace',
-				filePath: parseDirectivePath(line, PATCH_REPLACE_PREFIX),
-				hunks: [],
-				phase: 'idle',
-				findLines: [],
-				withLines: [],
-			};
+			builder = createReplaceBuilder(
+				parseDirectivePath(line, PATCH_REPLACE_PREFIX),
+			);
 			continue;
 		}
 

package/src/core/src/tools/builtin/patch/parse-unified.ts

@@ -1,111 +1,21 @@
-import type {
-	PatchAddOperation,
-	PatchDeleteOperation,
-	PatchHunk,
-	PatchHunkLine,
-	PatchOperation,
-	PatchUpdateOperation,
-} from './types.ts';
-
-function stripPath(raw: string): string | null {
-	let trimmed = raw.trim();
-	if (!trimmed || trimmed === '/dev/null') return null;
-	if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-		trimmed = trimmed.slice(1, -1).replace(/\\"/g, '"');
-	}
-	if (trimmed.startsWith('a/') || trimmed.startsWith('b/')) {
-		trimmed = trimmed.slice(2);
-	}
-	if (trimmed.startsWith('./')) {
-		trimmed = trimmed.slice(2);
-	}
-	return trimmed || null;
-}
-
-function parseHunkHeader(raw: string) {
-	const match = raw.match(
-		/^@@\s*-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s*@@(?:\s*(.*))?$/,
-	);
-	if (match) {
-		const [, oldStart, oldCount, newStart, newCount, context] = match;
-		return {
-			oldStart: Number.parseInt(oldStart, 10),
-			oldLines: oldCount ? Number.parseInt(oldCount, 10) : undefined,
-			newStart: Number.parseInt(newStart, 10),
-			newLines: newCount ? Number.parseInt(newCount, 10) : undefined,
-			context: context?.trim() || undefined,
-		};
-	}
-	const context = raw.replace(/^@@/, '').trim();
-	return context ? { context } : {};
-}
-
-function shouldIgnoreMetadata(line: string) {
-	const trimmed = line.trim();
-	if (trimmed === '') return true;
-	if (trimmed === '\') return true;
-	const prefixes = [
-		'diff --git',
-		'index ',
-		'similarity index',
-		'dissimilarity index',
-		'rename from',
-		'rename to',
-		'copy from',
-		'copy to',
-		'new file mode',
-		'deleted file mode',
-		'old mode',
-		'new mode',
-		'Binary files',
-	];
-	return prefixes.some((prefix) => trimmed.startsWith(prefix));
-}
+import type { PatchHunk, PatchHunkLine, PatchOperation } from './types.ts';
+import { parseHunkHeader } from './hunk-header.ts';
+import {
+	flushUnifiedBuilder,
+	shouldIgnoreUnifiedMetadata,
+	stripUnifiedPath,
+	type UnifiedBuilder,
+} from './unified-state.ts';
 
 export function parseUnifiedPatch(patch: string): PatchOperation[] {
 	const normalized = patch.replace(/\r\n/g, '\n');
 	const lines = normalized.split('\n');
 	const operations: PatchOperation[] = [];
 
-	type Builder =
-		| (PatchAddOperation & { kind: 'add' })
-		| (PatchDeleteOperation & { kind: 'delete' })
-		| (PatchUpdateOperation & {
-				kind: 'update';
-				currentHunk: PatchHunk | null;
-		  });
-
-	let builder: Builder | null = null;
+	let builder: UnifiedBuilder | null = null;
 
 	const flush = () => {
-		if (!builder) return;
-		if (builder.kind === 'update') {
-			if (builder.currentHunk && builder.currentHunk.lines.length === 0) {
-				builder.hunks.pop();
-			}
-			if (builder.hunks.length === 0) {
-				throw new Error(
-					`Update for ${builder.filePath} does not contain any diff hunks.`,
-				);
-			}
-			operations.push({
-				kind: 'update',
-				filePath: builder.filePath,
-				hunks: builder.hunks.map((hunk) => ({
-					header: { ...hunk.header },
-					lines: hunk.lines.map((line) => ({ ...line })),
-				})),
-			});
-		} else if (builder.kind === 'add') {
-			operations.push({
-				kind: 'add',
-				filePath: builder.filePath,
-				lines: [...builder.lines],
-			});
-		} else {
-			operations.push({ kind: 'delete', filePath: builder.filePath });
-		}
-		builder = null;
+		builder = flushUnifiedBuilder(builder, operations);
 	};
 
 	for (let i = 0; i < lines.length; i++) {
@@ -124,8 +34,8 @@ export function parseUnifiedPatch(patch: string): PatchOperation[] {
 
 			flush();
 
-			const oldPath = stripPath(oldPathRaw);
-			const newPath = stripPath(newPathRaw);
+			const oldPath = stripUnifiedPath(oldPathRaw);
+			const newPath = stripUnifiedPath(newPathRaw);
 
 			if (!oldPath && !newPath) {
 				throw new Error(
@@ -171,13 +81,13 @@ export function parseUnifiedPatch(patch: string): PatchOperation[] {
 		}
 
 		if (!builder) {
-			if (shouldIgnoreMetadata(line)) continue;
+			if (shouldIgnoreUnifiedMetadata(line)) continue;
 			if (line.trim() === '') continue;
 			throw new Error(`Unrecognized content in patch: "${line}"`);
 		}
 
 		if (builder.kind === 'add') {
-			if (shouldIgnoreMetadata(line) || line.startsWith('@@')) continue;
+			if (shouldIgnoreUnifiedMetadata(line) || line.startsWith('@@')) continue;
 			if (line.startsWith('+')) {
 				builder.lines.push(line.slice(1));
 			}
@@ -188,7 +98,7 @@ export function parseUnifiedPatch(patch: string): PatchOperation[] {
 			continue;
 		}
 
-		if (shouldIgnoreMetadata(line)) continue;
+		if (shouldIgnoreUnifiedMetadata(line)) continue;
 
 		if (line.startsWith('@@')) {
 			const hunk: PatchHunk = { header: parseHunkHeader(line), lines: [] };

package/src/core/src/tools/builtin/patch/replace-builder.ts

@@ -0,0 +1,64 @@
+import type {
+	PatchHunk,
+	PatchHunkLine,
+	PatchUpdateOperation,
+} from './types.ts';
+
+export interface ReplaceBuilder {
+	kind: 'replace';
+	filePath: string;
+	hunks: PatchHunk[];
+	phase: 'idle' | 'find' | 'with';
+	findLines: string[];
+	withLines: string[];
+}
+
+export function createReplaceBuilder(filePath: string): ReplaceBuilder {
+	return {
+		kind: 'replace',
+		filePath,
+		hunks: [],
+		phase: 'idle',
+		findLines: [],
+		withLines: [],
+	};
+}
+
+export function flushReplacePair(builder: ReplaceBuilder) {
+	if (builder.findLines.length === 0 && builder.withLines.length === 0) return;
+	if (builder.findLines.length === 0) {
+		throw new Error(
+			`Replace in ${builder.filePath}: *** Find: block is empty.`,
+		);
+	}
+	const lines: PatchHunkLine[] = [];
+	for (const line of builder.findLines) {
+		lines.push({ kind: 'remove', content: line });
+	}
+	for (const line of builder.withLines) {
+		lines.push({ kind: 'add', content: line });
+	}
+	builder.hunks.push({ header: {}, lines });
+	builder.findLines = [];
+	builder.withLines = [];
+	builder.phase = 'idle';
+}
+
+export function flushReplaceBuilder(
+	builder: ReplaceBuilder,
+): PatchUpdateOperation {
+	flushReplacePair(builder);
+	if (builder.hunks.length === 0) {
+		throw new Error(
+			`Replace in ${builder.filePath} does not contain any *** Find:/*** With: pairs.`,
+		);
+	}
+	return {
+		kind: 'update',
+		filePath: builder.filePath,
+		hunks: builder.hunks.map((hunk) => ({
+			header: { ...hunk.header },
+			lines: hunk.lines.map((line) => ({ ...line })),
+		})),
+	};
+}

package/src/core/src/tools/builtin/patch/unified-state.ts

@@ -0,0 +1,86 @@
+import type {
+	PatchAddOperation,
+	PatchDeleteOperation,
+	PatchHunk,
+	PatchOperation,
+	PatchUpdateOperation,
+} from './types.ts';
+
+export type UnifiedBuilder =
+	| (PatchAddOperation & { kind: 'add' })
+	| (PatchDeleteOperation & { kind: 'delete' })
+	| (PatchUpdateOperation & {
+			kind: 'update';
+			currentHunk: PatchHunk | null;
+	  });
+
+export function stripUnifiedPath(raw: string): string | null {
+	let trimmed = raw.trim();
+	if (!trimmed || trimmed === '/dev/null') return null;
+	if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+		trimmed = trimmed.slice(1, -1).replace(/\\"/g, '"');
+	}
+	if (trimmed.startsWith('a/') || trimmed.startsWith('b/')) {
+		trimmed = trimmed.slice(2);
+	}
+	if (trimmed.startsWith('./')) {
+		trimmed = trimmed.slice(2);
+	}
+	return trimmed || null;
+}
+
+export function shouldIgnoreUnifiedMetadata(line: string) {
+	const trimmed = line.trim();
+	if (trimmed === '') return true;
+	if (trimmed === '\') return true;
+	const prefixes = [
+		'diff --git',
+		'index ',
+		'similarity index',
+		'dissimilarity index',
+		'rename from',
+		'rename to',
+		'copy from',
+		'copy to',
+		'new file mode',
+		'deleted file mode',
+		'old mode',
+		'new mode',
+		'Binary files',
+	];
+	return prefixes.some((prefix) => trimmed.startsWith(prefix));
+}
+
+export function flushUnifiedBuilder(
+	builder: UnifiedBuilder | null,
+	operations: PatchOperation[],
+): UnifiedBuilder | null {
+	if (!builder) return null;
+	if (builder.kind === 'update') {
+		if (builder.currentHunk && builder.currentHunk.lines.length === 0) {
+			builder.hunks.pop();
+		}
+		if (builder.hunks.length === 0) {
+			throw new Error(
+				`Update for ${builder.filePath} does not contain any diff hunks.`,
+			);
+		}
+		operations.push({
+			kind: 'update',
+			filePath: builder.filePath,
+			hunks: builder.hunks.map((hunk) => ({
+				header: { ...hunk.header },
+				lines: hunk.lines.map((line) => ({ ...line })),
+			})),
+		});
+	} else if (builder.kind === 'add') {
+		operations.push({
+			kind: 'add',
+			filePath: builder.filePath,
+			lines: [...builder.lines],
+		});
+	} else {
+		operations.push({ kind: 'delete', filePath: builder.filePath });
+	}
+	return null;
+}