@peaske7/readit 0.1.8 → 0.2.1

package/src/lib/anchor.bench.ts

@@ -1,112 +1,91 @@
 import { bench, describe } from "vitest";
-import { LARGE_DOC } from "./__fixtures__/bench-data";
+import {
+  COMMENTS_1,
+  COMMENTS_10,
+  COMMENTS_50,
+  LARGE_DOC,
+  MEDIUM_DOC,
+} from "./__fixtures__/bench-data";
 import {
   findAnchor,
   findAnchorFuzzy,
   findAnchorNormalized,
   findAnchorWithFallback,
-  levenshteinDistance,
 } from "./anchor";
 
-// Text known to exist at specific lines in LARGE_DOC
-const EXACT_TEXT_L149 =
-  "The conclusion of section 8 summarizes the key findings";
-const EXACT_TEXT_L250 = "- Item 1 in section 14";
-const WHITESPACE_TEXT = "Item 1  in\n  section 14";
-const FUZZY_TEXT = "- Item 1 in section 1x"; // 1-char typo
-
-describe("levenshteinDistance", () => {
-  const str20 = "hello world testing!";
-
-  bench("identical strings (20 chars)", () => {
-    levenshteinDistance(str20, str20);
-  });
-
-  bench("1 edit distance (20 chars)", () => {
-    levenshteinDistance("hello world testing!", "hello world testinx!");
-  });
-
-  bench("maxDistance early exit", () => {
-    levenshteinDistance("completely different", "nothing alike here!", 3);
-  });
-
-  const longA = "a".repeat(50) + "b".repeat(50);
-  const longB = "a".repeat(50) + "c".repeat(50);
-
-  bench("longer strings (100 chars)", () => {
-    levenshteinDistance(longA, longB);
-  });
-});
+describe("findAnchor — exact match", () => {
+  const comment = COMMENTS_10[5];
 
-describe("findAnchor (exact)", () => {
-  bench("300-line doc, correct hint", () => {
+  bench("medium doc (150 lines)", () => {
     findAnchor({
-      source: LARGE_DOC,
-      selectedText: EXACT_TEXT_L149,
-      lineHint: "L149",
+      source: MEDIUM_DOC,
+      selectedText: comment.selectedText,
+      lineHint: comment.lineHint ?? "L1",
     });
   });
 
-  bench("300-line doc, wrong hint (global fallback)", () => {
+  bench("large doc (300 lines)", () => {
     findAnchor({
       source: LARGE_DOC,
-      selectedText: EXACT_TEXT_L250,
-      lineHint: "L10",
+      selectedText: comment.selectedText,
+      lineHint: comment.lineHint ?? "L1",
     });
   });
 });
 
 describe("findAnchorNormalized", () => {
-  bench("300-line doc, whitespace-collapsed match", () => {
+  const comment = COMMENTS_10[5];
+  const normalizedText = comment.selectedText.replace(/ /g, "  ");
+
+  bench("large doc — normalized whitespace", () => {
     findAnchorNormalized({
       source: LARGE_DOC,
-      selectedText: WHITESPACE_TEXT,
-      lineHint: "L250",
+      selectedText: normalizedText,
+      lineHint: comment.lineHint ?? "L1",
     });
   });
 });
 
 describe("findAnchorFuzzy", () => {
-  bench("300-line doc, 1-char typo with hint", () => {
-    findAnchorFuzzy({
-      source: LARGE_DOC,
-      selectedText: FUZZY_TEXT,
-      lineHint: "L250",
-      threshold: 3,
-    });
-  });
+  const comment = COMMENTS_10[5];
+  const mutated = `X${comment.selectedText.slice(1, -1)}Z`;
 
-  bench("300-line doc, no hint (full scan)", () => {
+  bench("large doc — fuzzy (mutated text)", () => {
     findAnchorFuzzy({
       source: LARGE_DOC,
-      selectedText: FUZZY_TEXT,
-      threshold: 3,
+      selectedText: mutated.slice(0, 50), // Keep within MAX_FUZZY_TEXT_LENGTH
+      lineHint: comment.lineHint ?? "L1",
     });
   });
 });
 
 describe("findAnchorWithFallback", () => {
-  bench("exact match (fast path)", () => {
+  bench("1 comment — exact hit", () => {
+    const c = COMMENTS_1[0];
     findAnchorWithFallback({
       source: LARGE_DOC,
-      selectedText: EXACT_TEXT_L149,
-      lineHint: "L149",
+      selectedText: c.selectedText,
+      lineHint: c.lineHint ?? "L1",
     });
   });
 
-  bench("normalized fallback", () => {
-    findAnchorWithFallback({
-      source: LARGE_DOC,
-      selectedText: WHITESPACE_TEXT,
-      lineHint: "L250",
-    });
+  bench("10 comments — exact hits", () => {
+    for (const c of COMMENTS_10) {
+      findAnchorWithFallback({
+        source: LARGE_DOC,
+        selectedText: c.selectedText,
+        lineHint: c.lineHint ?? "L1",
+      });
+    }
   });
 
-  bench("fuzzy fallback", () => {
-    findAnchorWithFallback({
-      source: LARGE_DOC,
-      selectedText: FUZZY_TEXT,
-      lineHint: "L250",
-    });
+  bench("50 comments — exact hits", () => {
+    for (const c of COMMENTS_50) {
+      findAnchorWithFallback({
+        source: LARGE_DOC,
+        selectedText: c.selectedText,
+        lineHint: c.lineHint ?? "L1",
+      });
+    }
   });
 });

package/src/lib/anchor.test.ts

@@ -64,12 +64,10 @@ describe("levenshteinDistance", () => {
   });
 
   it("returns Infinity when exceeding maxDistance threshold", () => {
-    // Length difference alone exceeds threshold
     expect(levenshteinDistance("hello", "hi", 1)).toBe(
       Number.POSITIVE_INFINITY,
     );
 
-    // Content difference exceeds threshold during computation
     expect(levenshteinDistance("hello", "world", 2)).toBe(
       Number.POSITIVE_INFINITY,
     );
@@ -135,8 +133,12 @@ describe("parseLineHint", () => {
   });
 
   it("parses line range hint", () => {
+    expect(parseLineHint("L42-L45")).toEqual({ start: 42, end: 45 });
+    expect(parseLineHint("L10-L20")).toEqual({ start: 10, end: 20 });
+  });
+
+  it("parses legacy format without L prefix on end line", () => {
     expect(parseLineHint("L42-45")).toEqual({ start: 42, end: 45 });
-    expect(parseLineHint("L10-20")).toEqual({ start: 10, end: 20 });
   });
 
   it("returns default for invalid hint", () => {
@@ -248,7 +250,6 @@ line eight`;
 
 describe("findAnchorNormalized", () => {
   it("finds text with collapsed whitespace", () => {
-    // Original had "hello world" but source was reformatted
     const source = "hello\n  world";
     const result = findAnchorNormalized({
       source,
@@ -271,7 +272,6 @@ describe("findAnchorNormalized", () => {
   });
 
   it("returns null when text has no collapsible whitespace", () => {
-    // If original text has no extra whitespace, exact match would have worked
     const result = findAnchorNormalized({
       source: "hello world",
       selectedText: "hello world",
@@ -407,7 +407,6 @@ describe("findAnchorWithFallback", () => {
   });
 
   it("falls back to normalized match when exact fails", () => {
-    // Source was reformatted (newlines instead of spaces)
     const result = findAnchorWithFallback({
       source: "hello\nworld",
       selectedText: "hello  world",
@@ -440,7 +439,6 @@ describe("findAnchorWithFallback", () => {
 describe("findClosestOccurrence", () => {
   it("finds the occurrence closest to hint", () => {
     const content = "the cat sat on the mat and the rat";
-    // "the" appears at positions 0, 15, and 27
 
     const result = findClosestOccurrence({
       source: content,
@@ -448,7 +446,6 @@ describe("findClosestOccurrence", () => {
       lineHint: "L1",
     });
     expect(result).not.toBeUndefined();
-    // Should find the first "the" at position 0 since hint is L1
     expect(result?.start).toBe(0);
   });
 
@@ -459,7 +456,6 @@ line three the
 line four
 line five the`;
 
-    // Test finding closest to line 3
     const result = findClosestOccurrence({
       source: content,
       selectedText: "the",

package/src/lib/anchor.ts

@@ -1,16 +1,11 @@
-import { type Anchor, AnchorConfidences } from "../types";
+import { type Anchor, AnchorConfidences } from "../schema";
 import { getLineNumber } from "./comment-storage";
 
-// Anchor matching configuration
-const DEFAULT_SEARCH_WINDOW = 500; // chars before/after line hint for exact match
-const DEFAULT_FUZZY_THRESHOLD = 5; // max Levenshtein distance for fuzzy match
-const MAX_FUZZY_TEXT_LENGTH = 200; // skip fuzzy matching for texts longer than this
-const FUZZY_SEARCH_WINDOW = 2000; // larger window for fuzzy search near line hint
+const DEFAULT_SEARCH_WINDOW = 500;
+const DEFAULT_FUZZY_THRESHOLD = 5;
+const MAX_FUZZY_TEXT_LENGTH = 200;
+const FUZZY_SEARCH_WINDOW = 2000;
 
-/**
- * Common parameters for anchor finding functions.
- * Using object destructuring per style guide §3.5 for multiple string parameters.
- */
 export interface FindAnchorParams {
   source: string;
   selectedText: string;
@@ -32,27 +27,15 @@ export interface FindAnchorWithFallbackParams {
   fuzzyThreshold?: number;
 }
 
-/**
- * Normalize whitespace for comparison: collapse runs of whitespace to single space.
- * This allows matching text that was reformatted (line breaks, indentation changes).
- */
 export function normalizeWhitespace(text: string): string {
   return text.replace(/\s+/g, " ").trim();
 }
 
-/**
- * Calculate Levenshtein distance between two strings.
- * Uses Wagner-Fischer algorithm with O(min(m,n)) space.
- *
- * @param maxDistance Optional early exit threshold. If set, returns Infinity
- *                    when distance is guaranteed to exceed this value.
- */
 export function levenshteinDistance(
   a: string,
   b: string,
   maxDistance?: number,
 ): number {
-  // Ensure a is the shorter string for space optimization
   if (a.length > b.length) {
     [a, b] = [b, a];
   }
@@ -60,20 +43,16 @@ export function levenshteinDistance(
   const m = a.length;
   const n = b.length;
 
-  // Early termination for empty strings
   if (m === 0) return n;
   if (n === 0) return m;
 
-  // Early exit: length difference alone exceeds threshold
   if (maxDistance !== undefined && Math.abs(m - n) > maxDistance) {
     return Number.POSITIVE_INFINITY;
   }
 
-  // Use single row for space optimization
   let prevRow = new Array(m + 1);
   let currRow = new Array(m + 1);
 
-  // Initialize first row
   for (let i = 0; i <= m; i++) {
     prevRow[i] = i;
   }
@@ -81,20 +60,18 @@ export function levenshteinDistance(
   for (let j = 1; j <= n; j++) {
     currRow[0] = j;
 
-    // Track minimum value in this row for early exit
     let rowMin = currRow[0];
 
     for (let i = 1; i <= m; i++) {
       const cost = a[i - 1] === b[j - 1] ? 0 : 1;
       currRow[i] = Math.min(
-        prevRow[i] + 1, // deletion
-        currRow[i - 1] + 1, // insertion
-        prevRow[i - 1] + cost, // substitution
+        prevRow[i] + 1,
+        currRow[i - 1] + 1,
+        prevRow[i - 1] + cost,
       );
       rowMin = Math.min(rowMin, currRow[i]);
     }
 
-    // Early exit: minimum possible distance exceeds threshold
     if (maxDistance !== undefined && rowMin > maxDistance) {
       return Number.POSITIVE_INFINITY;
     }
@@ -105,9 +82,6 @@ export function levenshteinDistance(
   return prevRow[m];
 }
 
-/**
- * Get character offset for the start of a line number (1-indexed).
- */
 export function getLineOffset(content: string, lineNumber: number): number {
   if (lineNumber <= 1) return 0;
 
@@ -125,15 +99,11 @@ export function getLineOffset(content: string, lineNumber: number): number {
   return content.length;
 }
 
-/**
- * Parse line hint string to get line number(s).
- * Supports "L42" and "L42-45" formats.
- */
 export function parseLineHint(lineHint: string): {
   start: number;
   end: number;
 } {
-  const match = lineHint.match(/^L(\d+)(?:-(\d+))?$/);
+  const match = lineHint.match(/^L(\d+)(?:-L?(\d+))?$/);
   if (!match) {
     return { start: 1, end: 1 };
   }
@@ -143,10 +113,6 @@ export function parseLineHint(lineHint: string): {
   return { start, end };
 }
 
-/**
- * Find anchor position for selected text in source content.
- * Uses line hint for fast lookup, falls back to global search.
- */
 export function findAnchor({
   source,
   selectedText,
@@ -158,7 +124,6 @@ export function findAnchor({
   }
   const { start: hintLine } = parseLineHint(lineHint);
 
-  // Fast path: search near line hint
   const lineOffset = getLineOffset(source, hintLine);
   const windowStart = Math.max(0, lineOffset - searchWindow);
   const windowEnd = Math.min(source.length, lineOffset + searchWindow);
@@ -176,7 +141,6 @@ export function findAnchor({
     };
   }
 
-  // Fallback: global search
   const globalIndex = source.indexOf(selectedText);
   if (globalIndex !== -1) {
     return {
@@ -190,10 +154,6 @@ export function findAnchor({
   return undefined;
 }
 
-/**
- * Build a position map from normalized string positions back to original positions.
- * Returns array where normalizedToOriginal[i] = original position for normalized char i.
- */
 function buildNormalizedPositionMap(text: string): {
   normalized: string;
   toOriginal: number[];
@@ -208,7 +168,6 @@ function buildNormalizedPositionMap(text: string): {
 
     if (isSpace) {
       if (!inWhitespace && normalized.length > 0) {
-        // First whitespace after content - emit single space
         normalized += " ";
         toOriginal.push(i);
       }
@@ -220,7 +179,6 @@ function buildNormalizedPositionMap(text: string): {
     }
   }
 
-  // Trim trailing space
   if (normalized.endsWith(" ")) {
     normalized = normalized.slice(0, -1);
     toOriginal.pop();
@@ -229,16 +187,6 @@ function buildNormalizedPositionMap(text: string): {
   return { normalized, toOriginal };
 }
 
-/**
- * Find anchor using whitespace-normalized matching.
- * Useful when document was reformatted but content is unchanged.
- * Returns "normalized" confidence level.
- *
- * Algorithm:
- * 1. Normalize source and build position map
- * 2. Find normalized text in normalized source (fast substring search)
- * 3. Map positions back to original source
- */
 export function findAnchorNormalized({
   source,
   selectedText,
@@ -254,31 +202,24 @@ export function findAnchorNormalized({
     return undefined;
   }
 
-  // Skip if text has no collapsible whitespace (exact match would have worked)
   if (normalizedText === selectedText) {
     return undefined;
   }
   const { start: hintLine } = parseLineHint(lineHint);
   const lineOffset = getLineOffset(source, hintLine);
 
-  // Define search window
   const windowStart = Math.max(0, lineOffset - searchWindow);
   const windowEnd = Math.min(source.length, lineOffset + searchWindow);
   const window = source.slice(windowStart, windowEnd);
 
-  // Build normalized version with position mapping
   const { normalized: normalizedWindow, toOriginal } =
     buildNormalizedPositionMap(window);
 
-  // Fast substring search on normalized text
   const normalizedIndex = normalizedWindow.indexOf(normalizedText);
   if (normalizedIndex !== -1) {
-    // Map back to original positions
     const originalStart = windowStart + toOriginal[normalizedIndex];
     const endNormIndex = normalizedIndex + normalizedText.length - 1;
-    // Find original end: scan forward from mapped position to include trailing whitespace
     let originalEnd = windowStart + toOriginal[endNormIndex] + 1;
-    // Extend to include any trailing whitespace that was collapsed
     while (originalEnd < source.length && /\s/.test(source[originalEnd])) {
       originalEnd++;
     }
@@ -291,7 +232,6 @@ export function findAnchorNormalized({
     };
   }
 
-  // Global fallback (outside hint window)
   const { normalized: fullNormalized, toOriginal: fullToOriginal } =
     buildNormalizedPositionMap(source);
   const globalIndex = fullNormalized.indexOf(normalizedText);
@@ -314,10 +254,6 @@ export function findAnchorNormalized({
   return undefined;
 }
 
-/**
- * Find anchor using fuzzy matching with Levenshtein distance.
- * Scans the source for substrings similar to the selected text.
- */
 export function findAnchorFuzzy({
   source,
   selectedText,
@@ -330,7 +266,6 @@ export function findAnchorFuzzy({
 
   const textLen = selectedText.length;
 
-  // For very long texts, skip fuzzy matching (too expensive)
   if (textLen > MAX_FUZZY_TEXT_LENGTH) {
     return undefined;
   }
@@ -338,26 +273,22 @@ export function findAnchorFuzzy({
   let bestMatch: Anchor | undefined;
   let bestDistance = threshold + 1;
 
-  // Determine search range based on line hint
   let searchStart = 0;
   let searchEnd = source.length;
 
   if (lineHint) {
     const { start: hintLine } = parseLineHint(lineHint);
     const lineOffset = getLineOffset(source, hintLine);
-    // Search in a larger window for fuzzy matching
     searchStart = Math.max(0, lineOffset - FUZZY_SEARCH_WINDOW);
     searchEnd = Math.min(source.length, lineOffset + FUZZY_SEARCH_WINDOW);
   }
 
-  // Slide window of similar length through the search range
   const minLen = Math.max(1, textLen - threshold);
   const maxLen = textLen + threshold;
 
   for (let len = minLen; len <= maxLen; len++) {
     for (let i = searchStart; i <= searchEnd - len; i++) {
       const candidate = source.slice(i, i + len);
-      // Use early exit: only compute if distance could improve on current best
       const distance = levenshteinDistance(
         selectedText,
         candidate,
@@ -374,7 +305,6 @@ export function findAnchorFuzzy({
           distance,
         };
 
-        // Early exit if we found an exact match
         if (distance === 0) {
           return bestMatch;
         }
@@ -385,27 +315,17 @@ export function findAnchorFuzzy({
   return bestMatch;
 }
 
-/**
- * Find anchor with fallback chain: exact → normalized → fuzzy.
- *
- * Matching strategies in order of preference:
- * 1. Exact: Fast substring match (O(n))
- * 2. Normalized: Whitespace-collapsed match for reformatted text (O(n))
- * 3. Fuzzy: Levenshtein distance for small edits (O(n × m × threshold))
- */
 export function findAnchorWithFallback({
   source,
   selectedText,
   lineHint,
   fuzzyThreshold,
 }: FindAnchorWithFallbackParams): Anchor | undefined {
-  // Try exact match first (fastest)
   const exactMatch = findAnchor({ source, selectedText, lineHint });
   if (exactMatch) {
     return exactMatch;
   }
 
-  // Try normalized match (handles reformatting)
   const normalizedMatch = findAnchorNormalized({
     source,
     selectedText,
@@ -415,7 +335,6 @@ export function findAnchorWithFallback({
     return normalizedMatch;
   }
 
-  // Fall back to fuzzy matching (handles small edits)
   return findAnchorFuzzy({
     source,
     selectedText,
@@ -424,9 +343,6 @@ export function findAnchorWithFallback({
   });
 }
 
-/**
- * Find the closest match when multiple occurrences exist.
- */
 export function findClosestOccurrence({
   source,
   selectedText,

package/src/lib/comment-storage.bench.ts

@@ -4,12 +4,12 @@ import {
   COMMENT_FILE_MEDIUM,
   COMMENT_FILE_OBJ_LARGE,
   COMMENT_FILE_OBJ_MEDIUM,
+  COMMENT_FILE_OBJ_SMALL,
   COMMENT_FILE_SMALL,
   LARGE_DOC,
 } from "./__fixtures__/bench-data";
 import {
   computeHash,
-  createComment,
   parseCommentFile,
   serializeComments,
 } from "./comment-storage";
@@ -29,6 +29,10 @@ describe("parseCommentFile", () => {
 });
 
 describe("serializeComments", () => {
+  bench("1 comment", () => {
+    serializeComments(COMMENT_FILE_OBJ_SMALL);
+  });
+
   bench("10 comments", () => {
     serializeComments(COMMENT_FILE_OBJ_MEDIUM);
   });
@@ -39,25 +43,7 @@ describe("serializeComments", () => {
 });
 
 describe("computeHash", () => {
-  const shortString = "x".repeat(100);
-
-  bench("short string (100 chars)", () => {
-    computeHash(shortString);
-  });
-
-  bench("large doc (~10k chars)", () => {
+  bench("300-line document", () => {
     computeHash(LARGE_DOC);
   });
 });
-
-describe("createComment", () => {
-  bench("short selection", () => {
-    createComment("selected text here", "my comment", 100, 118, LARGE_DOC);
-  });
-
-  const longSelection = "a".repeat(2000);
-
-  bench("long selection (triggers truncation)", () => {
-    createComment(longSelection, "my comment", 0, 2000, LARGE_DOC);
-  });
-});