gsd-pi 2.10.1 → 2.10.2

package/node_modules/@gsd/pi-coding-agent/src/core/tools/edit-diff.ts

@@ -1,9 +1,16 @@
 /**
  * Shared diff computation utilities for the edit tool.
  * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering).
+ *
+ * Hot-path functions (fuzzyFindText, normalizeForFuzzyMatch, generateDiffString)
+ * delegate to the native Rust engine for performance on large files.
  */
 
-import * as Diff from "diff";
+import {
+	fuzzyFindText as nativeFuzzyFindText,
+	generateDiff as nativeGenerateDiff,
+	normalizeForFuzzyMatch as nativeNormalizeForFuzzyMatch,
+} from "@gsd/native";
 import { constants } from "fs";
 import { access, readFile } from "fs/promises";
 import { resolveToCwd } from "./path-utils.js";
@@ -25,32 +32,14 @@ export function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string
 }
 
 /**
- * Normalize text for fuzzy matching. Applies progressive transformations:
+ * Normalize text for fuzzy matching (native Rust implementation).
  * - Strip trailing whitespace from each line
  * - Normalize smart quotes to ASCII equivalents
  * - Normalize Unicode dashes/hyphens to ASCII hyphen
  * - Normalize special Unicode spaces to regular space
  */
 export function normalizeForFuzzyMatch(text: string): string {
-	return (
-		text
-			// Strip trailing whitespace per line
-			.split("\n")
-			.map((line) => line.trimEnd())
-			.join("\n")
-			// Smart single quotes → '
-			.replace(/[\u2018\u2019\u201A\u201B]/g, "'")
-			// Smart double quotes → "
-			.replace(/[\u201C\u201D\u201E\u201F]/g, '"')
-			// Various dashes/hyphens → -
-			// U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,
-			// U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus
-			.replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-")
-			// Special spaces → regular space
-			// U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,
-			// U+205F medium math space, U+3000 ideographic space
-			.replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ")
-	);
+	return nativeNormalizeForFuzzyMatch(text);
 }
 
 export interface FuzzyMatchResult {
@@ -70,49 +59,14 @@ export interface FuzzyMatchResult {
 }
 
 /**
- * Find oldText in content, trying exact match first, then fuzzy match.
+ * Find oldText in content, trying exact match first, then fuzzy match
+ * (native Rust implementation).
+ *
  * When fuzzy matching is used, the returned contentForReplacement is the
- * fuzzy-normalized version of the content (trailing whitespace stripped,
- * Unicode quotes/dashes normalized to ASCII).
+ * fuzzy-normalized version of the content.
  */
 export function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult {
-	// Try exact match first
-	const exactIndex = content.indexOf(oldText);
-	if (exactIndex !== -1) {
-		return {
-			found: true,
-			index: exactIndex,
-			matchLength: oldText.length,
-			usedFuzzyMatch: false,
-			contentForReplacement: content,
-		};
-	}
-
-	// Try fuzzy match - work entirely in normalized space
-	const fuzzyContent = normalizeForFuzzyMatch(content);
-	const fuzzyOldText = normalizeForFuzzyMatch(oldText);
-	const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
-
-	if (fuzzyIndex === -1) {
-		return {
-			found: false,
-			index: -1,
-			matchLength: 0,
-			usedFuzzyMatch: false,
-			contentForReplacement: content,
-		};
-	}
-
-	// When fuzzy matching, we work in the normalized space for replacement.
-	// This means the output will have normalized whitespace/quotes/dashes,
-	// which is acceptable since we're fixing minor formatting differences anyway.
-	return {
-		found: true,
-		index: fuzzyIndex,
-		matchLength: fuzzyOldText.length,
-		usedFuzzyMatch: true,
-		contentForReplacement: fuzzyContent,
-	};
+	return nativeFuzzyFindText(content, oldText);
 }
 
 /** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
@@ -121,7 +75,9 @@ export function stripBom(content: string): { bom: string; text: string } {
 }
 
 /**
- * Generate a unified diff string with line numbers and context.
+ * Generate a unified diff string with line numbers and context
+ * (native Rust implementation using Myers' algorithm via the `similar` crate).
+ *
  * Returns both the diff string and the first changed line number (in the new file).
  */
 export function generateDiffString(
@@ -129,101 +85,11 @@ export function generateDiffString(
 	newContent: string,
 	contextLines = 4,
 ): { diff: string; firstChangedLine: number | undefined } {
-	const parts = Diff.diffLines(oldContent, newContent);
-	const output: string[] = [];
-
-	const oldLines = oldContent.split("\n");
-	const newLines = newContent.split("\n");
-	const maxLineNum = Math.max(oldLines.length, newLines.length);
-	const lineNumWidth = String(maxLineNum).length;
-
-	let oldLineNum = 1;
-	let newLineNum = 1;
-	let lastWasChange = false;
-	let firstChangedLine: number | undefined;
-
-	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i];
-		const raw = part.value.split("\n");
-		if (raw[raw.length - 1] === "") {
-			raw.pop();
-		}
-
-		if (part.added || part.removed) {
-			// Capture the first changed line (in the new file)
-			if (firstChangedLine === undefined) {
-				firstChangedLine = newLineNum;
-			}
-
-			// Show the change
-			for (const line of raw) {
-				if (part.added) {
-					const lineNum = String(newLineNum).padStart(lineNumWidth, " ");
-					output.push(`+${lineNum} ${line}`);
-					newLineNum++;
-				} else {
-					// removed
-					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
-					output.push(`-${lineNum} ${line}`);
-					oldLineNum++;
-				}
-			}
-			lastWasChange = true;
-		} else {
-			// Context lines - only show a few before/after changes
-			const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
-
-			if (lastWasChange || nextPartIsChange) {
-				// Show context
-				let linesToShow = raw;
-				let skipStart = 0;
-				let skipEnd = 0;
-
-				if (!lastWasChange) {
-					// Show only last N lines as leading context
-					skipStart = Math.max(0, raw.length - contextLines);
-					linesToShow = raw.slice(skipStart);
-				}
-
-				if (!nextPartIsChange && linesToShow.length > contextLines) {
-					// Show only first N lines as trailing context
-					skipEnd = linesToShow.length - contextLines;
-					linesToShow = linesToShow.slice(0, contextLines);
-				}
-
-				// Add ellipsis if we skipped lines at start
-				if (skipStart > 0) {
-					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-					// Update line numbers for the skipped leading context
-					oldLineNum += skipStart;
-					newLineNum += skipStart;
-				}
-
-				for (const line of linesToShow) {
-					const lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
-					output.push(` ${lineNum} ${line}`);
-					oldLineNum++;
-					newLineNum++;
-				}
-
-				// Add ellipsis if we skipped lines at end
-				if (skipEnd > 0) {
-					output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-					// Update line numbers for the skipped trailing context
-					oldLineNum += skipEnd;
-					newLineNum += skipEnd;
-				}
-			} else {
-				// Skip these context lines entirely
-				oldLineNum += raw.length;
-				newLineNum += raw.length;
-			}
-
-			lastWasChange = false;
-		}
-	}
-
-	return { diff: output.join("\n"), firstChangedLine };
+	const result = nativeGenerateDiff(oldContent, newContent, contextLines);
+	return {
+		diff: result.diff,
+		firstChangedLine: result.firstChangedLine ?? undefined,
+	};
 }
 
 export interface EditDiffResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.10.1",
+  "version": "2.10.2",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/native/dist/diff/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Native fuzzy text matching and diff generation for the edit tool.
+ *
+ * Uses the `similar` Rust crate (Myers' algorithm) for O(n+d) diffing,
+ * and single-pass Unicode normalization for fuzzy matching.
+ */
+import type { DiffResult, FuzzyMatchResult } from "./types.js";
+export type { DiffResult, FuzzyMatchResult };
+/**
+ * Normalize text for fuzzy matching:
+ * - Strip trailing whitespace from each line
+ * - Smart quotes to ASCII equivalents
+ * - Unicode dashes/hyphens to ASCII hyphen
+ * - Special Unicode spaces to regular space
+ */
+export declare function normalizeForFuzzyMatch(text: string): string;
+/**
+ * Find `oldText` in `content`, trying exact match first, then fuzzy match.
+ *
+ * When fuzzy matching is used, `contentForReplacement` is the normalized
+ * version of `content`.
+ */
+export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
+/**
+ * Generate a unified diff string with line numbers and context.
+ *
+ * Uses Myers' diff algorithm via the `similar` Rust crate.
+ *
+ * @param oldContent  Original text
+ * @param newContent  Modified text
+ * @param contextLines  Number of context lines around changes (default: 4)
+ */
+export declare function generateDiff(oldContent: string, newContent: string, contextLines?: number): DiffResult;

package/packages/native/dist/diff/index.js

@@ -0,0 +1,38 @@
+/**
+ * Native fuzzy text matching and diff generation for the edit tool.
+ *
+ * Uses the `similar` Rust crate (Myers' algorithm) for O(n+d) diffing,
+ * and single-pass Unicode normalization for fuzzy matching.
+ */
+import { native } from "../native.js";
+/**
+ * Normalize text for fuzzy matching:
+ * - Strip trailing whitespace from each line
+ * - Smart quotes to ASCII equivalents
+ * - Unicode dashes/hyphens to ASCII hyphen
+ * - Special Unicode spaces to regular space
+ */
+export function normalizeForFuzzyMatch(text) {
+    return native.normalizeForFuzzyMatch(text);
+}
+/**
+ * Find `oldText` in `content`, trying exact match first, then fuzzy match.
+ *
+ * When fuzzy matching is used, `contentForReplacement` is the normalized
+ * version of `content`.
+ */
+export function fuzzyFindText(content, oldText) {
+    return native.fuzzyFindText(content, oldText);
+}
+/**
+ * Generate a unified diff string with line numbers and context.
+ *
+ * Uses Myers' diff algorithm via the `similar` Rust crate.
+ *
+ * @param oldContent  Original text
+ * @param newContent  Modified text
+ * @param contextLines  Number of context lines around changes (default: 4)
+ */
+export function generateDiff(oldContent, newContent, contextLines) {
+    return native.generateDiff(oldContent, newContent, contextLines);
+}

package/packages/native/dist/diff/types.d.ts

@@ -0,0 +1,23 @@
+/** Result of fuzzy text matching (exact match tried first, then normalized). */
+export interface FuzzyMatchResult {
+    /** Whether a match was found. */
+    found: boolean;
+    /** UTF-16 code unit index where the match starts (-1 if not found). */
+    index: number;
+    /** Length of the matched text in UTF-16 code units (0 if not found). */
+    matchLength: number;
+    /** Whether fuzzy (normalized) matching was used instead of exact. */
+    usedFuzzyMatch: boolean;
+    /**
+     * Content to use for replacement operations.
+     * Original content when exact match; normalized content when fuzzy match.
+     */
+    contentForReplacement: string;
+}
+/** Result of unified diff generation. */
+export interface DiffResult {
+    /** The unified diff string with line numbers. */
+    diff: string;
+    /** Line number of the first change in the new file (undefined if no changes). */
+    firstChangedLine: number | undefined;
+}

package/packages/native/dist/diff/types.js

@@ -0,0 +1 @@
+export {};

package/packages/native/dist/index.d.ts

@@ -28,7 +28,13 @@ export { htmlToMarkdown } from "./html/index.js";
 export type { HtmlToMarkdownOptions } from "./html/index.js";
 export { wrapTextWithAnsi, truncateToWidth, sliceWithWidth, extractSegments, sanitizeText, visibleWidth, EllipsisKind, } from "./text/index.js";
 export type { SliceResult, ExtractSegmentsResult } from "./text/index.js";
+export { normalizeForFuzzyMatch, fuzzyFindText, generateDiff, } from "./diff/index.js";
+export type { FuzzyMatchResult, DiffResult } from "./diff/index.js";
 export { fuzzyFind } from "./fd/index.js";
 export type { FuzzyFindMatch, FuzzyFindOptions, FuzzyFindResult, } from "./fd/index.js";
 export { parseImage, ImageFormat, SamplingFilter } from "./image/index.js";
 export type { NativeImageHandle } from "./image/index.js";
+export { ttsrCompileRules, ttsrCheckBuffer, ttsrFreeRules } from "./ttsr/index.js";
+export type { TtsrHandle, TtsrRuleInput } from "./ttsr/index.js";
+export { parseFrontmatter, extractSection as nativeExtractSection, extractAllSections, batchParseGsdFiles, parseRoadmapFile, } from "./gsd-parser/index.js";
+export type { BatchParseResult, FrontmatterResult, NativeBoundaryMapEntry, NativeRoadmap, NativeRoadmapSlice, ParsedGsdFile, SectionResult, } from "./gsd-parser/index.js";

package/packages/native/dist/index.js

@@ -21,5 +21,8 @@ export { glob, invalidateFsScanCache } from "./glob/index.js";
 export { astGrep, astEdit } from "./ast/index.js";
 export { htmlToMarkdown } from "./html/index.js";
 export { wrapTextWithAnsi, truncateToWidth, sliceWithWidth, extractSegments, sanitizeText, visibleWidth, EllipsisKind, } from "./text/index.js";
+export { normalizeForFuzzyMatch, fuzzyFindText, generateDiff, } from "./diff/index.js";
 export { fuzzyFind } from "./fd/index.js";
 export { parseImage, ImageFormat, SamplingFilter } from "./image/index.js";
+export { ttsrCompileRules, ttsrCheckBuffer, ttsrFreeRules } from "./ttsr/index.js";
+export { parseFrontmatter, extractSection as nativeExtractSection, extractAllSections, batchParseGsdFiles, parseRoadmapFile, } from "./gsd-parser/index.js";

package/packages/native/dist/native.d.ts

@@ -29,5 +29,16 @@ export declare const native: {
     sanitizeText: (text: string) => string;
     visibleWidth: (text: string, tabWidth?: number) => number;
     fuzzyFind: (options: unknown) => unknown;
+    normalizeForFuzzyMatch: (text: string) => string;
+    fuzzyFindText: (content: string, oldText: string) => unknown;
+    generateDiff: (oldContent: string, newContent: string, contextLines?: number) => unknown;
     NativeImage: unknown;
+    ttsrCompileRules: (rules: unknown[]) => number;
+    ttsrCheckBuffer: (handle: number, buffer: string) => string[];
+    ttsrFreeRules: (handle: number) => void;
+    parseFrontmatter: (content: string) => unknown;
+    extractSection: (content: string, heading: string, level?: number) => unknown;
+    extractAllSections: (content: string, level?: number) => string;
+    batchParseGsdFiles: (directory: string) => unknown;
+    parseRoadmapFile: (content: string) => unknown;
 };

package/packages/native/dist/ttsr/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Native TTSR regex engine.
+ *
+ * Pre-compiles all rule condition patterns into a single Rust RegexSet for
+ * O(1)-style matching per buffer check, replacing per-rule JS regex iteration.
+ */
+import type { TtsrHandle, TtsrRuleInput } from "./types.js";
+export type { TtsrHandle, TtsrRuleInput };
+/**
+ * Compile TTSR rules into an optimized native regex engine.
+ *
+ * Returns an opaque handle for use with `ttsrCheckBuffer` and `ttsrFreeRules`.
+ */
+export declare function ttsrCompileRules(rules: TtsrRuleInput[]): TtsrHandle;
+/**
+ * Check a buffer against compiled TTSR rules.
+ *
+ * Returns an array of unique rule names whose conditions matched.
+ * All patterns are tested in a single pass via Rust's RegexSet.
+ */
+export declare function ttsrCheckBuffer(handle: TtsrHandle, buffer: string): string[];
+/**
+ * Free a compiled TTSR rule set, releasing native memory.
+ *
+ * Call when rules are no longer needed (e.g., session end).
+ */
+export declare function ttsrFreeRules(handle: TtsrHandle): void;

package/packages/native/dist/ttsr/index.js

@@ -0,0 +1,32 @@
+/**
+ * Native TTSR regex engine.
+ *
+ * Pre-compiles all rule condition patterns into a single Rust RegexSet for
+ * O(1)-style matching per buffer check, replacing per-rule JS regex iteration.
+ */
+import { native } from "../native.js";
+/**
+ * Compile TTSR rules into an optimized native regex engine.
+ *
+ * Returns an opaque handle for use with `ttsrCheckBuffer` and `ttsrFreeRules`.
+ */
+export function ttsrCompileRules(rules) {
+    return native.ttsrCompileRules(rules);
+}
+/**
+ * Check a buffer against compiled TTSR rules.
+ *
+ * Returns an array of unique rule names whose conditions matched.
+ * All patterns are tested in a single pass via Rust's RegexSet.
+ */
+export function ttsrCheckBuffer(handle, buffer) {
+    return native.ttsrCheckBuffer(handle, buffer);
+}
+/**
+ * Free a compiled TTSR rule set, releasing native memory.
+ *
+ * Call when rules are no longer needed (e.g., session end).
+ */
+export function ttsrFreeRules(handle) {
+    native.ttsrFreeRules(handle);
+}

package/packages/native/dist/ttsr/types.d.ts

@@ -0,0 +1,9 @@
+/** Input rule for TTSR regex compilation. */
+export interface TtsrRuleInput {
+    /** Unique rule name. */
+    name: string;
+    /** Regex condition patterns (any match triggers the rule). */
+    conditions: string[];
+}
+/** Opaque handle to a compiled TTSR rule set. */
+export type TtsrHandle = number;

package/packages/native/dist/ttsr/types.js

@@ -0,0 +1 @@
+export {};

package/packages/native/src/__tests__/diff.test.mjs

@@ -0,0 +1,189 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Load the native addon directly
+const addonDir = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "native",
+  "addon",
+);
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error(
+    "Native addon not found. Run `npm run build:native -w @gsd/native` first.",
+  );
+  process.exit(1);
+}
+
+// ── normalizeForFuzzyMatch ──────────────────────────────────────────────
+
+describe("normalizeForFuzzyMatch", () => {
+  test("strips trailing whitespace per line", () => {
+    assert.equal(native.normalizeForFuzzyMatch("hello   \nworld  "), "hello\nworld");
+  });
+
+  test("normalizes smart quotes to ASCII", () => {
+    assert.equal(
+      native.normalizeForFuzzyMatch("\u201Chello\u201D \u2018world\u2019"),
+      '"hello" \'world\'',
+    );
+  });
+
+  test("normalizes dashes to ASCII hyphen", () => {
+    assert.equal(native.normalizeForFuzzyMatch("a\u2013b\u2014c"), "a-b-c");
+  });
+
+  test("normalizes special spaces to regular space", () => {
+    assert.equal(native.normalizeForFuzzyMatch("a\u00A0b\u3000c"), "a b c");
+  });
+
+  test("handles empty string", () => {
+    assert.equal(native.normalizeForFuzzyMatch(""), "");
+  });
+
+  test("preserves leading whitespace", () => {
+    assert.equal(native.normalizeForFuzzyMatch("  hello  "), "  hello");
+  });
+});
+
+// ── fuzzyFindText ───────────────────────────────────────────────────────
+
+describe("fuzzyFindText", () => {
+  test("finds exact match", () => {
+    const result = native.fuzzyFindText("hello world", "world");
+    assert.equal(result.found, true);
+    assert.equal(result.index, 6);
+    assert.equal(result.matchLength, 5);
+    assert.equal(result.usedFuzzyMatch, false);
+    assert.equal(result.contentForReplacement, "hello world");
+  });
+
+  test("finds fuzzy match with smart quotes", () => {
+    const content = 'let x = \u201Chello\u201D;';
+    const oldText = 'let x = "hello";';
+    const result = native.fuzzyFindText(content, oldText);
+    assert.equal(result.found, true);
+    assert.equal(result.usedFuzzyMatch, true);
+  });
+
+  test("returns not found for missing text", () => {
+    const result = native.fuzzyFindText("hello world", "xyz");
+    assert.equal(result.found, false);
+    assert.equal(result.index, -1);
+    assert.equal(result.matchLength, 0);
+  });
+
+  test("returns correct UTF-16 index for non-ASCII content", () => {
+    // Emoji U+1F600 is 2 UTF-16 code units (surrogate pair), 4 UTF-8 bytes
+    const content = "\u{1F600}hello";
+    const result = native.fuzzyFindText(content, "hello");
+    assert.equal(result.found, true);
+    // Emoji is 2 UTF-16 code units, so "hello" starts at index 2
+    assert.equal(result.index, 2);
+    assert.equal(result.matchLength, 5);
+  });
+
+  test("index is compatible with JS substring()", () => {
+    const content = "abc\u{1F600}def";
+    const result = native.fuzzyFindText(content, "def");
+    assert.equal(result.found, true);
+    // "abc" = 3, emoji = 2 UTF-16 code units → index 5
+    assert.equal(result.index, 5);
+    // Verify substring works correctly with the returned index
+    const extracted = result.contentForReplacement.substring(
+      result.index,
+      result.index + result.matchLength,
+    );
+    assert.equal(extracted, "def");
+  });
+
+  test("fuzzy match with trailing whitespace differences", () => {
+    const content = "hello   \nworld  ";
+    const oldText = "hello\nworld";
+    const result = native.fuzzyFindText(content, oldText);
+    assert.equal(result.found, true);
+    assert.equal(result.usedFuzzyMatch, true);
+  });
+});
+
+// ── generateDiff ────────────────────────────────────────────────────────
+
+describe("generateDiff", () => {
+  test("generates diff for a line change", () => {
+    const old = "line1\nline2\nline3";
+    const newText = "line1\nmodified\nline3";
+    const result = native.generateDiff(old, newText);
+    assert.ok(result.diff.includes("line2"));
+    assert.ok(result.diff.includes("modified"));
+    assert.ok(result.diff.includes("-"));
+    assert.ok(result.diff.includes("+"));
+    assert.notEqual(result.firstChangedLine, null);
+  });
+
+  test("generates diff for an addition", () => {
+    const old = "line1\nline3";
+    const newText = "line1\nline2\nline3";
+    const result = native.generateDiff(old, newText);
+    assert.ok(result.diff.includes("+"));
+    assert.ok(result.diff.includes("line2"));
+  });
+
+  test("generates diff for a deletion", () => {
+    const old = "line1\nline2\nline3";
+    const newText = "line1\nline3";
+    const result = native.generateDiff(old, newText);
+    assert.ok(result.diff.includes("-"));
+    assert.ok(result.diff.includes("line2"));
+  });
+
+  test("returns empty diff for identical content", () => {
+    const result = native.generateDiff("same", "same");
+    assert.equal(result.diff, "");
+    // napi-rs maps Option::None to undefined (not null)
+    assert.equal(result.firstChangedLine, undefined);
+  });
+
+  test("respects context lines parameter", () => {
+    const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`);
+    const old = lines.join("\n");
+    lines[10] = "modified";
+    const newText = lines.join("\n");
+    const result = native.generateDiff(old, newText, 2);
+    assert.ok(result.diff.includes("..."));
+  });
+
+  test("default context is 4 lines", () => {
+    const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`);
+    const old = lines.join("\n");
+    lines[10] = "modified";
+    const newText = lines.join("\n");
+    const result = native.generateDiff(old, newText);
+    // Should show 4 context lines before and after
+    assert.ok(result.diff.length > 0);
+  });
+});