libretto 0.6.12 → 0.6.13

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

@@ -1,195 +0,0 @@
-import { readSnapshotModel } from "./config.js";
-import { LIBRETTO_CONFIG_PATH } from "./context.js";
-import { librettoCommand } from "../../shared/package-manager.js";
-import {
-  hasProviderCredentials,
-  parseModel
-} from "./resolve-model.js";
-import { parseDotEnvAssignment } from "../../shared/env/load-env.js";
-const DEFAULT_SNAPSHOT_MODELS = {
-  openai: "openai/gpt-5.4",
-  anthropic: "anthropic/claude-sonnet-4-6",
-  google: "google/gemini-3-flash-preview",
-  vertex: "vertex/gemini-2.5-flash",
-  openrouter: "openrouter/free"
-};
-function detectProviderEnvVar(provider, env = process.env) {
-  switch (provider) {
-    case "openai":
-      return env.OPENAI_API_KEY?.trim() ? "OPENAI_API_KEY" : null;
-    case "anthropic":
-      return env.ANTHROPIC_API_KEY?.trim() ? "ANTHROPIC_API_KEY" : null;
-    case "google":
-      if (env.GEMINI_API_KEY?.trim()) return "GEMINI_API_KEY";
-      if (env.GOOGLE_GENERATIVE_AI_API_KEY?.trim())
-        return "GOOGLE_GENERATIVE_AI_API_KEY";
-      return null;
-    case "vertex":
-      if (env.GOOGLE_CLOUD_PROJECT?.trim()) return "GOOGLE_CLOUD_PROJECT";
-      if (env.GCLOUD_PROJECT?.trim()) return "GCLOUD_PROJECT";
-      return null;
-    case "openrouter":
-      return env.OPENROUTER_API_KEY?.trim() ? "OPENROUTER_API_KEY" : null;
-  }
-}
-class SnapshotApiUnavailableError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SnapshotApiUnavailableError";
-  }
-}
-function providerSetupSentence(provider) {
-  switch (provider) {
-    case "openai":
-      return "Add OPENAI_API_KEY to .env or as a shell environment variable.";
-    case "anthropic":
-      return "Add ANTHROPIC_API_KEY to .env or as a shell environment variable.";
-    case "google":
-      return "Add GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY to .env or as a shell environment variable.";
-    case "vertex":
-      return "Add GOOGLE_CLOUD_PROJECT or GCLOUD_PROJECT to .env or as a shell environment variable, and make sure application default credentials are configured.";
-    case "openrouter":
-      return "Add OPENROUTER_API_KEY to .env or as a shell environment variable.";
-  }
-}
-function defaultModelCommandLine() {
-  return librettoCommand(
-    "ai configure openai | anthropic | gemini | vertex | openrouter"
-  );
-}
-function providerMissingCredentialSummary(provider) {
-  switch (provider) {
-    case "openai":
-      return "OPENAI_API_KEY is missing";
-    case "anthropic":
-      return "ANTHROPIC_API_KEY is missing";
-    case "google":
-      return "GEMINI_API_KEY and GOOGLE_GENERATIVE_AI_API_KEY are missing";
-    case "vertex":
-      return "GOOGLE_CLOUD_PROJECT and GCLOUD_PROJECT are missing";
-    case "openrouter":
-      return "OPENROUTER_API_KEY is missing";
-  }
-}
-function noSnapshotApiConfiguredMessage() {
-  return [
-    "Failed to analyze snapshot because no snapshot analyzer is configured.",
-    `Add OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY or GOOGLE_GENERATIVE_AI_API_KEY, GOOGLE_CLOUD_PROJECT, or OPENROUTER_API_KEY to .env or as a shell environment variable, or choose a default model with \`${defaultModelCommandLine()}\`.`,
-    `For more info, run \`${librettoCommand("setup")}\`.`
-  ].join(" ");
-}
-function missingProviderSnapshotMessage(selection) {
-  const configuredSource = selection.source === "config" ? ` in ${LIBRETTO_CONFIG_PATH}` : " from process env or .env";
-  return [
-    `Failed to analyze snapshot because ${selection.provider} is configured${configuredSource}, but ${providerMissingCredentialSummary(selection.provider)}.`,
-    providerSetupSentence(selection.provider),
-    `For more info, run \`${librettoCommand("setup")}\`.`
-  ].join(" ");
-}
-function inferAutoSnapshotModel() {
-  const providersInPriorityOrder = [
-    "openai",
-    "anthropic",
-    "google",
-    "vertex",
-    "openrouter"
-  ];
-  for (const provider of providersInPriorityOrder) {
-    const envVar = detectProviderEnvVar(provider);
-    if (!envVar) continue;
-    return {
-      model: DEFAULT_SNAPSHOT_MODELS[provider],
-      provider,
-      source: `env:${envVar}`
-    };
-  }
-  return null;
-}
-function resolveSnapshotApiModel(snapshotModel = readSnapshotModel()) {
-  if (snapshotModel) {
-    const { provider } = parseModel(snapshotModel);
-    return {
-      model: snapshotModel,
-      provider,
-      source: "config"
-    };
-  }
-  return inferAutoSnapshotModel();
-}
-function resolveSnapshotApiModelOrThrow(snapshotModel = readSnapshotModel()) {
-  const selection = resolveSnapshotApiModel(snapshotModel);
-  if (!selection) {
-    throw new SnapshotApiUnavailableError(noSnapshotApiConfiguredMessage());
-  }
-  if (!hasProviderCredentials(selection.provider)) {
-    throw new SnapshotApiUnavailableError(
-      missingProviderSnapshotMessage(selection)
-    );
-  }
-  return selection;
-}
-function isSnapshotApiUnavailableError(error) {
-  return error instanceof SnapshotApiUnavailableError;
-}
-function readSnapshotModelSafely(configPath) {
-  try {
-    return { ok: true, model: readSnapshotModel(configPath) };
-  } catch (err) {
-    return {
-      ok: false,
-      message: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function resolveAiSetupStatus(configPath = LIBRETTO_CONFIG_PATH) {
-  const result = readSnapshotModelSafely(configPath);
-  if (!result.ok) {
-    return { kind: "invalid-config", message: result.message };
-  }
-  if (result.model) {
-    let selection;
-    try {
-      selection = resolveSnapshotApiModel(result.model);
-    } catch (err) {
-      return {
-        kind: "invalid-config",
-        message: err instanceof Error ? err.message : String(err)
-      };
-    }
-    if (!selection) {
-      return { kind: "unconfigured" };
-    }
-    if (hasProviderCredentials(selection.provider)) {
-      return {
-        kind: "ready",
-        model: selection.model,
-        provider: selection.provider,
-        source: selection.source
-      };
-    }
-    return {
-      kind: "configured-missing-credentials",
-      model: selection.model,
-      provider: selection.provider
-    };
-  }
-  const envSelection = resolveSnapshotApiModel(null);
-  if (envSelection && hasProviderCredentials(envSelection.provider)) {
-    return {
-      kind: "ready",
-      model: envSelection.model,
-      provider: envSelection.provider,
-      source: envSelection.source
-    };
-  }
-  return { kind: "unconfigured" };
-}
-export {
-  DEFAULT_SNAPSHOT_MODELS,
-  SnapshotApiUnavailableError,
-  isSnapshotApiUnavailableError,
-  parseDotEnvAssignment,
-  resolveAiSetupStatus,
-  resolveSnapshotApiModel,
-  resolveSnapshotApiModelOrThrow
-};

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

@@ -1,86 +0,0 @@
-import { readFileSync } from "node:fs";
-import { generateObject } from "ai";
-import { resolveModel } from "./resolve-model.js";
-import {
-  InterpretResultSchema,
-  buildInlinePromptSelection,
-  getMimeType,
-  readFileAsBase64
-} from "./snapshot-analyzer.js";
-import { readSnapshotModel } from "./config.js";
-import { resolveSnapshotApiModelOrThrow } from "./ai-model.js";
-async function runApiInterpret(args, logger, snapshotModel = readSnapshotModel()) {
-  const selection = resolveSnapshotApiModelOrThrow(snapshotModel);
-  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 model = await resolveModel(selection.model);
-  const { object: result } = await generateObject({
-    model,
-    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("");
-  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
-};