opencode-dux 1.0.0

package/src/hooks/apply-patch/codec.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  formatPatch,
+  normalizeUnicode,
+  parsePatch,
+  parsePatchStrict,
+  stripHeredoc,
+} from './codec';
+import type { ParsedPatch } from './types';
+
+describe('apply-patch/codec', () => {
+  test('stripHeredoc extracts the real patch content', () => {
+    expect(
+      stripHeredoc(`cat <<'PATCH'
+*** Begin Patch
+*** End Patch
+PATCH`),
+    ).toBe('*** Begin Patch\n*** End Patch');
+  });
+
+  test('parsePatch recognizes add delete update and move', () => {
+    const parsed = parsePatch(`*** Begin Patch
+*** Add File: added.txt
++alpha
+*** Delete File: removed.txt
+*** Update File: before.txt
+*** Move to: after.txt
+@@ ctx
+ line-a
+-line-b
++line-c
+*** End of File
+*** End Patch`);
+
+    expect(parsed.hunks).toHaveLength(3);
+    expect(parsed.hunks[0]).toEqual({
+      type: 'add',
+      path: 'added.txt',
+      contents: 'alpha',
+    });
+    expect(parsed.hunks[1]).toEqual({ type: 'delete', path: 'removed.txt' });
+    expect(parsed.hunks[2]).toEqual({
+      type: 'update',
+      path: 'before.txt',
+      move_path: 'after.txt',
+      chunks: [
+        {
+          old_lines: ['line-a', 'line-b'],
+          new_lines: ['line-a', 'line-c'],
+          change_context: 'ctx',
+          is_end_of_file: true,
+        },
+      ],
+    });
+  });
+
+  test('parsePatch tolerates heredocs with aggressive CRLF and preserves EOF', () => {
+    const parsed = parsePatch(`cat <<'PATCH'\r
+*** Begin Patch\r
+*** Update File: sample.txt\r
+@@\r
+-alpha\r
++beta\r
+*** End of File\r
+*** End Patch\r
+PATCH`);
+
+    expect(parsed.hunks).toEqual([
+      {
+        type: 'update',
+        path: 'sample.txt',
+        chunks: [
+          {
+            old_lines: ['alpha'],
+            new_lines: ['beta'],
+            change_context: undefined,
+            is_end_of_file: true,
+          },
+        ],
+      },
+    ]);
+  });
+
+  test('parsePatchStrict preserves End Patch text when it is hunk context', () => {
+    const markerPadding = '  ';
+    const parsed = parsePatchStrict(`*** Begin Patch${markerPadding}
+*** Update File: sample.txt
+@@ marker
+ *** End Patch
+ keep
+*** End Patch${markerPadding}`);
+
+    expect(parsed.hunks).toEqual([
+      {
+        type: 'update',
+        path: 'sample.txt',
+        chunks: [
+          {
+            old_lines: ['*** End Patch', 'keep'],
+            new_lines: ['*** End Patch', 'keep'],
+            change_context: 'marker',
+            is_end_of_file: undefined,
+          },
+        ],
+      },
+    ]);
+  });
+
+  test('parsePatchStrict fails on garbage inside @@', () => {
+    expect(() =>
+      parsePatchStrict(`*** Begin Patch
+*** Update File: sample.txt
+@@
+-alpha
+garbage
++beta
+*** End Patch`),
+    ).toThrow('unexpected line in patch chunk');
+  });
+
+  test('parsePatchStrict fails on garbage inside Add File', () => {
+    expect(() =>
+      parsePatchStrict(`*** Begin Patch
+*** Add File: sample.txt
++alpha
+garbage
+*** End Patch`),
+    ).toThrow('unexpected line in Add File body');
+  });
+
+  test('parsePatchStrict fails on malformed Delete File', () => {
+    expect(() =>
+      parsePatchStrict(`*** Begin Patch
+*** Delete File: sample.txt
++ghost
+*** End Patch`),
+    ).toThrow('unexpected line between hunks');
+  });
+
+  test('parsePatchStrict fails on garbage after End Patch', () => {
+    expect(() =>
+      parsePatchStrict(`*** Begin Patch
+*** Delete File: sample.txt
+*** End Patch
+garbage`),
+    ).toThrow('unexpected line after End Patch');
+  });
+
+  test('parsePatchStrict fails when Update File has no @@ chunks', () => {
+    expect(() =>
+      parsePatchStrict(`*** Begin Patch
+*** Update File: sample.txt
+*** End Patch`),
+    ).toThrow('missing @@ chunk body');
+  });
+
+  test('formatPatch allows stable parse -> format -> parse roundtrips', () => {
+    const parsed: ParsedPatch = {
+      hunks: [
+        {
+          type: 'update',
+          path: 'sample.txt',
+          chunks: [
+            {
+              old_lines: ['alpha', 'beta'],
+              new_lines: ['alpha', 'BETA'],
+            },
+          ],
+        },
+      ],
+    };
+
+    expect(parsePatch(formatPatch(parsed))).toEqual(parsed);
+  });
+
+  test('normalizeUnicode unifies expected typographic variants', () => {
+    expect(normalizeUnicode('“uno”…\u00A0dos-tres')).toBe('"uno"... dos-tres');
+  });
+
+  test('normalizeUnicode covers less common typographic variants', () => {
+    expect(normalizeUnicode('‛uno‟―dos')).toBe(`'uno"-dos`);
+  });
+});

package/src/hooks/apply-patch/codec.ts

@@ -0,0 +1,352 @@
+import type { ParsedPatch, PatchChunk, PatchHunk } from './types';
+
+type ParseMode = 'permissive' | 'strict';
+
+function normalizeLineEndings(text: string): string {
+  return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+export function normalizeUnicode(text: string): string {
+  return text
+    .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
+    .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
+    .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, '-')
+    .replace(/\u2026/g, '...')
+    .replace(/\u00A0/g, ' ');
+}
+
+export function stripHeredoc(input: string): string {
+  const normalized = normalizeLineEndings(input);
+  const match = normalized.match(
+    /^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/,
+  );
+  return match ? match[2] : normalized;
+}
+
+export function normalizePatchText(patchText: string): string {
+  return stripHeredoc(normalizeLineEndings(patchText).trim());
+}
+
+function parseHeader(lines: string[], index: number) {
+  const line = lines[index];
+
+  if (line.startsWith('*** Add File:')) {
+    const file = line.slice('*** Add File:'.length).trim();
+    return file ? { file, next: index + 1 } : null;
+  }
+
+  if (line.startsWith('*** Delete File:')) {
+    const file = line.slice('*** Delete File:'.length).trim();
+    return file ? { file, next: index + 1 } : null;
+  }
+
+  if (line.startsWith('*** Update File:')) {
+    const file = line.slice('*** Update File:'.length).trim();
+    let move: string | undefined;
+    let next = index + 1;
+
+    if (next < lines.length && lines[next].startsWith('*** Move to:')) {
+      const moveTarget = lines[next].slice('*** Move to:'.length).trim();
+      if (!moveTarget) {
+        return null;
+      }
+
+      move = moveTarget;
+      next += 1;
+    }
+
+    return file ? { file, move, next } : null;
+  }
+
+  return null;
+}
+
+function unexpectedPatchLine(context: string, line: string): never {
+  const rendered = line.length === 0 ? '<empty>' : line;
+  throw new Error(
+    `Invalid patch format: unexpected line ${context}: ${rendered}`,
+  );
+}
+
+function parseChangeContext(line: string): string | undefined {
+  const context = line.slice(2);
+  if (context.length === 0) {
+    return undefined;
+  }
+
+  return context.startsWith(' ') ? context.slice(1) || undefined : context;
+}
+
+function isPatchBoundary(line: string, marker: string): boolean {
+  return line.trimEnd() === marker;
+}
+
+function parseChunks(lines: string[], index: number, mode: ParseMode) {
+  const chunks: PatchChunk[] = [];
+  let at = index;
+
+  while (at < lines.length && !lines[at].startsWith('***')) {
+    if (!lines[at].startsWith('@@')) {
+      if (mode === 'strict') {
+        unexpectedPatchLine('in update body', lines[at]);
+      }
+      at += 1;
+      continue;
+    }
+
+    const context = parseChangeContext(lines[at]);
+    at += 1;
+
+    const old_lines: string[] = [];
+    const new_lines: string[] = [];
+    let eof = false;
+
+    while (
+      at < lines.length &&
+      !lines[at].startsWith('@@') &&
+      (!lines[at].startsWith('***') || lines[at] === '*** End of File')
+    ) {
+      const line = lines[at];
+
+      if (line === '*** End of File') {
+        eof = true;
+        at += 1;
+        break;
+      }
+
+      if (line.startsWith(' ')) {
+        old_lines.push(line.slice(1));
+        new_lines.push(line.slice(1));
+        at += 1;
+        continue;
+      }
+
+      if (line.startsWith('-')) {
+        old_lines.push(line.slice(1));
+        at += 1;
+        continue;
+      }
+
+      if (line.startsWith('+')) {
+        new_lines.push(line.slice(1));
+        at += 1;
+        continue;
+      }
+
+      if (mode === 'strict') {
+        unexpectedPatchLine('in patch chunk', line);
+      }
+
+      at += 1;
+    }
+
+    chunks.push({
+      old_lines,
+      new_lines,
+      change_context: context,
+      is_end_of_file: eof || undefined,
+    });
+  }
+
+  return { chunks, next: at };
+}
+
+function parseAdd(lines: string[], index: number, mode: ParseMode) {
+  const contents: string[] = [];
+  let at = index;
+
+  while (at < lines.length && !lines[at].startsWith('***')) {
+    if (lines[at].startsWith('+')) {
+      contents.push(lines[at].slice(1));
+      at += 1;
+      continue;
+    }
+
+    if (mode === 'strict') {
+      unexpectedPatchLine('in Add File body', lines[at]);
+    }
+
+    at += 1;
+  }
+
+  return { content: contents.join('\n'), next: at };
+}
+
+function parsePatchInternal(patchText: string, mode: ParseMode): ParsedPatch {
+  const clean = normalizePatchText(patchText);
+  const lines = clean.split('\n');
+  const begin = lines.findIndex((line) =>
+    isPatchBoundary(line, '*** Begin Patch'),
+  );
+  const end = lines.findIndex(
+    (line, index) => index > begin && isPatchBoundary(line, '*** End Patch'),
+  );
+
+  if (begin === -1 || end === -1 || begin >= end) {
+    throw new Error('Invalid patch format: missing Begin/End markers');
+  }
+
+  if (mode === 'strict') {
+    for (const line of lines.slice(0, begin)) {
+      unexpectedPatchLine('before Begin Patch', line);
+    }
+
+    for (const line of lines.slice(end + 1)) {
+      unexpectedPatchLine('after End Patch', line);
+    }
+  }
+
+  const hunks: PatchHunk[] = [];
+  let index = begin + 1;
+
+  while (index < end) {
+    const header = parseHeader(lines, index);
+
+    if (!header) {
+      if (mode === 'strict') {
+        unexpectedPatchLine('between hunks', lines[index]);
+      }
+      index += 1;
+      continue;
+    }
+
+    if (lines[index].startsWith('*** Add File:')) {
+      const next = parseAdd(lines, header.next, mode);
+      hunks.push({
+        type: 'add',
+        path: header.file,
+        contents: next.content,
+      });
+      index = next.next;
+      continue;
+    }
+
+    if (lines[index].startsWith('*** Delete File:')) {
+      hunks.push({ type: 'delete', path: header.file });
+      index = header.next;
+      continue;
+    }
+
+    const next = parseChunks(lines, header.next, mode);
+    if (mode === 'strict' && next.chunks.length === 0) {
+      throw new Error(
+        `Invalid patch format: Update File is missing @@ chunk body: ${header.file}`,
+      );
+    }
+
+    hunks.push({
+      type: 'update',
+      path: header.file,
+      move_path: header.move,
+      chunks: next.chunks,
+    });
+    index = next.next;
+  }
+
+  return { hunks };
+}
+
+export function parsePatch(patchText: string): ParsedPatch {
+  return parsePatchInternal(patchText, 'permissive');
+}
+
+export function parsePatchStrict(patchText: string): ParsedPatch {
+  return parsePatchInternal(patchText, 'strict');
+}
+
+function diffMatrix(old_lines: string[], new_lines: string[]): number[][] {
+  const dp = Array.from({ length: old_lines.length + 1 }, () =>
+    Array<number>(new_lines.length + 1).fill(0),
+  );
+
+  for (let oldIndex = 1; oldIndex <= old_lines.length; oldIndex += 1) {
+    for (let newIndex = 1; newIndex <= new_lines.length; newIndex += 1) {
+      dp[oldIndex][newIndex] =
+        old_lines[oldIndex - 1] === new_lines[newIndex - 1]
+          ? dp[oldIndex - 1][newIndex - 1] + 1
+          : Math.max(dp[oldIndex - 1][newIndex], dp[oldIndex][newIndex - 1]);
+    }
+  }
+
+  return dp;
+}
+
+function renderChunk(chunk: PatchChunk): string[] {
+  const lines = [chunk.change_context ? `@@ ${chunk.change_context}` : '@@'];
+  const dp = diffMatrix(chunk.old_lines, chunk.new_lines);
+  const body: string[] = [];
+  let oldIndex = chunk.old_lines.length;
+  let newIndex = chunk.new_lines.length;
+
+  while (oldIndex > 0 && newIndex > 0) {
+    if (chunk.old_lines[oldIndex - 1] === chunk.new_lines[newIndex - 1]) {
+      body.push(` ${chunk.old_lines[oldIndex - 1]}`);
+      oldIndex -= 1;
+      newIndex -= 1;
+      continue;
+    }
+
+    if (dp[oldIndex - 1][newIndex] >= dp[oldIndex][newIndex - 1]) {
+      body.push(`-${chunk.old_lines[oldIndex - 1]}`);
+      oldIndex -= 1;
+      continue;
+    }
+
+    body.push(`+${chunk.new_lines[newIndex - 1]}`);
+    newIndex -= 1;
+  }
+
+  while (oldIndex > 0) {
+    body.push(`-${chunk.old_lines[oldIndex - 1]}`);
+    oldIndex -= 1;
+  }
+
+  while (newIndex > 0) {
+    body.push(`+${chunk.new_lines[newIndex - 1]}`);
+    newIndex -= 1;
+  }
+
+  lines.push(...body.reverse());
+
+  if (chunk.is_end_of_file) {
+    lines.push('*** End of File');
+  }
+
+  return lines;
+}
+
+function renderAddContents(contents: string): string[] {
+  if (contents.length === 0) {
+    return [];
+  }
+
+  return contents.split('\n').map((line) => `+${line}`);
+}
+
+export function formatPatch(patch: ParsedPatch): string {
+  const lines = ['*** Begin Patch'];
+
+  for (const hunk of patch.hunks) {
+    if (hunk.type === 'add') {
+      lines.push(`*** Add File: ${hunk.path}`);
+      lines.push(...renderAddContents(hunk.contents));
+      continue;
+    }
+
+    if (hunk.type === 'delete') {
+      lines.push(`*** Delete File: ${hunk.path}`);
+      continue;
+    }
+
+    lines.push(`*** Update File: ${hunk.path}`);
+    if (hunk.move_path) {
+      lines.push(`*** Move to: ${hunk.move_path}`);
+    }
+    for (const chunk of hunk.chunks) {
+      lines.push(...renderChunk(chunk));
+    }
+  }
+
+  lines.push('*** End Patch');
+  return lines.join('\n');
+}

package/src/hooks/apply-patch/errors.ts

@@ -0,0 +1,117 @@
+import type { ApplyPatchErrorCode, ApplyPatchErrorKind } from './types';
+
+const APPLY_PATCH_ERROR_PREFIX: Record<ApplyPatchErrorKind, string> = {
+  blocked: 'apply_patch blocked',
+  validation: 'apply_patch validation failed',
+  verification: 'apply_patch verification failed',
+  internal: 'apply_patch internal error',
+};
+
+export class ApplyPatchError extends Error {
+  override readonly cause?: unknown;
+
+  constructor(
+    readonly kind: ApplyPatchErrorKind,
+    readonly code: ApplyPatchErrorCode,
+    message: string,
+    options?: {
+      cause?: unknown;
+    },
+  ) {
+    super(`${APPLY_PATCH_ERROR_PREFIX[kind]}: ${message}`);
+    this.name = 'ApplyPatchError';
+    this.cause = options?.cause;
+  }
+}
+
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function createApplyPatchBlockedError(
+  message: string,
+  cause?: unknown,
+): ApplyPatchError {
+  return new ApplyPatchError('blocked', 'outside_workspace', message, {
+    cause,
+  });
+}
+
+export function createApplyPatchValidationError(
+  message: string,
+  cause?: unknown,
+): ApplyPatchError {
+  return new ApplyPatchError('validation', 'malformed_patch', message, {
+    cause,
+  });
+}
+
+export function createApplyPatchVerificationError(
+  message: string,
+  cause?: unknown,
+): ApplyPatchError {
+  return new ApplyPatchError('verification', 'verification_failed', message, {
+    cause,
+  });
+}
+
+export function createApplyPatchInternalError(
+  message: string,
+  cause?: unknown,
+): ApplyPatchError {
+  return new ApplyPatchError('internal', 'internal_unexpected', message, {
+    cause,
+  });
+}
+
+export function isApplyPatchError(error: unknown): error is ApplyPatchError {
+  return error instanceof ApplyPatchError;
+}
+
+export function isApplyPatchBlockedError(error: unknown): boolean {
+  return isApplyPatchError(error) && error.kind === 'blocked';
+}
+
+export function isApplyPatchValidationError(error: unknown): boolean {
+  return isApplyPatchError(error) && error.kind === 'validation';
+}
+
+export function isApplyPatchVerificationError(error: unknown): boolean {
+  return isApplyPatchError(error) && error.kind === 'verification';
+}
+
+export function isApplyPatchInternalError(error: unknown): boolean {
+  return isApplyPatchError(error) && error.kind === 'internal';
+}
+
+export function getApplyPatchErrorDetails(error: unknown):
+  | {
+      kind: ApplyPatchErrorKind;
+      code: ApplyPatchErrorCode;
+      message: string;
+    }
+  | undefined {
+  if (!isApplyPatchError(error)) {
+    return undefined;
+  }
+
+  return {
+    kind: error.kind,
+    code: error.code,
+    message: error.message,
+  };
+}
+
+export function ensureApplyPatchError(
+  error: unknown,
+  context: string,
+): ApplyPatchError {
+  if (isApplyPatchError(error)) {
+    return error;
+  }
+
+  return createApplyPatchInternalError(
+    `${context}: ${getErrorMessage(error)}`,
+    error,
+  );
+}