md-redline 0.1.0

package/src/lib/diff.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest';
+import { computeDiff } from './diff';
+
+describe('computeDiff', () => {
+  it('returns all same lines for identical inputs', () => {
+    const text = 'line 1\nline 2\nline 3';
+    const diff = computeDiff(text, text);
+    expect(diff.every((l) => l.type === 'same')).toBe(true);
+    expect(diff).toHaveLength(3);
+  });
+
+  it('returns empty array for two empty strings', () => {
+    const diff = computeDiff('', '');
+    // Empty string splits to [''], so 1 "same" line
+    expect(diff).toHaveLength(1);
+    expect(diff[0].type).toBe('same');
+    expect(diff[0].text).toBe('');
+  });
+
+  it('detects added lines', () => {
+    const diff = computeDiff('a\nb', 'a\nb\nc');
+    const added = diff.filter((l) => l.type === 'added');
+    expect(added).toHaveLength(1);
+    expect(added[0].text).toBe('c');
+  });
+
+  it('detects removed lines', () => {
+    const diff = computeDiff('a\nb\nc', 'a\nc');
+    const removed = diff.filter((l) => l.type === 'removed');
+    expect(removed).toHaveLength(1);
+    expect(removed[0].text).toBe('b');
+  });
+
+  it('handles completely different content', () => {
+    const diff = computeDiff('old line 1\nold line 2', 'new line 1\nnew line 2');
+    const removed = diff.filter((l) => l.type === 'removed');
+    const added = diff.filter((l) => l.type === 'added');
+    expect(removed).toHaveLength(2);
+    expect(added).toHaveLength(2);
+  });
+
+  it('handles new content from empty', () => {
+    const diff = computeDiff('', 'new line');
+    // '' -> [''], 'new line' -> ['new line']
+    const removed = diff.filter((l) => l.type === 'removed');
+    const added = diff.filter((l) => l.type === 'added');
+    expect(removed).toHaveLength(1);
+    expect(removed[0].text).toBe('');
+    expect(added).toHaveLength(1);
+    expect(added[0].text).toBe('new line');
+  });
+
+  it('handles removal to empty', () => {
+    const diff = computeDiff('old line', '');
+    const removed = diff.filter((l) => l.type === 'removed');
+    const added = diff.filter((l) => l.type === 'added');
+    expect(removed).toHaveLength(1);
+    expect(removed[0].text).toBe('old line');
+    expect(added).toHaveLength(1);
+    expect(added[0].text).toBe('');
+  });
+
+  it('preserves line numbers for same lines', () => {
+    const diff = computeDiff('a\nb\nc', 'a\nb\nc');
+    expect(diff[0]).toMatchObject({ type: 'same', text: 'a', oldLineNo: 1, newLineNo: 1 });
+    expect(diff[1]).toMatchObject({ type: 'same', text: 'b', oldLineNo: 2, newLineNo: 2 });
+    expect(diff[2]).toMatchObject({ type: 'same', text: 'c', oldLineNo: 3, newLineNo: 3 });
+  });
+
+  it('assigns correct line numbers for mixed changes', () => {
+    const diff = computeDiff('a\nb\nc', 'a\nx\nc');
+    // a = same, b = removed, x = added, c = same
+    const removed = diff.find((l) => l.type === 'removed');
+    const added = diff.find((l) => l.type === 'added');
+    expect(removed?.oldLineNo).toBe(2);
+    expect(added?.newLineNo).toBe(2);
+  });
+
+  it('handles multi-line insertions in the middle', () => {
+    const diff = computeDiff('a\nc', 'a\nb1\nb2\nc');
+    const added = diff.filter((l) => l.type === 'added');
+    expect(added).toHaveLength(2);
+    expect(added[0].text).toBe('b1');
+    expect(added[1].text).toBe('b2');
+  });
+
+  it('handles multi-line removals in the middle', () => {
+    const diff = computeDiff('a\nb1\nb2\nc', 'a\nc');
+    const removed = diff.filter((l) => l.type === 'removed');
+    expect(removed).toHaveLength(2);
+    expect(removed[0].text).toBe('b1');
+    expect(removed[1].text).toBe('b2');
+  });
+
+  it('produces correct output order: removed then added for replacements', () => {
+    const diff = computeDiff('a\nold\nc', 'a\nnew\nc');
+    const changeIdx = diff.findIndex((l) => l.type !== 'same');
+    // The removed line should come before the added line
+    expect(diff[changeIdx].type).toBe('removed');
+    expect(diff[changeIdx].text).toBe('old');
+    expect(diff[changeIdx + 1].type).toBe('added');
+    expect(diff[changeIdx + 1].text).toBe('new');
+  });
+
+  it('handles large files without hanging (prefix/suffix optimization)', () => {
+    // Create two 2000-line files with a small change in the middle
+    const lines = Array.from({ length: 2000 }, (_, i) => `line ${i + 1}`);
+    const oldText = lines.join('\n');
+    const newLines = [...lines];
+    newLines[1000] = 'CHANGED LINE';
+    const newText = newLines.join('\n');
+
+    const start = Date.now();
+    const diff = computeDiff(oldText, newText);
+    const elapsed = Date.now() - start;
+
+    // Should complete in well under 5 seconds (prefix/suffix optimization)
+    expect(elapsed).toBeLessThan(5000);
+    // Should detect the change
+    const removed = diff.filter((l) => l.type === 'removed');
+    const added = diff.filter((l) => l.type === 'added');
+    expect(removed).toHaveLength(1);
+    expect(removed[0].text).toBe('line 1001');
+    expect(added).toHaveLength(1);
+    expect(added[0].text).toBe('CHANGED LINE');
+  });
+
+  it('handles large files with completely different content', () => {
+    const oldLines = Array.from({ length: 1500 }, (_, i) => `old ${i}`);
+    const newLines = Array.from({ length: 1500 }, (_, i) => `new ${i}`);
+
+    const start = Date.now();
+    const diff = computeDiff(oldLines.join('\n'), newLines.join('\n'));
+    const elapsed = Date.now() - start;
+
+    expect(elapsed).toBeLessThan(5000);
+    expect(diff.filter((l) => l.type === 'removed').length).toBe(1500);
+    expect(diff.filter((l) => l.type === 'added').length).toBe(1500);
+  });
+
+  it('handles large files with shared prefix/suffix but large different middle', () => {
+    // Common prefix + 1200 different lines + common suffix
+    // Middle is 1200x1200 = 1.44M cells, exceeds threshold -> inner fallback
+    const prefix = Array.from({ length: 50 }, (_, i) => `shared-prefix-${i}`);
+    const suffix = Array.from({ length: 50 }, (_, i) => `shared-suffix-${i}`);
+    const oldMiddle = Array.from({ length: 1200 }, (_, i) => `old-middle-${i}`);
+    const newMiddle = Array.from({ length: 1200 }, (_, i) => `new-middle-${i}`);
+
+    const oldText = [...prefix, ...oldMiddle, ...suffix].join('\n');
+    const newText = [...prefix, ...newMiddle, ...suffix].join('\n');
+
+    const start = Date.now();
+    const diff = computeDiff(oldText, newText);
+    const elapsed = Date.now() - start;
+
+    expect(elapsed).toBeLessThan(5000);
+    // Prefix and suffix should be 'same'
+    const same = diff.filter((l) => l.type === 'same');
+    expect(same.length).toBe(100); // 50 prefix + 50 suffix
+    // Middle should be all removed + all added
+    expect(diff.filter((l) => l.type === 'removed').length).toBe(1200);
+    expect(diff.filter((l) => l.type === 'added').length).toBe(1200);
+  });
+});

package/src/lib/diff.ts

@@ -0,0 +1,139 @@
+export interface DiffLine {
+  type: 'same' | 'added' | 'removed';
+  text: string;
+  oldLineNo?: number;
+  newLineNo?: number;
+}
+
+/**
+ * Simple line-based diff using the longest common subsequence algorithm.
+ * Returns an array of DiffLine objects for rendering.
+ *
+ * For large files (where the DP table would exceed 1M cells), uses a
+ * hash-based pre-filtering approach to keep memory usage bounded.
+ */
+export function computeDiff(oldText: string, newText: string): DiffLine[] {
+  const oldLines = oldText.split('\n');
+  const newLines = newText.split('\n');
+
+  const m = oldLines.length;
+  const n = newLines.length;
+
+  // For large inputs, use a chunked approach to avoid O(m*n) memory
+  if (m * n > 1_000_000) {
+    return computeDiffLargeFile(oldLines, newLines);
+  }
+
+  return lcsBasedDiff(oldLines, newLines);
+}
+
+/** Standard LCS-based diff for reasonably sized inputs. */
+function lcsBasedDiff(oldLines: string[], newLines: string[]): DiffLine[] {
+  const m = oldLines.length;
+  const n = newLines.length;
+
+  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (oldLines[i - 1] === newLines[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtrack to produce diff
+  const stack: DiffLine[] = [];
+  let i = m;
+  let j = n;
+
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      stack.push({ type: 'same', text: oldLines[i - 1], oldLineNo: i, newLineNo: j });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      stack.push({ type: 'added', text: newLines[j - 1], newLineNo: j });
+      j--;
+    } else {
+      stack.push({ type: 'removed', text: oldLines[i - 1], oldLineNo: i });
+      i--;
+    }
+  }
+
+  // Reverse since we built it backwards
+  const result: DiffLine[] = [];
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result.push(stack[k]);
+  }
+  return result;
+}
+
+/**
+ * For large files: strip common prefix/suffix, then apply LCS to the
+ * remaining (typically much smaller) changed region.
+ */
+function computeDiffLargeFile(oldLines: string[], newLines: string[]): DiffLine[] {
+  const result: DiffLine[] = [];
+
+  // Find common prefix
+  let prefixLen = 0;
+  const minLen = Math.min(oldLines.length, newLines.length);
+  while (prefixLen < minLen && oldLines[prefixLen] === newLines[prefixLen]) {
+    prefixLen++;
+  }
+
+  // Find common suffix (don't overlap with prefix)
+  let suffixLen = 0;
+  while (
+    suffixLen < minLen - prefixLen &&
+    oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]
+  ) {
+    suffixLen++;
+  }
+
+  // Emit common prefix
+  for (let i = 0; i < prefixLen; i++) {
+    result.push({ type: 'same', text: oldLines[i], oldLineNo: i + 1, newLineNo: i + 1 });
+  }
+
+  // Diff the middle section
+  const oldMiddle = oldLines.slice(prefixLen, oldLines.length - suffixLen);
+  const newMiddle = newLines.slice(prefixLen, newLines.length - suffixLen);
+
+  if (oldMiddle.length * newMiddle.length <= 1_000_000) {
+    // Middle is small enough for standard LCS
+    const middleDiff = lcsBasedDiff(oldMiddle, newMiddle);
+    for (const line of middleDiff) {
+      result.push({
+        ...line,
+        oldLineNo: line.oldLineNo ? line.oldLineNo + prefixLen : undefined,
+        newLineNo: line.newLineNo ? line.newLineNo + prefixLen : undefined,
+      });
+    }
+  } else {
+    // Still too large — fall back to simple remove-then-add
+    for (let i = 0; i < oldMiddle.length; i++) {
+      result.push({ type: 'removed', text: oldMiddle[i], oldLineNo: prefixLen + i + 1 });
+    }
+    for (let i = 0; i < newMiddle.length; i++) {
+      result.push({ type: 'added', text: newMiddle[i], newLineNo: prefixLen + i + 1 });
+    }
+  }
+
+  // Emit common suffix
+  for (let i = 0; i < suffixLen; i++) {
+    const oldIdx = oldLines.length - suffixLen + i;
+    const newIdx = newLines.length - suffixLen + i;
+    result.push({
+      type: 'same',
+      text: oldLines[oldIdx],
+      oldLineNo: oldIdx + 1,
+      newLineNo: newIdx + 1,
+    });
+  }
+
+  return result;
+}

package/src/lib/heading-slugs.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { slugify, uniqueSlugs } from './heading-slugs';
+
+describe('slugify', () => {
+  it('converts text to lowercase hyphenated slug', () => {
+    expect(slugify('Hello World')).toBe('hello-world');
+  });
+
+  it('strips special characters', () => {
+    expect(slugify("What's New?")).toBe('whats-new');
+  });
+
+  it('collapses multiple spaces to single hyphen', () => {
+    expect(slugify('Hello   World')).toBe('hello-world');
+  });
+
+  it('trims whitespace', () => {
+    expect(slugify('  Hello  ')).toBe('hello');
+  });
+
+  it('preserves hyphens', () => {
+    expect(slugify('pre-existing')).toBe('pre-existing');
+  });
+
+  it('preserves underscores', () => {
+    expect(slugify('my_variable')).toBe('my_variable');
+  });
+
+  it('handles numbers', () => {
+    expect(slugify('Section 1.2')).toBe('section-12');
+  });
+
+  it('falls back to "heading" for empty text', () => {
+    expect(slugify('')).toBe('heading');
+    expect(slugify('   ')).toBe('heading');
+  });
+
+  it('falls back to "heading" when all chars are stripped', () => {
+    expect(slugify('!@#$%')).toBe('heading');
+  });
+
+  it('handles tabs and newlines as whitespace', () => {
+    expect(slugify('Hello\tWorld\nFoo')).toBe('hello-world-foo');
+  });
+});
+
+describe('uniqueSlugs', () => {
+  it('returns unique slugs for distinct headings', () => {
+    expect(uniqueSlugs(['Introduction', 'Background', 'Conclusion'])).toEqual([
+      'introduction',
+      'background',
+      'conclusion',
+    ]);
+  });
+
+  it('appends -1, -2 for duplicate headings', () => {
+    expect(uniqueSlugs(['Overview', 'Overview', 'Overview'])).toEqual([
+      'overview',
+      'overview-1',
+      'overview-2',
+    ]);
+  });
+
+  it('handles mixed duplicates', () => {
+    expect(uniqueSlugs(['Title', 'Sub', 'Detail', 'Sub'])).toEqual([
+      'title',
+      'sub',
+      'detail',
+      'sub-1',
+    ]);
+  });
+
+  it('handles empty heading text', () => {
+    expect(uniqueSlugs(['', ''])).toEqual(['heading', 'heading-1']);
+  });
+
+  it('handles headings that become identical after slugification', () => {
+    // "Hello World!" and "Hello World?" both slugify to "hello-world"
+    expect(uniqueSlugs(['Hello World!', 'Hello World?'])).toEqual(['hello-world', 'hello-world-1']);
+  });
+
+  it('returns empty array for no headings', () => {
+    expect(uniqueSlugs([])).toEqual([]);
+  });
+});

package/src/lib/heading-slugs.ts

@@ -0,0 +1,44 @@
+/**
+ * Generate a URL-friendly slug from heading text.
+ * Strips non-word characters (except hyphens), collapses whitespace to hyphens,
+ * and lowercases everything.
+ */
+export function slugify(text: string): string {
+  const slug = text
+    .trim()
+    .toLowerCase()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/\s+/g, '-');
+  return slug || 'heading';
+}
+
+/**
+ * Generate unique slugs for an array of heading texts.
+ * Duplicate slugs get `-1`, `-2`, etc. suffixes.
+ */
+export function uniqueSlugs(texts: string[]): string[] {
+  const used = new Set<string>();
+  return texts.map((text) => {
+    const slug = slugify(text);
+    let unique = slug;
+    let counter = 1;
+    while (used.has(unique)) {
+      unique = `${slug}-${counter++}`;
+    }
+    used.add(unique);
+    return unique;
+  });
+}
+
+/**
+ * Assign unique slug IDs to heading elements in a container.
+ * Duplicate slugs get `-1`, `-2`, etc. suffixes.
+ */
+export function assignHeadingIds(container: HTMLElement): void {
+  const headingEls = container.querySelectorAll('h1, h2, h3, h4, h5, h6');
+  const texts = Array.from(headingEls).map((el) => el.textContent || '');
+  const slugs = uniqueSlugs(texts);
+  headingEls.forEach((el, i) => {
+    el.id = slugs[i];
+  });
+}

package/src/lib/http.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { getApiErrorMessage, readJsonResponse } from './http';
+
+describe('readJsonResponse', () => {
+  it('parses valid JSON', async () => {
+    const res = new Response(JSON.stringify({ ok: true }), {
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+    await expect(readJsonResponse<{ ok: boolean }>(res)).resolves.toEqual({ ok: true });
+  });
+
+  it('returns null for empty bodies', async () => {
+    const res = new Response('', { status: 502 });
+
+    await expect(readJsonResponse(res)).resolves.toBeNull();
+  });
+
+  it('returns null for invalid JSON', async () => {
+    const res = new Response('not-json');
+
+    await expect(readJsonResponse(res)).resolves.toBeNull();
+  });
+});
+
+describe('getApiErrorMessage', () => {
+  it('prefers an api error payload', () => {
+    const res = new Response('', { status: 400 });
+    expect(getApiErrorMessage(res, { error: 'Bad request' }, 'Fallback')).toBe('Bad request');
+  });
+
+  it('maps gateway failures to a backend-unavailable message', () => {
+    const res = new Response('', { status: 502 });
+    expect(getApiErrorMessage(res, null, 'Fallback')).toBe(
+      'Backend unavailable. Start the md-redline server.',
+    );
+  });
+
+  it('falls back when no api error payload exists', () => {
+    const res = new Response('', { status: 500 });
+    expect(getApiErrorMessage(res, null, 'Fallback')).toBe('Fallback');
+  });
+});

package/src/lib/http.ts

@@ -0,0 +1,29 @@
+export interface ApiErrorPayload {
+  error?: string;
+}
+
+export async function readJsonResponse<T>(res: Response): Promise<T | null> {
+  const text = await res.text();
+  if (!text) return null;
+
+  try {
+    return JSON.parse(text) as T;
+  } catch {
+    return null;
+  }
+}
+
+export function getApiErrorMessage(res: Response, data: unknown, fallback: string): string {
+  if (data && typeof data === 'object' && 'error' in data) {
+    const error = (data as ApiErrorPayload).error;
+    if (typeof error === 'string' && error.trim()) {
+      return error;
+    }
+  }
+
+  if (res.status === 502 || res.status === 503 || res.status === 504) {
+    return 'Backend unavailable. Start the md-redline server.';
+  }
+
+  return fallback;
+}