@agi-cli/sdk 0.1.81 → 0.1.83

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

@@ -0,0 +1,209 @@
+import {
+	PATCH_ADD_PREFIX,
+	PATCH_BEGIN_MARKER,
+	PATCH_DELETE_PREFIX,
+	PATCH_END_MARKER,
+	PATCH_UPDATE_PREFIX,
+} from './constants.ts';
+import type {
+	PatchAddOperation,
+	PatchDeleteOperation,
+	PatchHunk,
+	PatchHunkLine,
+	PatchOperation,
+	PatchUpdateOperation,
+} from './types.ts';
+
+function parseDirectivePath(line: string, prefix: string): string {
+	const filePath = line.slice(prefix.length).trim();
+	if (!filePath) {
+		throw new Error(`Missing file path for directive: ${line}`);
+	}
+	if (filePath.startsWith('/') || filePath.includes('..')) {
+		throw new Error('Patch file paths must be relative to the project root.');
+	}
+	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 } : {};
+}
+
+export function parseEnvelopedPatch(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 inside = false;
+	let encounteredEnd = false;
+
+	const flushBuilder = () => {
+		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;
+	};
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+
+		if (!inside) {
+			if (line.trim() === '') continue;
+			if (line.startsWith(PATCH_BEGIN_MARKER)) {
+				inside = true;
+				continue;
+			}
+			throw new Error(
+				'Patch must start with "*** Begin Patch" and use the enveloped patch format.',
+			);
+		}
+
+		if (line.startsWith(PATCH_BEGIN_MARKER)) {
+			throw new Error('Nested "*** Begin Patch" markers are not supported.');
+		}
+
+		if (line.startsWith(PATCH_END_MARKER)) {
+			flushBuilder();
+			encounteredEnd = true;
+			const remaining = lines.slice(i + 1).find((rest) => rest.trim() !== '');
+			if (remaining) {
+				throw new Error(
+					'Unexpected content found after "*** End Patch" marker.',
+				);
+			}
+			break;
+		}
+
+		if (line.startsWith(PATCH_ADD_PREFIX)) {
+			flushBuilder();
+			builder = {
+				kind: 'add',
+				filePath: parseDirectivePath(line, PATCH_ADD_PREFIX),
+				lines: [],
+			};
+			continue;
+		}
+
+		if (line.startsWith(PATCH_UPDATE_PREFIX)) {
+			flushBuilder();
+			builder = {
+				kind: 'update',
+				filePath: parseDirectivePath(line, PATCH_UPDATE_PREFIX),
+				hunks: [],
+				currentHunk: null,
+			};
+			continue;
+		}
+
+		if (line.startsWith(PATCH_DELETE_PREFIX)) {
+			flushBuilder();
+			builder = {
+				kind: 'delete',
+				filePath: parseDirectivePath(line, PATCH_DELETE_PREFIX),
+			};
+			continue;
+		}
+
+		if (!builder) {
+			if (line.trim() === '') continue;
+			throw new Error(`Unexpected content in patch: "${line}"`);
+		}
+
+		if (builder.kind === 'add') {
+			builder.lines.push(line.startsWith('+') ? line.slice(1) : line);
+			continue;
+		}
+
+		if (builder.kind === 'delete') {
+			if (line.trim() !== '') {
+				throw new Error(
+					`Delete directive for ${builder.filePath} should not contain additional lines.`,
+				);
+			}
+			continue;
+		}
+
+		if (line.startsWith('@@')) {
+			const hunk: PatchHunk = { header: parseHunkHeader(line), lines: [] };
+			builder.hunks.push(hunk);
+			builder.currentHunk = hunk;
+			continue;
+		}
+
+		if (!builder.currentHunk) {
+			const fallback: PatchHunk = { header: {}, lines: [] };
+			builder.hunks.push(fallback);
+			builder.currentHunk = fallback;
+		}
+
+		const hunk = builder.currentHunk;
+		const prefix = line[0];
+		const createLine = (kind: PatchHunkLine['kind'], content: string) => ({
+			kind,
+			content,
+		});
+
+		if (prefix === '+') {
+			hunk.lines.push(createLine('add', line.slice(1)));
+		} else if (prefix === '-') {
+			hunk.lines.push(createLine('remove', line.slice(1)));
+		} else if (prefix === ' ') {
+			hunk.lines.push(createLine('context', line.slice(1)));
+		} else {
+			hunk.lines.push(createLine('context', line));
+		}
+	}
+
+	if (!encounteredEnd) {
+		throw new Error('Missing "*** End Patch" marker.');
+	}
+
+	return operations;
+}

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

@@ -0,0 +1,231 @@
+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));
+}
+
+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;
+
+	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;
+	};
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+
+		if (line.startsWith('--- ')) {
+			const oldPathRaw = line.slice(4);
+			const next = lines[i + 1];
+			if (!next?.startsWith('+++ ')) {
+				throw new Error(
+					'Invalid unified diff: expected "+++ <path>" after "--- <path>"',
+				);
+			}
+			const newPathRaw = next.slice(4);
+			i += 1;
+
+			flush();
+
+			const oldPath = stripPath(oldPathRaw);
+			const newPath = stripPath(newPathRaw);
+
+			if (!oldPath && !newPath) {
+				throw new Error(
+					'Invalid unified diff: missing file paths after ---/+++ headers.',
+				);
+			}
+
+			if (!oldPath) {
+				if (!newPath) {
+					throw new Error(
+						'Invalid unified diff: missing target path for added file.',
+					);
+				}
+				builder = {
+					kind: 'add',
+					filePath: newPath,
+					lines: [],
+				};
+				continue;
+			}
+
+			if (!newPath) {
+				builder = {
+					kind: 'delete',
+					filePath: oldPath,
+				};
+				continue;
+			}
+
+			if (oldPath !== newPath) {
+				throw new Error(
+					`Renames are not supported in apply_patch. Old path: ${oldPath}, new path: ${newPath}`,
+				);
+			}
+
+			builder = {
+				kind: 'update',
+				filePath: newPath,
+				hunks: [],
+				currentHunk: null,
+			};
+			continue;
+		}
+
+		if (!builder) {
+			if (shouldIgnoreMetadata(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 (line.startsWith('+')) {
+				builder.lines.push(line.slice(1));
+			}
+			continue;
+		}
+
+		if (builder.kind === 'delete') {
+			continue;
+		}
+
+		if (shouldIgnoreMetadata(line)) continue;
+
+		if (line.startsWith('@@')) {
+			const hunk: PatchHunk = { header: parseHunkHeader(line), lines: [] };
+			builder.hunks.push(hunk);
+			builder.currentHunk = hunk;
+			continue;
+		}
+
+		if (!builder.currentHunk) {
+			const fallback: PatchHunk = { header: {}, lines: [] };
+			builder.hunks.push(fallback);
+			builder.currentHunk = fallback;
+		}
+
+		const hunk = builder.currentHunk;
+		const prefix = line[0];
+		const getLine = (kind: PatchHunkLine['kind'], content: string) => ({
+			kind,
+			content,
+		});
+
+		if (prefix === '+') {
+			hunk.lines.push(getLine('add', line.slice(1)));
+		} else if (prefix === '-') {
+			hunk.lines.push(getLine('remove', line.slice(1)));
+		} else if (prefix === ' ') {
+			hunk.lines.push(getLine('context', line.slice(1)));
+		} else {
+			hunk.lines.push(getLine('context', line));
+		}
+	}
+
+	flush();
+
+	if (operations.length === 0) {
+		throw new Error('No operations found in unified diff.');
+	}
+
+	return operations;
+}

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

@@ -0,0 +1,28 @@
+import { PATCH_BEGIN_MARKER } from './constants.ts';
+import { parseEnvelopedPatch } from './parse-enveloped.ts';
+import { parseUnifiedPatch } from './parse-unified.ts';
+import type { PatchOperation } from './types.ts';
+
+export type PatchFormat = 'enveloped' | 'unified';
+
+export function parsePatchInput(patch: string): {
+	format: PatchFormat;
+	operations: PatchOperation[];
+} {
+	const trimmed = patch.trim();
+	if (!trimmed) {
+		throw new Error('Patch content is empty.');
+	}
+
+	if (trimmed.includes(PATCH_BEGIN_MARKER)) {
+		return {
+			format: 'enveloped',
+			operations: parseEnvelopedPatch(patch),
+		};
+	}
+
+	return {
+		format: 'unified',
+		operations: parseUnifiedPatch(patch),
+	};
+}

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

@@ -0,0 +1,23 @@
+export function splitLines(value: string): {
+	lines: string[];
+	newline: string;
+} {
+	const newline = value.includes('\r\n') ? '\r\n' : '\n';
+	const normalized = newline === '\n' ? value : value.replace(/\r\n/g, '\n');
+	const parts = normalized.split('\n');
+	if (parts.length > 0 && parts[parts.length - 1] === '') {
+		parts.pop();
+	}
+	return { lines: parts, newline };
+}
+
+export function joinLines(lines: string[], newline: string): string {
+	const base = lines.join('\n');
+	return newline === '\n' ? base : base.replace(/\n/g, newline);
+}
+
+export function ensureTrailingNewline(lines: string[]) {
+	if (lines.length === 0 || lines[lines.length - 1] !== '') {
+		lines.push('');
+	}
+}

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

@@ -0,0 +1,82 @@
+export type PatchOperationKind = 'add' | 'update' | 'delete';
+
+export interface PatchHunkLine {
+	kind: 'context' | 'add' | 'remove';
+	content: string;
+}
+
+export interface PatchHunkHeader {
+	oldStart?: number;
+	oldLines?: number;
+	newStart?: number;
+	newLines?: number;
+	context?: string;
+}
+
+export interface PatchHunk {
+	header: PatchHunkHeader;
+	lines: PatchHunkLine[];
+}
+
+export interface PatchAddOperation {
+	kind: 'add';
+	filePath: string;
+	lines: string[];
+}
+
+export interface PatchDeleteOperation {
+	kind: 'delete';
+	filePath: string;
+}
+
+export interface PatchUpdateOperation {
+	kind: 'update';
+	filePath: string;
+	hunks: PatchHunk[];
+}
+
+export type PatchOperation =
+	| PatchAddOperation
+	| PatchDeleteOperation
+	| PatchUpdateOperation;
+
+export interface AppliedPatchHunk {
+	header: PatchHunkHeader;
+	lines: PatchHunkLine[];
+	oldStart: number;
+	oldLines: number;
+	newStart: number;
+	newLines: number;
+	additions: number;
+	deletions: number;
+}
+
+export interface AppliedPatchOperation {
+	kind: PatchOperationKind;
+	filePath: string;
+	stats: {
+		additions: number;
+		deletions: number;
+	};
+	hunks: AppliedPatchHunk[];
+}
+
+export interface PatchSummary {
+	files: number;
+	additions: number;
+	deletions: number;
+}
+
+export interface PatchApplicationResult {
+	operations: AppliedPatchOperation[];
+	summary: PatchSummary;
+	normalizedPatch: string;
+	rejected: RejectedPatch[];
+}
+
+export interface RejectedPatch {
+	kind: PatchOperationKind;
+	filePath: string;
+	reason: string;
+	operation: PatchOperation;
+}