@sentry/warden 0.0.0

package/src/cli/context.ts

@@ -0,0 +1,131 @@
+import { basename } from 'node:path';
+import type { EventContext, FileChange } from '../types/index.js';
+import { pluralize } from './output/index.js';
+import { expandAndCreateFileChanges } from './files.js';
+import {
+  getChangedFilesWithPatches,
+  getCurrentBranch,
+  getHeadSha,
+  getDefaultBranch,
+  getRepoRoot,
+  getRepoName,
+  getCommitMessage,
+  type GitFileChange,
+} from './git.js';
+
+/**
+ * Convert git file change to EventContext FileChange format.
+ */
+function toFileChange(file: GitFileChange): FileChange {
+  return {
+    filename: file.filename,
+    status: file.status,
+    additions: file.additions,
+    deletions: file.deletions,
+    patch: file.patch,
+    chunks: file.chunks,
+  };
+}
+
+export interface LocalContextOptions {
+  base?: string;
+  head?: string;
+  cwd?: string;
+  /** Override auto-detected default branch (from config) */
+  defaultBranch?: string;
+}
+
+/**
+ * Build an EventContext from local git repository state.
+ * Creates a synthetic pull_request event from git diff.
+ *
+ * When analyzing a specific commit (head is set), uses the actual commit
+ * message as title/body to provide intent context to the LLM.
+ */
+export function buildLocalEventContext(options: LocalContextOptions = {}): EventContext {
+  const cwd = options.cwd ?? process.cwd();
+  const repoPath = getRepoRoot(cwd);
+  const { owner, name } = getRepoName(cwd);
+  const defaultBranch = options.defaultBranch ?? getDefaultBranch(cwd);
+
+  const base = options.base ?? defaultBranch;
+  const head = options.head; // undefined means working tree
+  const currentBranch = getCurrentBranch(cwd);
+  const headSha = head ? head : getHeadSha(cwd);
+
+  const changedFiles = getChangedFilesWithPatches(base, head, cwd);
+  const files = changedFiles.map(toFileChange);
+
+  // Use actual commit message when analyzing a specific commit
+  let title: string;
+  let body: string;
+  if (head) {
+    const commitMsg = getCommitMessage(head, cwd);
+    title = commitMsg.subject || `Commit ${head}`;
+    body = commitMsg.body || `Analyzing changes in ${head}`;
+  } else {
+    title = `Local changes: ${currentBranch}`;
+    body = `Analyzing local changes from ${base} to working tree`;
+  }
+
+  return {
+    eventType: 'pull_request',
+    action: 'opened',
+    repository: {
+      owner,
+      name,
+      fullName: `${owner}/${name}`,
+      defaultBranch,
+    },
+    pullRequest: {
+      number: 0, // Local run, no real PR number
+      title,
+      body,
+      author: 'local',
+      baseBranch: base,
+      headBranch: currentBranch,
+      headSha,
+      files,
+    },
+    repoPath,
+  };
+}
+
+export interface FileContextOptions {
+  patterns: string[];
+  cwd?: string;
+}
+
+/**
+ * Build an EventContext from a list of files or glob patterns.
+ * Creates a synthetic pull_request event treating files as newly added.
+ * This allows analysis without requiring git or a warden.toml config.
+ */
+export async function buildFileEventContext(options: FileContextOptions): Promise<EventContext> {
+  const cwd = options.cwd ?? process.cwd();
+  const dirName = basename(cwd);
+
+  const files = await expandAndCreateFileChanges(options.patterns, cwd);
+
+  return {
+    eventType: 'pull_request',
+    action: 'opened',
+    repository: {
+      owner: 'local',
+      name: dirName,
+      fullName: `local/${dirName}`,
+      defaultBranch: 'main',
+    },
+    pullRequest: {
+      number: 0,
+      title: 'File analysis',
+      body: `Analyzing ${files.length} ${pluralize(files.length, 'file')}`,
+      author: 'local',
+      baseBranch: 'main',
+      headBranch: 'file-analysis',
+      headSha: 'file-analysis',
+      files,
+    },
+    repoPath: cwd,
+  };
+}

package/src/cli/files.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  createPatchFromContent,
+  createSyntheticFileChange,
+  expandFileGlobs,
+  expandAndCreateFileChanges,
+} from './files.js';
+
+describe('createPatchFromContent', () => {
+  it('creates patch for single line content', () => {
+    const patch = createPatchFromContent('hello world');
+    expect(patch).toBe('@@ -0,0 +1,1 @@\n+hello world');
+  });
+
+  it('creates patch for multi-line content', () => {
+    const patch = createPatchFromContent('line1\nline2\nline3');
+    expect(patch).toBe('@@ -0,0 +1,3 @@\n+line1\n+line2\n+line3');
+  });
+
+  it('handles empty file', () => {
+    const patch = createPatchFromContent('');
+    expect(patch).toBe('@@ -0,0 +0,0 @@\n');
+  });
+
+  it('handles file ending with newline', () => {
+    const patch = createPatchFromContent('line1\nline2\n');
+    expect(patch).toBe('@@ -0,0 +1,3 @@\n+line1\n+line2\n+');
+  });
+});
+
+describe('createSyntheticFileChange', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `warden-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('creates FileChange from file', () => {
+    const filePath = join(tempDir, 'test.ts');
+    writeFileSync(filePath, 'const x = 1;\nconst y = 2;');
+
+    const change = createSyntheticFileChange(filePath, tempDir);
+
+    expect(change.filename).toBe('test.ts');
+    expect(change.status).toBe('added');
+    expect(change.additions).toBe(2);
+    expect(change.deletions).toBe(0);
+    expect(change.patch).toContain('+const x = 1;');
+    expect(change.patch).toContain('+const y = 2;');
+  });
+
+  it('handles nested files', () => {
+    const subDir = join(tempDir, 'src', 'utils');
+    mkdirSync(subDir, { recursive: true });
+    const filePath = join(subDir, 'helper.ts');
+    writeFileSync(filePath, 'export const helper = () => {};\n');
+
+    const change = createSyntheticFileChange(filePath, tempDir);
+
+    expect(change.filename).toBe('src/utils/helper.ts');
+  });
+});
+
+describe('expandFileGlobs', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `warden-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('expands glob pattern', async () => {
+    writeFileSync(join(tempDir, 'file1.ts'), 'content1');
+    writeFileSync(join(tempDir, 'file2.ts'), 'content2');
+    writeFileSync(join(tempDir, 'file.js'), 'content3');
+
+    const files = await expandFileGlobs(['*.ts'], tempDir);
+
+    expect(files).toHaveLength(2);
+    expect(files.some(f => f.endsWith('file1.ts'))).toBe(true);
+    expect(files.some(f => f.endsWith('file2.ts'))).toBe(true);
+    expect(files.some(f => f.endsWith('file.js'))).toBe(false);
+  });
+
+  it('expands nested glob pattern', async () => {
+    const srcDir = join(tempDir, 'src');
+    mkdirSync(srcDir, { recursive: true });
+    writeFileSync(join(tempDir, 'root.ts'), 'root');
+    writeFileSync(join(srcDir, 'nested.ts'), 'nested');
+
+    const files = await expandFileGlobs(['**/*.ts'], tempDir);
+
+    expect(files).toHaveLength(2);
+    expect(files.some(f => f.endsWith('root.ts'))).toBe(true);
+    expect(files.some(f => f.includes('src/nested.ts'))).toBe(true);
+  });
+
+  it('handles specific file path', async () => {
+    const filePath = join(tempDir, 'specific.ts');
+    writeFileSync(filePath, 'content');
+
+    const files = await expandFileGlobs(['specific.ts'], tempDir);
+
+    expect(files).toHaveLength(1);
+    expect(files[0]).toContain('specific.ts');
+  });
+
+  it('returns empty for no matches', async () => {
+    const files = await expandFileGlobs(['*.nonexistent'], tempDir);
+    expect(files).toHaveLength(0);
+  });
+});
+
+describe('expandAndCreateFileChanges', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `warden-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('combines glob expansion and file change creation', async () => {
+    writeFileSync(join(tempDir, 'file1.ts'), 'const a = 1;');
+    writeFileSync(join(tempDir, 'file2.ts'), 'const b = 2;\nconst c = 3;');
+
+    const changes = await expandAndCreateFileChanges(['*.ts'], tempDir);
+
+    expect(changes).toHaveLength(2);
+    expect(changes.every(c => c.status === 'added')).toBe(true);
+
+    const file1 = changes.find(c => c.filename === 'file1.ts');
+    expect(file1).toBeDefined();
+    expect(file1?.additions).toBe(1);
+
+    const file2 = changes.find(c => c.filename === 'file2.ts');
+    expect(file2).toBeDefined();
+    expect(file2?.additions).toBe(2);
+  });
+});

package/src/cli/files.ts

@@ -0,0 +1,89 @@
+import { readFileSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import fg from 'fast-glob';
+import { countPatchChunks } from '../types/index.js';
+import type { FileChange } from '../types/index.js';
+
+/**
+ * Expand glob patterns to a list of file paths.
+ */
+export async function expandFileGlobs(
+  patterns: string[],
+  cwd: string = process.cwd()
+): Promise<string[]> {
+  const files = await fg(patterns, {
+    cwd,
+    onlyFiles: true,
+    absolute: true,
+    dot: false,
+  });
+
+  return files.sort();
+}
+
+/**
+ * Create a unified diff patch for a file, treating entire content as added.
+ */
+export function createPatchFromContent(content: string): string {
+  const lines = content.split('\n');
+  const lineCount = lines.length;
+
+  // Handle empty files
+  if (lineCount === 0 || (lineCount === 1 && lines[0] === '')) {
+    return '@@ -0,0 +0,0 @@\n';
+  }
+
+  // Create patch header showing all lines as additions
+  const patchLines = [`@@ -0,0 +1,${lineCount} @@`];
+
+  for (const line of lines) {
+    patchLines.push(`+${line}`);
+  }
+
+  return patchLines.join('\n');
+}
+
+/**
+ * Read a file and create a synthetic FileChange treating it as newly added.
+ */
+export function createSyntheticFileChange(
+  absolutePath: string,
+  basePath: string
+): FileChange {
+  const content = readFileSync(absolutePath, 'utf-8');
+  const lines = content.split('\n');
+  const lineCount = lines.length;
+  const relativePath = relative(basePath, absolutePath);
+  const patch = createPatchFromContent(content);
+
+  return {
+    filename: relativePath,
+    status: 'added',
+    additions: lineCount,
+    deletions: 0,
+    patch,
+    chunks: countPatchChunks(patch),
+  };
+}
+
+/**
+ * Process a list of file paths into FileChange objects.
+ */
+export function createSyntheticFileChanges(
+  absolutePaths: string[],
+  basePath: string
+): FileChange[] {
+  return absolutePaths.map((filePath) => createSyntheticFileChange(filePath, basePath));
+}
+
+/**
+ * Expand glob patterns and create FileChange objects for all matching files.
+ */
+export async function expandAndCreateFileChanges(
+  patterns: string[],
+  cwd: string = process.cwd()
+): Promise<FileChange[]> {
+  const resolvedCwd = resolve(cwd);
+  const files = await expandFileGlobs(patterns, resolvedCwd);
+  return createSyntheticFileChanges(files, resolvedCwd);
+}

package/src/cli/fix.test.ts

@@ -0,0 +1,310 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  applyUnifiedDiff,
+  collectFixableFindings,
+  applyAllFixes,
+} from './fix.js';
+import type { Finding, SkillReport } from '../types/index.js';
+
+describe('applyUnifiedDiff', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `warden-fix-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('applies a single-line replacement', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'const x = "hello";\nconst y = "world";\n');
+
+    const diff = `@@ -1,2 +1,2 @@
+-const x = "hello";
++const x = "goodbye";
+ const y = "world";`;
+
+    applyUnifiedDiff(filePath, diff);
+
+    const result = readFileSync(filePath, 'utf-8');
+    expect(result).toBe('const x = "goodbye";\nconst y = "world";\n');
+  });
+
+  it('applies a multi-line addition', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'function foo() {\n  return 1;\n}\n');
+
+    const diff = `@@ -1,3 +1,5 @@
+ function foo() {
++  // Added comment
++  const x = 1;
+   return 1;
+ }`;
+
+    applyUnifiedDiff(filePath, diff);
+
+    const result = readFileSync(filePath, 'utf-8');
+    expect(result).toBe('function foo() {\n  // Added comment\n  const x = 1;\n  return 1;\n}\n');
+  });
+
+  it('applies a multi-line deletion', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'line1\nline2\nline3\nline4\n');
+
+    const diff = `@@ -1,4 +1,2 @@
+ line1
+-line2
+-line3
+ line4`;
+
+    applyUnifiedDiff(filePath, diff);
+
+    const result = readFileSync(filePath, 'utf-8');
+    expect(result).toBe('line1\nline4\n');
+  });
+
+  it('applies multiple hunks in reverse order', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'a\nb\nc\nd\ne\nf\ng\n');
+
+    // Two hunks: one at line 2, one at line 6
+    const diff = `@@ -2,1 +2,1 @@
+-b
++B
+@@ -6,1 +6,1 @@
+-f
++F`;
+
+    applyUnifiedDiff(filePath, diff);
+
+    const result = readFileSync(filePath, 'utf-8');
+    expect(result).toBe('a\nB\nc\nd\ne\nF\ng\n');
+  });
+
+  it('throws error for non-existent file', () => {
+    const filePath = join(testDir, 'nonexistent.ts');
+    const diff = `@@ -1,1 +1,1 @@
+-old
++new`;
+
+    expect(() => applyUnifiedDiff(filePath, diff)).toThrow('File not found');
+  });
+
+  it('throws error for context mismatch', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'actual content\n');
+
+    const diff = `@@ -1,1 +1,1 @@
+-expected content
++new content`;
+
+    expect(() => applyUnifiedDiff(filePath, diff)).toThrow('context mismatch');
+  });
+
+  it('throws error for empty diff', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'content\n');
+
+    expect(() => applyUnifiedDiff(filePath, '')).toThrow('No valid hunks');
+  });
+});
+
+describe('collectFixableFindings', () => {
+  it('returns empty array when no findings have fixes', () => {
+    const reports: SkillReport[] = [
+      {
+        skill: 'test',
+        summary: 'Test summary',
+        findings: [
+          {
+            id: '1',
+            severity: 'high',
+            title: 'Test finding',
+            description: 'No fix available',
+          },
+        ],
+      },
+    ];
+
+    const result = collectFixableFindings(reports);
+    expect(result).toEqual([]);
+  });
+
+  it('returns only findings with both diff and location', () => {
+    const fixableFinding: Finding = {
+      id: '1',
+      severity: 'high',
+      title: 'Fixable',
+      description: 'Has fix',
+      location: { path: 'test.ts', startLine: 10 },
+      suggestedFix: { description: 'Fix it', diff: '@@ -10,1 +10,1 @@\n-old\n+new' },
+    };
+
+    const noLocation: Finding = {
+      id: '2',
+      severity: 'high',
+      title: 'No location',
+      description: 'Missing location',
+      suggestedFix: { description: 'Fix it', diff: '@@ -1,1 +1,1 @@\n-old\n+new' },
+    };
+
+    const noDiff: Finding = {
+      id: '3',
+      severity: 'high',
+      title: 'No diff',
+      description: 'Missing diff',
+      location: { path: 'test.ts', startLine: 5 },
+    };
+
+    const reports: SkillReport[] = [
+      {
+        skill: 'test',
+        summary: 'Test',
+        findings: [fixableFinding, noLocation, noDiff],
+      },
+    ];
+
+    const result = collectFixableFindings(reports);
+    expect(result).toHaveLength(1);
+    expect(result[0]?.id).toBe('1');
+  });
+
+  it('sorts findings by file then by line (descending)', () => {
+    const finding1: Finding = {
+      id: '1',
+      severity: 'high',
+      title: 'F1',
+      description: 'D1',
+      location: { path: 'b.ts', startLine: 10 },
+      suggestedFix: { description: 'Fix', diff: '@@ -10,1 +10,1 @@\n-x\n+y' },
+    };
+
+    const finding2: Finding = {
+      id: '2',
+      severity: 'high',
+      title: 'F2',
+      description: 'D2',
+      location: { path: 'a.ts', startLine: 20 },
+      suggestedFix: { description: 'Fix', diff: '@@ -20,1 +20,1 @@\n-x\n+y' },
+    };
+
+    const finding3: Finding = {
+      id: '3',
+      severity: 'high',
+      title: 'F3',
+      description: 'D3',
+      location: { path: 'a.ts', startLine: 5 },
+      suggestedFix: { description: 'Fix', diff: '@@ -5,1 +5,1 @@\n-x\n+y' },
+    };
+
+    const reports: SkillReport[] = [
+      { skill: 'test', summary: 'Test', findings: [finding1, finding2, finding3] },
+    ];
+
+    const result = collectFixableFindings(reports);
+    expect(result).toHaveLength(3);
+    // Sorted: a.ts:20, a.ts:5, b.ts:10
+    expect(result[0]?.id).toBe('2'); // a.ts:20
+    expect(result[1]?.id).toBe('3'); // a.ts:5
+    expect(result[2]?.id).toBe('1'); // b.ts:10
+  });
+});
+
+describe('applyAllFixes', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `warden-fix-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('applies all valid fixes', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'line1\nline2\nline3\n');
+
+    const findings: Finding[] = [
+      {
+        id: '1',
+        severity: 'high',
+        title: 'Fix line 2',
+        description: 'Change line 2',
+        location: { path: filePath, startLine: 2 },
+        suggestedFix: { description: 'Fix', diff: '@@ -2,1 +2,1 @@\n-line2\n+LINE2' },
+      },
+    ];
+
+    const summary = applyAllFixes(findings);
+
+    expect(summary.applied).toBe(1);
+    expect(summary.failed).toBe(0);
+    expect(summary.skipped).toBe(0);
+
+    const result = readFileSync(filePath, 'utf-8');
+    expect(result).toBe('line1\nLINE2\nline3\n');
+  });
+
+  it('handles failed fixes and continues', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'actual\n');
+
+    const findings: Finding[] = [
+      {
+        id: '1',
+        severity: 'high',
+        title: 'Bad fix',
+        description: 'Wrong context',
+        location: { path: filePath, startLine: 1 },
+        suggestedFix: { description: 'Fix', diff: '@@ -1,1 +1,1 @@\n-wrong\n+new' },
+      },
+    ];
+
+    const summary = applyAllFixes(findings);
+
+    expect(summary.applied).toBe(0);
+    expect(summary.failed).toBe(1);
+    expect(summary.results[0]?.error).toContain('mismatch');
+  });
+
+  it('applies multiple fixes to same file in correct order', () => {
+    const filePath = join(testDir, 'test.ts');
+    writeFileSync(filePath, 'a\nb\nc\nd\ne\n');
+
+    // Findings already sorted by line descending
+    const findings: Finding[] = [
+      {
+        id: '1',
+        severity: 'high',
+        title: 'Fix line 4',
+        description: 'Change d',
+        location: { path: filePath, startLine: 4 },
+        suggestedFix: { description: 'Fix', diff: '@@ -4,1 +4,1 @@\n-d\n+D' },
+      },
+      {
+        id: '2',
+        severity: 'high',
+        title: 'Fix line 2',
+        description: 'Change b',
+        location: { path: filePath, startLine: 2 },
+        suggestedFix: { description: 'Fix', diff: '@@ -2,1 +2,1 @@\n-b\n+B' },
+      },
+    ];
+
+    const summary = applyAllFixes(findings);
+
+    expect(summary.applied).toBe(2);
+    expect(summary.failed).toBe(0);
+
+    const result = readFileSync(filePath, 'utf-8');
+    expect(result).toBe('a\nB\nc\nD\ne\n');
+  });
+});