libretto 0.3.2 → 0.4.1

package/dist/cli/commands/snapshot.js

@@ -1,11 +1,18 @@
 import { mkdirSync } from "node:fs";
+import { z } from "zod";
 import { connect, disconnectBrowser } from "../core/browser.js";
 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 {
-  canAnalyzeSnapshots,
-  runInterpret
-} from "../core/snapshot-analyzer.js";
+  loadSessionStateMiddleware,
+  pageOption,
+  resolveSessionMiddleware,
+  sessionOption
+} from "./shared.js";
+import { runApiInterpret } from "../core/api-snapshot-analyzer.js";
+import { readAiConfig } from "../core/ai-config.js";
 const DEFAULT_SNAPSHOT_CONTEXT = "No additional user context provided.";
 const FALLBACK_SNAPSHOT_VIEWPORT = { width: 1280, height: 800 };
 function generateSnapshotRunId() {
@@ -97,6 +104,7 @@ async function captureScreenshot(session, logger, pageId) {
     }
     const pngPath = `${snapshotRunDir}/page.png`;
     const htmlPath = `${snapshotRunDir}/page.html`;
+    const condensedHtmlPath = `${snapshotRunDir}/page.condensed.html`;
     const restoreViewport = resolveSnapshotViewport(session, logger);
     const viewportMetrics = await readSnapshotViewportMetrics(page);
     logger.info("screenshot-viewport-metrics", {
@@ -132,15 +140,23 @@ async function captureScreenshot(session, logger, pageId) {
     const htmlContent = await page.content();
     const fs = await import("node:fs/promises");
     await fs.writeFile(htmlPath, htmlContent);
+    const condenseResult = condenseDom(htmlContent);
+    await fs.writeFile(condensedHtmlPath, condenseResult.html);
     logger.info("screenshot-success", {
       session,
       pageUrl,
       title,
       pngPath,
       htmlPath,
-      snapshotRunId
+      condensedHtmlPath,
+      snapshotRunId,
+      domCondenseStats: {
+        originalLength: condenseResult.originalLength,
+        condensedLength: condenseResult.condensedLength,
+        reductions: condenseResult.reductions
+      }
     });
-    return { pngPath, htmlPath, baseName: snapshotRunId };
+    return { pngPath, htmlPath, condensedHtmlPath, baseName: snapshotRunId };
   } catch (err) {
     let pageAlive = false;
     let browserConnected = false;
@@ -168,50 +184,59 @@ async function captureScreenshot(session, logger, pageId) {
   }
 }
 async function runSnapshot(session, logger, pageId, objective, context) {
-  const { pngPath, htmlPath } = await captureScreenshot(session, logger, pageId);
-  console.log("Screenshot saved:");
-  console.log(`  PNG:  ${pngPath}`);
-  console.log(`  HTML: ${htmlPath}`);
   const normalizedObjective = objective?.trim();
   const normalizedContext = context?.trim();
-  if (!normalizedObjective && !normalizedContext) {
-    console.log("Use --objective flag to analyze snapshots.");
-    return;
-  }
-  if (!normalizedObjective) {
+  if (!normalizedObjective && normalizedContext) {
     throw new Error(
       "Couldn't run analysis: --objective is required when providing --context."
     );
   }
-  if (!canAnalyzeSnapshots()) {
-    throw new Error(
-      "Couldn't run analysis: no AI config set. Run 'libretto-cli ai configure codex' (or claude/gemini) to enable analysis."
-    );
+  const { pngPath, htmlPath, condensedHtmlPath } = await captureScreenshot(
+    session,
+    logger,
+    pageId
+  );
+  console.log("Screenshot saved:");
+  console.log(`  PNG:             ${pngPath}`);
+  console.log(`  HTML:            ${htmlPath}`);
+  console.log(`  Condensed HTML:  ${condensedHtmlPath}`);
+  if (!normalizedObjective) {
+    console.log("Use --objective flag to analyze snapshots.");
+    return;
   }
-  await runInterpret({
+  const interpretArgs = {
     objective: normalizedObjective,
     session,
     context: normalizedContext ?? DEFAULT_SNAPSHOT_CONTEXT,
     pngPath,
-    htmlPath
-  }, logger);
+    htmlPath,
+    condensedHtmlPath
+  };
+  await runApiInterpret(interpretArgs, logger, readAiConfig());
 }
-function registerSnapshotCommands(yargs, logger) {
-  return yargs.command(
-    "snapshot",
-    "Capture PNG + HTML; analyze when --objective is provided (--context optional)",
-    (cmd) => cmd.option("page", { type: "string" }).option("objective", { type: "string" }).option("context", { type: "string" }),
-    async (argv) => {
-      await runSnapshot(
-        String(argv.session),
-        logger,
-        argv.page ? String(argv.page) : void 0,
-        argv.objective,
-        argv.context
-      );
-    }
-  );
+const snapshotInput = SimpleCLI.input({
+  positionals: [],
+  named: {
+    session: sessionOption(),
+    page: pageOption(),
+    objective: SimpleCLI.option(z.string().optional()),
+    context: SimpleCLI.option(z.string().optional())
+  }
+});
+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
+    );
+  });
 }
 export {
-  registerSnapshotCommands
+  createSnapshotCommand,
+  snapshotInput
 };

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

@@ -1,13 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
+import { dirname } from "node:path";
 import { z } from "zod";
 import { LIBRETTO_CONFIG_PATH } from "./context.js";
 const CURRENT_CONFIG_VERSION = 1;
-const AiPresetSchema = z.enum(["codex", "claude", "gemini"]);
 const AiConfigSchema = z.object({
-  preset: AiPresetSchema,
-  commandPrefix: z.array(z.string()).min(1),
+  model: z.string().min(1),
   updatedAt: z.string()
 }).strict();
 const ViewportConfigSchema = z.object({
@@ -19,11 +16,14 @@ const LibrettoConfigSchema = z.object({
   ai: AiConfigSchema.optional(),
   viewport: ViewportConfigSchema.optional()
 }).passthrough();
-const AI_CONFIG_PRESETS = {
-  codex: ["codex", "exec", "--skip-git-repo-check", "--sandbox", "read-only"],
-  claude: [join(homedir(), ".claude", "local", "claude"), "-p"],
-  gemini: ["gemini", "--output-format", "json"]
+const DEFAULT_MODELS = {
+  openai: "openai/gpt-5.4",
+  anthropic: "anthropic/claude-sonnet-4-6",
+  gemini: "google/gemini-2.5-flash",
+  google: "google/gemini-2.5-flash",
+  vertex: "vertex/gemini-2.5-pro"
 };
+const CONFIGURE_PROVIDERS = Object.keys(DEFAULT_MODELS);
 function invalidConfigError(configPath) {
   return new Error(
     `AI config is invalid at ${configPath}. Fix the file to match the expected schema or delete it.`
@@ -51,18 +51,10 @@ function writeLibrettoConfig(config, configPath = LIBRETTO_CONFIG_PATH) {
 function readAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   return readLibrettoConfig(configPath).ai ?? null;
 }
-function quoteShellArg(value) {
-  if (/^[a-zA-Z0-9_./:@=-]+$/.test(value)) return value;
-  return JSON.stringify(value);
-}
-function formatCommandPrefix(prefix) {
-  return prefix.map((arg) => quoteShellArg(arg)).join(" ");
-}
-function writeAiConfig(preset, commandPrefix, configPath = LIBRETTO_CONFIG_PATH) {
+function writeAiConfig(model, configPath = LIBRETTO_CONFIG_PATH) {
   const librettoConfig = readLibrettoConfig(configPath);
   const ai = AiConfigSchema.parse({
-    preset,
-    commandPrefix,
+    model,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   writeLibrettoConfig(
@@ -88,27 +80,24 @@ function clearAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   return true;
 }
 function printAiConfig(config, configPath) {
-  console.log(`AI preset: ${config.preset}`);
-  console.log(`Command prefix: ${formatCommandPrefix(config.commandPrefix)}`);
+  console.log(`Model: ${config.model}`);
   console.log(`Config file: ${configPath}`);
   console.log(`Updated at: ${config.updatedAt}`);
 }
-function printConfigureUsage(commandName) {
-  console.log(
-    `Usage: ${commandName} <codex|claude|gemini> [-- <command prefix...>]
-       ${commandName}
-       ${commandName} --clear`
-  );
+function resolveModelFromInput(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (trimmed.includes("/")) return trimmed;
+  return DEFAULT_MODELS[trimmed.toLowerCase()] ?? null;
 }
 function runAiConfigure(input, options = {}) {
-  const configureCommandName = options.configureCommandName ?? "libretto-cli ai configure";
+  const configureCommandName = options.configureCommandName ?? "npx libretto ai configure";
   const configPath = options.configPath ?? LIBRETTO_CONFIG_PATH;
   const presetArg = input.preset?.trim();
-  const customPrefix = (input.customPrefix ?? []).filter(Boolean);
-  if (!presetArg && customPrefix.length === 0 && !input.clear) {
+  if (!presetArg && !input.clear) {
     const config2 = readAiConfig(configPath);
     if (!config2) {
-      console.log(`No AI config set. Run '${configureCommandName} codex' to set one.`);
+      console.log(`No AI config set. Run '${configureCommandName} openai' to set one.`);
       return;
     }
     printAiConfig(config2, configPath);
@@ -123,31 +112,27 @@ function runAiConfigure(input, options = {}) {
     }
     return;
   }
-  const parsedPreset = AiPresetSchema.safeParse(presetArg);
-  if (!parsedPreset.success) {
-    printConfigureUsage(configureCommandName);
+  const model = resolveModelFromInput(presetArg);
+  if (!model) {
+    console.log(
+      `Usage: ${configureCommandName} <${CONFIGURE_PROVIDERS.join("|")}|provider/model-id>
+       ${configureCommandName}
+       ${configureCommandName} --clear`
+    );
     throw new Error(
-      "Missing or invalid preset. Use one of: codex, claude, gemini."
+      `Invalid provider or model. Use one of: ${CONFIGURE_PROVIDERS.join(", ")}, or a full model string like "openai/gpt-4o".`
     );
   }
-  if (input.customPrefix && input.customPrefix.length > 0 && customPrefix.length === 0) {
-    throw new Error("Custom command prefix cannot be empty.");
-  }
-  const preset = parsedPreset.data;
-  const commandPrefix = customPrefix.length > 0 ? customPrefix : AI_CONFIG_PRESETS[preset];
-  const config = writeAiConfig(preset, commandPrefix, configPath);
+  const config = writeAiConfig(model, configPath);
   console.log("AI config saved.");
   printAiConfig(config, configPath);
 }
 export {
-  AI_CONFIG_PRESETS,
   AiConfigSchema,
-  AiPresetSchema,
   CURRENT_CONFIG_VERSION,
   LibrettoConfigSchema,
   ViewportConfigSchema,
   clearAiConfig,
-  formatCommandPrefix,
   readAiConfig,
   readLibrettoConfig,
   runAiConfigure,

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

@@ -0,0 +1,74 @@
+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";
+async function runApiInterpret(args, logger, configuredAi = readAiConfig()) {
+  const selection = resolveSnapshotApiModelOrThrow(configuredAi);
+  logger.info("api-interpret-start", {
+    objective: args.objective,
+    pngPath: args.pngPath,
+    htmlPath: args.htmlPath,
+    condensedHtmlPath: args.condensedHtmlPath,
+    model: selection.model,
+    modelSource: selection.source
+  });
+  const fullHtmlContent = readFileSync(args.htmlPath, "utf-8");
+  const condensedHtmlContent = readFileSync(args.condensedHtmlPath, "utf-8");
+  const promptSelection = buildInlinePromptSelection(
+    args,
+    fullHtmlContent,
+    condensedHtmlContent,
+    selection.model
+  );
+  logger.info("api-interpret-dom-selection", {
+    configuredModel: promptSelection.stats.configuredModel,
+    fullDomEstimatedTokens: promptSelection.stats.fullDomEstimatedTokens,
+    condensedDomEstimatedTokens: promptSelection.stats.condensedDomEstimatedTokens,
+    contextWindowTokens: promptSelection.budget.contextWindowTokens,
+    promptBudgetTokens: promptSelection.budget.promptBudgetTokens,
+    selectedDom: promptSelection.domSource,
+    selectedHtmlEstimatedTokens: promptSelection.htmlEstimatedTokens,
+    selectedPromptEstimatedTokens: promptSelection.promptEstimatedTokens,
+    selectionReason: promptSelection.selectionReason,
+    truncated: promptSelection.truncated
+  });
+  const imageBase64 = readFileAsBase64(args.pngPath);
+  const imageMimeType = getMimeType(args.pngPath);
+  const imageBytes = Buffer.from(imageBase64, "base64");
+  const client = createLLMClient(selection.model);
+  const result = await client.generateObjectFromMessages({
+    schema: InterpretResultSchema,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: promptSelection.prompt },
+          {
+            type: "image",
+            image: imageBytes,
+            mediaType: imageMimeType
+          }
+        ]
+      }
+    ],
+    temperature: 0.1
+  });
+  const parsed = InterpretResultSchema.parse(result);
+  logger.info("api-interpret-success", {
+    selectorCount: parsed.selectors.length,
+    answer: parsed.answer.slice(0, 200)
+  });
+  console.log(formatInterpretationOutput(parsed, "Interpretation (via API):"));
+}
+export {
+  runApiInterpret
+};

package/dist/cli/core/context.js

@@ -86,7 +86,7 @@ function getLLMClientFactory() {
 }
 function maybeConfigureLLMClientFactoryFromEnv() {
   if (llmClientFactory) return;
-  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+  const hasAnyCreds = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
   if (!hasAnyCreds) return;
   setLLMClientFactory(async (_logger, model) => {
     const { createLLMClient } = await import("../../shared/llm/index.js");