@sentry/warden 0.0.0

package/src/cli/output/tasks.ts

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

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

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

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

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