@sentry/warden 0.0.0

package/src/diff/context.test.ts

@@ -0,0 +1,226 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  expandHunkContext,
+  expandDiffContext,
+  formatHunkForAnalysis,
+} from './context.js';
+import type { DiffHunk, ParsedDiff } from './parser.js';
+
+describe('expandHunkContext', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `warden-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('expands hunk with surrounding file context', () => {
+    const fileContent = Array.from({ length: 50 }, (_, i) => `line ${i + 1}`).join('\n');
+    writeFileSync(join(tempDir, 'test.ts'), fileContent);
+
+    const hunk: DiffHunk = {
+      oldStart: 20,
+      oldCount: 3,
+      newStart: 20,
+      newCount: 4,
+      content: '@@ -20,3 +20,4 @@\n line 20\n+added\n line 21\n line 22',
+      lines: [' line 20', '+added', ' line 21', ' line 22'],
+    };
+
+    const result = expandHunkContext(tempDir, 'test.ts', hunk, 5);
+
+    expect(result.filename).toBe('test.ts');
+    expect(result.hunk).toBe(hunk);
+    expect(result.language).toBe('typescript');
+    expect(result.contextBefore).toHaveLength(5); // lines 15-19
+    expect(result.contextBefore[0]).toBe('line 15');
+    expect(result.contextAfter).toHaveLength(5); // lines 24-28
+    expect(result.contextAfter[0]).toBe('line 24');
+    expect(result.contextStartLine).toBe(15);
+  });
+
+  it('handles missing file gracefully', () => {
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 2,
+      newStart: 1,
+      newCount: 2,
+      content: '@@ -1,2 +1,2 @@',
+      lines: [],
+    };
+
+    const result = expandHunkContext(tempDir, 'nonexistent.ts', hunk);
+
+    expect(result.contextBefore).toEqual([]);
+    expect(result.contextAfter).toEqual([]);
+  });
+
+  it('detects language from file extension', () => {
+    writeFileSync(join(tempDir, 'test.py'), 'print("hello")');
+
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 1,
+      newStart: 1,
+      newCount: 1,
+      content: '@@ -1 +1 @@',
+      lines: [],
+    };
+
+    const result = expandHunkContext(tempDir, 'test.py', hunk);
+    expect(result.language).toBe('python');
+  });
+
+  it('handles files at start with limited context before', () => {
+    const fileContent = 'line 1\nline 2\nline 3\nline 4\nline 5';
+    writeFileSync(join(tempDir, 'start.ts'), fileContent);
+
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 2,
+      newStart: 1,
+      newCount: 3,
+      content: '@@ -1,2 +1,3 @@',
+      lines: [],
+    };
+
+    const result = expandHunkContext(tempDir, 'start.ts', hunk, 10);
+    expect(result.contextBefore).toEqual([]);
+    expect(result.contextStartLine).toBe(1);
+  });
+});
+
+describe('expandDiffContext', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `warden-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('expands all hunks in a parsed diff', () => {
+    const fileContent = Array.from({ length: 100 }, (_, i) => `line ${i + 1}`).join('\n');
+    writeFileSync(join(tempDir, 'multi.ts'), fileContent);
+
+    const diff: ParsedDiff = {
+      filename: 'multi.ts',
+      status: 'modified',
+      hunks: [
+        {
+          oldStart: 10,
+          oldCount: 2,
+          newStart: 10,
+          newCount: 3,
+          content: '@@ -10,2 +10,3 @@',
+          lines: [],
+        },
+        {
+          oldStart: 50,
+          oldCount: 2,
+          newStart: 51,
+          newCount: 3,
+          content: '@@ -50,2 +51,3 @@',
+          lines: [],
+        },
+      ],
+      rawPatch: '',
+    };
+
+    const results = expandDiffContext(tempDir, diff, 3);
+
+    expect(results).toHaveLength(2);
+    expect(results[0]!.hunk.newStart).toBe(10);
+    expect(results[1]!.hunk.newStart).toBe(51);
+  });
+});
+
+describe('formatHunkForAnalysis', () => {
+  it('formats hunk with all sections', () => {
+    const hunkCtx = {
+      filename: 'src/index.ts',
+      hunk: {
+        oldStart: 10,
+        oldCount: 2,
+        newStart: 10,
+        newCount: 3,
+        header: 'function example()',
+        content: '@@ -10,2 +10,3 @@ function example()\n const x = 1;\n+const y = 2;\n return x;',
+        lines: [' const x = 1;', '+const y = 2;', ' return x;'],
+      },
+      contextBefore: ['// before line 1', '// before line 2'],
+      contextAfter: ['// after line 1'],
+      contextStartLine: 8,
+      language: 'typescript',
+    };
+
+    const output = formatHunkForAnalysis(hunkCtx);
+
+    expect(output).toContain('## File: src/index.ts');
+    expect(output).toContain('## Language: typescript');
+    expect(output).toContain('## Hunk: lines 10-12');
+    expect(output).toContain('## Scope: function example()');
+    expect(output).toContain('### Context Before (lines 8-9)');
+    expect(output).toContain('```typescript');
+    expect(output).toContain('// before line 1');
+    expect(output).toContain('### Changes');
+    expect(output).toContain('```diff');
+    expect(output).toContain('### Context After (lines 13-13)');
+  });
+
+  it('omits context sections when empty', () => {
+    const hunkCtx = {
+      filename: 'new.ts',
+      hunk: {
+        oldStart: 0,
+        oldCount: 0,
+        newStart: 1,
+        newCount: 2,
+        content: '@@ -0,0 +1,2 @@\n+line 1\n+line 2',
+        lines: ['+line 1', '+line 2'],
+      },
+      contextBefore: [],
+      contextAfter: [],
+      contextStartLine: 1,
+      language: 'typescript',
+    };
+
+    const output = formatHunkForAnalysis(hunkCtx);
+
+    expect(output).not.toContain('### Context Before');
+    expect(output).not.toContain('### Context After');
+    expect(output).toContain('### Changes');
+  });
+
+  it('omits scope when no header', () => {
+    const hunkCtx = {
+      filename: 'test.ts',
+      hunk: {
+        oldStart: 1,
+        oldCount: 1,
+        newStart: 1,
+        newCount: 1,
+        content: '@@ -1 +1 @@',
+        lines: [],
+      },
+      contextBefore: [],
+      contextAfter: [],
+      contextStartLine: 1,
+      language: 'typescript',
+    };
+
+    const output = formatHunkForAnalysis(hunkCtx);
+
+    expect(output).not.toContain('## Scope:');
+  });
+});

package/src/diff/context.ts

@@ -0,0 +1,201 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { DiffHunk, ParsedDiff } from './parser.js';
+import { getExpandedLineRange } from './parser.js';
+
+/** Cache for file contents to avoid repeated reads */
+const fileCache = new Map<string, string[] | null>();
+
+/** Clear the file cache (useful for testing or long-running processes) */
+export function clearFileCache(): void {
+  fileCache.clear();
+}
+
+/** Get cached file lines or read and cache them */
+function getCachedFileLines(filePath: string): string[] | null {
+  if (fileCache.has(filePath)) {
+    return fileCache.get(filePath) ?? null;
+  }
+
+  if (!existsSync(filePath)) {
+    fileCache.set(filePath, null);
+    return null;
+  }
+
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    fileCache.set(filePath, lines);
+    return lines;
+  } catch {
+    // Binary file or read error
+    fileCache.set(filePath, null);
+    return null;
+  }
+}
+
+export interface HunkWithContext {
+  /** File path */
+  filename: string;
+  /** The hunk being analyzed */
+  hunk: DiffHunk;
+  /** Lines before the hunk (from actual file) */
+  contextBefore: string[];
+  /** Lines after the hunk (from actual file) */
+  contextAfter: string[];
+  /** Start line of contextBefore */
+  contextStartLine: number;
+  /** Detected language from file extension */
+  language: string;
+}
+
+/**
+ * Detect language from filename.
+ */
+function detectLanguage(filename: string): string {
+  const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+  const languageMap: Record<string, string> = {
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    rb: 'ruby',
+    go: 'go',
+    rs: 'rust',
+    java: 'java',
+    kt: 'kotlin',
+    cs: 'csharp',
+    cpp: 'cpp',
+    c: 'c',
+    h: 'c',
+    hpp: 'cpp',
+    swift: 'swift',
+    php: 'php',
+    sh: 'bash',
+    bash: 'bash',
+    zsh: 'bash',
+    yml: 'yaml',
+    yaml: 'yaml',
+    json: 'json',
+    toml: 'toml',
+    md: 'markdown',
+    sql: 'sql',
+    html: 'html',
+    css: 'css',
+    scss: 'scss',
+    less: 'less',
+  };
+  return languageMap[ext] ?? ext;
+}
+
+/**
+ * Read specific lines from a file using the cache.
+ * Returns empty array if file doesn't exist or is binary.
+ */
+function readFileLines(
+  filePath: string,
+  startLine: number,
+  endLine: number
+): string[] {
+  const lines = getCachedFileLines(filePath);
+  if (!lines) {
+    return [];
+  }
+  // Lines are 1-indexed, arrays are 0-indexed
+  return lines.slice(startLine - 1, endLine);
+}
+
+/**
+ * Expand a hunk with surrounding context from the actual file.
+ */
+export function expandHunkContext(
+  repoPath: string,
+  filename: string,
+  hunk: DiffHunk,
+  contextLines = 20
+): HunkWithContext {
+  const filePath = join(repoPath, filename);
+  const expandedRange = getExpandedLineRange(hunk, contextLines);
+
+  // Read context before the hunk
+  const contextBefore = readFileLines(
+    filePath,
+    expandedRange.start,
+    hunk.newStart - 1
+  );
+
+  // Read context after the hunk
+  const contextAfter = readFileLines(
+    filePath,
+    hunk.newStart + hunk.newCount,
+    expandedRange.end
+  );
+
+  return {
+    filename,
+    hunk,
+    contextBefore,
+    contextAfter,
+    contextStartLine: expandedRange.start,
+    language: detectLanguage(filename),
+  };
+}
+
+/**
+ * Expand all hunks in a parsed diff with context.
+ */
+export function expandDiffContext(
+  repoPath: string,
+  diff: ParsedDiff,
+  contextLines = 20
+): HunkWithContext[] {
+  return diff.hunks.map((hunk) =>
+    expandHunkContext(repoPath, diff.filename, hunk, contextLines)
+  );
+}
+
+/**
+ * Format a hunk with context for LLM analysis.
+ */
+export function formatHunkForAnalysis(hunkCtx: HunkWithContext): string {
+  const lines: string[] = [];
+
+  lines.push(`## File: ${hunkCtx.filename}`);
+  lines.push(`## Language: ${hunkCtx.language}`);
+  lines.push(`## Hunk: lines ${hunkCtx.hunk.newStart}-${hunkCtx.hunk.newStart + hunkCtx.hunk.newCount - 1}`);
+
+  if (hunkCtx.hunk.header) {
+    lines.push(`## Scope: ${hunkCtx.hunk.header}`);
+  }
+
+  lines.push('');
+
+  // Context before
+  if (hunkCtx.contextBefore.length > 0) {
+    lines.push(`### Context Before (lines ${hunkCtx.contextStartLine}-${hunkCtx.hunk.newStart - 1})`);
+    lines.push('```' + hunkCtx.language);
+    lines.push(hunkCtx.contextBefore.join('\n'));
+    lines.push('```');
+    lines.push('');
+  }
+
+  // The actual changes
+  lines.push(`### Changes`);
+  lines.push('```diff');
+  lines.push(hunkCtx.hunk.content);
+  lines.push('```');
+  lines.push('');
+
+  // Context after
+  if (hunkCtx.contextAfter.length > 0) {
+    const afterStart = hunkCtx.hunk.newStart + hunkCtx.hunk.newCount;
+    const afterEnd = afterStart + hunkCtx.contextAfter.length - 1;
+    lines.push(`### Context After (lines ${afterStart}-${afterEnd})`);
+    lines.push('```' + hunkCtx.language);
+    lines.push(hunkCtx.contextAfter.join('\n'));
+    lines.push('```');
+  }
+
+  return lines.join('\n');
+}

package/src/diff/index.ts

@@ -0,0 +1,4 @@
+export * from './parser.js';
+export * from './context.js';
+export * from './classify.js';
+export * from './coalesce.js';

package/src/diff/parser.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parsePatch,
+  parseFileDiff,
+  getHunkLineRange,
+  getExpandedLineRange,
+  type DiffHunk,
+} from './parser.js';
+
+describe('parsePatch', () => {
+  it('parses a simple hunk', () => {
+    const patch = `@@ -1,3 +1,4 @@
+ line 1
++added line
+ line 2
+ line 3`;
+
+    const hunks = parsePatch(patch);
+    expect(hunks).toHaveLength(1);
+    const hunk = hunks[0]!;
+    expect(hunk.oldStart).toBe(1);
+    expect(hunk.oldCount).toBe(3);
+    expect(hunk.newStart).toBe(1);
+    expect(hunk.newCount).toBe(4);
+    expect(hunk.lines).toEqual([' line 1', '+added line', ' line 2', ' line 3']);
+  });
+
+  it('parses multiple hunks', () => {
+    const patch = `@@ -1,3 +1,4 @@
+ line 1
++added line
+ line 2
+@@ -10,2 +11,3 @@
+ line 10
++another added
+ line 11`;
+
+    const hunks = parsePatch(patch);
+    expect(hunks).toHaveLength(2);
+    expect(hunks[0]!.newStart).toBe(1);
+    expect(hunks[1]!.newStart).toBe(11);
+  });
+
+  it('parses hunk with function header', () => {
+    const patch = `@@ -5,3 +5,4 @@ function example()
+ const x = 1;
++const y = 2;
+ return x;`;
+
+    const hunks = parsePatch(patch);
+    expect(hunks).toHaveLength(1);
+    expect(hunks[0]!.header).toBe('function example()');
+  });
+
+  it('handles hunk without count (single line)', () => {
+    const patch = `@@ -1 +1,2 @@
+ existing
++added`;
+
+    const hunks = parsePatch(patch);
+    expect(hunks).toHaveLength(1);
+    const hunk = hunks[0]!;
+    expect(hunk.oldCount).toBe(1);
+    expect(hunk.newCount).toBe(2);
+  });
+
+  it('skips diff metadata lines', () => {
+    const patch = `diff --git a/file.ts b/file.ts
+index abc123..def456 100644
+--- a/file.ts
++++ b/file.ts
+@@ -1,2 +1,3 @@
+ line 1
++added
+ line 2`;
+
+    const hunks = parsePatch(patch);
+    expect(hunks).toHaveLength(1);
+    const hunk = hunks[0]!;
+    expect(hunk.lines).toEqual([' line 1', '+added', ' line 2']);
+    expect(hunk.content).not.toContain('diff --git');
+    expect(hunk.content).not.toContain('index ');
+  });
+
+  it('handles "No newline at end of file" marker', () => {
+    const patch = `@@ -1,2 +1,2 @@
+ line 1
+-old line
++new line
+\`;
+
+    const hunks = parsePatch(patch);
+    expect(hunks).toHaveLength(1);
+    expect(hunks[0]!.lines).not.toContain('\');
+  });
+
+  it('returns empty array for empty patch', () => {
+    expect(parsePatch('')).toEqual([]);
+  });
+
+  it('returns empty array for patch with only metadata', () => {
+    const patch = `diff --git a/file.ts b/file.ts
+index abc123..def456 100644
+--- a/file.ts
++++ b/file.ts`;
+
+    expect(parsePatch(patch)).toEqual([]);
+  });
+});
+
+describe('parseFileDiff', () => {
+  it('creates parsed diff with correct structure', () => {
+    const patch = `@@ -1,2 +1,3 @@
+ line 1
++added
+ line 2`;
+
+    const diff = parseFileDiff('src/index.ts', patch);
+    expect(diff.filename).toBe('src/index.ts');
+    expect(diff.status).toBe('modified');
+    expect(diff.hunks).toHaveLength(1);
+    expect(diff.rawPatch).toBe(patch);
+  });
+
+  it('accepts different status values', () => {
+    const patch = `@@ -0,0 +1,2 @@
++new file
++content`;
+
+    expect(parseFileDiff('new.ts', patch, 'added').status).toBe('added');
+    expect(parseFileDiff('old.ts', patch, 'removed').status).toBe('removed');
+    expect(parseFileDiff('moved.ts', patch, 'renamed').status).toBe('renamed');
+  });
+});
+
+describe('getHunkLineRange', () => {
+  it('returns correct range for hunk', () => {
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 3,
+      newStart: 5,
+      newCount: 10,
+      content: '',
+      lines: [],
+    };
+
+    const range = getHunkLineRange(hunk);
+    expect(range.start).toBe(5);
+    expect(range.end).toBe(14); // 5 + 10 - 1
+  });
+
+  it('handles single line hunk', () => {
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 1,
+      newStart: 1,
+      newCount: 1,
+      content: '',
+      lines: [],
+    };
+
+    const range = getHunkLineRange(hunk);
+    expect(range.start).toBe(1);
+    expect(range.end).toBe(1);
+  });
+});
+
+describe('getExpandedLineRange', () => {
+  it('expands range with default context', () => {
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 3,
+      newStart: 50,
+      newCount: 5,
+      content: '',
+      lines: [],
+    };
+
+    const range = getExpandedLineRange(hunk);
+    expect(range.start).toBe(30); // 50 - 20
+    expect(range.end).toBe(74); // 54 + 20
+  });
+
+  it('does not go below line 1', () => {
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 2,
+      newStart: 5,
+      newCount: 3,
+      content: '',
+      lines: [],
+    };
+
+    const range = getExpandedLineRange(hunk);
+    expect(range.start).toBe(1); // Math.max(1, 5 - 20)
+  });
+
+  it('accepts custom context lines', () => {
+    const hunk: DiffHunk = {
+      oldStart: 1,
+      oldCount: 2,
+      newStart: 100,
+      newCount: 5,
+      content: '',
+      lines: [],
+    };
+
+    const range = getExpandedLineRange(hunk, 50);
+    expect(range.start).toBe(50); // 100 - 50
+    expect(range.end).toBe(154); // 104 + 50
+  });
+});