libretto 0.5.0 → 0.5.1

package/dist/cli/commands/snapshot.js

@@ -5,16 +5,10 @@ import { getSessionSnapshotRunDir } from "../core/context.js";
 import { condenseDom } from "../../shared/condense-dom/condense-dom.js";
 import { readSessionState } from "../core/session.js";
 import { SimpleCLI } from "../framework/simple-cli.js";
-import {
-  loadSessionStateMiddleware,
-  pageOption,
-  resolveSessionMiddleware,
-  sessionOption
-} from "./shared.js";
+import { pageOption, sessionOption, withRequiredSession } from "./shared.js";
 import { runApiInterpret } from "../core/api-snapshot-analyzer.js";
 import { readAiConfig } from "../core/ai-config.js";
 import { resolveSnapshotApiModelOrThrow } from "../core/snapshot-api-config.js";
-const DEFAULT_SNAPSHOT_CONTEXT = "No additional user context provided.";
 const FALLBACK_SNAPSHOT_VIEWPORT = { width: 1280, height: 800 };
 function generateSnapshotRunId() {
   return `snapshot-${Date.now()}`;
@@ -106,6 +100,12 @@ async function captureScreenshot(session, logger, pageId) {
     const pngPath = `${snapshotRunDir}/page.png`;
     const htmlPath = `${snapshotRunDir}/page.html`;
     const condensedHtmlPath = `${snapshotRunDir}/page.condensed.html`;
+    const RENDER_SETTLE_TIMEOUT_MS = 1e4;
+    await Promise.race([
+      page.waitForLoadState("networkidle").catch(() => {
+      }),
+      new Promise((resolve) => setTimeout(resolve, RENDER_SETTLE_TIMEOUT_MS))
+    ]);
     const restoreViewport = resolveSnapshotViewport(session, logger);
     const viewportMetrics = await readSnapshotViewportMetrics(page);
     logger.info("screenshot-viewport-metrics", {
@@ -185,17 +185,10 @@ async function captureScreenshot(session, logger, pageId) {
   }
 }
 async function runSnapshot(session, logger, pageId, objective, context) {
-  const normalizedObjective = objective?.trim();
-  const normalizedContext = context?.trim();
-  if (!normalizedObjective && normalizedContext) {
-    throw new Error(
-      "Couldn't run analysis: --objective is required when providing --context."
-    );
-  }
-  const configuredAi = normalizedObjective ? readAiConfig() : null;
-  if (normalizedObjective) {
-    resolveSnapshotApiModelOrThrow(configuredAi);
-  }
+  const normalizedObjective = objective.trim();
+  const normalizedContext = context.trim();
+  const configuredAi = readAiConfig();
+  resolveSnapshotApiModelOrThrow(configuredAi);
   const { pngPath, htmlPath, condensedHtmlPath } = await captureScreenshot(
     session,
     logger,
@@ -205,14 +198,10 @@ async function runSnapshot(session, logger, pageId, objective, context) {
   console.log(`  PNG:             ${pngPath}`);
   console.log(`  HTML:            ${htmlPath}`);
   console.log(`  Condensed HTML:  ${condensedHtmlPath}`);
-  if (!normalizedObjective) {
-    console.log("Use --objective flag to analyze snapshots.");
-    return;
-  }
   const interpretArgs = {
     objective: normalizedObjective,
     session,
-    context: normalizedContext ?? DEFAULT_SNAPSHOT_CONTEXT,
+    context: normalizedContext,
     pngPath,
     htmlPath,
     condensedHtmlPath
@@ -224,24 +213,22 @@ const snapshotInput = SimpleCLI.input({
   named: {
     session: sessionOption(),
     page: pageOption(),
-    objective: SimpleCLI.option(z.string().optional()),
-    context: SimpleCLI.option(z.string().optional())
+    objective: SimpleCLI.option(z.string()),
+    context: SimpleCLI.option(z.string())
   }
 });
-function createSnapshotCommand(logger) {
-  return SimpleCLI.command({
-    description: "Capture PNG + HTML; analyze when --objective is provided (--context optional)"
-  }).input(snapshotInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
-    await runSnapshot(
-      ctx.session,
-      logger,
-      input.page,
-      input.objective,
-      input.context
-    );
-  });
-}
+const snapshotCommand = SimpleCLI.command({
+  description: "Capture PNG + HTML and analyze with --objective and --context"
+}).input(snapshotInput).use(withRequiredSession()).handle(async ({ input, ctx }) => {
+  await runSnapshot(
+    ctx.session,
+    ctx.logger,
+    input.page,
+    input.objective,
+    input.context
+  );
+});
 export {
-  createSnapshotCommand,
+  snapshotCommand,
   snapshotInput
 };

package/dist/cli/core/ai-config.js

@@ -26,7 +26,12 @@ const PROVIDER_ALIASES = {
   claude: DEFAULT_MODELS.anthropic,
   google: DEFAULT_MODELS.gemini
 };
-const CONFIGURE_PROVIDERS = ["openai", "anthropic", "gemini", "vertex"];
+const CONFIGURE_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "gemini",
+  "vertex"
+];
 function formatConfigureProviders(separator = " | ") {
   return CONFIGURE_PROVIDERS.join(separator);
 }
@@ -147,7 +152,9 @@ function runAiConfigure(input, options = {}) {
       console.log(
         `No AI config set. Choose a default model: ${configureCommandName} ${formatConfigureProviders()}`
       );
-      console.log("Provider credentials still come from your shell or .env file.");
+      console.log(
+        "Provider credentials still come from your shell or .env file."
+      );
       return;
     }
     printAiConfig(config2, configPath);

package/dist/cli/core/api-snapshot-analyzer.js

@@ -1,16 +1,13 @@
 import { readFileSync } from "node:fs";
 import { createLLMClient } from "../../shared/llm/client.js";
 import {
-  formatInterpretationOutput,
   InterpretResultSchema,
   buildInlinePromptSelection,
   getMimeType,
   readFileAsBase64
 } from "./snapshot-analyzer.js";
 import { readAiConfig } from "./ai-config.js";
-import {
-  resolveSnapshotApiModelOrThrow
-} from "./snapshot-api-config.js";
+import { resolveSnapshotApiModelOrThrow } from "./snapshot-api-config.js";
 async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
   const selection = resolveSnapshotApiModelOrThrow(configuredAi);
   logger.info("api-interpret-start", {
@@ -67,7 +64,20 @@ async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
     selectorCount: parsed.selectors.length,
     answer: parsed.answer.slice(0, 200)
   });
-  console.log(formatInterpretationOutput(parsed, "Interpretation (via API):"));
+  console.log("");
+  console.log("Analysis:");
+  console.log(parsed.answer);
+  if (parsed.selectors.length > 0) {
+    console.log("");
+    console.log("Selectors:");
+    parsed.selectors.forEach((selector, index) => {
+      console.log(`  ${index + 1}. ${selector.label}: ${selector.selector}`);
+    });
+  }
+  if (parsed.notes?.trim()) {
+    console.log("");
+    console.log(`Notes: ${parsed.notes.trim()}`);
+  }
 }
 export {
   runApiInterpret

package/dist/cli/core/browser.js

@@ -1,4 +1,6 @@
-import { chromium } from "playwright";
+import {
+  chromium
+} from "playwright";
 import { openSync, existsSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -57,9 +59,8 @@ function getProfilePath(domain) {
 function hasProfile(domain) {
   return existsSync(getProfilePath(domain));
 }
-async function tryConnectToPort(port, logger, timeoutMs = 5e3) {
-  const endpoint = `http://localhost:${port}`;
-  logger.info("cdp-connect-attempt", { port, endpoint, timeoutMs });
+async function tryConnectToCDP(endpoint, logger, timeoutMs = 5e3) {
+  logger.info("cdp-connect-attempt", { endpoint, timeoutMs });
   try {
     const connectPromise = chromium.connectOverCDP(endpoint);
     const timeoutPromise = new Promise(
@@ -68,16 +69,15 @@ async function tryConnectToPort(port, logger, timeoutMs = 5e3) {
     const browser = await Promise.race([connectPromise, timeoutPromise]);
     if (browser) {
       logger.info("cdp-connect-success", {
-        port,
         endpoint,
         contexts: browser.contexts().length
       });
     } else {
-      logger.warn("cdp-connect-timeout", { port, endpoint, timeoutMs });
+      logger.warn("cdp-connect-timeout", { endpoint, timeoutMs });
     }
     return browser;
   } catch (err) {
-    logger.error("cdp-connect-error", { error: err, port, endpoint });
+    logger.error("cdp-connect-error", { error: err, endpoint });
     return null;
   }
 }
@@ -102,7 +102,9 @@ async function resolvePageId(page) {
     const targetInfo = await cdpSession.send("Target.getTargetInfo");
     const targetId = targetInfo?.targetInfo?.targetId;
     if (typeof targetId !== "string" || targetId.length === 0) {
-      throw new Error(`Could not resolve target id for page at URL "${page.url()}".`);
+      throw new Error(
+        `Could not resolve target id for page at URL "${page.url()}".`
+      );
     }
     return targetId;
   } finally {
@@ -135,21 +137,22 @@ async function listOpenPages(session, logger) {
 async function connect(session, logger, timeoutMs = 1e4, options) {
   logger.info("connect", { session, timeoutMs });
   const state = readSessionStateOrThrow(session);
-  const browser = await tryConnectToPort(state.port, logger, timeoutMs);
+  const endpoint = state.cdpEndpoint ?? `http://localhost:${state.port}`;
+  const browser = await tryConnectToCDP(endpoint, logger, timeoutMs);
   if (!browser) {
     logger.error("connect-no-browser", {
       session,
-      port: state.port,
+      endpoint,
       pid: state.pid
     });
-    if (!isPidRunning(state.pid)) {
+    if (state.pid == null || !isPidRunning(state.pid)) {
       clearSessionState(session, logger);
       throw new Error(
         `No browser running for session "${session}". Run 'libretto open <url> --session ${session}' first.`
       );
     }
     throw new Error(
-      `Could not connect to the browser for session "${session}" at http://127.0.0.1:${state.port}, but the session process (pid ${state.pid}) is still running. Try the command again, or close and reopen the session if it stays stuck.`
+      `Could not connect to the browser for session "${session}" at ${endpoint}, but the session process (pid ${state.pid}) is still running. Try the command again, or close and reopen the session if it stays stuck.`
     );
   }
   const contexts = browser.contexts();
@@ -230,10 +233,16 @@ function resolveViewport(cliViewport, logger) {
   }
   const config = readLibrettoConfig();
   if (config.viewport) {
-    logger.info("viewport-source", { source: "config", viewport: config.viewport });
+    logger.info("viewport-source", {
+      source: "config",
+      viewport: config.viewport
+    });
     return config.viewport;
   }
-  logger.info("viewport-source", { source: "default", viewport: DEFAULT_VIEWPORT });
+  logger.info("viewport-source", {
+    source: "default",
+    viewport: DEFAULT_VIEWPORT
+  });
   return DEFAULT_VIEWPORT;
 }
 async function runOpen(rawUrl, headed, session, logger, options) {
@@ -414,14 +423,17 @@ await new Promise(() => {});
       logger.info("open-waiting-for-cdp", { attempt: i, port, session });
     }
     if (ready) {
-      writeSessionState({
-        port,
-        pid: child.pid,
-        session,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "active",
-        viewport
-      }, logger);
+      writeSessionState(
+        {
+          port,
+          pid: child.pid,
+          session,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "active",
+          viewport
+        },
+        logger
+      );
       logger.info("open-success", {
         url,
         mode: browserMode,
@@ -517,8 +529,10 @@ async function runClose(session, logger) {
     return;
   }
   logger.info("close-killing", { session, pid: state.pid, port: state.port });
-  sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
-  await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  if (state.pid != null) {
+    sendSignalToProcessGroupOrPid(state.pid, "SIGTERM", logger, session);
+    await waitForCloseSignalWindow(CLOSE_WAIT_MS);
+  }
   clearSessionState(session, logger);
   logger.info("close-success", { session });
   console.log(`Browser closed (session: ${session}).`);
@@ -575,7 +589,7 @@ function resolveClosableSessions(logger) {
 function clearStoppedSessionStates(sessions, logger) {
   let cleared = 0;
   for (const session of sessions) {
-    if (!isPidRunning(session.pid)) {
+    if (session.pid == null || !isPidRunning(session.pid)) {
       clearSessionState(session.session, logger);
       cleared += 1;
     }
@@ -601,10 +615,19 @@ async function runCloseAll(logger, options) {
       pid: target.pid,
       port: target.port
     });
-    sendSignalToProcessGroupOrPid(target.pid, "SIGTERM", logger, target.session);
+    if (target.pid != null) {
+      sendSignalToProcessGroupOrPid(
+        target.pid,
+        "SIGTERM",
+        logger,
+        target.session
+      );
+    }
   }
   await waitForCloseSignalWindow(CLOSE_WAIT_MS);
-  let survivors = closable.filter((target) => isPidRunning(target.pid));
+  let survivors = closable.filter(
+    (target) => target.pid != null && isPidRunning(target.pid)
+  );
   if (survivors.length > 0 && !force) {
     const closed = clearStoppedSessionStates(closable, logger);
     throw new Error(
@@ -622,11 +645,20 @@ async function runCloseAll(logger, options) {
         session: survivor.session,
         pid: survivor.pid
       });
-      sendSignalToProcessGroupOrPid(survivor.pid, "SIGKILL", logger, survivor.session);
+      if (survivor.pid != null) {
+        sendSignalToProcessGroupOrPid(
+          survivor.pid,
+          "SIGKILL",
+          logger,
+          survivor.session
+        );
+      }
       forceKilled += 1;
     }
     await waitForCloseSignalWindow(FORCE_CLOSE_WAIT_MS);
-    survivors = survivors.filter((target) => isPidRunning(target.pid));
+    survivors = survivors.filter(
+      (target) => target.pid != null && isPidRunning(target.pid)
+    );
     if (survivors.length > 0) {
       const closed = clearStoppedSessionStates(closable, logger);
       throw new Error(
@@ -648,6 +680,75 @@ async function runCloseAll(logger, options) {
     console.log(`Force-killed ${forceKilled} session(s).`);
   }
 }
+async function runConnect(cdpUrl, session, logger) {
+  logger.info("connect-start", { cdpUrl, session });
+  assertSessionAvailableForStart(session, logger);
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(cdpUrl);
+  } catch {
+    throw new Error(
+      [
+        `Invalid CDP URL: ${cdpUrl}`,
+        ``,
+        `Expected an HTTP URL pointing to a Chrome DevTools Protocol endpoint, for example:`,
+        `  libretto connect http://127.0.0.1:9222`,
+        `  libretto connect http://remote-host:9222`,
+        `  libretto connect http://remote-host:9222/devtools/browser/<id>`
+      ].join("\n")
+    );
+  }
+  const endpoint = parsedUrl.href;
+  const port = parsedUrl.port ? Number(parsedUrl.port) : parsedUrl.protocol === "https:" ? 443 : 80;
+  console.log(
+    `Connecting to CDP endpoint at ${endpoint} (session: ${session})...`
+  );
+  const versionUrl = `${parsedUrl.protocol}//${parsedUrl.host}/json/version`;
+  try {
+    const resp = await fetch(versionUrl);
+    const versionInfo = await resp.json();
+    logger.info("connect-version-ok", { versionUrl, versionInfo });
+  } catch (err) {
+    logger.error("connect-version-failed", { versionUrl, error: err });
+    throw new Error(
+      `Cannot reach CDP endpoint at ${versionUrl}. Make sure the target is running and accessible at ${parsedUrl.host}.`
+    );
+  }
+  const browser = await tryConnectToCDP(endpoint, logger, 1e4);
+  if (!browser) {
+    throw new Error(
+      `CDP endpoint at ${endpoint} is reachable but Playwright could not connect. Check that the URL is a Chrome DevTools Protocol endpoint.`
+    );
+  }
+  const pages = resolveOperationalPages(browser);
+  logger.info("connect-pages", {
+    session,
+    pageCount: pages.length,
+    urls: pages.map((p) => p.url())
+  });
+  disconnectBrowser(browser, logger, session);
+  writeSessionState(
+    {
+      port,
+      cdpEndpoint: endpoint,
+      session,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "active"
+    },
+    logger
+  );
+  logger.info("connect-success", { cdpUrl: endpoint, session, port });
+  console.log(`Connected to ${endpoint} (session: ${session})`);
+  console.log(`  Pages found: ${pages.length}`);
+  if (pages.length > 0) {
+    for (const p of pages.slice(0, 5)) {
+      console.log(`    ${p.url()}`);
+    }
+    if (pages.length > 5) {
+      console.log(`    ... and ${pages.length - 5} more`);
+    }
+  }
+}
 function resolvePath(filePath) {
   return join(process.cwd(), filePath);
 }
@@ -666,8 +767,10 @@ export {
   normalizeDomain,
   normalizeUrl,
   resolvePath,
+  resolveViewport,
   runClose,
   runCloseAll,
+  runConnect,
   runOpen,
   runPages,
   runSave

package/dist/cli/core/context.js

@@ -49,7 +49,10 @@ function createLoggerForSession(session) {
   const sessionDir = getSessionDir(session);
   mkdirSync(sessionDir, { recursive: true });
   const logFilePath = getSessionLogsPath(session);
-  return new Logger(["libretto"], [createFileLogSink({ filePath: logFilePath })]);
+  return new Logger(
+    ["libretto"],
+    [createFileLogSink({ filePath: logFilePath })]
+  );
 }
 async function closeLogger(logger) {
   if (!logger) return;

package/dist/cli/core/session-telemetry.js

@@ -12,7 +12,9 @@ async function installSessionTelemetry(options) {
       const targetInfo = await cdpSession.send("Target.getTargetInfo");
       const targetId = targetInfo?.targetInfo?.targetId;
       if (typeof targetId !== "string" || targetId.length === 0) {
-        throw new Error(`Could not resolve target id for page at URL "${page.url()}".`);
+        throw new Error(
+          `Could not resolve target id for page at URL "${page.url()}".`
+        );
       }
       pageIdCache.set(page, targetId);
       return targetId;
@@ -439,7 +441,8 @@ async function installSessionTelemetry(options) {
     page.on("response", async (response) => {
       const request = response.request();
       const url = request.url();
-      if (STATIC_EXT_RE.test(url) || url.startsWith("chrome-extension://")) return;
+      if (STATIC_EXT_RE.test(url) || url.startsWith("chrome-extension://"))
+        return;
       emitNetwork({
         pageId,
         method: request.method(),

package/dist/cli/core/session.js

@@ -18,9 +18,16 @@ import {
   serializeSessionState
 } from "../../shared/state/index.js";
 const SESSION_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
-const SESSION_DEFAULT = "default";
 const SESSION_DEV_SERVER = "dev-server";
 const SESSION_BROWSER_AGENT = "browser-agent";
+function generateSessionName() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 4; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `ses-${id}`;
+}
 function logFileForSession(session) {
   validateSessionName(session);
   const dir = getSessionDir(session);
@@ -108,7 +115,10 @@ function readSessionStateOrThrow(session) {
     throwSessionNotFoundError(session);
   }
   try {
-    return parseSessionStateContent(readFileSync(stateFile, "utf-8"), stateFile);
+    return parseSessionStateContent(
+      readFileSync(stateFile, "utf-8"),
+      stateFile
+    );
   } catch (err) {
     throw new Error(
       `Could not read session state for "${session}": ${err instanceof Error ? err.message : String(err)}`
@@ -147,15 +157,18 @@ function setSessionStatus(session, status, logger) {
   const state = readSessionState(session, logger);
   if (!state) return;
   if (state.status === status) return;
-  writeSessionState({
-    ...state,
-    status
-  }, logger);
+  writeSessionState(
+    {
+      ...state,
+      status
+    },
+    logger
+  );
 }
 function assertSessionAvailableForStart(session, logger) {
   const existingState = readSessionState(session, logger);
   if (!existingState) return;
-  if (!isPidRunning(existingState.pid)) {
+  if (existingState.pid == null || !isPidRunning(existingState.pid)) {
     setSessionStatus(session, "exited", logger);
     return;
   }
@@ -166,12 +179,12 @@ function assertSessionAvailableForStart(session, logger) {
 }
 export {
   SESSION_BROWSER_AGENT,
-  SESSION_DEFAULT,
   SESSION_DEV_SERVER,
   SESSION_STATE_VERSION,
   assertSessionAvailableForStart,
   assertSessionStateExistsOrThrow,
   clearSessionState,
+  generateSessionName,
   getStateFilePath,
   listSessionsWithStateFile,
   logFileForSession,

package/dist/cli/core/snapshot-analyzer.js

@@ -1,9 +1,4 @@
-import {
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync
-} from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { extname, isAbsolute, join, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -60,7 +55,12 @@ Screenshot file path: ${pngPath}
 Use the screenshot alongside the HTML snapshot context above.`;
   }
   async runAnalyzer(args, logger, stdinText) {
-    const result = await runExternalCommand(this.command, args, logger, stdinText);
+    const result = await runExternalCommand(
+      this.command,
+      args,
+      logger,
+      stdinText
+    );
     if (result.exitCode !== 0) {
       throw new Error(
         `Analyzer command failed (${[this.command, ...args].join(" ")}).
@@ -535,7 +535,9 @@ function buildInlinePromptSelection(args, fullHtmlContent, condensedHtmlContent,
     fullDomChars: fullHtmlContent.length,
     fullDomEstimatedTokens: estimateTokensFromChars(fullHtmlContent.length),
     condensedDomChars: condensedHtmlContent.length,
-    condensedDomEstimatedTokens: estimateTokensFromChars(condensedHtmlContent.length),
+    condensedDomEstimatedTokens: estimateTokensFromChars(
+      condensedHtmlContent.length
+    ),
     configuredModel: model
   };
   const buildCandidate = (domSource, htmlContent, selectionReason, truncated) => {
@@ -607,7 +609,10 @@ function buildInlinePromptSelection(args, fullHtmlContent, condensedHtmlContent,
     2e3,
     budget.promptBudgetTokens - estimateTokensFromChars(basePrompt.length)
   );
-  const truncatedHtml = truncateText(condensedHtmlContent, availableHtmlTokens * 4);
+  const truncatedHtml = truncateText(
+    condensedHtmlContent,
+    availableHtmlTokens * 4
+  );
   return buildCandidate(
     "condensed",
     truncatedHtml.text,
@@ -615,27 +620,6 @@ function buildInlinePromptSelection(args, fullHtmlContent, condensedHtmlContent,
     truncatedHtml.truncated
   );
 }
-function formatInterpretationOutput(parsed, header = "Interpretation:") {
-  const outputLines = [];
-  outputLines.push(header);
-  outputLines.push(`Answer: ${parsed.answer}`);
-  outputLines.push("");
-  if (parsed.selectors.length === 0) {
-    outputLines.push("Selectors: none found.");
-  } else {
-    outputLines.push("Selectors:");
-    parsed.selectors.forEach((selector, index) => {
-      outputLines.push(`  ${index + 1}. ${selector.label}`);
-      outputLines.push(`     selector: ${selector.selector}`);
-      outputLines.push(`     rationale: ${selector.rationale}`);
-    });
-  }
-  if (parsed.notes && parsed.notes.trim()) {
-    outputLines.push("");
-    outputLines.push(`Notes: ${parsed.notes.trim()}`);
-  }
-  return outputLines.join("\n");
-}
 async function runInterpret(args, logger) {
   logger.info("interpret-start", {
     objective: args.objective,
@@ -676,7 +660,6 @@ export {
   InterpretResultSchema,
   buildInlinePromptSelection,
   canAnalyzeSnapshots,
-  formatInterpretationOutput,
   getMimeType,
   readFileAsBase64,
   runInterpret

package/dist/cli/core/snapshot-api-config.js

@@ -1,8 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import {
-  readAiConfig
-} from "./ai-config.js";
+import { readAiConfig } from "./ai-config.js";
 import { LIBRETTO_CONFIG_PATH, REPO_ROOT } from "./context.js";
 import {
   hasProviderCredentials,
@@ -154,9 +152,7 @@ function resolveSnapshotApiModel(config = readAiConfig()) {
 function resolveSnapshotApiModelOrThrow(config = readAiConfig()) {
   const selection = resolveSnapshotApiModel(config);
   if (!selection) {
-    throw new SnapshotApiUnavailableError(
-      noSnapshotApiConfiguredMessage()
-    );
+    throw new SnapshotApiUnavailableError(noSnapshotApiConfiguredMessage());
   }
   if (!hasProviderCredentials(selection.provider)) {
     throw new SnapshotApiUnavailableError(

package/dist/cli/core/telemetry.js

@@ -1,4 +1,9 @@
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  appendFileSync,
+  existsSync,
+  readFileSync,
+  writeFileSync
+} from "node:fs";
 import {
   getSessionActionsLogPath,
   getSessionNetworkLogPath
@@ -56,7 +61,10 @@ function clearNetworkLog(session) {
 function parentLogAction(session, entry) {
   try {
     const record = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry };
-    appendFileSync(getSessionActionsLogPath(session), JSON.stringify(record) + "\n");
+    appendFileSync(
+      getSessionActionsLogPath(session),
+      JSON.stringify(record) + "\n"
+    );
   } catch {
   }
 }