@vellumai/assistant 0.4.26 → 0.4.29

package/src/tools/assets/materialize.ts

@@ -7,21 +7,24 @@
  * regular file.
  */
 
-import { mkdirSync,writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-import { eq } from 'drizzle-orm';
-
-import { type AttachmentContext,isAttachmentVisible } from '../../daemon/media-visibility-policy.js';
-import { getConversationThreadType } from '../../memory/conversation-store.js';
-import { getDb } from '../../memory/db.js';
-import { attachments } from '../../memory/schema.js';
-import { RiskLevel } from '../../permissions/types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { sandboxPolicy } from '../shared/filesystem/path-policy.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import { getAttachmentSourceConversations } from './search.js';
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { eq } from "drizzle-orm";
+
+import {
+  type AttachmentContext,
+  isAttachmentVisible,
+} from "../../daemon/media-visibility-policy.js";
+import { getConversationThreadType } from "../../memory/conversation-store.js";
+import { getDb } from "../../memory/db.js";
+import { attachments } from "../../memory/schema.js";
+import { RiskLevel } from "../../permissions/types.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import { registerTool } from "../registry.js";
+import { sandboxPolicy } from "../shared/filesystem/path-policy.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+import { getAttachmentSourceConversations } from "./search.js";
 
 // ---------------------------------------------------------------------------
 // Size limit — prevent materializing excessively large attachments
@@ -46,9 +49,13 @@ function formatBytes(bytes: number): string {
  * Not scoped by assistantId because attachment access is enforced by
  * conversation visibility checks in execute().
  */
-function loadAttachmentById(
-  attachmentId: string,
-): { id: string; originalFilename: string; mimeType: string; sizeBytes: number; dataBase64: string } | null {
+function loadAttachmentById(attachmentId: string): {
+  id: string;
+  originalFilename: string;
+  mimeType: string;
+  sizeBytes: number;
+  dataBase64: string;
+} | null {
   const db = getDb();
   const row = db
     .select({
@@ -70,25 +77,31 @@ function loadAttachmentById(
 // ---------------------------------------------------------------------------
 
 const definition: ToolDefinition = {
-  name: 'asset_materialize',
+  name: "asset_materialize",
   description:
-    'Copy a stored attachment to a file on disk inside the sandbox directory. ' +
-    'Use attachment IDs from asset_search results. The file can then be used ' +
-    'as input to scripts, tools, or other processing.',
+    "Copy a stored attachment to a file on disk inside the sandbox directory. " +
+    "Use attachment IDs from asset_search results. The file can then be used " +
+    "as input to scripts, tools, or other processing.",
   input_schema: {
-    type: 'object',
+    type: "object",
     properties: {
       attachment_id: {
-        type: 'string',
-        description: 'The ID of the attachment to materialize (from asset_search results).',
+        type: "string",
+        description:
+          "The ID of the attachment to materialize (from asset_search results).",
       },
       destination_path: {
-        type: 'string',
+        type: "string",
+        description:
+          "Path where the file should be written, relative to (or inside) the sandbox working directory.",
+      },
+      reason: {
+        type: "string",
         description:
-          'Path where the file should be written, relative to (or inside) the sandbox working directory.',
+          "Brief non-technical explanation of what you are saving and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
       },
     },
-    required: ['attachment_id', 'destination_path'],
+    required: ["attachment_id", "destination_path"],
   },
 };
 
@@ -97,38 +110,43 @@ const definition: ToolDefinition = {
 // ---------------------------------------------------------------------------
 
 class AssetMaterializeTool implements Tool {
-  name = 'asset_materialize';
+  name = "asset_materialize";
   description = definition.description;
-  category = 'assets';
+  category = "assets";
   defaultRiskLevel = RiskLevel.Medium;
 
   getDefinition(): ToolDefinition {
     return definition;
   }
 
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+  async execute(
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> {
     const attachmentId = input.attachment_id as string | undefined;
     const destinationPath = input.destination_path as string | undefined;
 
     // --- Input validation ---------------------------------------------------
 
-    if (!attachmentId || typeof attachmentId !== 'string') {
+    if (!attachmentId || typeof attachmentId !== "string") {
       return {
-        content: 'Error: attachment_id is required and must be a string.',
+        content: "Error: attachment_id is required and must be a string.",
         isError: true,
       };
     }
 
-    if (!destinationPath || typeof destinationPath !== 'string') {
+    if (!destinationPath || typeof destinationPath !== "string") {
       return {
-        content: 'Error: destination_path is required and must be a string.',
+        content: "Error: destination_path is required and must be a string.",
         isError: true,
       };
     }
 
     // --- Sandbox path enforcement -------------------------------------------
 
-    const pathCheck = sandboxPolicy(destinationPath, context.workingDir, { mustExist: false });
+    const pathCheck = sandboxPolicy(destinationPath, context.workingDir, {
+      mustExist: false,
+    });
     if (!pathCheck.ok) {
       return {
         content: `Error: ${pathCheck.error}`,
@@ -155,16 +173,16 @@ class AssetMaterializeTool implements Tool {
     const currentThreadType = getConversationThreadType(context.conversationId);
     const currentContext: AttachmentContext = {
       conversationId: context.conversationId,
-      isPrivate: currentThreadType === 'private',
+      isPrivate: currentThreadType === "private",
     };
 
     const sources = getAttachmentSourceConversations(attachmentId);
     if (sources.length > 0) {
-      const hasStandard = sources.some((s) => s.threadType !== 'private');
+      const hasStandard = sources.some((s) => s.threadType !== "private");
       if (!hasStandard) {
         // All sources are private — check if the caller is in any of those threads
-        const callerInSourceThread = sources.some(
-          (s) => isAttachmentVisible(
+        const callerInSourceThread = sources.some((s) =>
+          isAttachmentVisible(
             { conversationId: s.conversationId, isPrivate: true },
             currentContext,
           ),
@@ -195,7 +213,7 @@ class AssetMaterializeTool implements Tool {
     // --- Decode and write ---------------------------------------------------
 
     try {
-      const buffer = Buffer.from(attachment.dataBase64, 'base64');
+      const buffer = Buffer.from(attachment.dataBase64, "base64");
 
       // Ensure parent directories exist
       mkdirSync(dirname(resolvedPath), { recursive: true });

package/src/tools/assets/search.ts

@@ -7,18 +7,26 @@
  * passed to asset_materialize (PR 35) to retrieve actual content.
  */
 
-import { and, desc,eq, gte, like } from 'drizzle-orm';
-
-import { type AttachmentContext,isAttachmentVisible } from '../../daemon/media-visibility-policy.js';
-import type { StoredAttachment } from '../../memory/attachments-store.js';
-import { getConversationThreadType } from '../../memory/conversation-store.js';
-import { getDb, rawAll } from '../../memory/db.js';
-import { attachments, conversations,messageAttachments, messages } from '../../memory/schema.js';
-import { escapeLikeWildcards } from '../../memory/search/lexical.js';
-import { RiskLevel } from '../../permissions/types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
+import { and, desc, eq, gte, like } from "drizzle-orm";
+
+import {
+  type AttachmentContext,
+  isAttachmentVisible,
+} from "../../daemon/media-visibility-policy.js";
+import type { StoredAttachment } from "../../memory/attachments-store.js";
+import { getConversationThreadType } from "../../memory/conversation-store.js";
+import { getDb, rawAll } from "../../memory/db.js";
+import {
+  attachments,
+  conversations,
+  messageAttachments,
+  messages,
+} from "../../memory/schema.js";
+import { escapeLikeWildcards } from "../../memory/search/lexical.js";
+import { RiskLevel } from "../../permissions/types.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import { registerTool } from "../registry.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 // ---------------------------------------------------------------------------
 // Recency presets — map human-readable labels to epoch-ms cutoff offsets
@@ -50,7 +58,7 @@ function formatAttachment(a: StoredAttachment): string {
     `- **${a.originalFilename}** (ID: ${a.id})`,
     `  Type: ${a.mimeType} | Kind: ${a.kind} | Size: ${formatBytes(a.sizeBytes)}`,
     `  Created: ${date}`,
-  ].join('\n');
+  ].join("\n");
 }
 
 // ---------------------------------------------------------------------------
@@ -87,20 +95,26 @@ export function getAttachmentSourceConversations(
  * - All-private attachments are visible only if the caller is in one of
  *   the source private threads.
  */
-function isAttachmentVisibleFromContext(attachmentId: string, currentContext: AttachmentContext): boolean {
+function isAttachmentVisibleFromContext(
+  attachmentId: string,
+  currentContext: AttachmentContext,
+): boolean {
   const sources = getAttachmentSourceConversations(attachmentId);
   if (sources.length === 0) {
     return true;
   }
 
-  const hasStandard = sources.some((s) => s.threadType !== 'private');
+  const hasStandard = sources.some((s) => s.threadType !== "private");
   if (hasStandard) {
     return true;
   }
 
   // All sources are private — visible only if the caller is in one of those threads
-  return sources.some(
-    (s) => isAttachmentVisible({ conversationId: s.conversationId, isPrivate: true }, currentContext),
+  return sources.some((s) =>
+    isAttachmentVisible(
+      { conversationId: s.conversationId, isPrivate: true },
+      currentContext,
+    ),
   );
 }
 
@@ -119,19 +133,26 @@ export interface AssetSearchParams {
 const MAX_RESULTS = 100;
 const DEFAULT_LIMIT = 20;
 
-export function searchAttachments(params: AssetSearchParams): StoredAttachment[] {
+export function searchAttachments(
+  params: AssetSearchParams,
+): StoredAttachment[] {
   const db = getDb();
   const conditions = [];
 
   // MIME type filter — supports wildcards like 'image/*' via LIKE
   if (params.mime_type) {
-    const mimePattern = params.mime_type.replace(/\*/g, '%');
+    const mimePattern = params.mime_type.replace(/\*/g, "%");
     conditions.push(like(attachments.mimeType, mimePattern));
   }
 
   // Filename filter — case-insensitive substring match (escape LIKE wildcards)
   if (params.filename) {
-    conditions.push(like(attachments.originalFilename, `%${escapeLikeWildcards(params.filename)}%`));
+    conditions.push(
+      like(
+        attachments.originalFilename,
+        `%${escapeLikeWildcards(params.filename)}%`,
+      ),
+    );
   }
 
   // Recency filter — computed cutoff timestamp
@@ -158,7 +179,7 @@ export function searchAttachments(params: AssetSearchParams): StoredAttachment[]
       return [];
     }
 
-    const placeholders = linkedIds.map(() => '?').join(', ');
+    const placeholders = linkedIds.map(() => "?").join(", ");
 
     // Build WHERE clauses for raw query (FTS5 virtual table not involved,
     // but dynamic IN-list with optional filters is simpler in raw SQL)
@@ -166,7 +187,7 @@ export function searchAttachments(params: AssetSearchParams): StoredAttachment[]
     const bindValues: (string | number)[] = [...linkedIds];
 
     if (params.mime_type) {
-      const mimePattern = params.mime_type.replace(/\*/g, '%');
+      const mimePattern = params.mime_type.replace(/\*/g, "%");
       whereParts.push(`a.mime_type LIKE ?`);
       bindValues.push(mimePattern);
     }
@@ -196,10 +217,11 @@ export function searchAttachments(params: AssetSearchParams): StoredAttachment[]
     const rows = rawAll<AttachmentRow>(
       `SELECT a.id, a.original_filename, a.mime_type, a.size_bytes, a.kind, a.thumbnail_base64, a.created_at
        FROM attachments a
-       WHERE ${whereParts.join(' AND ')}
+       WHERE ${whereParts.join(" AND ")}
        ORDER BY a.created_at DESC
        LIMIT ?`,
-      ...bindValues, limit,
+      ...bindValues,
+      limit,
     );
 
     return rows.map((r) => ({
@@ -242,39 +264,45 @@ export function searchAttachments(params: AssetSearchParams): StoredAttachment[]
 // ---------------------------------------------------------------------------
 
 const definition: ToolDefinition = {
-  name: 'asset_search',
+  name: "asset_search",
   description:
-    'Search for previously uploaded media assets (images, documents, etc.) by metadata. ' +
-    'Returns attachment IDs and metadata — not file content. Use the returned IDs with ' +
-    'asset_materialize to retrieve actual file data.',
+    "Search for previously uploaded media assets (images, documents, etc.) by metadata. " +
+    "Returns attachment IDs and metadata — not file content. Use the returned IDs with " +
+    "asset_materialize to retrieve actual file data.",
   input_schema: {
-    type: 'object',
+    type: "object",
     properties: {
       mime_type: {
-        type: 'string',
+        type: "string",
         description:
           'Filter by MIME type. Supports wildcards: "image/*" matches all images, ' +
           '"application/pdf" matches PDFs exactly.',
       },
       filename: {
-        type: 'string',
-        description: 'Search by original filename (case-insensitive substring match).',
+        type: "string",
+        description:
+          "Search by original filename (case-insensitive substring match).",
       },
       recency: {
-        type: 'string',
+        type: "string",
         enum: VALID_RECENCY_VALUES,
         description:
-          'Filter by recency. One of: last_hour, last_24_hours, last_7_days, last_30_days, last_90_days.',
+          "Filter by recency. One of: last_hour, last_24_hours, last_7_days, last_30_days, last_90_days.",
       },
       conversation_id: {
-        type: 'string',
+        type: "string",
         description:
-          'Constrain results to attachments linked to messages in a specific conversation.',
+          "Constrain results to attachments linked to messages in a specific conversation.",
       },
       limit: {
-        type: 'number',
+        type: "number",
         description: `Maximum results to return (default ${DEFAULT_LIMIT}, max ${MAX_RESULTS}).`,
       },
+      reason: {
+        type: "string",
+        description:
+          "Brief non-technical explanation of what you are searching for and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
+      },
     },
     required: [],
   },
@@ -285,16 +313,19 @@ const definition: ToolDefinition = {
 // ---------------------------------------------------------------------------
 
 class AssetSearchTool implements Tool {
-  name = 'asset_search';
+  name = "asset_search";
   description = definition.description;
-  category = 'assets';
+  category = "assets";
   defaultRiskLevel = RiskLevel.Low;
 
   getDefinition(): ToolDefinition {
     return definition;
   }
 
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+  async execute(
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> {
     const mimeType = input.mime_type as string | undefined;
     const filename = input.filename as string | undefined;
     const recency = input.recency as string | undefined;
@@ -304,15 +335,15 @@ class AssetSearchTool implements Tool {
     // Validate recency if provided
     if (recency && !RECENCY_MS[recency]) {
       return {
-        content: `Error: Invalid recency value "${recency}". Valid values: ${VALID_RECENCY_VALUES.join(', ')}`,
+        content: `Error: Invalid recency value "${recency}". Valid values: ${VALID_RECENCY_VALUES.join(", ")}`,
         isError: true,
       };
     }
 
     // Validate limit if provided
-    if (limit !== undefined && (typeof limit !== 'number' || limit < 1)) {
+    if (limit !== undefined && (typeof limit !== "number" || limit < 1)) {
       return {
-        content: 'Error: limit must be a positive number.',
+        content: "Error: limit must be a positive number.",
         isError: true,
       };
     }
@@ -330,19 +361,26 @@ class AssetSearchTool implements Tool {
 
       // Enforce private-thread visibility: filter out attachments that
       // belong exclusively to private threads the caller cannot access.
-      const currentThreadType = getConversationThreadType(context.conversationId);
+      const currentThreadType = getConversationThreadType(
+        context.conversationId,
+      );
       const currentContext: AttachmentContext = {
         conversationId: context.conversationId,
-        isPrivate: currentThreadType === 'private',
+        isPrivate: currentThreadType === "private",
       };
 
       const effectiveLimit = Math.min(limit ?? DEFAULT_LIMIT, MAX_RESULTS);
       const visible = results
-        .filter((attachment) => isAttachmentVisibleFromContext(attachment.id, currentContext))
+        .filter((attachment) =>
+          isAttachmentVisibleFromContext(attachment.id, currentContext),
+        )
         .slice(0, effectiveLimit);
 
       if (visible.length === 0) {
-        return { content: 'No assets found matching the search criteria.', isError: false };
+        return {
+          content: "No assets found matching the search criteria.",
+          isError: false,
+        };
       }
 
       const lines = [`Found ${visible.length} asset(s):\n`];
@@ -350,7 +388,7 @@ class AssetSearchTool implements Tool {
         lines.push(formatAttachment(attachment));
       }
 
-      return { content: lines.join('\n'), isError: false };
+      return { content: lines.join("\n"), isError: false };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       return { content: `Error: ${msg}`, isError: true };

package/src/tools/browser/api-map.ts

@@ -4,14 +4,14 @@
  * calls to the same endpoint are grouped together.
  */
 
-import { mkdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
 
-import { getCliLogger } from '../../util/logger.js';
-import { getDataDir } from '../../util/platform.js';
-import type { NetworkRecordedEntry } from './network-recording-types.js';
+import { getCliLogger } from "../../util/logger.js";
+import { getDataDir } from "../../util/platform.js";
+import type { NetworkRecordedEntry } from "./network-recording-types.js";
 
-const log = getCliLogger('api-map');
+const log = getCliLogger("api-map");
 
 // ---------------------------------------------------------------------------
 // Types
@@ -39,7 +39,8 @@ export interface ApiMapResult {
 // Helpers
 // ---------------------------------------------------------------------------
 
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_RE =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const NUMERIC_RE = /^\d+$/;
 const HEX_HASH_RE = /^[0-9a-f]{8,}$/i;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -73,17 +74,19 @@ function isIdSegment(segment: string): boolean {
 /** Replace ID-like path segments with `{id}`. */
 function normalizePathSegments(pathname: string): string {
   return pathname
-    .split('/')
-    .map((seg) => (isIdSegment(seg) ? '{id}' : seg))
-    .join('/');
+    .split("/")
+    .map((seg) => (isIdSegment(seg) ? "{id}" : seg))
+    .join("/");
 }
 
 /** Safely parse JSON, returning undefined on failure. */
-function tryParseJson(text: string | undefined): Record<string, unknown> | undefined {
+function tryParseJson(
+  text: string | undefined,
+): Record<string, unknown> | undefined {
   if (!text) return undefined;
   try {
     const parsed = JSON.parse(text);
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed as Record<string, unknown>;
     }
   } catch {
@@ -93,17 +96,22 @@ function tryParseJson(text: string | undefined): Record<string, unknown> | undef
 }
 
 /** Extract GraphQL operation name from request body. */
-function extractGraphQLOperationName(postData: string | undefined): string | null {
+function extractGraphQLOperationName(
+  postData: string | undefined,
+): string | null {
   if (!postData) return null;
   const body = tryParseJson(postData);
   if (!body) return null;
-  if (typeof body.operationName === 'string' && body.operationName) return body.operationName;
+  if (typeof body.operationName === "string" && body.operationName)
+    return body.operationName;
   // Try extracting from query string: "query FooBar { ..." or "mutation FooBar { ..."
-  if (typeof body.query === 'string') {
+  if (typeof body.query === "string") {
     const named = body.query.match(/(?:query|mutation|subscription)\s+(\w+)/);
     if (named) return named[1];
     // Unnamed query — extract the first field name: "query{fooBar(" or "query { fooBar {"
-    const firstField = body.query.match(/(?:query|mutation|subscription)\s*\{?\s*(\w+)/);
+    const firstField = body.query.match(
+      /(?:query|mutation|subscription)\s*\{?\s*(\w+)/,
+    );
     if (firstField) return firstField[1];
   }
   return null;
@@ -140,11 +148,12 @@ export function analyzeApiMap(
     }
 
     // Skip non-API noise
-    if (NOISE_PATH_PATTERNS.some(p => p.test(parsed.pathname))) continue;
+    if (NOISE_PATH_PATTERNS.some((p) => p.test(parsed.pathname))) continue;
 
     // Skip non-JSON responses
-    const mimeType = response?.mimeType ?? '';
-    if (response && !mimeType.includes('json') && !mimeType.includes('graphql')) continue;
+    const mimeType = response?.mimeType ?? "";
+    if (response && !mimeType.includes("json") && !mimeType.includes("graphql"))
+      continue;
 
     const method = request.method.toUpperCase();
     const normalizedPath = normalizePathSegments(parsed.pathname);
@@ -152,8 +161,8 @@ export function analyzeApiMap(
 
     // For GraphQL endpoints, split by operation name
     let urlPattern = basePattern;
-    const isGraphQL = normalizedPath.includes('graphql');
-    if (isGraphQL && method === 'POST') {
+    const isGraphQL = normalizedPath.includes("graphql");
+    if (isGraphQL && method === "POST") {
       const opName = extractGraphQLOperationName(request.postData);
       if (opName) {
         urlPattern = `${basePattern} → ${opName}`;
@@ -183,11 +192,11 @@ export function analyzeApiMap(
       group.queryParams.add(paramKey);
     }
 
-    if (['POST', 'PUT', 'PATCH'].includes(method)) {
+    if (["POST", "PUT", "PATCH"].includes(method)) {
       const body = tryParseJson(request.postData);
       if (body) {
         for (const k of Object.keys(body)) {
-          if (k !== 'query' && k !== 'operationName' && k !== 'extensions') {
+          if (k !== "query" && k !== "operationName" && k !== "extensions") {
             group.requestBodyKeys.add(k);
           }
         }
@@ -240,7 +249,7 @@ export function analyzeApiMap(
 // ---------------------------------------------------------------------------
 
 export function saveApiMap(domain: string, result: ApiMapResult): string {
-  const dir = join(getDataDir(), 'api-maps');
+  const dir = join(getDataDir(), "api-maps");
   mkdirSync(dir, { recursive: true });
 
   const timestamp = Date.now();
@@ -254,13 +263,15 @@ export function saveApiMap(domain: string, result: ApiMapResult): string {
 // ---------------------------------------------------------------------------
 
 export function printApiMapTable(result: ApiMapResult): void {
-  const dataEndpoints = result.endpoints.filter(ep => ep.count <= 15);
-  const boilerplate = result.endpoints.filter(ep => ep.count > 15);
+  const dataEndpoints = result.endpoints.filter((ep) => ep.count <= 15);
+  const boilerplate = result.endpoints.filter((ep) => ep.count > 15);
 
-  log.info(`\nAPI Map for ${result.domain} — ${result.endpoints.length} endpoints discovered\n`);
+  log.info(
+    `\nAPI Map for ${result.domain} — ${result.endpoints.length} endpoints discovered\n`,
+  );
 
   const stripDomain = (pattern: string) => {
-    const idx = pattern.indexOf('/');
+    const idx = pattern.indexOf("/");
     return idx >= 0 ? pattern.slice(idx) : pattern;
   };
 
@@ -268,30 +279,35 @@ export function printApiMapTable(result: ApiMapResult): void {
     if (eps.length === 0) return;
     log.info(`  ${title} (${eps.length})\n`);
 
-    const header = ['Method', 'Endpoint', 'Hits', 'Response Keys'];
+    const header = ["Method", "Endpoint", "Hits", "Response Keys"];
     const rows = eps.map((ep) => [
       ep.method,
       stripDomain(ep.urlPattern),
       String(ep.count),
-      ep.responseBodyKeys.slice(0, 5).join(', ') || '-',
+      ep.responseBodyKeys.slice(0, 5).join(", ") || "-",
     ]);
 
     const widths = header.map((h, i) =>
-      Math.min(i === 1 ? 72 : i === 3 ? 50 : 200, Math.max(h.length, ...rows.map((r) => r[i].length))),
+      Math.min(
+        i === 1 ? 72 : i === 3 ? 50 : 200,
+        Math.max(h.length, ...rows.map((r) => r[i].length)),
+      ),
     );
 
-    const sep = widths.map((w) => '-'.repeat(w)).join(' | ');
+    const sep = widths.map((w) => "-".repeat(w)).join(" | ");
     const fmt = (row: string[]) =>
-      row.map((cell, i) => cell.slice(0, widths[i]).padEnd(widths[i])).join(' | ');
+      row
+        .map((cell, i) => cell.slice(0, widths[i]).padEnd(widths[i]))
+        .join(" | ");
 
     log.info(`  ${fmt(header)}`);
     log.info(`  ${sep}`);
     for (const row of rows) {
       log.info(`  ${fmt(row)}`);
     }
-    log.info('');
+    log.info("");
   };
 
-  printSection('DATA ENDPOINTS', dataEndpoints);
-  printSection('PAGE-LOAD BOILERPLATE', boilerplate);
+  printSection("DATA ENDPOINTS", dataEndpoints);
+  printSection("PAGE-LOAD BOILERPLATE", boilerplate);
 }