@sentry/warden 0.0.0

package/src/config/writer.ts

@@ -0,0 +1,84 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import type { Trigger } from './schema.js';
+
+/**
+ * Generate TOML representation of a trigger.
+ */
+export function generateTriggerToml(trigger: Trigger): string {
+  const lines: string[] = ['[[triggers]]'];
+  lines.push(`name = "${trigger.name}"`);
+  lines.push(`event = "${trigger.event}"`);
+
+  // Format actions array (optional for schedule events)
+  if (trigger.actions && trigger.actions.length > 0) {
+    const actionsStr = trigger.actions.map((a) => `"${a}"`).join(', ');
+    lines.push(`actions = [${actionsStr}]`);
+  }
+
+  lines.push(`skill = "${trigger.skill}"`);
+
+  if (trigger.remote) {
+    lines.push(`remote = "${trigger.remote}"`);
+  }
+
+  // Optional fields
+  if (trigger.filters) {
+    if (trigger.filters.paths && trigger.filters.paths.length > 0) {
+      lines.push('');
+      lines.push('[triggers.filters]');
+      const pathsStr = trigger.filters.paths.map((p) => `"${p}"`).join(', ');
+      lines.push(`paths = [${pathsStr}]`);
+    }
+    if (trigger.filters.ignorePaths && trigger.filters.ignorePaths.length > 0) {
+      if (!trigger.filters.paths) {
+        lines.push('');
+        lines.push('[triggers.filters]');
+      }
+      const ignoreStr = trigger.filters.ignorePaths.map((p) => `"${p}"`).join(', ');
+      lines.push(`ignorePaths = [${ignoreStr}]`);
+    }
+  }
+
+  if (trigger.output) {
+    lines.push('');
+    lines.push('[triggers.output]');
+    if (trigger.output.failOn) {
+      lines.push(`failOn = "${trigger.output.failOn}"`);
+    }
+    if (trigger.output.commentOn) {
+      lines.push(`commentOn = "${trigger.output.commentOn}"`);
+    }
+    if (trigger.output.maxFindings) {
+      lines.push(`maxFindings = ${trigger.output.maxFindings}`);
+    }
+  }
+
+  if (trigger.model) {
+    lines.push(`model = "${trigger.model}"`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Append a trigger to the warden.toml configuration file.
+ * Preserves existing content and formatting by appending to the end.
+ */
+export function appendTrigger(configPath: string, trigger: Trigger): void {
+  const existingContent = readFileSync(configPath, 'utf-8');
+
+  // Ensure proper spacing before the new trigger
+  let separator: string;
+  if (existingContent.endsWith('\n\n')) {
+    separator = '';
+  } else if (existingContent.endsWith('\n')) {
+    separator = '\n';
+  } else {
+    separator = '\n\n';
+  }
+
+  const triggerToml = generateTriggerToml(trigger);
+  const newContent = existingContent + separator + triggerToml + '\n';
+
+  writeFileSync(configPath, newContent, 'utf-8');
+}

package/src/diff/classify.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect } from 'vitest';
+import {
+  classifyFile,
+  shouldSkipFile,
+  BUILTIN_SKIP_PATTERNS,
+} from './classify.js';
+import type { FilePattern } from '../config/schema.js';
+
+describe('classifyFile', () => {
+  describe('built-in skip patterns', () => {
+    it.each([
+      'pnpm-lock.yaml',
+      'package-lock.json',
+      'yarn.lock',
+      'Cargo.lock',
+      'go.sum',
+      'poetry.lock',
+      'composer.lock',
+      'Gemfile.lock',
+      'Pipfile.lock',
+      'bun.lockb',
+    ])('skips lock file: %s', (filename) => {
+      expect(classifyFile(filename)).toBe('skip');
+    });
+
+    it.each([
+      'src/pnpm-lock.yaml',
+      'packages/web/package-lock.json',
+      'nested/deep/yarn.lock',
+    ])('skips nested lock file: %s', (filename) => {
+      expect(classifyFile(filename)).toBe('skip');
+    });
+
+    it.each([
+      'bundle.min.js',
+      'styles.min.css',
+      'vendor.bundle.js',
+      'app.bundle.css',
+    ])('skips minified/bundled file: %s', (filename) => {
+      expect(classifyFile(filename)).toBe('skip');
+    });
+
+    it.each([
+      'dist/index.js',
+      'build/main.js',
+      'node_modules/lodash/index.js',
+      '.next/static/chunks/main.js',
+      'out/index.html',
+      'coverage/lcov.info',
+    ])('skips build artifacts: %s', (filename) => {
+      expect(classifyFile(filename)).toBe('skip');
+    });
+
+    it.each([
+      'types.generated.ts',
+      'schema.g.ts',
+      'model.g.dart',
+      'generated/api.ts',
+      '__generated__/graphql.ts',
+    ])('skips generated files: %s', (filename) => {
+      expect(classifyFile(filename)).toBe('skip');
+    });
+  });
+
+  describe('non-skipped files', () => {
+    it.each([
+      'src/index.ts',
+      'lib/utils.js',
+      'app/page.tsx',
+      'server/routes.py',
+      'main.go',
+      'Cargo.toml', // toml, not lock
+      'package.json', // json, not lock
+      'README.md',
+    ])('processes normal source file: %s', (filename) => {
+      expect(classifyFile(filename)).toBe('per-hunk');
+    });
+  });
+
+  describe('user patterns', () => {
+    it('allows user pattern to override built-in skip', () => {
+      const userPatterns: FilePattern[] = [
+        { pattern: '**/pnpm-lock.yaml', mode: 'per-hunk' },
+      ];
+      expect(classifyFile('pnpm-lock.yaml', userPatterns)).toBe('per-hunk');
+    });
+
+    it('allows user pattern to skip custom files', () => {
+      const userPatterns: FilePattern[] = [
+        { pattern: '**/fixtures/**', mode: 'skip' },
+      ];
+      expect(classifyFile('src/fixtures/data.json', userPatterns)).toBe('skip');
+    });
+
+    it('supports whole-file mode', () => {
+      const userPatterns: FilePattern[] = [
+        { pattern: '**/*.sql', mode: 'whole-file' },
+      ];
+      expect(classifyFile('migrations/001.sql', userPatterns)).toBe('whole-file');
+    });
+
+    it('user patterns take precedence over built-ins', () => {
+      const userPatterns: FilePattern[] = [
+        { pattern: '**/dist/**', mode: 'per-hunk' }, // override built-in skip
+      ];
+      expect(classifyFile('dist/index.js', userPatterns)).toBe('per-hunk');
+    });
+
+    it('checks user patterns in order', () => {
+      const userPatterns: FilePattern[] = [
+        { pattern: '**/*.ts', mode: 'skip' },
+        { pattern: '**/index.ts', mode: 'per-hunk' },
+      ];
+      // First matching pattern wins
+      expect(classifyFile('src/index.ts', userPatterns)).toBe('skip');
+    });
+
+    it('falls back to built-ins if no user pattern matches', () => {
+      const userPatterns: FilePattern[] = [
+        { pattern: '**/*.custom', mode: 'skip' },
+      ];
+      expect(classifyFile('pnpm-lock.yaml', userPatterns)).toBe('skip');
+    });
+  });
+});
+
+describe('shouldSkipFile', () => {
+  it('returns true for skipped files', () => {
+    expect(shouldSkipFile('pnpm-lock.yaml')).toBe(true);
+    expect(shouldSkipFile('dist/bundle.js')).toBe(true);
+  });
+
+  it('returns false for non-skipped files', () => {
+    expect(shouldSkipFile('src/index.ts')).toBe(false);
+    expect(shouldSkipFile('package.json')).toBe(false);
+  });
+
+  it('respects user patterns', () => {
+    const userPatterns: FilePattern[] = [
+      { pattern: '**/pnpm-lock.yaml', mode: 'per-hunk' },
+    ];
+    expect(shouldSkipFile('pnpm-lock.yaml', userPatterns)).toBe(false);
+  });
+});
+
+describe('BUILTIN_SKIP_PATTERNS', () => {
+  it('includes common lock files', () => {
+    expect(BUILTIN_SKIP_PATTERNS).toContain('**/pnpm-lock.yaml');
+    expect(BUILTIN_SKIP_PATTERNS).toContain('**/package-lock.json');
+    expect(BUILTIN_SKIP_PATTERNS).toContain('**/yarn.lock');
+  });
+
+  it('includes minified files', () => {
+    expect(BUILTIN_SKIP_PATTERNS).toContain('**/*.min.js');
+    expect(BUILTIN_SKIP_PATTERNS).toContain('**/*.min.css');
+  });
+
+  it('includes build directories', () => {
+    expect(BUILTIN_SKIP_PATTERNS).toContain('**/dist/**');
+    expect(BUILTIN_SKIP_PATTERNS).toContain('**/node_modules/**');
+  });
+});

package/src/diff/classify.ts

@@ -0,0 +1,92 @@
+/**
+ * File classification for chunking - determines how files should be processed
+ */
+
+import { matchGlob } from '../triggers/matcher.js';
+import type { FilePattern } from '../config/schema.js';
+
+/** Processing mode for a file */
+export type FileMode = 'per-hunk' | 'whole-file' | 'skip';
+
+/**
+ * Built-in patterns that are always applied before user patterns.
+ * These skip common lock files, minified code, and build artifacts.
+ */
+export const BUILTIN_SKIP_PATTERNS = [
+  // Package manager lock files
+  '**/pnpm-lock.yaml',
+  '**/package-lock.json',
+  '**/yarn.lock',
+  '**/Cargo.lock',
+  '**/go.sum',
+  '**/poetry.lock',
+  '**/composer.lock',
+  '**/Gemfile.lock',
+  '**/Pipfile.lock',
+  '**/bun.lockb',
+
+  // Minified/bundled code
+  '**/*.min.js',
+  '**/*.min.css',
+  '**/*.bundle.js',
+  '**/*.bundle.css',
+
+  // Build artifacts
+  '**/dist/**',
+  '**/build/**',
+  '**/node_modules/**',
+  '**/.next/**',
+  '**/out/**',
+  '**/coverage/**',
+
+  // Generated code
+  '**/*.generated.*',
+  '**/*.g.ts',
+  '**/*.g.dart',
+  '**/generated/**',
+  '**/__generated__/**',
+];
+
+/**
+ * Classify a file to determine how it should be processed.
+ *
+ * @param filename - The file path to classify
+ * @param userPatterns - Optional user-defined patterns (can override built-ins)
+ * @returns The processing mode: 'per-hunk', 'whole-file', or 'skip'
+ *
+ * Order of precedence:
+ * 1. User patterns are checked first (higher priority, allows overriding built-ins)
+ * 2. Built-in skip patterns are checked second
+ * 3. Default is 'per-hunk' if no patterns match
+ */
+export function classifyFile(
+  filename: string,
+  userPatterns?: FilePattern[]
+): FileMode {
+  // Check user patterns first (allows overriding built-in skips)
+  for (const { pattern, mode } of userPatterns ?? []) {
+    if (matchGlob(pattern, filename)) {
+      return mode;
+    }
+  }
+
+  // Check built-in skip patterns
+  for (const pattern of BUILTIN_SKIP_PATTERNS) {
+    if (matchGlob(pattern, filename)) {
+      return 'skip';
+    }
+  }
+
+  // Default: process per-hunk
+  return 'per-hunk';
+}
+
+/**
+ * Check if a file should be skipped based on classification.
+ */
+export function shouldSkipFile(
+  filename: string,
+  userPatterns?: FilePattern[]
+): boolean {
+  return classifyFile(filename, userPatterns) === 'skip';
+}

package/src/diff/coalesce.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import { coalesceHunks, wouldCoalesceReduce } from './coalesce.js';
+import type { DiffHunk } from './parser.js';
+
+function makeHunk(
+  newStart: number,
+  newCount: number,
+  content: string,
+  options: { oldStart?: number; oldCount?: number; header?: string } = {}
+): DiffHunk {
+  const { oldStart = newStart, oldCount = newCount, header } = options;
+  return {
+    oldStart,
+    oldCount,
+    newStart,
+    newCount,
+    content,
+    lines: content.split('\n'),
+    header,
+  };
+}
+
+describe('coalesceHunks', () => {
+  describe('edge cases', () => {
+    it('returns empty array for empty input', () => {
+      expect(coalesceHunks([])).toEqual([]);
+    });
+
+    it('returns single hunk unchanged', () => {
+      const hunk = makeHunk(1, 5, 'test content');
+      expect(coalesceHunks([hunk])).toEqual([hunk]);
+    });
+  });
+
+  describe('merging nearby hunks', () => {
+    it('merges two adjacent hunks within gap limit', () => {
+      const hunk1 = makeHunk(1, 5, 'first');
+      const hunk2 = makeHunk(10, 5, 'second');
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 10 });
+      const [merged] = result;
+
+      expect(result).toHaveLength(1);
+      expect(merged!.newStart).toBe(1);
+      expect(merged!.newCount).toBe(14);
+      expect(merged!.content).toContain('first');
+      expect(merged!.content).toContain('...');
+      expect(merged!.content).toContain('second');
+    });
+
+    it('does not merge hunks beyond gap limit', () => {
+      const hunk1 = makeHunk(1, 5, 'first');
+      const hunk2 = makeHunk(50, 5, 'second');
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 30 });
+
+      expect(result).toHaveLength(2);
+    });
+
+    it('does not merge when combined size exceeds limit', () => {
+      const hunk1 = makeHunk(1, 5, 'a'.repeat(5000));
+      const hunk2 = makeHunk(10, 5, 'b'.repeat(5000));
+
+      const result = coalesceHunks([hunk1, hunk2], { maxChunkSize: 8000 });
+
+      expect(result).toHaveLength(2);
+    });
+
+    it('merges multiple hunks into one when all within limits', () => {
+      const hunks = [
+        makeHunk(1, 3, 'a'),
+        makeHunk(10, 3, 'b'),
+        makeHunk(20, 3, 'c'),
+        makeHunk(30, 3, 'd'),
+      ];
+
+      const result = coalesceHunks(hunks, { maxGapLines: 15, maxChunkSize: 10000 });
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.content).toContain('a');
+      expect(result[0]!.content).toContain('d');
+    });
+
+    it('creates multiple chunks when limits are reached', () => {
+      const hunks = [
+        makeHunk(1, 3, 'a'.repeat(3000)),
+        makeHunk(10, 3, 'b'.repeat(3000)),
+        makeHunk(20, 3, 'c'.repeat(3000)),
+        makeHunk(30, 3, 'd'.repeat(3000)),
+      ];
+
+      const result = coalesceHunks(hunks, { maxGapLines: 15, maxChunkSize: 8000 });
+
+      // First two can merge (6000 chars), third can't fit (9000 > 8000)
+      // So result should be: [a+b], [c+d]
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('sorting', () => {
+    it('sorts hunks by start line before merging', () => {
+      const hunks = [
+        makeHunk(20, 3, 'third'),
+        makeHunk(1, 3, 'first'),
+        makeHunk(10, 3, 'second'),
+      ];
+
+      const result = coalesceHunks(hunks, { maxGapLines: 15, maxChunkSize: 10000 });
+
+      expect(result).toHaveLength(1);
+      // Should be merged in order: first, second, third
+      const content = result[0]!.content;
+      const firstPos = content.indexOf('first');
+      const secondPos = content.indexOf('second');
+      const thirdPos = content.indexOf('third');
+      expect(firstPos).toBeLessThan(secondPos);
+      expect(secondPos).toBeLessThan(thirdPos);
+    });
+  });
+
+  describe('merged hunk properties', () => {
+    it('calculates correct line ranges', () => {
+      const hunk1 = makeHunk(10, 5, 'first', { oldStart: 8, oldCount: 5 });
+      const hunk2 = makeHunk(25, 10, 'second', { oldStart: 23, oldCount: 10 });
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 20 });
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.newStart).toBe(10);
+      expect(result[0]!.newCount).toBe(25); // 10 to 35 (25 + 10)
+      expect(result[0]!.oldStart).toBe(8);
+      expect(result[0]!.oldCount).toBe(25); // 8 to 33 (23 + 10)
+    });
+
+    it('combines different headers from both hunks', () => {
+      const hunk1 = makeHunk(1, 3, 'first', { header: 'function foo()' });
+      const hunk2 = makeHunk(10, 3, 'second', { header: 'function bar()' });
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 20 });
+
+      expect(result[0]!.header).toBe('function foo() → function bar()');
+    });
+
+    it('preserves single header when only first hunk has one', () => {
+      const hunk1 = makeHunk(1, 3, 'first', { header: 'function foo()' });
+      const hunk2 = makeHunk(10, 3, 'second');
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 20 });
+
+      expect(result[0]!.header).toBe('function foo()');
+    });
+
+    it('preserves single header when only second hunk has one', () => {
+      const hunk1 = makeHunk(1, 3, 'first');
+      const hunk2 = makeHunk(10, 3, 'second', { header: 'function bar()' });
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 20 });
+
+      expect(result[0]!.header).toBe('function bar()');
+    });
+
+    it('preserves header when both hunks have identical headers', () => {
+      const hunk1 = makeHunk(1, 3, 'first', { header: 'function foo()' });
+      const hunk2 = makeHunk(10, 3, 'second', { header: 'function foo()' });
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 20 });
+
+      expect(result[0]!.header).toBe('function foo()');
+    });
+
+    it('combines lines from all merged hunks', () => {
+      const hunk1 = makeHunk(1, 3, 'line1\nline2');
+      const hunk2 = makeHunk(10, 3, 'line3\nline4');
+
+      const result = coalesceHunks([hunk1, hunk2], { maxGapLines: 20 });
+
+      expect(result[0]!.lines).toEqual(['line1', 'line2', 'line3', 'line4']);
+    });
+  });
+
+});
+
+describe('wouldCoalesceReduce', () => {
+  it('returns false for empty array', () => {
+    expect(wouldCoalesceReduce([])).toBe(false);
+  });
+
+  it('returns false for single hunk', () => {
+    const hunk = makeHunk(1, 5, 'test');
+    expect(wouldCoalesceReduce([hunk])).toBe(false);
+  });
+
+  it('returns true when coalescing would reduce count', () => {
+    const hunks = [
+      makeHunk(1, 3, 'a'),
+      makeHunk(10, 3, 'b'),
+    ];
+    expect(wouldCoalesceReduce(hunks, { maxGapLines: 20 })).toBe(true);
+  });
+
+  it('returns false when coalescing would not reduce count', () => {
+    const hunks = [
+      makeHunk(1, 3, 'a'),
+      makeHunk(100, 3, 'b'), // Too far apart
+    ];
+    expect(wouldCoalesceReduce(hunks, { maxGapLines: 10 })).toBe(false);
+  });
+});

package/src/diff/coalesce.ts

@@ -0,0 +1,133 @@
+/**
+ * Hunk coalescing - merges nearby hunks into fewer, larger chunks
+ * to reduce the number of LLM API calls while keeping chunk sizes manageable.
+ */
+
+import type { DiffHunk } from './parser.js';
+
+/** Default maximum gap in lines between hunks to merge */
+export const DEFAULT_MAX_GAP_LINES = 30;
+
+/** Default maximum chunk size in characters */
+export const DEFAULT_MAX_CHUNK_SIZE = 8000;
+
+/**
+ * Options for coalescing hunks.
+ */
+export interface CoalesceOptions {
+  /** Max lines gap between hunks to merge (default: 30) */
+  maxGapLines?: number;
+  /** Target max size per chunk in characters (default: 8000) */
+  maxChunkSize?: number;
+}
+
+/**
+ * Merge two adjacent hunks into one.
+ *
+ * The merged hunk spans from the start of the first hunk to the end of the second,
+ * with content combined using '...' as a visual separator. When both hunks have
+ * different headers (indicating different function/class scopes), both are preserved.
+ */
+function mergeHunks(a: DiffHunk, b: DiffHunk): DiffHunk {
+  // Calculate the new range that spans both hunks
+  const newStart = Math.min(a.newStart, b.newStart);
+  const newEnd = Math.max(a.newStart + a.newCount, b.newStart + b.newCount);
+  const oldStart = Math.min(a.oldStart, b.oldStart);
+  const oldEnd = Math.max(a.oldStart + a.oldCount, b.oldStart + b.oldCount);
+
+  // Combine headers when both exist and are different
+  let header: string | undefined;
+  if (a.header && b.header && a.header !== b.header) {
+    header = `${a.header} → ${b.header}`;
+  } else {
+    header = a.header ?? b.header;
+  }
+
+  return {
+    oldStart,
+    oldCount: oldEnd - oldStart,
+    newStart,
+    newCount: newEnd - newStart,
+    header,
+    content: a.content + '\n...\n' + b.content,
+    lines: [...a.lines, ...b.lines],
+  };
+}
+
+/**
+ * Calculate the gap in lines between two hunks.
+ * Returns the number of lines between the end of hunk A and the start of hunk B.
+ */
+function calculateGap(a: DiffHunk, b: DiffHunk): number {
+  const aEnd = a.newStart + a.newCount;
+  return b.newStart - aEnd;
+}
+
+/**
+ * Coalesce hunks that are close together into larger chunks.
+ *
+ * This reduces the number of LLM API calls by merging nearby hunks,
+ * while respecting size limits to keep chunks manageable.
+ *
+ * @param hunks - Array of hunks to coalesce
+ * @param options - Coalescing options (maxGapLines, maxChunkSize)
+ * @returns Array of coalesced hunks (may be smaller than input)
+ *
+ * Algorithm:
+ * 1. Sort hunks by start line
+ * 2. For each hunk, check if it can be merged with the previous:
+ *    - Gap between hunks <= maxGapLines
+ *    - Combined size <= maxChunkSize
+ * 3. If both conditions are met, merge; otherwise start a new chunk
+ */
+export function coalesceHunks(
+  hunks: DiffHunk[],
+  options: CoalesceOptions = {}
+): DiffHunk[] {
+  const { maxGapLines = DEFAULT_MAX_GAP_LINES, maxChunkSize = DEFAULT_MAX_CHUNK_SIZE } = options;
+
+  // Nothing to coalesce with 0 or 1 hunks
+  if (hunks.length <= 1) {
+    return hunks;
+  }
+
+  // Sort hunks by start line to ensure we process them in order
+  const sorted = [...hunks].sort((a, b) => a.newStart - b.newStart);
+
+  const result: DiffHunk[] = [];
+  // sorted[0] is guaranteed to exist since we checked hunks.length > 1 above
+  let current = sorted[0] as DiffHunk;
+
+  for (let i = 1; i < sorted.length; i++) {
+    const next = sorted[i] as DiffHunk;
+    const gap = calculateGap(current, next);
+    const combinedSize = current.content.length + next.content.length;
+
+    // Merge if: close enough AND combined size under limit
+    if (gap <= maxGapLines && combinedSize <= maxChunkSize) {
+      current = mergeHunks(current, next);
+    } else {
+      // Can't merge - save current and start a new chunk
+      result.push(current);
+      current = next;
+    }
+  }
+
+  // Don't forget the last chunk
+  result.push(current);
+
+  return result;
+}
+
+/**
+ * Check if coalescing would reduce the number of hunks.
+ * Useful for deciding whether to show coalescing stats.
+ */
+export function wouldCoalesceReduce(
+  hunks: DiffHunk[],
+  options: CoalesceOptions = {}
+): boolean {
+  if (hunks.length <= 1) return false;
+  const coalesced = coalesceHunks(hunks, options);
+  return coalesced.length < hunks.length;
+}