@sentry/warden 0.1.0 → 0.2.0

package/src/cli/output/jsonl.test.ts

@@ -1,347 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { existsSync, readFileSync, rmSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-import {
-  writeJsonlReport,
-  getRunLogsDir,
-  generateRunLogFilename,
-  getRunLogPath,
-  type JsonlRecord,
-} from './jsonl.js';
-import type { SkillReport } from '../../types/index.js';
-
-describe('writeJsonlReport', () => {
-  let testDir: string;
-
-  beforeEach(() => {
-    testDir = join(tmpdir(), `warden-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true });
-    }
-  });
-
-  it('writes one line per report plus summary', () => {
-    const outputPath = join(testDir, 'output.jsonl');
-    const reports: SkillReport[] = [
-      {
-        skill: 'security-review',
-        summary: 'Found 1 issue',
-        findings: [
-          {
-            id: 'sec-001',
-            severity: 'high',
-            title: 'SQL Injection',
-            description: 'User input passed directly to query',
-          },
-        ],
-        durationMs: 1234,
-      },
-      {
-        skill: 'code-review',
-        summary: 'No issues',
-        findings: [],
-        durationMs: 567,
-      },
-    ];
-
-    writeJsonlReport(outputPath, reports, 2000);
-
-    expect(existsSync(outputPath)).toBe(true);
-
-    const content = readFileSync(outputPath, 'utf-8');
-    const lines = content.trim().split('\n');
-
-    // 2 reports + 1 summary = 3 lines
-    expect(lines.length).toBe(3);
-
-    // First line: security-review report
-    const record1 = JSON.parse(lines[0]!) as JsonlRecord;
-    expect(record1.skill).toBe('security-review');
-    expect(record1.findings.length).toBe(1);
-    expect(record1.findings[0]!.id).toBe('sec-001');
-    expect(record1.durationMs).toBe(1234);
-    expect(record1.run.durationMs).toBe(2000);
-    expect(record1.run.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-
-    // Second line: code-review report
-    const record2 = JSON.parse(lines[1]!) as JsonlRecord;
-    expect(record2.skill).toBe('code-review');
-    expect(record2.findings.length).toBe(0);
-
-    // Third line: summary
-    const summary = JSON.parse(lines[2]!);
-    expect(summary.type).toBe('summary');
-    expect(summary.totalFindings).toBe(1);
-    expect(summary.bySeverity.high).toBe(1);
-  });
-
-  it('handles empty reports', () => {
-    const outputPath = join(testDir, 'empty.jsonl');
-
-    writeJsonlReport(outputPath, [], 500);
-
-    const content = readFileSync(outputPath, 'utf-8');
-    const lines = content.trim().split('\n');
-
-    // Just the summary line
-    expect(lines.length).toBe(1);
-
-    const summary = JSON.parse(lines[0]!);
-    expect(summary.type).toBe('summary');
-    expect(summary.totalFindings).toBe(0);
-  });
-
-  it('aggregates usage stats in summary', () => {
-    const outputPath = join(testDir, 'usage.jsonl');
-    const reports: SkillReport[] = [
-      {
-        skill: 'skill-1',
-        summary: 'Done',
-        findings: [],
-        usage: {
-          inputTokens: 100,
-          outputTokens: 50,
-          cacheReadInputTokens: 10,
-          cacheCreationInputTokens: 5,
-          costUSD: 0.001,
-        },
-      },
-      {
-        skill: 'skill-2',
-        summary: 'Done',
-        findings: [],
-        usage: {
-          inputTokens: 200,
-          outputTokens: 100,
-          cacheReadInputTokens: 20,
-          cacheCreationInputTokens: 10,
-          costUSD: 0.002,
-        },
-      },
-    ];
-
-    writeJsonlReport(outputPath, reports, 1000);
-
-    const content = readFileSync(outputPath, 'utf-8');
-    const lines = content.trim().split('\n');
-    const summary = JSON.parse(lines[2]!);
-
-    expect(summary.usage.inputTokens).toBe(300);
-    expect(summary.usage.outputTokens).toBe(150);
-    expect(summary.usage.cacheReadInputTokens).toBe(30);
-    expect(summary.usage.cacheCreationInputTokens).toBe(15);
-    expect(summary.usage.costUSD).toBeCloseTo(0.003);
-  });
-
-  it('creates parent directories if they do not exist', () => {
-    const outputPath = join(testDir, 'nested', 'deep', 'output.jsonl');
-
-    writeJsonlReport(outputPath, [], 100);
-
-    expect(existsSync(outputPath)).toBe(true);
-    const content = readFileSync(outputPath, 'utf-8');
-    const summary = JSON.parse(content.trim());
-    expect(summary.type).toBe('summary');
-  });
-
-  it('counts findings by severity in summary', () => {
-    const outputPath = join(testDir, 'severity.jsonl');
-    const reports: SkillReport[] = [
-      {
-        skill: 'review',
-        summary: 'Issues found',
-        findings: [
-          { id: '1', severity: 'critical', title: 'A', description: 'A' },
-          { id: '2', severity: 'high', title: 'B', description: 'B' },
-          { id: '3', severity: 'high', title: 'C', description: 'C' },
-          { id: '4', severity: 'medium', title: 'D', description: 'D' },
-          { id: '5', severity: 'low', title: 'E', description: 'E' },
-          { id: '6', severity: 'info', title: 'F', description: 'F' },
-        ],
-      },
-    ];
-
-    writeJsonlReport(outputPath, reports, 1000);
-
-    const content = readFileSync(outputPath, 'utf-8');
-    const lines = content.trim().split('\n');
-    const summary = JSON.parse(lines[1]!);
-
-    expect(summary.totalFindings).toBe(6);
-    expect(summary.bySeverity.critical).toBe(1);
-    expect(summary.bySeverity.high).toBe(2);
-    expect(summary.bySeverity.medium).toBe(1);
-    expect(summary.bySeverity.low).toBe(1);
-    expect(summary.bySeverity.info).toBe(1);
-  });
-});
-
-describe('getRunLogsDir', () => {
-  const originalEnv = process.env['WARDEN_STATE_DIR'];
-
-  afterEach(() => {
-    if (originalEnv === undefined) {
-      delete process.env['WARDEN_STATE_DIR'];
-    } else {
-      process.env['WARDEN_STATE_DIR'] = originalEnv;
-    }
-  });
-
-  it('returns default path when WARDEN_STATE_DIR is not set', () => {
-    delete process.env['WARDEN_STATE_DIR'];
-    const result = getRunLogsDir();
-    expect(result).toBe(join(homedir(), '.local', 'warden', 'runs'));
-  });
-
-  it('uses WARDEN_STATE_DIR when set', () => {
-    process.env['WARDEN_STATE_DIR'] = '/custom/state';
-    const result = getRunLogsDir();
-    expect(result).toBe('/custom/state/runs');
-  });
-});
-
-describe('generateRunLogFilename', () => {
-  it('generates filename with directory name and timestamp', () => {
-    const timestamp = new Date('2026-01-29T14:32:15.123Z');
-    const result = generateRunLogFilename('/path/to/my-project', timestamp);
-    expect(result).toBe('my-project_2026-01-29T14-32-15.123Z.jsonl');
-  });
-
-  it('replaces colons in timestamp with hyphens', () => {
-    const timestamp = new Date('2026-01-29T10:05:30.000Z');
-    const result = generateRunLogFilename('/some/dir', timestamp);
-    expect(result).toMatch(/^\w+_2026-01-29T10-05-30\.000Z\.jsonl$/);
-  });
-
-  it('uses "unknown" for empty directory name', () => {
-    const timestamp = new Date('2026-01-29T12:00:00.000Z');
-    const result = generateRunLogFilename('/', timestamp);
-    expect(result).toBe('unknown_2026-01-29T12-00-00.000Z.jsonl');
-  });
-
-  it('handles directory paths with trailing slash', () => {
-    const timestamp = new Date('2026-01-29T12:00:00.000Z');
-    // basename handles trailing slashes, so /foo/bar/ becomes 'bar'
-    const result = generateRunLogFilename('/foo/bar', timestamp);
-    expect(result).toBe('bar_2026-01-29T12-00-00.000Z.jsonl');
-  });
-});
-
-describe('getRunLogPath', () => {
-  const originalEnv = process.env['WARDEN_STATE_DIR'];
-
-  afterEach(() => {
-    if (originalEnv === undefined) {
-      delete process.env['WARDEN_STATE_DIR'];
-    } else {
-      process.env['WARDEN_STATE_DIR'] = originalEnv;
-    }
-  });
-
-  it('returns full path combining logs dir and filename', () => {
-    delete process.env['WARDEN_STATE_DIR'];
-    const timestamp = new Date('2026-01-29T14:32:15.123Z');
-    const result = getRunLogPath('/path/to/warden', timestamp);
-    expect(result).toBe(
-      join(homedir(), '.local', 'warden', 'runs', 'warden_2026-01-29T14-32-15.123Z.jsonl')
-    );
-  });
-
-  it('respects WARDEN_STATE_DIR', () => {
-    process.env['WARDEN_STATE_DIR'] = '/custom/dir';
-    const timestamp = new Date('2026-01-29T14:32:15.123Z');
-    const result = getRunLogPath('/my/project', timestamp);
-    expect(result).toBe('/custom/dir/runs/project_2026-01-29T14-32-15.123Z.jsonl');
-  });
-});
-
-describe('automatic run logging integration', () => {
-  let testStateDir: string;
-  const originalEnv = process.env['WARDEN_STATE_DIR'];
-
-  beforeEach(() => {
-    testStateDir = join(tmpdir(), `warden-state-${Date.now()}`);
-    process.env['WARDEN_STATE_DIR'] = testStateDir;
-  });
-
-  afterEach(() => {
-    if (existsSync(testStateDir)) {
-      rmSync(testStateDir, { recursive: true });
-    }
-    if (originalEnv === undefined) {
-      delete process.env['WARDEN_STATE_DIR'];
-    } else {
-      process.env['WARDEN_STATE_DIR'] = originalEnv;
-    }
-  });
-
-  it('writes run log to auto-generated path', () => {
-    const reports: SkillReport[] = [
-      {
-        skill: 'test-skill',
-        summary: 'Test complete',
-        findings: [
-          { id: 'test-1', severity: 'low', title: 'Test', description: 'Test finding' },
-        ],
-        durationMs: 100,
-      },
-    ];
-
-    const timestamp = new Date('2026-01-29T14:32:15.123Z');
-    const runLogPath = getRunLogPath('/path/to/my-project', timestamp);
-
-    writeJsonlReport(runLogPath, reports, 500);
-
-    // Verify file was created at expected location
-    expect(existsSync(runLogPath)).toBe(true);
-    expect(runLogPath).toBe(join(testStateDir, 'runs', 'my-project_2026-01-29T14-32-15.123Z.jsonl'));
-
-    // Verify content
-    const content = readFileSync(runLogPath, 'utf-8');
-    const lines = content.trim().split('\n');
-    expect(lines.length).toBe(2); // 1 report + 1 summary
-
-    const record = JSON.parse(lines[0]!) as JsonlRecord;
-    expect(record.skill).toBe('test-skill');
-    expect(record.findings.length).toBe(1);
-  });
-
-  it('creates nested runs directory automatically', () => {
-    const runLogPath = getRunLogPath('/some/project', new Date());
-
-    // Directory shouldn't exist yet
-    expect(existsSync(join(testStateDir, 'runs'))).toBe(false);
-
-    writeJsonlReport(runLogPath, [], 100);
-
-    // Now it should exist with the file
-    expect(existsSync(runLogPath)).toBe(true);
-  });
-
-  it('handles multiple runs with unique timestamps', () => {
-    const timestamp1 = new Date('2026-01-29T14:00:00.000Z');
-    const timestamp2 = new Date('2026-01-29T14:01:00.000Z');
-
-    const path1 = getRunLogPath('/project', timestamp1);
-    const path2 = getRunLogPath('/project', timestamp2);
-
-    expect(path1).not.toBe(path2);
-
-    writeJsonlReport(path1, [], 100);
-    writeJsonlReport(path2, [], 200);
-
-    expect(existsSync(path1)).toBe(true);
-    expect(existsSync(path2)).toBe(true);
-
-    // Verify they have different durations
-    const content1 = JSON.parse(readFileSync(path1, 'utf-8').trim());
-    const content2 = JSON.parse(readFileSync(path2, 'utf-8').trim());
-    expect(content1.run.durationMs).toBe(100);
-    expect(content2.run.durationMs).toBe(200);
-  });
-});

package/src/cli/output/jsonl.ts

@@ -1,126 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
-import type { SkillReport, UsageStats } from '../../types/index.js';
-import { countBySeverity } from './formatters.js';
-
-/**
- * Get the default run logs directory.
- * Uses WARDEN_STATE_DIR env var if set, otherwise ~/.local/warden/runs
- */
-export function getRunLogsDir(): string {
-  const stateDir = process.env['WARDEN_STATE_DIR'];
-  if (stateDir) {
-    return join(stateDir, 'runs');
-  }
-  return join(homedir(), '.local', 'warden', 'runs');
-}
-
-/**
- * Generate a run log filename from directory name and timestamp.
- * Format: {dirname}_{timestamp}.jsonl
- * Timestamp has colons replaced with hyphens for filesystem compatibility.
- */
-export function generateRunLogFilename(cwd: string, timestamp: Date = new Date()): string {
-  const dirName = basename(cwd) || 'unknown';
-  const ts = timestamp.toISOString().replace(/:/g, '-');
-  return `${dirName}_${ts}.jsonl`;
-}
-
-/**
- * Get the full path for an automatic run log.
- */
-export function getRunLogPath(cwd: string, timestamp: Date = new Date()): string {
-  return join(getRunLogsDir(), generateRunLogFilename(cwd, timestamp));
-}
-
-/**
- * Metadata for a JSONL run record.
- */
-export interface JsonlRunMetadata {
-  timestamp: string;
-  durationMs: number;
-  cwd: string;
-}
-
-/**
- * A single JSONL record representing one skill's report.
- */
-export interface JsonlRecord {
-  run: JsonlRunMetadata;
-  skill: string;
-  summary: string;
-  findings: SkillReport['findings'];
-  metadata?: Record<string, unknown>;
-  durationMs?: number;
-  usage?: UsageStats;
-}
-
-/**
- * Aggregate usage stats from reports.
- */
-function aggregateUsage(reports: SkillReport[]): UsageStats | undefined {
-  const usages = reports.map((r) => r.usage).filter((u) => u !== undefined);
-  if (usages.length === 0) return undefined;
-
-  return usages.reduce((acc, u) => ({
-    inputTokens: acc.inputTokens + u.inputTokens,
-    outputTokens: acc.outputTokens + u.outputTokens,
-    cacheReadInputTokens: (acc.cacheReadInputTokens ?? 0) + (u.cacheReadInputTokens ?? 0),
-    cacheCreationInputTokens: (acc.cacheCreationInputTokens ?? 0) + (u.cacheCreationInputTokens ?? 0),
-    costUSD: acc.costUSD + u.costUSD,
-  }));
-}
-
-/**
- * Write skill reports to a JSONL file.
- * Each line contains one skill report with run metadata.
- * A final summary line is appended at the end.
- */
-export function writeJsonlReport(
-  outputPath: string,
-  reports: SkillReport[],
-  durationMs: number
-): void {
-  const resolvedPath = resolve(process.cwd(), outputPath);
-  const timestamp = new Date().toISOString();
-  const cwd = process.cwd();
-
-  const runMetadata: JsonlRunMetadata = {
-    timestamp,
-    durationMs,
-    cwd,
-  };
-
-  const lines: string[] = [];
-
-  // Write one line per skill report
-  for (const report of reports) {
-    const record: JsonlRecord = {
-      run: runMetadata,
-      skill: report.skill,
-      summary: report.summary,
-      findings: report.findings,
-      metadata: report.metadata,
-      durationMs: report.durationMs,
-      usage: report.usage,
-    };
-    lines.push(JSON.stringify(record));
-  }
-
-  // Write a summary line at the end
-  const allFindings = reports.flatMap((r) => r.findings);
-  const summaryRecord = {
-    run: runMetadata,
-    type: 'summary',
-    totalFindings: allFindings.length,
-    bySeverity: countBySeverity(allFindings),
-    usage: aggregateUsage(reports),
-  };
-  lines.push(JSON.stringify(summaryRecord));
-
-  // Ensure parent directory exists
-  mkdirSync(dirname(resolvedPath), { recursive: true });
-
-  writeFileSync(resolvedPath, lines.join('\n') + '\n');
-}