@sentry/warden 0.1.0 → 0.2.0

package/src/config/writer.ts

@@ -1,84 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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

@@ -1,92 +0,0 @@
-/**
- * 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

@@ -1,208 +0,0 @@
-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

@@ -1,133 +0,0 @@
-/**
- * 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;
-}