libretto 0.3.1 → 0.4.0

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

@@ -1,24 +1,29 @@
 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({
+  width: z.number().int().min(1),
+  height: z.number().int().min(1)
+});
 const LibrettoConfigSchema = z.object({
   version: z.literal(CURRENT_CONFIG_VERSION),
-  ai: AiConfigSchema.optional()
+  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.`
@@ -46,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(
@@ -73,36 +70,34 @@ function writeAiConfig(preset, commandPrefix, configPath = LIBRETTO_CONFIG_PATH)
 function clearAiConfig(configPath = LIBRETTO_CONFIG_PATH) {
   const librettoConfig = readLibrettoConfig(configPath);
   if (!librettoConfig.ai) return false;
+  const { ai: _ai, ...rest } = librettoConfig;
   writeLibrettoConfig(
     {
-      version: librettoConfig.version
+      ...rest
     },
     configPath
   );
   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);
@@ -117,30 +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/browser.js

@@ -9,6 +9,7 @@ import {
   getSessionNetworkLogPath,
   PROFILES_DIR
 } from "./context.js";
+import { readLibrettoConfig } from "./ai-config.js";
 import {
   assertSessionAvailableForStart,
   clearSessionState,
@@ -216,9 +217,24 @@ async function runPages(session, logger) {
     console.log(`  id=${pageSummary.id} url=${pageSummary.url}${activeSuffix}`);
   });
 }
-async function runOpen(rawUrl, headed, session, logger) {
+const DEFAULT_VIEWPORT = { width: 1366, height: 768 };
+function resolveViewport(cliViewport, logger) {
+  if (cliViewport) {
+    logger.info("viewport-source", { source: "cli", viewport: cliViewport });
+    return cliViewport;
+  }
+  const config = readLibrettoConfig();
+  if (config.viewport) {
+    logger.info("viewport-source", { source: "config", viewport: config.viewport });
+    return config.viewport;
+  }
+  logger.info("viewport-source", { source: "default", viewport: DEFAULT_VIEWPORT });
+  return DEFAULT_VIEWPORT;
+}
+async function runOpen(rawUrl, headed, session, logger, options) {
   const url = normalizeUrl(rawUrl);
-  logger.info("open-start", { url, headed, session });
+  const viewport = resolveViewport(options?.viewport, logger);
+  logger.info("open-start", { url, headed, session, viewport });
   assertSessionAvailableForStart(session, logger);
   const port = await pickFreePort();
   const runLogPath = logFileForSession(session);
@@ -296,7 +312,7 @@ browser.on('disconnected', () => {
 
 const context = await browser.newContext({
 	${storageStateCode}
-	viewport: { width: 1366, height: 768 },
+	viewport: { width: ${viewport.width}, height: ${viewport.height} },
 	userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
 });
 
@@ -398,7 +414,8 @@ await new Promise(() => {});
         pid: child.pid,
         session,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        status: "active"
+        status: "active",
+        viewport
       }, logger);
       logger.info("open-success", {
         url,

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");