libretto 0.6.11 → 0.6.13

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

@@ -1,192 +0,0 @@
-import { readSnapshotModel } from "./config.js";
-import { LIBRETTO_CONFIG_PATH } from "./context.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 "npx libretto 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 `npx libretto 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 `npx libretto 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
-};

package/dist/cli/core/daemon/index.js

@@ -1,16 +0,0 @@
-import {
-  DaemonServer,
-  DaemonClient,
-  DaemonClientError,
-  getDaemonSocketPath
-} from "./ipc.js";
-import {
-  spawnSessionDaemon
-} from "./spawn.js";
-export {
-  DaemonClient,
-  DaemonClientError,
-  DaemonServer,
-  getDaemonSocketPath,
-  spawnSessionDaemon
-};

package/dist/cli/core/daemon/spawn.js

@@ -1,90 +0,0 @@
-import { openSync, closeSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { createRequire } from "node:module";
-import { spawn } from "node:child_process";
-import { getDaemonSocketPath } from "./ipc.js";
-import { DaemonClient } from "./ipc.js";
-const DEFAULT_IPC_TIMEOUT_MS = 1e4;
-const IPC_POLL_INTERVAL_MS = 250;
-async function spawnSessionDaemon(options) {
-  const {
-    config,
-    session,
-    logger,
-    logPath,
-    ipcTimeoutMs = DEFAULT_IPC_TIMEOUT_MS,
-    onFailure
-  } = options;
-  const daemonEntryPath = fileURLToPath(
-    new URL("./daemon.js", import.meta.url)
-  );
-  const require2 = createRequire(import.meta.url);
-  const tsxImportPath = pathToFileURL(require2.resolve("tsx/esm")).href;
-  const childStderrFd = openSync(logPath, "a");
-  const child = spawn(
-    process.execPath,
-    ["--import", tsxImportPath, daemonEntryPath, JSON.stringify(config)],
-    {
-      detached: true,
-      stdio: ["ignore", "ignore", childStderrFd]
-    }
-  );
-  child.unref();
-  closeSync(childStderrFd);
-  const pid = child.pid;
-  logger.info("daemon-spawned", { pid, session });
-  let childSpawnError = null;
-  let childEarlyExit = null;
-  child.on("error", (err) => {
-    childSpawnError = err;
-    logger.error("daemon-spawn-error", { error: err, session });
-  });
-  child.on("exit", (code, signal) => {
-    childEarlyExit = { code, signal };
-    logger.warn("daemon-early-exit", { code, signal, session, pid });
-  });
-  const socketPath = getDaemonSocketPath(session);
-  const client = new DaemonClient(socketPath);
-  const maxAttempts = Math.ceil(ipcTimeoutMs / IPC_POLL_INTERVAL_MS);
-  let ipcReady = false;
-  for (let i = 0; i < maxAttempts; i++) {
-    const spawnError = childSpawnError;
-    if (spawnError !== null) {
-      await onFailure?.();
-      const errWithCode = spawnError;
-      const hint = errWithCode.code === "ENOENT" ? " Ensure Node.js is available in PATH for child processes." : "";
-      throw new Error(
-        `Failed to spawn daemon: ${spawnError.message}.${hint} Check logs: ${logPath}`
-      );
-    }
-    const earlyExit = childEarlyExit;
-    if (earlyExit !== null) {
-      await onFailure?.();
-      const status = earlyExit.code ?? earlyExit.signal ?? "unknown";
-      throw new Error(
-        `Daemon exited before startup (status: ${status}). Check logs: ${logPath}`
-      );
-    }
-    await new Promise((r) => setTimeout(r, IPC_POLL_INTERVAL_MS));
-    ipcReady = await client.ping();
-    if (ipcReady) break;
-    if (i > 0 && i % 10 === 0) {
-      logger.info("daemon-waiting-for-ipc", { attempt: i, session });
-    }
-  }
-  if (!ipcReady) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
-    }
-    await onFailure?.();
-    throw new Error(
-      `Daemon failed to start within ${Math.ceil(ipcTimeoutMs / 1e3)}s. Check logs: ${logPath}`
-    );
-  }
-  logger.info("daemon-ipc-ready", { session, socketPath });
-  return { pid, socketPath, client };
-}
-export {
-  spawnSessionDaemon
-};

package/dist/cli/core/pause-signals.js

@@ -1,29 +0,0 @@
-import { existsSync } from "node:fs";
-import { unlink } from "node:fs/promises";
-import { join } from "node:path";
-import { getSessionDir } from "./context.js";
-function getPauseSignalPaths(session) {
-  const sessionDir = getSessionDir(session);
-  return {
-    pausedSignalPath: join(sessionDir, `${session}.paused`),
-    resumeSignalPath: join(sessionDir, `${session}.resume`),
-    completedSignalPath: join(sessionDir, `${session}.completed`),
-    failedSignalPath: join(sessionDir, `${session}.failed`),
-    outputSignalPath: join(sessionDir, `${session}.output`)
-  };
-}
-async function removeSignalIfExists(path) {
-  if (!existsSync(path)) return;
-  try {
-    await unlink(path);
-  } catch (error) {
-    const code = error.code;
-    if (code !== "ENOENT") {
-      throw error;
-    }
-  }
-}
-export {
-  getPauseSignalPaths,
-  removeSignalIfExists
-};