vellum 0.0.16 → 0.2.0

package/src/util/diff.ts

@@ -0,0 +1,181 @@
+/**
+ * Minimal line-level diff utility with colored unified diff output.
+ * No external dependencies.
+ */
+
+interface DiffEntry {
+  type: 'same' | 'add' | 'remove';
+  line: string;
+}
+
+/**
+ * Compute a line-level diff using LCS (longest common subsequence).
+ * O(n*m) time and space — fine for typical source files.
+ */
+function computeLineDiff(oldLines: string[], newLines: string[]): DiffEntry[] {
+  const m = oldLines.length;
+  const n = newLines.length;
+
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (oldLines[i - 1] === newLines[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  const result: DiffEntry[] = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      result.unshift({ type: 'same', line: oldLines[i - 1] });
+      i--; j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: 'add', line: newLines[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: 'remove', line: oldLines[i - 1] });
+      i--;
+    }
+  }
+
+  return result;
+}
+
+interface Hunk {
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  lines: DiffEntry[];
+}
+
+const CONTEXT_LINES = 3;
+const MAX_DIFF_LINES = 1000;
+
+/**
+ * Group diff entries into hunks with surrounding context lines.
+ */
+function buildHunks(entries: DiffEntry[]): Hunk[] {
+  const changeRanges: Array<{ start: number; end: number }> = [];
+  for (let i = 0; i < entries.length; i++) {
+    if (entries[i].type !== 'same') {
+      if (changeRanges.length > 0 && i - changeRanges[changeRanges.length - 1].end <= CONTEXT_LINES * 2) {
+        changeRanges[changeRanges.length - 1].end = i + 1;
+      } else {
+        changeRanges.push({ start: i, end: i + 1 });
+      }
+    }
+  }
+
+  const hunks: Hunk[] = [];
+  for (const range of changeRanges) {
+    const contextStart = Math.max(0, range.start - CONTEXT_LINES);
+    const contextEnd = Math.min(entries.length, range.end + CONTEXT_LINES);
+    const hunkEntries = entries.slice(contextStart, contextEnd);
+
+    let oldLine = 1, newLine = 1;
+    for (let i = 0; i < contextStart; i++) {
+      if (entries[i].type === 'same' || entries[i].type === 'remove') oldLine++;
+      if (entries[i].type === 'same' || entries[i].type === 'add') newLine++;
+    }
+
+    let oldCount = 0, newCount = 0;
+    for (const entry of hunkEntries) {
+      if (entry.type === 'same' || entry.type === 'remove') oldCount++;
+      if (entry.type === 'same' || entry.type === 'add') newCount++;
+    }
+
+    hunks.push({
+      oldStart: oldLine,
+      oldCount,
+      newStart: newLine,
+      newCount,
+      lines: hunkEntries,
+    });
+  }
+
+  return hunks;
+}
+
+// ANSI color codes
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+/**
+ * Format a colored unified diff from old and new file content.
+ * Returns an empty string if the contents are identical.
+ */
+export function formatDiff(oldContent: string, newContent: string, filePath: string): string {
+  if (oldContent === newContent) return '';
+
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+
+  // Guard against quadratic blowup on large files
+  if (oldLines.length > MAX_DIFF_LINES || newLines.length > MAX_DIFF_LINES) {
+    const removed = oldLines.length;
+    const added = newLines.length;
+    let output = `${DIM}--- a/${filePath}${RESET}\n`;
+    output += `${DIM}+++ b/${filePath}${RESET}\n`;
+    output += `${DIM}[Diff too large to display: ${removed} lines → ${added} lines]${RESET}\n`;
+    return output;
+  }
+
+  const entries = computeLineDiff(oldLines, newLines);
+  const hunks = buildHunks(entries);
+
+  if (hunks.length === 0) return '';
+
+  let output = `${DIM}--- a/${filePath}${RESET}\n`;
+  output += `${DIM}+++ b/${filePath}${RESET}\n`;
+
+  for (const hunk of hunks) {
+    output += `${CYAN}@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@${RESET}\n`;
+    for (const entry of hunk.lines) {
+      switch (entry.type) {
+        case 'same':
+          output += ` ${entry.line}\n`;
+          break;
+        case 'remove':
+          output += `${RED}-${entry.line}${RESET}\n`;
+          break;
+        case 'add':
+          output += `${GREEN}+${entry.line}${RESET}\n`;
+          break;
+      }
+    }
+  }
+
+  return output;
+}
+
+/**
+ * Format a "new file" diff (everything is added).
+ * Truncates to maxLines to avoid flooding the terminal.
+ */
+export function formatNewFileDiff(content: string, filePath: string, maxLines = 20): string {
+  const lines = content.split('\n');
+  const truncated = lines.length > maxLines;
+  const displayLines = truncated ? lines.slice(0, maxLines) : lines;
+
+  let output = `${DIM}--- /dev/null${RESET}\n`;
+  output += `${DIM}+++ b/${filePath}${RESET}\n`;
+  output += `${CYAN}@@ -0,0 +1,${lines.length} @@${RESET}\n`;
+
+  for (const line of displayLines) {
+    output += `${GREEN}+${line}${RESET}\n`;
+  }
+
+  if (truncated) {
+    output += `${DIM}... ${lines.length - maxLines} more lines${RESET}\n`;
+  }
+
+  return output;
+}

package/src/util/errors.ts

@@ -0,0 +1,129 @@
+export enum ErrorCode {
+  // Provider errors
+  PROVIDER_ERROR = 'PROVIDER_ERROR',
+
+  // Tool errors
+  TOOL_ERROR = 'TOOL_ERROR',
+
+  // Permission errors
+  PERMISSION_DENIED = 'PERMISSION_DENIED',
+
+  // Config errors
+  CONFIG_ERROR = 'CONFIG_ERROR',
+
+  // Daemon errors
+  DAEMON_ERROR = 'DAEMON_ERROR',
+
+  // IPC/socket errors
+  IPC_ERROR = 'IPC_ERROR',
+
+  // Platform-specific errors (clipboard, unsupported OS features)
+  PLATFORM_ERROR = 'PLATFORM_ERROR',
+
+  // WASM integrity check failures
+  INTEGRITY_ERROR = 'INTEGRITY_ERROR',
+
+  // Rate limit exceeded
+  RATE_LIMIT_ERROR = 'RATE_LIMIT_ERROR',
+
+  // Secret detected in inbound content
+  INGRESS_BLOCKED = 'INGRESS_BLOCKED',
+
+  // Internal/unexpected errors
+  INTERNAL_ERROR = 'INTERNAL_ERROR',
+}
+
+export class AssistantError extends Error {
+  constructor(
+    message: string,
+    public readonly code: ErrorCode,
+    options?: { cause?: unknown },
+  ) {
+    super(message, options);
+    this.name = 'AssistantError';
+  }
+}
+
+export class ProviderError extends AssistantError {
+  constructor(
+    message: string,
+    public readonly provider: string,
+    public readonly statusCode?: number,
+    options?: { cause?: unknown },
+  ) {
+    super(message, ErrorCode.PROVIDER_ERROR, options);
+    this.name = 'ProviderError';
+  }
+}
+
+export class ToolError extends AssistantError {
+  constructor(
+    message: string,
+    public readonly toolName: string,
+  ) {
+    super(message, ErrorCode.TOOL_ERROR);
+    this.name = 'ToolError';
+  }
+}
+
+export class PermissionDeniedError extends AssistantError {
+  constructor(
+    message: string,
+    public readonly toolName: string,
+  ) {
+    super(message, ErrorCode.PERMISSION_DENIED);
+    this.name = 'PermissionDeniedError';
+  }
+}
+
+export class ConfigError extends AssistantError {
+  constructor(message: string) {
+    super(message, ErrorCode.CONFIG_ERROR);
+    this.name = 'ConfigError';
+  }
+}
+
+export class DaemonError extends AssistantError {
+  constructor(message: string) {
+    super(message, ErrorCode.DAEMON_ERROR);
+    this.name = 'DaemonError';
+  }
+}
+
+export class IpcError extends AssistantError {
+  constructor(message: string) {
+    super(message, ErrorCode.IPC_ERROR);
+    this.name = 'IpcError';
+  }
+}
+
+export class PlatformError extends AssistantError {
+  constructor(message: string) {
+    super(message, ErrorCode.PLATFORM_ERROR);
+    this.name = 'PlatformError';
+  }
+}
+
+export class IntegrityError extends AssistantError {
+  constructor(message: string) {
+    super(message, ErrorCode.INTEGRITY_ERROR);
+    this.name = 'IntegrityError';
+  }
+}
+
+export class RateLimitError extends AssistantError {
+  constructor(message: string) {
+    super(message, ErrorCode.RATE_LIMIT_ERROR);
+    this.name = 'RateLimitError';
+  }
+}
+
+export class IngressBlockedError extends AssistantError {
+  constructor(
+    message: string,
+    public readonly detectedTypes: string[],
+  ) {
+    super(message, ErrorCode.INGRESS_BLOCKED);
+    this.name = 'IngressBlockedError';
+  }
+}

package/src/util/logger.ts

@@ -0,0 +1,243 @@
+import { existsSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { Writable } from 'node:stream';
+import pino from 'pino';
+import pinoPretty from 'pino-pretty';
+import { getLogPath } from './platform.js';
+
+export type LogFileConfig = {
+  dir: string | undefined;
+  retentionDays: number;
+};
+
+const LOG_FILE_PREFIX = 'assistant-';
+const LOG_FILE_SUFFIX = '.log';
+const LOG_FILE_PATTERN = /^assistant-(\d{4}-\d{2}-\d{2})\.log$/;
+
+function formatDate(date: Date): string {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, '0');
+  const d = String(date.getUTCDate()).padStart(2, '0');
+  return `${y}-${m}-${d}`;
+}
+
+function logFilePathForDate(dir: string, date: Date): string {
+  return join(dir, `${LOG_FILE_PREFIX}${formatDate(date)}${LOG_FILE_SUFFIX}`);
+}
+
+export function pruneOldLogFiles(dir: string, retentionDays: number): number {
+  if (!existsSync(dir)) return 0;
+
+  const cutoff = new Date();
+  cutoff.setUTCDate(cutoff.getUTCDate() - retentionDays);
+  cutoff.setUTCHours(0, 0, 0, 0);
+
+  let removed = 0;
+  for (const name of readdirSync(dir)) {
+    const match = LOG_FILE_PATTERN.exec(name);
+    if (!match) continue;
+    const fileDate = new Date(match[1] + 'T00:00:00Z');
+    if (fileDate < cutoff) {
+      try {
+        unlinkSync(join(dir, name));
+        removed++;
+      } catch {
+        // best-effort
+      }
+    }
+  }
+  return removed;
+}
+
+let rootLogger: pino.Logger | null = null;
+let activeLogDate: string | null = null;
+let activeLogFileConfig: LogFileConfig | null = null;
+
+function buildRotatingLogger(config: LogFileConfig): pino.Logger {
+  if (!config.dir) {
+    return pino({ name: 'assistant' });
+  }
+
+  if (!existsSync(config.dir)) {
+    mkdirSync(config.dir, { recursive: true });
+  }
+
+  const today = formatDate(new Date());
+  const filePath = logFilePathForDate(config.dir, new Date());
+  const fileStream = pino.destination({ dest: filePath, sync: false, mkdir: true });
+
+  activeLogDate = today;
+  activeLogFileConfig = config;
+
+  const level = process.env.VELLUM_DEBUG === '1' ? 'debug' : 'info';
+
+  if (process.env.VELLUM_DEBUG === '1') {
+    const prettyStream = pinoPretty({ destination: 2 });
+    return pino(
+      { name: 'assistant', level },
+      pino.multistream([
+        { stream: fileStream, level: 'info' as const },
+        { stream: prettyStream, level: 'debug' as const },
+      ]),
+    );
+  }
+
+  return pino(
+    { name: 'assistant', level },
+    pino.multistream([
+      { stream: fileStream, level: 'info' as const },
+      { stream: pino.destination(1), level: 'info' as const },
+    ]),
+  );
+}
+
+function ensureCurrentDate(): void {
+  if (!activeLogFileConfig?.dir || !activeLogDate) return;
+  const today = formatDate(new Date());
+  if (today !== activeLogDate) {
+    rootLogger = buildRotatingLogger(activeLogFileConfig);
+  }
+}
+
+export function initLogger(config: LogFileConfig): void {
+  rootLogger = buildRotatingLogger(config);
+
+  if (config.dir && config.retentionDays > 0) {
+    const removed = pruneOldLogFiles(config.dir, config.retentionDays);
+    if (removed > 0) {
+      rootLogger.info({ removed, retentionDays: config.retentionDays }, 'Pruned old log files');
+    }
+  }
+}
+
+function getRootLogger(): pino.Logger {
+  if (activeLogFileConfig) {
+    ensureCurrentDate();
+  }
+  if (!rootLogger) {
+    const forceStderr =
+      process.env.BUN_TEST === '1'
+      || process.env.NODE_ENV === 'test'
+      || process.env.VELLUM_LOG_STDERR === '1';
+    if (forceStderr) {
+      rootLogger = pino(
+        { level: process.env.VELLUM_DEBUG === '1' ? 'debug' : 'info' },
+        pino.destination(2),
+      );
+      return rootLogger;
+    }
+
+    try {
+      const fileStream = pino.destination({ dest: getLogPath(), sync: false, mkdir: true });
+
+      if (process.env.VELLUM_DEBUG === '1') {
+        const prettyStream = pinoPretty({ destination: 2 });
+        const multi = pino.multistream([
+          { stream: fileStream, level: 'info' as const },
+          { stream: prettyStream, level: 'debug' as const },
+        ]);
+        rootLogger = pino({ level: 'debug' }, multi);
+      } else if (process.env.DEBUG_STDOUT_LOGS === '1') {
+        rootLogger = pino(
+          { level: 'info' },
+          pino.multistream([
+            { stream: fileStream, level: 'info' as const },
+            { stream: pino.destination(1), level: 'info' as const },
+          ]),
+        );
+      } else {
+        rootLogger = pino({ level: 'info' }, fileStream);
+      }
+    } catch {
+      rootLogger = pino({ level: process.env.VELLUM_DEBUG === '1' ? 'debug' : 'info' }, pino.destination(2));
+    }
+  }
+  return rootLogger;
+}
+
+/** Returns true when VELLUM_DEBUG=1 is set. */
+export function isDebug(): boolean {
+  return process.env.VELLUM_DEBUG === '1';
+}
+
+/**
+ * Truncate a string for debug logging. Returns the original if under maxLen,
+ * otherwise returns the first maxLen chars with a suffix indicating how much was cut.
+ */
+export function truncateForLog(value: string, maxLen = 500): string {
+  if (value.length <= maxLen) return value;
+  return value.slice(0, maxLen) + `... (${value.length - maxLen} chars truncated)`;
+}
+
+/**
+ * Returns a lazy logger that only initializes pino when a log method is called.
+ * This avoids "sonic boom is not ready yet" errors when the process exits
+ * quickly (e.g. `assistant --help`).
+ */
+export function getLogger(name: string): pino.Logger {
+  let child: pino.Logger | null = null;
+  const handler: ProxyHandler<pino.Logger> = {
+    get(_target, prop, receiver) {
+      if (!child) {
+        child = getRootLogger().child({ module: name });
+      }
+      const val = Reflect.get(child, prop, receiver);
+      if (typeof val === 'function') {
+        return val.bind(child);
+      }
+      return val;
+    },
+  };
+  return new Proxy({} as pino.Logger, handler);
+}
+
+/**
+ * Pino destination that extracts the message text from JSON log entries
+ * and writes it as plain text. Routes info/warn to stdout and error/fatal
+ * to stderr, matching console.log/console.error behavior.
+ */
+function cliDestination(fd: number, maxLevel?: number): Writable {
+  const output = fd === 2 ? process.stderr : process.stdout;
+  return new Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        const obj = JSON.parse(chunk.toString());
+        if (maxLevel !== undefined && obj.level > maxLevel) {
+          callback();
+          return;
+        }
+        output.write((obj.msg ?? '') + '\n', callback);
+      } catch {
+        output.write(chunk, callback);
+      }
+    },
+  });
+}
+
+/**
+ * Logger for CLI commands. Outputs plain message text to stdout (info/warn)
+ * and stderr (error/fatal) while providing structured log levels through pino.
+ * Uses lazy initialization to avoid issues with fast-exit paths like --help.
+ */
+export function getCliLogger(name: string): pino.Logger {
+  let logger: pino.Logger | null = null;
+  const handler: ProxyHandler<pino.Logger> = {
+    get(_target, prop, receiver) {
+      if (!logger) {
+        logger = pino(
+          { name, level: 'trace' },
+          pino.multistream([
+            { stream: cliDestination(1, 49), level: 'trace' as const },
+            { stream: cliDestination(2), level: 'error' as const },
+          ]),
+        );
+      }
+      const val = Reflect.get(logger, prop, receiver);
+      if (typeof val === 'function') {
+        return val.bind(logger);
+      }
+      return val;
+    },
+  };
+  return new Proxy({} as pino.Logger, handler);
+}