@sentry/warden 0.1.1 → 0.2.0

package/src/cli/output/tasks.ts

@@ -1,374 +0,0 @@
-/**
- * Task execution for skills.
- * Callback-based state updates for CLI and Ink rendering.
- */
-
-import type { SkillReport, SeverityThreshold, Finding, UsageStats, EventContext } from '../../types/index.js';
-import type { SkillDefinition } from '../../config/schema.js';
-import {
-  prepareFiles,
-  analyzeFile,
-  aggregateUsage,
-  deduplicateFindings,
-  generateSummary,
-  type SkillRunnerOptions,
-  type FileAnalysisCallbacks,
-  type PreparedFile,
-  type PRPromptContext,
-} from '../../sdk/runner.js';
-import chalk from 'chalk';
-import figures from 'figures';
-import { Verbosity } from './verbosity.js';
-import type { OutputMode } from './tty.js';
-import { ICON_CHECK, ICON_SKIPPED } from './icons.js';
-import { formatDuration } from './formatters.js';
-
-/**
- * State of a file being processed by a skill.
- */
-export interface FileState {
-  filename: string;
-  status: 'pending' | 'running' | 'done';
-  currentHunk: number;
-  totalHunks: number;
-  findings: Finding[];
-}
-
-/**
- * State of a skill being executed.
- */
-export interface SkillState {
-  name: string;
-  displayName: string;
-  status: 'pending' | 'running' | 'done' | 'skipped' | 'error';
-  startTime?: number;
-  durationMs?: number;
-  files: FileState[];
-  findings: Finding[];
-  usage?: UsageStats;
-  error?: string;
-}
-
-/**
- * Result from running a skill task.
- */
-export interface SkillTaskResult {
-  name: string;
-  report?: SkillReport;
-  failOn?: SeverityThreshold;
-  error?: unknown;
-}
-
-/**
- * Options for creating a skill task.
- */
-export interface SkillTaskOptions {
-  name: string;
-  displayName?: string;
-  failOn?: SeverityThreshold;
-  /** Resolve the skill definition (may be async for loading) */
-  resolveSkill: () => Promise<SkillDefinition>;
-  /** The event context with files to analyze */
-  context: EventContext;
-  /** Options passed to the runner */
-  runnerOptions?: SkillRunnerOptions;
-}
-
-/**
- * Options for running skill tasks.
- */
-export interface RunTasksOptions {
-  mode: OutputMode;
-  verbosity: Verbosity;
-  concurrency: number;
-}
-
-/**
- * Callbacks for reporting skill execution progress to the UI.
- */
-export interface SkillProgressCallbacks {
-  onSkillStart: (skill: SkillState) => void;
-  onSkillUpdate: (name: string, updates: Partial<SkillState>) => void;
-  onFileUpdate: (skillName: string, filename: string, updates: Partial<FileState>) => void;
-  onSkillComplete: (name: string, report: SkillReport) => void;
-  onSkillSkipped: (name: string) => void;
-  onSkillError: (name: string, error: string) => void;
-  /** Called when a prompt exceeds the large prompt threshold */
-  onLargePrompt?: (skillName: string, filename: string, lineRange: string, chars: number, estimatedTokens: number) => void;
-  /** Called with prompt size info in debug mode */
-  onPromptSize?: (skillName: string, filename: string, lineRange: string, systemChars: number, userChars: number, totalChars: number, estimatedTokens: number) => void;
-}
-
-/**
- * Run a single skill task.
- */
-export async function runSkillTask(
-  options: SkillTaskOptions,
-  fileConcurrency: number,
-  callbacks: SkillProgressCallbacks
-): Promise<SkillTaskResult> {
-  const { name, displayName = name, failOn, resolveSkill, context, runnerOptions = {} } = options;
-  const startTime = Date.now();
-
-  try {
-    // Resolve the skill
-    const skill = await resolveSkill();
-
-    // Prepare files (parse patches into hunks)
-    const { files: preparedFiles, skippedFiles } = prepareFiles(context, {
-      contextLines: runnerOptions.contextLines,
-    });
-
-    if (preparedFiles.length === 0) {
-      // No files to analyze - skip
-      callbacks.onSkillSkipped(name);
-      return {
-        name,
-        report: {
-          skill: skill.name,
-          summary: 'No code changes to analyze',
-          findings: [],
-          usage: { inputTokens: 0, outputTokens: 0, costUSD: 0 },
-          skippedFiles: skippedFiles.length > 0 ? skippedFiles : undefined,
-        },
-        failOn,
-      };
-    }
-
-    // Initialize file states
-    const fileStates: FileState[] = preparedFiles.map((file) => ({
-      filename: file.filename,
-      status: 'pending',
-      currentHunk: 0,
-      totalHunks: file.hunks.length,
-      findings: [],
-    }));
-
-    // Notify skill start
-    callbacks.onSkillStart({
-      name,
-      displayName,
-      status: 'running',
-      startTime,
-      files: fileStates,
-      findings: [],
-    });
-
-    // Build PR context for inclusion in prompts (if available)
-    const prContext: PRPromptContext | undefined = context.pullRequest
-      ? {
-          changedFiles: context.pullRequest.files.map((f) => f.filename),
-          title: context.pullRequest.title,
-          body: context.pullRequest.body,
-        }
-      : undefined;
-
-    // Process files with concurrency
-    const processFile = async (prepared: PreparedFile, index: number): Promise<{ findings: Finding[]; usage?: UsageStats; failedHunks: number }> => {
-      const filename = prepared.filename;
-
-      // Update file state to running
-      callbacks.onFileUpdate(name, filename, { status: 'running' });
-
-      const fileCallbacks: FileAnalysisCallbacks = {
-        skillStartTime: startTime,
-        onHunkStart: (hunkNum, totalHunks) => {
-          callbacks.onFileUpdate(name, filename, {
-            currentHunk: hunkNum,
-            totalHunks,
-          });
-        },
-        onHunkComplete: (_hunkNum, findings) => {
-          // Accumulate findings for this file
-          const current = fileStates[index];
-          if (current) {
-            current.findings.push(...findings);
-          }
-        },
-        onLargePrompt: callbacks.onLargePrompt
-          ? (lineRange, chars, estimatedTokens) => {
-              callbacks.onLargePrompt?.(name, filename, lineRange, chars, estimatedTokens);
-            }
-          : undefined,
-        onPromptSize: callbacks.onPromptSize
-          ? (lineRange, systemChars, userChars, totalChars, estimatedTokens) => {
-              callbacks.onPromptSize?.(name, filename, lineRange, systemChars, userChars, totalChars, estimatedTokens);
-            }
-          : undefined,
-      };
-
-      const result = await analyzeFile(
-        skill,
-        prepared,
-        context.repoPath,
-        runnerOptions,
-        fileCallbacks,
-        prContext
-      );
-
-      // Update file state to done
-      callbacks.onFileUpdate(name, filename, {
-        status: 'done',
-        findings: result.findings,
-      });
-
-      return { findings: result.findings, usage: result.usage, failedHunks: result.failedHunks };
-    };
-
-    // Process files in batches with concurrency
-    const allResults: { findings: Finding[]; usage?: UsageStats; failedHunks: number }[] = [];
-
-    for (let i = 0; i < preparedFiles.length; i += fileConcurrency) {
-      const batch = preparedFiles.slice(i, i + fileConcurrency);
-      const batchResults = await Promise.all(
-        batch.map((file, batchIndex) => processFile(file, i + batchIndex))
-      );
-      allResults.push(...batchResults);
-    }
-
-    // Build report
-    const duration = Date.now() - startTime;
-    const allFindings = allResults.flatMap((r) => r.findings);
-    const allUsage = allResults.map((r) => r.usage).filter((u): u is UsageStats => u !== undefined);
-    const totalFailedHunks = allResults.reduce((sum, r) => sum + r.failedHunks, 0);
-    const uniqueFindings = deduplicateFindings(allFindings);
-
-    const report: SkillReport = {
-      skill: skill.name,
-      summary: generateSummary(skill.name, uniqueFindings),
-      findings: uniqueFindings,
-      usage: aggregateUsage(allUsage),
-      durationMs: duration,
-    };
-    if (skippedFiles.length > 0) {
-      report.skippedFiles = skippedFiles;
-    }
-    if (totalFailedHunks > 0) {
-      report.failedHunks = totalFailedHunks;
-    }
-
-    // Notify skill complete
-    callbacks.onSkillUpdate(name, {
-      status: 'done',
-      durationMs: duration,
-      findings: uniqueFindings,
-      usage: report.usage,
-    });
-    callbacks.onSkillComplete(name, report);
-
-    return { name, report, failOn };
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    callbacks.onSkillError(name, errorMessage);
-    return { name, error: err, failOn };
-  }
-}
-
-/**
- * Run multiple skill tasks with optional concurrency.
- * Uses callbacks to report progress for Ink rendering.
- */
-export async function runSkillTasks(
-  tasks: SkillTaskOptions[],
-  options: RunTasksOptions,
-  callbacks?: SkillProgressCallbacks
-): Promise<SkillTaskResult[]> {
-  const { mode, verbosity, concurrency } = options;
-
-  // File-level concurrency (within each skill)
-  const fileConcurrency = 5;
-
-  // Create default callbacks that output to console
-  const defaultCallbacks: SkillProgressCallbacks = {
-    onSkillStart: (_skill) => {
-      // We don't log start - we'll log completion with duration
-    },
-    onSkillUpdate: () => { /* no-op for default callbacks */ },
-    onFileUpdate: () => { /* no-op for default callbacks */ },
-    onSkillComplete: (name, report) => {
-      if (verbosity === Verbosity.Quiet) return;
-      const task = tasks.find((t) => t.name === name);
-      const displayName = task?.displayName ?? name;
-      const duration = report.durationMs ? ` ${chalk.dim(`[${formatDuration(report.durationMs)}]`)}` : '';
-      if (mode.isTTY) {
-        console.error(`${chalk.green(ICON_CHECK)} ${displayName}${duration}`);
-      } else {
-        console.log(`${ICON_CHECK} ${displayName}`);
-      }
-    },
-    onSkillSkipped: (name) => {
-      if (verbosity === Verbosity.Quiet) return;
-      const task = tasks.find((t) => t.name === name);
-      const displayName = task?.displayName ?? name;
-      if (mode.isTTY) {
-        console.error(`${chalk.yellow(ICON_SKIPPED)} ${displayName} ${chalk.dim('[skipped]')}`);
-      } else {
-        console.log(`${ICON_SKIPPED} ${displayName} [skipped]`);
-      }
-    },
-    onSkillError: (name, error) => {
-      if (verbosity === Verbosity.Quiet) return;
-      const task = tasks.find((t) => t.name === name);
-      const displayName = task?.displayName ?? name;
-      if (mode.isTTY) {
-        console.error(`${chalk.red('\u2717')} ${displayName} - ${chalk.red(error)}`);
-      } else {
-        console.error(`\u2717 ${displayName} - Error: ${error}`);
-      }
-    },
-    // Warn about large prompts (always shown unless quiet)
-    onLargePrompt: (skillName, filename, lineRange, chars, estimatedTokens) => {
-      if (verbosity === Verbosity.Quiet) return;
-      const location = `${filename}:${lineRange}`;
-      const size = `${Math.round(chars / 1000)}k chars (~${Math.round(estimatedTokens / 1000)}k tokens)`;
-      if (mode.isTTY) {
-        console.error(`${chalk.yellow(figures.warning)}  Large prompt for ${location}: ${size}`);
-      } else {
-        console.error(`WARN: Large prompt for ${location}: ${size}`);
-      }
-    },
-    // Debug mode: show prompt sizes
-    onPromptSize: verbosity >= Verbosity.Debug
-      ? (_skillName, filename, lineRange, systemChars, userChars, totalChars, estimatedTokens) => {
-          const location = `${filename}:${lineRange}`;
-          if (mode.isTTY) {
-            console.error(chalk.dim(`[debug] Prompt for ${location}: system=${systemChars}, user=${userChars}, total=${totalChars} chars (~${estimatedTokens} tokens)`));
-          } else {
-            console.error(`DEBUG: Prompt for ${location}: system=${systemChars}, user=${userChars}, total=${totalChars} chars (~${estimatedTokens} tokens)`);
-          }
-        }
-      : undefined,
-  };
-
-  const effectiveCallbacks = callbacks ?? defaultCallbacks;
-
-  // Output SKILLS header
-  if (verbosity !== Verbosity.Quiet && tasks.length > 0) {
-    if (mode.isTTY) {
-      console.error(chalk.bold('SKILLS'));
-    } else {
-      console.error('SKILLS');
-    }
-  }
-
-  const results: SkillTaskResult[] = [];
-
-  if (concurrency <= 1) {
-    // Sequential execution
-    for (const task of tasks) {
-      const result = await runSkillTask(task, fileConcurrency, effectiveCallbacks);
-      results.push(result);
-    }
-  } else {
-    // Parallel execution with concurrency limit
-    for (let i = 0; i < tasks.length; i += concurrency) {
-      const batch = tasks.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map((task) => runSkillTask(task, fileConcurrency, effectiveCallbacks))
-      );
-      results.push(...batchResults);
-    }
-  }
-
-  return results;
-}

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

@@ -1,117 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { detectOutputMode } from './tty.js';
-
-describe('detectOutputMode', () => {
-  const originalEnv = process.env;
-  const originalStderr = process.stderr.isTTY;
-  const originalStdout = process.stdout.isTTY;
-
-  beforeEach(() => {
-    process.env = { ...originalEnv };
-    // Reset to non-TTY by default for predictable tests
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: false,
-      configurable: true,
-    });
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: false,
-      configurable: true,
-    });
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: originalStderr,
-      configurable: true,
-    });
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: originalStdout,
-      configurable: true,
-    });
-  });
-
-  it('returns isTTY=false when streams are not TTY', () => {
-    process.env['TERM'] = 'xterm-256color';
-    const mode = detectOutputMode();
-    expect(mode.isTTY).toBe(false);
-  });
-
-  it('returns isTTY=true when stderr is TTY with valid TERM', () => {
-    process.env['TERM'] = 'xterm-256color';
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: true,
-      configurable: true,
-    });
-    const mode = detectOutputMode();
-    expect(mode.isTTY).toBe(true);
-  });
-
-  it('returns isTTY=false when TERM=dumb even if stream is TTY', () => {
-    process.env['TERM'] = 'dumb';
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: true,
-      configurable: true,
-    });
-    const mode = detectOutputMode();
-    expect(mode.isTTY).toBe(false);
-  });
-
-  it('returns isTTY=false when TERM is empty even if stream is TTY', () => {
-    process.env['TERM'] = '';
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: true,
-      configurable: true,
-    });
-    const mode = detectOutputMode();
-    expect(mode.isTTY).toBe(false);
-  });
-
-  it('returns isTTY=false when TERM is unset even if stream is TTY', () => {
-    delete process.env['TERM'];
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: true,
-      configurable: true,
-    });
-    const mode = detectOutputMode();
-    expect(mode.isTTY).toBe(false);
-  });
-
-  it('respects NO_COLOR environment variable', () => {
-    process.env['TERM'] = 'xterm-256color';
-    process.env['NO_COLOR'] = '1';
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: true,
-      configurable: true,
-    });
-    const mode = detectOutputMode();
-    expect(mode.supportsColor).toBe(false);
-  });
-
-  it('respects FORCE_COLOR environment variable', () => {
-    process.env['TERM'] = 'xterm-256color';
-    process.env['FORCE_COLOR'] = '1';
-    const mode = detectOutputMode();
-    expect(mode.supportsColor).toBe(true);
-  });
-
-  it('respects colorOverride=true', () => {
-    const mode = detectOutputMode(true);
-    expect(mode.supportsColor).toBe(true);
-  });
-
-  it('respects colorOverride=false', () => {
-    process.env['TERM'] = 'xterm-256color';
-    Object.defineProperty(process.stderr, 'isTTY', {
-      value: true,
-      configurable: true,
-    });
-    const mode = detectOutputMode(false);
-    expect(mode.supportsColor).toBe(false);
-  });
-
-  it('defaults columns to 80', () => {
-    const mode = detectOutputMode();
-    expect(mode.columns).toBe(80);
-  });
-});

package/src/cli/output/tty.ts

@@ -1,60 +0,0 @@
-import chalk from 'chalk';
-
-/**
- * Output mode configuration based on terminal capabilities.
- */
-export interface OutputMode {
-  /** Whether stdout is a TTY */
-  isTTY: boolean;
-  /** Whether colors are supported */
-  supportsColor: boolean;
-  /** Terminal width in columns */
-  columns: number;
-}
-
-/**
- * Detect terminal capabilities.
- * @param colorOverride - Optional override for color support (--color / --no-color)
- */
-export function detectOutputMode(colorOverride?: boolean): OutputMode {
-  // Check both stderr and stdout for TTY - some environments have TTY on one but not the other
-  const streamIsTTY = (process.stderr.isTTY || process.stdout.isTTY) ?? false;
-
-  // Treat dumb terminals as non-TTY (e.g., TERM=dumb used by some editors/agents)
-  const term = process.env['TERM'] ?? '';
-  const isDumbTerminal = term === 'dumb' || term === '';
-
-  const isTTY = streamIsTTY && !isDumbTerminal;
-
-  // Determine color support
-  let supportsColor: boolean;
-  if (colorOverride !== undefined) {
-    supportsColor = colorOverride;
-  } else if (process.env['NO_COLOR']) {
-    supportsColor = false;
-  } else if (process.env['FORCE_COLOR']) {
-    supportsColor = true;
-  } else {
-    supportsColor = isTTY && chalk.level > 0;
-  }
-
-  // Configure chalk based on color support
-  if (!supportsColor) {
-    chalk.level = 0;
-  }
-
-  const columns = process.stderr.columns ?? process.stdout.columns ?? 80;
-
-  return {
-    isTTY,
-    supportsColor,
-    columns,
-  };
-}
-
-/**
- * Get a timestamp for CI/non-TTY output.
- */
-export function timestamp(): string {
-  return new Date().toISOString();
-}

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

@@ -1,40 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Verbosity, parseVerbosity } from './verbosity.js';
-
-describe('parseVerbosity', () => {
-  it('returns Quiet when quiet is true', () => {
-    expect(parseVerbosity(true, 0)).toBe(Verbosity.Quiet);
-    expect(parseVerbosity(true, 1)).toBe(Verbosity.Quiet);
-    expect(parseVerbosity(true, 2)).toBe(Verbosity.Quiet);
-  });
-
-  it('returns Normal when verbose count is 0', () => {
-    expect(parseVerbosity(false, 0)).toBe(Verbosity.Normal);
-  });
-
-  it('returns Verbose when verbose count is 1', () => {
-    expect(parseVerbosity(false, 1)).toBe(Verbosity.Verbose);
-  });
-
-  it('returns Debug when verbose count is 2 or more', () => {
-    expect(parseVerbosity(false, 2)).toBe(Verbosity.Debug);
-    expect(parseVerbosity(false, 3)).toBe(Verbosity.Debug);
-    expect(parseVerbosity(false, 10)).toBe(Verbosity.Debug);
-  });
-});
-
-describe('Verbosity enum', () => {
-  it('has correct numeric values', () => {
-    expect(Verbosity.Quiet).toBe(0);
-    expect(Verbosity.Normal).toBe(1);
-    expect(Verbosity.Verbose).toBe(2);
-    expect(Verbosity.Debug).toBe(3);
-  });
-
-  it('supports comparison operators', () => {
-    expect(Verbosity.Quiet < Verbosity.Normal).toBe(true);
-    expect(Verbosity.Normal < Verbosity.Verbose).toBe(true);
-    expect(Verbosity.Verbose < Verbosity.Debug).toBe(true);
-    expect(Verbosity.Debug >= Verbosity.Verbose).toBe(true);
-  });
-});

package/src/cli/output/verbosity.ts

@@ -1,31 +0,0 @@
-/**
- * Verbosity levels for CLI output.
- */
-export enum Verbosity {
-  /** Errors + final summary only */
-  Quiet = 0,
-  /** Normal output with progress */
-  Normal = 1,
-  /** Real-time findings, hunk details */
-  Verbose = 2,
-  /** Token counts, latencies, debug info */
-  Debug = 3,
-}
-
-/**
- * Parse verbosity from CLI flags.
- * @param quiet - If true, return Quiet
- * @param verboseCount - Number of -v flags (0, 1, or 2+)
- */
-export function parseVerbosity(quiet: boolean, verboseCount: number): Verbosity {
-  if (quiet) {
-    return Verbosity.Quiet;
-  }
-  if (verboseCount >= 2) {
-    return Verbosity.Debug;
-  }
-  if (verboseCount === 1) {
-    return Verbosity.Verbose;
-  }
-  return Verbosity.Normal;
-}