libretto 0.5.0 → 0.5.1

package/src/cli/core/browser.ts

@@ -1,4 +1,10 @@
-import { chromium, type Browser, type BrowserContext, type CDPSession, type Page } from "playwright";
+import {
+  chromium,
+  type Browser,
+  type BrowserContext,
+  type CDPSession,
+  type Page,
+} from "playwright";
 import { openSync, existsSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -66,13 +72,12 @@ export function hasProfile(domain: string): boolean {
   return existsSync(getProfilePath(domain));
 }
 
-async function tryConnectToPort(
-  port: number,
+async function tryConnectToCDP(
+  endpoint: string,
   logger: LoggerApi,
   timeoutMs: number = 5000,
 ): Promise<Browser | null> {
-  const endpoint = `http://localhost:${port}`;
-  logger.info("cdp-connect-attempt", { port, endpoint, timeoutMs });
+  logger.info("cdp-connect-attempt", { endpoint, timeoutMs });
   try {
     const connectPromise = chromium.connectOverCDP(endpoint);
     const timeoutPromise = new Promise<null>((resolve) =>
@@ -81,16 +86,15 @@ async function tryConnectToPort(
     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;
   }
 }
@@ -135,10 +139,12 @@ async function resolvePageId(page: Page): Promise<string> {
   const cdpSession: CDPSession = await page.context().newCDPSession(page);
   try {
     const targetInfo = await cdpSession.send("Target.getTargetInfo");
-    const targetId = (targetInfo as { targetInfo?: { targetId?: unknown } })?.targetInfo
-      ?.targetId;
+    const targetId = (targetInfo as { targetInfo?: { targetId?: unknown } })
+      ?.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 {
@@ -162,7 +168,10 @@ export async function listOpenPages(
 ): Promise<OpenPageSummary[]> {
   const { browser, page: activePage } = await connect(session, logger);
   try {
-    const pages = browser.contexts().flatMap((ctx) => ctx.pages()).filter(isOperationalPage);
+    const pages = browser
+      .contexts()
+      .flatMap((ctx) => ctx.pages())
+      .filter(isOperationalPage);
     const pageRefs = await resolvePageReferences(pages);
     return pageRefs.map(({ id, page }) => ({
       id,
@@ -190,14 +199,15 @@ export async function connect(
 }> {
   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.`,
@@ -205,7 +215,7 @@ export async function connect(
     }
 
     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.`,
     );
   }
 
@@ -276,7 +286,10 @@ export async function connect(
   return { browser, context, page, pageId: pageRef.id };
 }
 
-export async function runPages(session: string, logger: LoggerApi): Promise<void> {
+export async function runPages(
+  session: string,
+  logger: LoggerApi,
+): Promise<void> {
   logger.info("pages-start", { session });
   const pageSummaries = await listOpenPages(session, logger);
 
@@ -294,7 +307,7 @@ export async function runPages(session: string, logger: LoggerApi): Promise<void
 
 const DEFAULT_VIEWPORT = { width: 1366, height: 768 } as const;
 
-function resolveViewport(
+export function resolveViewport(
   cliViewport: { width: number; height: number } | undefined,
   logger: LoggerApi,
 ): { width: number; height: number } {
@@ -304,10 +317,16 @@ function resolveViewport(
   }
   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;
 }
 
@@ -474,8 +493,10 @@ await new Promise(() => {});
   logger.info("open-child-spawned", { pid: child.pid, port, session });
 
   let childSpawnError: Error | null = null;
-  let childEarlyExit: { code: number | null; signal: NodeJS.Signals | null } | null =
-    null;
+  let childEarlyExit: {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+  } | null = null;
 
   child.on("error", (err) => {
     childSpawnError = err;
@@ -529,14 +550,17 @@ await new Promise(() => {});
       logger.info("open-waiting-for-cdp", { attempt: i, port, session });
     }
     if (ready) {
-      writeSessionState({
-        port,
-        pid: child.pid!,
-        session,
-        startedAt: new Date().toISOString(),
-        status: "active",
-        viewport,
-      }, logger);
+      writeSessionState(
+        {
+          port,
+          pid: child.pid!,
+          session,
+          startedAt: new Date().toISOString(),
+          status: "active",
+          viewport,
+        },
+        logger,
+      );
       logger.info("open-success", {
         url,
         mode: browserMode,
@@ -644,7 +668,10 @@ export async function runSave(
   }
 }
 
-export async function runClose(session: string, logger: LoggerApi): Promise<void> {
+export async function runClose(
+  session: string,
+  logger: LoggerApi,
+): Promise<void> {
   logger.info("close-start", { session });
   const state = readSessionState(session, logger);
   if (!state) {
@@ -655,9 +682,10 @@ export async function runClose(session: string, logger: LoggerApi): Promise<void
 
   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 });
@@ -666,7 +694,7 @@ export async function runClose(session: string, logger: LoggerApi): Promise<void
 
 type ClosableSession = {
   session: string;
-  pid: number;
+  pid?: number;
   port: number;
 };
 
@@ -705,7 +733,9 @@ function sendSignalToProcessGroupOrPid(
   }
 }
 
-function formatSessionList(targets: ReadonlyArray<{ session: string }>): string {
+function formatSessionList(
+  targets: ReadonlyArray<{ session: string }>,
+): string {
   return targets.map((target) => `"${target.session}"`).join(", ");
 }
 
@@ -739,7 +769,7 @@ function clearStoppedSessionStates(
 ): number {
   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;
     }
@@ -770,12 +800,21 @@ export async function runCloseAll(
       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);
 
@@ -795,11 +834,20 @@ export async function runCloseAll(
         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(
@@ -824,6 +872,95 @@ export async function runCloseAll(
   }
 }
 
+export async function runConnect(
+  cdpUrl: string,
+  session: string,
+  logger: LoggerApi,
+): Promise<void> {
+  logger.info("connect-start", { cdpUrl, session });
+  assertSessionAvailableForStart(session, logger);
+
+  let parsedUrl: URL;
+  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})...`,
+  );
+
+  // Verify the CDP endpoint is reachable
+  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}.`,
+    );
+  }
+
+  // Connect via CDP using the full endpoint URL
+  const browser = await tryConnectToCDP(endpoint, logger, 10_000);
+  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: 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`);
+    }
+  }
+}
+
 export function resolvePath(filePath: string): string {
   return join(process.cwd(), filePath);
 }

package/src/cli/core/context.ts

@@ -66,10 +66,15 @@ export function createLoggerForSession(session: string): Logger {
   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 })],
+  );
 }
 
-export async function closeLogger(logger: Logger | null | undefined): Promise<void> {
+export async function closeLogger(
+  logger: Logger | null | undefined,
+): Promise<void> {
   if (!logger) return;
   await logger.close();
 }

package/src/cli/core/session-telemetry.ts

@@ -13,7 +13,8 @@ type InstallSessionTelemetryOptions = {
 export async function installSessionTelemetry(
   options: InstallSessionTelemetryOptions,
 ): Promise<void> {
-  const STATIC_EXT_RE = /\.(css|js|png|jpg|jpeg|gif|woff|woff2|ttf|ico|svg)(\?|$)/i;
+  const STATIC_EXT_RE =
+    /\.(css|js|png|jpg|jpeg|gif|woff|woff2|ttf|ico|svg)(\?|$)/i;
   const { context, initialPage, logAction, logNetwork } = options;
   const includeUserDomActions = options.includeUserDomActions ?? false;
   const pageIdCache = new WeakMap<Page, string>();
@@ -25,10 +26,12 @@ export async function installSessionTelemetry(
     const cdpSession = await context.newCDPSession(page);
     try {
       const targetInfo = await cdpSession.send("Target.getTargetInfo");
-      const targetId = (targetInfo as { targetInfo?: { targetId?: unknown } })?.targetInfo
-        ?.targetId;
+      const targetId = (targetInfo as { targetInfo?: { targetId?: unknown } })
+        ?.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;
@@ -51,7 +54,10 @@ export async function installSessionTelemetry(
     });
   };
 
-  const markApiActionInProgress = async (page: Page, inProgress: boolean): Promise<void> => {
+  const markApiActionInProgress = async (
+    page: Page,
+    inProgress: boolean,
+  ): Promise<void> => {
     await page.evaluate((flag) => {
       (window as any).__btApiActionInProgress = flag;
     }, inProgress);
@@ -180,7 +186,10 @@ export async function installSessionTelemetry(
     return locator;
   };
 
-  const installUserDomTracking = async (page: Page, pageId: string): Promise<void> => {
+  const installUserDomTracking = async (
+    page: Page,
+    pageId: string,
+  ): Promise<void> => {
     if (exposedPages.has(page)) return;
     exposedPages.add(page);
 
@@ -425,7 +434,8 @@ export async function installSessionTelemetry(
             action: method,
             source: "agent",
             selector: typeof args[0] === "string" ? args[0] : undefined,
-            value: args[1] !== undefined ? String(args[1]).slice(0, 100) : undefined,
+            value:
+              args[1] !== undefined ? String(args[1]).slice(0, 100) : undefined,
             duration: Date.now() - start,
             success: true,
           });
@@ -497,7 +507,8 @@ export async function installSessionTelemetry(
     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/src/cli/core/session.ts

@@ -23,9 +23,17 @@ import {
 
 const SESSION_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
 
-export const SESSION_DEFAULT = "default";
 export const SESSION_DEV_SERVER = "dev-server";
 export const SESSION_BROWSER_AGENT = "browser-agent";
+
+export function generateSessionName(): string {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 4; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `ses-${id}`;
+}
 export { SESSION_STATE_VERSION };
 export type { SessionStatus, SessionState };
 
@@ -136,7 +144,10 @@ export function readSessionStateOrThrow(session: string): SessionState {
   }
 
   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)}`,
@@ -186,10 +197,13 @@ export function setSessionStatus(
   const state = readSessionState(session, logger);
   if (!state) return;
   if (state.status === status) return;
-  writeSessionState({
-    ...state,
-    status,
-  }, logger);
+  writeSessionState(
+    {
+      ...state,
+      status,
+    },
+    logger,
+  );
 }
 
 export function assertSessionAvailableForStart(
@@ -198,7 +212,7 @@ export function assertSessionAvailableForStart(
 ): void {
   const existingState = readSessionState(session, logger);
   if (!existingState) return;
-  if (!isPidRunning(existingState.pid)) {
+  if (existingState.pid == null || !isPidRunning(existingState.pid)) {
     setSessionStatus(session, "exited", logger);
     return;
   }

package/src/cli/core/snapshot-analyzer.ts

@@ -8,15 +8,10 @@
  * to the CLI-agent approach if needed.
  *
  * Shared types and utilities (InterpretResultSchema, buildInlinePromptSelection,
- * formatInterpretationOutput, etc.) are still actively used by the API analyzer.
+ * etc.) are still actively used by the API analyzer.
  */
 
-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";
@@ -147,7 +142,12 @@ abstract class UserCodingAgent {
     logger: LoggerApi,
     stdinText?: string,
   ): Promise<ExternalCommandResult> {
-    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(" ")}).\n${stripAnsi(result.stderr).trim() || stripAnsi(result.stdout).trim() || "No error output."}`,
@@ -586,17 +586,18 @@ function estimateTokensFromChars(chars: number): number {
   return Math.ceil(chars / 4);
 }
 
-function inferContextWindowTokens(
-  model: string,
-): { contextWindowTokens: number; source: string } {
+function inferContextWindowTokens(model: string): {
+  contextWindowTokens: number;
+  source: string;
+} {
   const normalized = model.trim().toLowerCase();
   if (normalized.includes("claude")) {
     return { contextWindowTokens: 200_000, source: "model:claude" };
   }
   if (
-    normalized.includes("gpt-5")
-    || normalized.includes("o3")
-    || normalized.includes("o4")
+    normalized.includes("gpt-5") ||
+    normalized.includes("o3") ||
+    normalized.includes("o4")
   ) {
     return { contextWindowTokens: 200_000, source: "model:openai" };
   }
@@ -699,7 +700,9 @@ export function buildInlinePromptSelection(
     fullDomChars: fullHtmlContent.length,
     fullDomEstimatedTokens: estimateTokensFromChars(fullHtmlContent.length),
     condensedDomChars: condensedHtmlContent.length,
-    condensedDomEstimatedTokens: estimateTokensFromChars(condensedHtmlContent.length),
+    condensedDomEstimatedTokens: estimateTokensFromChars(
+      condensedHtmlContent.length,
+    ),
     configuredModel: model,
   };
 
@@ -740,8 +743,7 @@ export function buildInlinePromptSelection(
     false,
   );
   if (fullCandidate.promptEstimatedTokens <= budget.promptBudgetTokens) {
-    const selectionReason =
-      `Full DOM fits within the estimated prompt budget (~${fullCandidate.promptEstimatedTokens.toLocaleString()} <= ${budget.promptBudgetTokens.toLocaleString()} tokens), so the analyzer receives the uncondensed page HTML.`;
+    const selectionReason = `Full DOM fits within the estimated prompt budget (~${fullCandidate.promptEstimatedTokens.toLocaleString()} <= ${budget.promptBudgetTokens.toLocaleString()} tokens), so the analyzer receives the uncondensed page HTML.`;
     const prompt = buildInlineHtmlPrompt(args, {
       htmlContent: fullHtmlContent,
       domLabel: "full DOM",
@@ -784,7 +786,10 @@ export function buildInlinePromptSelection(
     2_000,
     budget.promptBudgetTokens - estimateTokensFromChars(basePrompt.length),
   );
-  const truncatedHtml = truncateText(condensedHtmlContent, availableHtmlTokens * 4);
+  const truncatedHtml = truncateText(
+    condensedHtmlContent,
+    availableHtmlTokens * 4,
+  );
 
   return buildCandidate(
     "condensed",
@@ -794,31 +799,6 @@ export function buildInlinePromptSelection(
   );
 }
 
-export function formatInterpretationOutput(
-  parsed: InterpretResult,
-  header: string = "Interpretation:",
-): string {
-  const outputLines: string[] = [];
-  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");
-}
-
 export async function runInterpret(
   args: InterpretArgs,
   logger: LoggerApi,
@@ -860,14 +840,14 @@ export async function runInterpret(
   // re-enabled, the caller must supply a valid provider/model-id string.
   throw new Error(
     "The CLI-agent snapshot analysis path is not active. " +
-    "Update your config to the current format with `npx libretto ai configure <provider>`, " +
-    "or set API credentials in .env for direct API analysis.",
+      "Update your config to the current format with `npx libretto ai configure <provider>`, " +
+      "or set API credentials in .env for direct API analysis.",
   );
 
   // Preserved for reference — to re-enable, remove the throw above and:
   // const selection = buildInlinePromptSelection(args, fullHtmlContent, condensedHtmlContent, model);
   // const parsed = await configuredAgent.analyzeSnapshot(selection.prompt, pngPath, logger);
-  // console.log(formatInterpretationOutput(parsed));
+  // console.log(parsed.answer);
 }
 
 export function canAnalyzeSnapshots(): boolean {