vellum 0.2.14 → 0.3.2

package/src/events/tool-audit-listener.ts

@@ -1,80 +0,0 @@
-import { recordToolInvocation, type ToolInvocationRecord } from '../memory/tool-usage-store.js';
-import type { ToolLifecycleEvent, ToolLifecycleEventHandler } from '../tools/types.js';
-import { getLogger } from '../util/logger.js';
-
-const RESULT_PREVIEW_LIMIT = 1000;
-const log = getLogger('tool-audit-listener');
-
-type InvocationRecorder = (record: ToolInvocationRecord) => void;
-
-export function createToolAuditListener(
-  recorder: InvocationRecorder = recordToolInvocation,
-): ToolLifecycleEventHandler {
-  return (event) => {
-    const record = toInvocationRecord(event);
-    if (!record) return;
-
-    try {
-      recorder(record);
-    } catch (err) {
-      log.warn({ err, eventType: event.type, toolName: event.toolName }, 'Failed to record tool invocation');
-    }
-  };
-}
-
-function toInvocationRecord(event: ToolLifecycleEvent): ToolInvocationRecord | null {
-  switch (event.type) {
-    case 'executed':
-      return {
-        conversationId: event.conversationId,
-        toolName: event.toolName,
-        input: stringifyInput(event.input),
-        result: event.result.content.slice(0, RESULT_PREVIEW_LIMIT),
-        decision: event.decision,
-        riskLevel: event.riskLevel,
-        durationMs: event.durationMs,
-      };
-    case 'error':
-      return {
-        conversationId: event.conversationId,
-        toolName: event.toolName,
-        input: stringifyInput(event.input),
-        result: `error: ${event.errorMessage}`,
-        decision: 'error',
-        riskLevel: event.riskLevel,
-        durationMs: event.durationMs,
-      };
-    case 'permission_denied':
-      return {
-        conversationId: event.conversationId,
-        toolName: event.toolName,
-        input: stringifyInput(event.input),
-        result: formatDeniedResult(event.reason, event.decision),
-        decision: 'denied',
-        riskLevel: event.riskLevel,
-        durationMs: event.durationMs,
-      };
-    case 'start':
-    case 'permission_prompt':
-    case 'secret_detected':
-      return null;
-  }
-}
-
-function stringifyInput(input: Record<string, unknown>): string {
-  try {
-    return JSON.stringify(input);
-  } catch {
-    return '[unserializable-input]';
-  }
-}
-
-function formatDeniedResult(reason: string, decision: 'deny' | 'always_deny'): string {
-  if (reason.startsWith('Blocked by deny rule:')) {
-    return `denied: ${reason}`;
-  }
-  if (decision === 'always_deny' && reason.includes('rule saved')) {
-    return 'denied (permanent)';
-  }
-  return 'denied';
-}

package/src/events/tool-domain-event-publisher.ts

@@ -1,111 +0,0 @@
-import type { EventBus } from './bus.js';
-import type { AssistantDomainEvents } from './domain-events.js';
-import type { ToolLifecycleEventHandler } from '../tools/types.js';
-
-const allowDecisions = new Set(['allow', 'always_allow']);
-
-function isAllowDecision(decision: string): decision is 'allow' | 'always_allow' {
-  return allowDecisions.has(decision);
-}
-
-export function createToolDomainEventPublisher(
-  eventBus: EventBus<AssistantDomainEvents>,
-): ToolLifecycleEventHandler {
-  return async (event) => {
-    switch (event.type) {
-      case 'start':
-        await eventBus.emit('tool.execution.started', {
-          conversationId: event.conversationId,
-          sessionId: event.sessionId,
-          requestId: event.requestId,
-          toolName: event.toolName,
-          input: event.input,
-          startedAtMs: event.startedAtMs,
-        });
-        break;
-      case 'permission_prompt':
-        await eventBus.emit('tool.permission.requested', {
-          conversationId: event.conversationId,
-          sessionId: event.sessionId,
-          requestId: event.requestId,
-          toolName: event.toolName,
-          riskLevel: event.riskLevel,
-          requestedAtMs: Date.now(),
-        });
-        break;
-      case 'permission_denied':
-        await eventBus.emit('tool.permission.decided', {
-          conversationId: event.conversationId,
-          sessionId: event.sessionId,
-          requestId: event.requestId,
-          toolName: event.toolName,
-          decision: event.decision,
-          riskLevel: event.riskLevel,
-          decidedAtMs: Date.now(),
-        });
-        break;
-      case 'executed':
-        if (isAllowDecision(event.decision)) {
-          await eventBus.emit('tool.permission.decided', {
-            conversationId: event.conversationId,
-            sessionId: event.sessionId,
-            requestId: event.requestId,
-            toolName: event.toolName,
-            decision: event.decision,
-            riskLevel: event.riskLevel,
-            decidedAtMs: Date.now(),
-          });
-        }
-        await eventBus.emit('tool.execution.finished', {
-          conversationId: event.conversationId,
-          sessionId: event.sessionId,
-          requestId: event.requestId,
-          toolName: event.toolName,
-          decision: event.decision,
-          riskLevel: event.riskLevel,
-          isError: event.result.isError,
-          durationMs: event.durationMs,
-          finishedAtMs: Date.now(),
-        });
-        break;
-      case 'error':
-        if (isAllowDecision(event.decision)) {
-          await eventBus.emit('tool.permission.decided', {
-            conversationId: event.conversationId,
-            sessionId: event.sessionId,
-            requestId: event.requestId,
-            toolName: event.toolName,
-            decision: event.decision,
-            riskLevel: event.riskLevel,
-            decidedAtMs: Date.now(),
-          });
-        }
-        await eventBus.emit('tool.execution.failed', {
-          conversationId: event.conversationId,
-          sessionId: event.sessionId,
-          requestId: event.requestId,
-          toolName: event.toolName,
-          decision: event.decision,
-          riskLevel: event.riskLevel,
-          durationMs: event.durationMs,
-          error: event.errorMessage,
-          isExpected: event.isExpected,
-          errorName: event.errorName,
-          errorStack: event.errorStack,
-          failedAtMs: Date.now(),
-        });
-        break;
-      case 'secret_detected':
-        await eventBus.emit('tool.secret.detected', {
-          conversationId: event.conversationId,
-          sessionId: event.sessionId,
-          requestId: event.requestId,
-          toolName: event.toolName,
-          action: event.action,
-          matches: event.matches,
-          detectedAtMs: event.detectedAtMs,
-        });
-        break;
-    }
-  };
-}

package/src/events/tool-metrics-listener.ts

@@ -1,159 +0,0 @@
-import type { EventBus, Subscription } from './bus.js';
-import type { AssistantDomainEvents } from './domain-events.js';
-import { getLogger, isDebug, truncateForLog } from '../util/logger.js';
-
-const INPUT_PREVIEW_LIMIT = 300;
-const defaultLogger = getLogger('tool-metrics-listener');
-
-interface MetricsLogger {
-  debug(meta: object, message: string): void;
-  info(meta: object, message: string): void;
-  warn(meta: object, message: string): void;
-  error(meta: object, message: string): void;
-}
-
-interface MetricsListenerOptions {
-  logger?: MetricsLogger;
-  debugEnabled?: () => boolean;
-  truncate?: (value: string, maxLen: number) => string;
-}
-
-export function registerToolMetricsLoggingListener(
-  eventBus: EventBus<AssistantDomainEvents>,
-  options?: MetricsListenerOptions,
-): Subscription {
-  const logger = options?.logger ?? defaultLogger;
-  const debugEnabled = options?.debugEnabled ?? isDebug;
-  const truncate = options?.truncate ?? truncateForLog;
-
-  return eventBus.onAny((event) => {
-    switch (event.type) {
-      case 'tool.execution.started':
-        if (!debugEnabled()) return;
-        logger.debug(
-          {
-            tool: event.payload.toolName,
-            input: formatInputForLog(event.payload.input, truncate),
-            sessionId: event.payload.sessionId,
-            conversationId: event.payload.conversationId,
-            requestId: event.payload.requestId,
-          },
-          'Tool execute start',
-        );
-        return;
-      case 'tool.permission.requested':
-        logger.info(
-          {
-            tool: event.payload.toolName,
-            riskLevel: event.payload.riskLevel,
-            sessionId: event.payload.sessionId,
-            conversationId: event.payload.conversationId,
-            requestId: event.payload.requestId,
-          },
-          'Tool permission requested',
-        );
-        return;
-      case 'tool.permission.decided': {
-        const meta = {
-          tool: event.payload.toolName,
-          decision: event.payload.decision,
-          riskLevel: event.payload.riskLevel,
-          sessionId: event.payload.sessionId,
-          conversationId: event.payload.conversationId,
-          requestId: event.payload.requestId,
-        };
-
-        if (event.payload.decision === 'deny' || event.payload.decision === 'always_deny') {
-          logger.info(meta, 'Tool permission denied');
-          return;
-        }
-        if (debugEnabled()) {
-          logger.debug(meta, 'Tool permission decided');
-        }
-        return;
-      }
-      case 'tool.secret.detected': {
-        const types = [...new Set(event.payload.matches.map((match) => match.type))];
-        logger.warn(
-          {
-            toolName: event.payload.toolName,
-            matchCount: event.payload.matches.length,
-            types,
-            action: event.payload.action,
-            sessionId: event.payload.sessionId,
-            conversationId: event.payload.conversationId,
-            requestId: event.payload.requestId,
-          },
-          'Secrets detected in tool output',
-        );
-        return;
-      }
-      case 'tool.execution.finished':
-        if (!debugEnabled()) return;
-        logger.debug(
-          {
-            tool: event.payload.toolName,
-            execDurationMs: event.payload.durationMs,
-            riskLevel: event.payload.riskLevel,
-            decision: event.payload.decision,
-            isError: event.payload.isError,
-            sessionId: event.payload.sessionId,
-            conversationId: event.payload.conversationId,
-            requestId: event.payload.requestId,
-          },
-          'Tool execute result',
-        );
-        return;
-      case 'tool.execution.failed':
-        if (event.payload.isExpected) {
-          logger.warn(
-            {
-              tool: event.payload.toolName,
-              execDurationMs: event.payload.durationMs,
-              riskLevel: event.payload.riskLevel,
-              decision: event.payload.decision,
-              error: event.payload.error,
-              errorName: event.payload.errorName,
-              errorStack: event.payload.errorStack,
-              isExpected: event.payload.isExpected,
-              sessionId: event.payload.sessionId,
-              conversationId: event.payload.conversationId,
-              requestId: event.payload.requestId,
-            },
-            'Tool execution failed (expected)',
-          );
-          return;
-        }
-        logger.error(
-          {
-            tool: event.payload.toolName,
-            execDurationMs: event.payload.durationMs,
-            riskLevel: event.payload.riskLevel,
-            decision: event.payload.decision,
-            error: event.payload.error,
-            errorName: event.payload.errorName,
-            errorStack: event.payload.errorStack,
-            isExpected: event.payload.isExpected,
-            sessionId: event.payload.sessionId,
-            conversationId: event.payload.conversationId,
-            requestId: event.payload.requestId,
-          },
-          'Tool execution error',
-        );
-        return;
-      default:
-        return;
-    }
-  });
-}
-
-function formatInputForLog(
-  input: Record<string, unknown>,
-  truncate: (value: string, maxLen: number) => string,
-): string {
-  try {
-    return truncate(JSON.stringify(input), INPUT_PREVIEW_LIMIT);
-  } catch {
-    return '[unserializable-input]';
-  }
-}

package/src/events/tool-notification-listener.ts

@@ -1,17 +0,0 @@
-import type { EventBus, Subscription } from './bus.js';
-import type { AssistantDomainEvents } from './domain-events.js';
-import type { ServerMessage } from '../daemon/ipc-protocol.js';
-
-export function registerToolNotificationListener(
-  eventBus: EventBus<AssistantDomainEvents>,
-  sendToClient: (message: ServerMessage) => void,
-): Subscription {
-  return eventBus.on('tool.secret.detected', (event) => {
-    sendToClient({
-      type: 'secret_detected',
-      toolName: event.toolName,
-      matches: event.matches,
-      action: event.action,
-    });
-  });
-}

package/src/events/tool-profiling-listener.ts

@@ -1,158 +0,0 @@
-import type { EventBus, Subscription } from './bus.js';
-import type { AssistantDomainEvents } from './domain-events.js';
-import type { TraceEmitter } from '../daemon/trace-emitter.js';
-import { getLogger } from '../util/logger.js';
-
-const log = getLogger('tool-profiler');
-
-export interface ToolStats {
-  count: number;
-  totalMs: number;
-  maxMs: number;
-  errors: number;
-}
-
-export interface ToolProfilingSummary {
-  toolCount: number;
-  totalToolTimeMs: number;
-  wallClockMs: number;
-  tools: Record<string, ToolStats>;
-  peakRssMb: number;
-  rssDeltaMb: number;
-}
-
-/**
- * Accumulates per-tool timing and resource stats across a request.
- * Call `startRequest()` at the beginning and `emitSummary()` at the end.
- */
-export class ToolProfiler {
-  private tools = new Map<string, ToolStats>();
-  private requestStartMs = 0;
-  private rssStartBytes = 0;
-  private peakRssBytes = 0;
-
-  startRequest(): void {
-    this.tools.clear();
-    this.requestStartMs = Date.now();
-    const rss = process.memoryUsage().rss;
-    this.rssStartBytes = rss;
-    this.peakRssBytes = rss;
-  }
-
-  recordToolCompletion(toolName: string, durationMs: number, isError: boolean): void {
-    let stats = this.tools.get(toolName);
-    if (!stats) {
-      stats = { count: 0, totalMs: 0, maxMs: 0, errors: 0 };
-      this.tools.set(toolName, stats);
-    }
-    stats.count++;
-    stats.totalMs += durationMs;
-    if (durationMs > stats.maxMs) stats.maxMs = durationMs;
-    if (isError) stats.errors++;
-
-    const currentRss = process.memoryUsage().rss;
-    if (currentRss > this.peakRssBytes) this.peakRssBytes = currentRss;
-  }
-
-  getSummary(): ToolProfilingSummary {
-    let totalToolTimeMs = 0;
-    let toolCount = 0;
-    const tools: Record<string, ToolStats> = {};
-
-    for (const [name, stats] of this.tools) {
-      tools[name] = { ...stats };
-      totalToolTimeMs += stats.totalMs;
-      toolCount += stats.count;
-    }
-
-    const peakRssMb = Math.round(this.peakRssBytes / 1024 / 1024);
-    const rssDeltaMb = Math.round((this.peakRssBytes - this.rssStartBytes) / 1024 / 1024);
-
-    return {
-      toolCount,
-      totalToolTimeMs,
-      wallClockMs: this.requestStartMs > 0 ? Date.now() - this.requestStartMs : 0,
-      tools,
-      peakRssMb,
-      rssDeltaMb,
-    };
-  }
-
-  /** Release all accumulated stats. */
-  clear(): void {
-    this.tools.clear();
-    this.requestStartMs = 0;
-    this.rssStartBytes = 0;
-    this.peakRssBytes = 0;
-  }
-
-  emitSummary(traceEmitter: TraceEmitter, requestId?: string): void {
-    const summary = this.getSummary();
-    if (summary.toolCount === 0) return;
-
-    // Find the slowest individual tool invocation
-    let slowestTool = '';
-    let slowestMs = 0;
-    for (const [name, stats] of Object.entries(summary.tools)) {
-      if (stats.maxMs > slowestMs) {
-        slowestMs = stats.maxMs;
-        slowestTool = name;
-      }
-    }
-
-    log.info({
-      toolCount: summary.toolCount,
-      totalToolTimeMs: summary.totalToolTimeMs,
-      wallClockMs: summary.wallClockMs,
-      peakRssMb: summary.peakRssMb,
-      rssDeltaMb: summary.rssDeltaMb,
-      slowestTool,
-      slowestToolMaxMs: slowestMs,
-      tools: summary.tools,
-    }, 'Tool execution profiling summary');
-
-    traceEmitter.emit(
-      'tool_profiling_summary',
-      `${summary.toolCount} tool calls in ${summary.wallClockMs}ms (tool time: ${summary.totalToolTimeMs}ms, slowest: ${slowestTool} ${slowestMs}ms)`,
-      {
-        requestId,
-        status: 'info',
-        attributes: {
-          toolCount: summary.toolCount,
-          totalToolTimeMs: summary.totalToolTimeMs,
-          wallClockMs: summary.wallClockMs,
-          slowestTool,
-          slowestToolMaxMs: slowestMs,
-          peakRssMb: summary.peakRssMb,
-          rssDeltaMb: summary.rssDeltaMb,
-        },
-      },
-    );
-  }
-}
-
-export function registerToolProfilingListener(
-  eventBus: EventBus<AssistantDomainEvents>,
-  profiler: ToolProfiler,
-): Subscription {
-  return eventBus.onAny((event) => {
-    switch (event.type) {
-      case 'tool.execution.finished':
-        profiler.recordToolCompletion(
-          event.payload.toolName,
-          event.payload.durationMs,
-          event.payload.isError,
-        );
-        return;
-      case 'tool.execution.failed':
-        profiler.recordToolCompletion(
-          event.payload.toolName,
-          event.payload.durationMs,
-          true,
-        );
-        return;
-      default:
-        return;
-    }
-  });
-}

package/src/events/tool-trace-listener.ts

@@ -1,75 +0,0 @@
-import type { EventBus, Subscription } from './bus.js';
-import type { AssistantDomainEvents } from './domain-events.js';
-import type { TraceEmitter } from '../daemon/trace-emitter.js';
-
-export function registerToolTraceListener(
-  eventBus: EventBus<AssistantDomainEvents>,
-  traceEmitter: TraceEmitter,
-): Subscription {
-  return eventBus.onAny((event) => {
-    switch (event.type) {
-      case 'tool.execution.started':
-        traceEmitter.emit('tool_started', `Tool ${event.payload.toolName} started`, {
-          requestId: event.payload.requestId,
-          attributes: { toolName: event.payload.toolName },
-        });
-        return;
-
-      case 'tool.permission.requested':
-        traceEmitter.emit('tool_permission_requested', `Permission requested for ${event.payload.toolName}`, {
-          requestId: event.payload.requestId,
-          attributes: {
-            toolName: event.payload.toolName,
-            riskLevel: event.payload.riskLevel,
-          },
-        });
-        return;
-
-      case 'tool.permission.decided':
-        traceEmitter.emit('tool_permission_decided', `Permission ${event.payload.decision} for ${event.payload.toolName}`, {
-          requestId: event.payload.requestId,
-          attributes: {
-            toolName: event.payload.toolName,
-            decision: event.payload.decision,
-          },
-        });
-        return;
-
-      case 'tool.execution.finished':
-        traceEmitter.emit('tool_finished', `Tool ${event.payload.toolName} finished in ${event.payload.durationMs}ms`, {
-          requestId: event.payload.requestId,
-          status: event.payload.isError ? 'error' : undefined,
-          attributes: {
-            toolName: event.payload.toolName,
-            durationMs: event.payload.durationMs,
-            isError: event.payload.isError,
-          },
-        });
-        return;
-
-      case 'tool.execution.failed':
-        traceEmitter.emit('tool_failed', `Tool ${event.payload.toolName} failed after ${event.payload.durationMs}ms`, {
-          requestId: event.payload.requestId,
-          status: 'error',
-          attributes: {
-            toolName: event.payload.toolName,
-            durationMs: event.payload.durationMs,
-          },
-        });
-        return;
-
-      case 'tool.secret.detected':
-        traceEmitter.emit('secret_detected', `Secret detected in ${event.payload.toolName} output`, {
-          requestId: event.payload.requestId,
-          status: 'warning',
-          attributes: {
-            toolName: event.payload.toolName,
-          },
-        });
-        return;
-
-      default:
-        return;
-    }
-  });
-}

package/src/export/formatter.ts

@@ -1,98 +0,0 @@
-/**
- * Conversation export formatters for markdown and JSON.
- */
-
-import { truncate } from '../util/truncate.js';
-
-interface ContentBlock {
-  type: string;
-  text?: string;
-  name?: string;
-  input?: Record<string, unknown>;
-  content?: string;
-  tool_use_id?: string;
-  is_error?: boolean;
-}
-
-interface ExportMessage {
-  role: string;
-  content: ContentBlock[];
-  createdAt: number;
-}
-
-interface ExportConversation {
-  id: string;
-  title: string | null;
-  createdAt: number;
-  updatedAt: number;
-  messages: ExportMessage[];
-}
-
-function formatTimestamp(ms: number): string {
-  return new Date(ms).toISOString().replace('T', ' ').slice(0, 19);
-}
-
-function extractText(blocks: ContentBlock[]): string {
-  const parts: string[] = [];
-  for (const block of blocks) {
-    switch (block.type) {
-      case 'text':
-        if (block.text) parts.push(block.text);
-        break;
-      case 'tool_use':
-        parts.push(`[Tool: ${block.name}] ${JSON.stringify(block.input ?? {})}`);
-        break;
-      case 'tool_result':
-        if (block.is_error) {
-          parts.push(`[Error: ${block.content ?? ''}]`);
-        } else {
-          parts.push(`[Result: ${truncate(block.content ?? '', 500)}]`);
-        }
-        break;
-    }
-  }
-  return parts.join('\n');
-}
-
-export function formatMarkdown(conversation: ExportConversation): string {
-  const title = conversation.title ?? 'Untitled';
-  const lines: string[] = [];
-
-  lines.push(`# ${title}`);
-  lines.push('');
-  lines.push(`*Session ID: ${conversation.id}*`);
-  lines.push(`*Created: ${formatTimestamp(conversation.createdAt)}*`);
-  lines.push('');
-  lines.push('---');
-  lines.push('');
-
-  for (const msg of conversation.messages) {
-    const role = msg.role === 'user' ? 'You' : 'Assistant';
-    const time = formatTimestamp(msg.createdAt);
-    lines.push(`## ${role} (${time})`);
-    lines.push('');
-    lines.push(extractText(msg.content));
-    lines.push('');
-  }
-
-  lines.push('---');
-  lines.push(`*Exported at ${formatTimestamp(Date.now())}*`);
-  lines.push('');
-
-  return lines.join('\n');
-}
-
-export function formatJson(conversation: ExportConversation): string {
-  return JSON.stringify({
-    id: conversation.id,
-    title: conversation.title,
-    createdAt: new Date(conversation.createdAt).toISOString(),
-    updatedAt: new Date(conversation.updatedAt).toISOString(),
-    exportedAt: new Date().toISOString(),
-    messages: conversation.messages.map((msg) => ({
-      role: msg.role,
-      content: msg.content,
-      timestamp: new Date(msg.createdAt).toISOString(),
-    })),
-  }, null, 2);
-}