libretto 0.3.2 → 0.4.1

package/dist/cli/commands/init.js

@@ -1,67 +1,175 @@
-import { accessSync, constants, statSync } from "node:fs";
-import { join, delimiter, extname } from "node:path";
+import { createInterface } from "node:readline";
+import { appendFileSync, cpSync, existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readAiConfig } from "../core/ai-config.js";
+import { REPO_ROOT } from "../core/context.js";
 import {
-  AI_CONFIG_PRESETS,
-  AiPresetSchema,
-  formatCommandPrefix,
-  readAiConfig
-} from "../core/ai-config.js";
-const AI_RUNTIME_PRESETS = AiPresetSchema.options;
-function getPresetCommand(preset) {
-  return AI_CONFIG_PRESETS[preset][0] ?? "";
+  loadSnapshotEnv,
+  resolveSnapshotApiModel
+} from "../core/snapshot-api-config.js";
+import { SimpleCLI } from "../framework/simple-cli.js";
+import { hasProviderCredentials } from "../../shared/llm/client.js";
+const PROVIDER_CHOICES = [
+  {
+    key: "1",
+    label: "OpenAI",
+    envVar: "OPENAI_API_KEY",
+    envHint: "Get your key at https://platform.openai.com/api-keys"
+  },
+  {
+    key: "2",
+    label: "Anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    envHint: "Get your key at https://console.anthropic.com/settings/keys"
+  },
+  {
+    key: "3",
+    label: "Google Gemini",
+    envVar: "GEMINI_API_KEY",
+    envHint: "Get your key at https://aistudio.google.com/apikey"
+  },
+  {
+    key: "4",
+    label: "Google Vertex AI",
+    envVar: "GOOGLE_CLOUD_PROJECT",
+    envHint: "Requires gcloud auth application-default login and a GCP project ID"
+  }
+];
+function promptUser(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+function askYesNo(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`${question} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
 }
-function isRunnableFile(filePath) {
+function safeReadAiConfig() {
   try {
-    const stats = statSync(filePath);
-    if (!stats.isFile()) return false;
-    if (process.platform === "win32") {
-      const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-      const extensions = pathExt.split(";").map((ext) => ext.trim().toUpperCase()).filter(Boolean);
-      const fileExt = extname(filePath).toUpperCase();
-      return extensions.includes(fileExt);
-    }
-    accessSync(filePath, constants.X_OK);
-    return true;
+    return readAiConfig();
   } catch {
-    return false;
-  }
-}
-function isCommandDefined(command) {
-  if (!command) return false;
-  if (command.includes("/") || command.includes("\\")) {
-    return isRunnableFile(command);
-  }
-  const pathEnv = process.env.PATH ?? "";
-  if (!pathEnv) return false;
-  const pathEntries = pathEnv.split(delimiter).filter(Boolean);
-  if (process.platform === "win32") {
-    const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-    const extensions = pathExt.split(";").map((ext) => ext.trim()).filter(Boolean);
-    const hasExtension = /\.[^./\\]+$/.test(command);
-    const candidates = hasExtension ? [command] : extensions.map(
-      (ext) => ext.startsWith(".") ? `${command}${ext}` : `${command}.${ext}`
-    );
-    return pathEntries.some(
-      (dir) => candidates.some((candidate) => isRunnableFile(join(dir, candidate)))
-    );
+    return null;
   }
-  return pathEntries.some((dir) => isRunnableFile(join(dir, command)));
 }
-function detectAvailableAiRuntimeCommands() {
-  return AI_RUNTIME_PRESETS.filter(
-    (preset) => isCommandDefined(getPresetCommand(preset))
+function printSnapshotApiStatus() {
+  const config = safeReadAiConfig();
+  const selection = resolveSnapshotApiModel(config);
+  const envPath = join(REPO_ROOT, ".env");
+  console.log("\nSnapshot analysis:");
+  console.log(
+    "  Libretto uses direct API calls for snapshot analysis when supported credentials are available."
   );
-}
-function printAiConfigureCommands(prefix = "    ") {
-  for (const preset of AI_RUNTIME_PRESETS) {
-    console.log(`${prefix}npx libretto ai configure ${preset}`);
+  console.log(`  Credentials are loaded from process env and ${envPath}.`);
+  if (selection && hasProviderCredentials(selection.provider)) {
+    console.log(`  \u2713 Ready: ${selection.model} (${selection.source})`);
+    console.log("    Snapshot objectives will use the API analyzer by default.");
+    console.log("    No further action required.");
+    return;
   }
-}
-function printDifferentAnalyzerHint(prefix = "    ") {
+  console.log("  \u2717 No snapshot API credentials detected.");
+  console.log("    Add one provider to .env:");
+  console.log("      OPENAI_API_KEY=...");
+  console.log("      ANTHROPIC_API_KEY=...");
+  console.log("      GEMINI_API_KEY=...  # or GOOGLE_GENERATIVE_AI_API_KEY");
+  console.log(
+    "      GOOGLE_CLOUD_PROJECT=...  # plus application default credentials for Vertex"
+  );
   console.log(
-    `${prefix}Use npx libretto ai configure <gemini|claude|codex> to configure a different AI analyzer.`
+    "    Or run `npx libretto ai configure <provider>` to set a specific model."
   );
+  console.log("    Run `npx libretto init` interactively to set up credentials.");
+}
+async function runInteractiveApiSetup() {
+  const config = safeReadAiConfig();
+  const selection = resolveSnapshotApiModel(config);
+  const envPath = join(REPO_ROOT, ".env");
+  console.log("\nSnapshot analysis setup:");
+  console.log("  Libretto uses direct API calls for snapshot analysis.");
+  console.log(`  Credentials are loaded from process env and ${envPath}.`);
+  if (selection && hasProviderCredentials(selection.provider)) {
+    console.log(`  \u2713 Ready: ${selection.model} (${selection.source})`);
+    console.log("    Snapshot objectives will use the API analyzer by default.");
+    return;
+  }
+  console.log("  \u2717 No snapshot API credentials detected.\n");
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log("  Which API provider would you like to use for snapshot analysis?\n");
+    for (const choice of PROVIDER_CHOICES) {
+      console.log(`    ${choice.key}) ${choice.label}`);
+    }
+    console.log("    s) Skip for now\n");
+    const answer = await promptUser(rl, "  Choice: ");
+    if (answer.toLowerCase() === "s" || !answer) {
+      console.log("\n  Skipped. You can set up API credentials later by rerunning `npx libretto init`.");
+      console.log("  Or add credentials directly to your .env file:");
+      console.log("    OPENAI_API_KEY=...");
+      console.log("    ANTHROPIC_API_KEY=...");
+      console.log("    GEMINI_API_KEY=...");
+      console.log(
+        "    Or run `npx libretto ai configure <provider>` to set a specific model."
+      );
+      return;
+    }
+    const selected = PROVIDER_CHOICES.find((choice) => choice.key === answer);
+    if (!selected) {
+      console.log(`
+  Unknown choice "${answer}". Skipping API setup.`);
+      return;
+    }
+    console.log(`
+  ${selected.label} selected.`);
+    console.log(`  ${selected.envHint}
+`);
+    const apiKeyValue = await promptUser(
+      rl,
+      `  Enter your ${selected.envVar}: `
+    );
+    if (!apiKeyValue) {
+      console.log("\n  No value entered. Skipping API key setup.");
+      return;
+    }
+    let envContent = "";
+    if (existsSync(envPath)) {
+      envContent = readFileSync(envPath, "utf-8");
+    }
+    const envLine = `${selected.envVar}=${apiKeyValue}`;
+    if (envContent.includes(`${selected.envVar}=`)) {
+      const updated = envContent.replace(
+        new RegExp(`^${selected.envVar}=.*$`, "m"),
+        () => envLine
+      );
+      writeFileSync(envPath, updated);
+      console.log(`
+  \u2713 Updated ${selected.envVar} in ${envPath}`);
+    } else {
+      const separator = envContent && !envContent.endsWith("\n") ? "\n" : "";
+      appendFileSync(envPath, `${separator}${envLine}
+`);
+      console.log(`
+  \u2713 Added ${selected.envVar} to ${envPath}`);
+    }
+    loadSnapshotEnv();
+    process.env[selected.envVar] = apiKeyValue;
+    const newSelection = resolveSnapshotApiModel(safeReadAiConfig());
+    if (newSelection && hasProviderCredentials(newSelection.provider)) {
+      console.log(`  \u2713 Snapshot API ready: ${newSelection.model}`);
+    }
+  } finally {
+    rl.close();
+  }
 }
 function installBrowsers() {
   console.log("\nInstalling Playwright Chromium...");
@@ -77,90 +185,85 @@ function installBrowsers() {
     );
   }
 }
-function checkAiRuntimeConfiguration() {
-  let config = null;
-  let configReadError = null;
-  try {
-    config = readAiConfig();
-  } catch (error) {
-    configReadError = error instanceof Error ? error.message : String(error);
+function getPackageSkillsDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  let dir = dirname(thisFile);
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "skills", "libretto"))) {
+      return join(dir, "skills", "libretto");
+    }
+    dir = dirname(dir);
   }
-  const availableCommands = detectAvailableAiRuntimeCommands();
-  console.log("\nAI runtime configuration:");
-  console.log(
-    "  Libretto can use your coding agent as a subagent to analyze snapshots and other page signals."
-  );
-  console.log(
-    "  This is optional, but it significantly improves page understanding and debugging performance."
-  );
-  if (configReadError) {
-    console.log(`  \u2717 Could not read AI config: ${configReadError}`);
-    console.log("    Reconfigure with:");
-    printAiConfigureCommands("      ");
-    printDifferentAnalyzerHint("    ");
+  throw new Error("Could not locate libretto skill files in package");
+}
+async function copySkills() {
+  const cwd = process.cwd();
+  const agentDirs = [];
+  if (existsSync(join(cwd, ".agents"))) {
+    agentDirs.push({
+      name: ".agents",
+      skillDest: join(cwd, ".agents", "skills", "libretto")
+    });
+  }
+  if (existsSync(join(cwd, ".claude"))) {
+    agentDirs.push({
+      name: ".claude",
+      skillDest: join(cwd, ".claude", "skills", "libretto")
+    });
+  }
+  if (agentDirs.length === 0) {
+    console.log("\nSkills: No .agents/ or .claude/ directory found \u2014 skipping skill copy.");
     return;
   }
-  if (config) {
-    const configuredCommand = config.commandPrefix[0];
-    if (!isCommandDefined(configuredCommand)) {
-      console.log(
-        `  \u2717 Configured command not found: ${configuredCommand ?? "(empty)"}`
-      );
-      if (availableCommands.length > 0) {
-        console.log(
-          `    Detected available commands: ${availableCommands.join(", ")}`
-        );
-      } else {
-        console.log(
-          "    No codex, claude, or gemini analyzer command was detected on PATH."
-        );
-      }
-      console.log("    Reconfigure with:");
-      printAiConfigureCommands("      ");
-      printDifferentAnalyzerHint("    ");
-      return;
-    }
-    console.log(
-      `  \u2713 Configured (${config.preset}): ${formatCommandPrefix(config.commandPrefix)}`
-    );
-    console.log("    Analysis commands are ready to use.");
-    printDifferentAnalyzerHint("    ");
+  const dirNames = agentDirs.map((d) => d.name).join(" and ");
+  const existing = agentDirs.filter((d) => existsSync(d.skillDest));
+  const verb = existing.length > 0 ? "Overwrite" : "Install";
+  const proceed = await askYesNo(`
+${verb} libretto skills in ${dirNames}?`);
+  if (!proceed) {
+    console.log("  Skipping skill copy.");
     return;
   }
-  console.log("  \u2717 No AI config set.");
-  if (availableCommands.length > 0) {
-    console.log(
-      `    Detected available commands: ${availableCommands.join(", ")}`
-    );
-  } else {
-    console.log("    No codex, claude, or gemini analyzer command was detected on PATH.");
+  let sourceDir;
+  try {
+    sourceDir = getPackageSkillsDir();
+  } catch (e) {
+    console.error(`  \u2717 ${e instanceof Error ? e.message : String(e)}`);
+    return;
+  }
+  for (const { name, skillDest } of agentDirs) {
+    cpSync(sourceDir, skillDest, { recursive: true });
+    const fileCount = readdirSync(skillDest).length;
+    console.log(`  \u2713 Copied ${fileCount} skill files to ${name}/skills/libretto/`);
   }
-  console.log("    Configure one with:");
-  printAiConfigureCommands("      ");
-  printDifferentAnalyzerHint("    ");
-  console.log("    Optionally provide a custom command prefix with '-- ...'.");
-}
-function registerInitCommand(yargs) {
-  return yargs.command(
-    "init",
-    "Initialize libretto in the current project",
-    (cmd) => cmd.option("skip-browsers", {
-      type: "boolean",
-      default: false,
-      describe: "Skip Playwright Chromium installation"
-    }),
-    (argv) => {
-      console.log("Initializing libretto...\n");
-      if (!argv["skip-browsers"]) {
-        installBrowsers();
-      } else {
-        console.log("\nSkipping browser installation (--skip-browsers)");
-      }
-      checkAiRuntimeConfiguration();
-      console.log("\n\u2713 libretto init complete");
-    }
-  );
 }
+const initInput = SimpleCLI.input({
+  positionals: [],
+  named: {
+    skipBrowsers: SimpleCLI.flag({
+      name: "skip-browsers",
+      help: "Skip Playwright Chromium installation"
+    })
+  }
+});
+const initCommand = SimpleCLI.command({
+  description: "Initialize libretto in the current project"
+}).input(initInput).handle(async ({ input }) => {
+  console.log("Initializing libretto...\n");
+  if (!input.skipBrowsers) {
+    installBrowsers();
+  } else {
+    console.log("\nSkipping browser installation (--skip-browsers)");
+  }
+  if (process.stdin.isTTY) {
+    await copySkills();
+    await runInteractiveApiSetup();
+  } else {
+    printSnapshotApiStatus();
+  }
+  console.log("\n\u2713 libretto init complete");
+});
 export {
-  registerInitCommand
+  initCommand,
+  initInput
 };

package/dist/cli/commands/logs.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { listOpenPages } from "../core/browser.js";
 import { withSessionLogger } from "../core/context.js";
 import {
@@ -8,6 +9,14 @@ import {
   readActionLog,
   readNetworkLog
 } from "../core/telemetry.js";
+import { SimpleCLI } from "../framework/simple-cli.js";
+import {
+  integerOption,
+  loadSessionStateMiddleware,
+  pageOption,
+  resolveSessionMiddleware,
+  sessionOption
+} from "./shared.js";
 async function resolvePageId(session, pageId) {
   if (!pageId) return void 0;
   const pages = await withSessionLogger(
@@ -22,72 +31,88 @@ async function resolvePageId(session, pageId) {
   }
   return pageId;
 }
-function registerLogCommands(yargs) {
-  return yargs.command(
-    "network",
-    "View captured network requests",
-    (cmd) => cmd.option("last", { type: "number" }).option("filter", { type: "string" }).option("method", { type: "string" }).option("page", { type: "string" }).option("clear", { type: "boolean", default: false }),
-    async (argv) => {
-      const session = String(argv.session);
-      if (argv.clear) {
-        clearNetworkLog(session);
-        console.log("Network log cleared.");
-        return;
-      }
-      const pageId = await resolvePageId(
-        session,
-        argv.page ? String(argv.page) : void 0
-      );
-      const entries = readNetworkLog(session, {
-        last: typeof argv.last === "number" ? argv.last : void 0,
-        filter: argv.filter,
-        method: argv.method,
-        pageId
-      });
-      if (entries.length === 0) {
-        console.log("No network requests captured.");
-        return;
-      }
-      for (const entry of entries) {
-        console.log(formatNetworkEntry(entry));
-      }
-      console.log(`
+const networkInput = SimpleCLI.input({
+  positionals: [],
+  named: {
+    session: sessionOption(),
+    last: integerOption(),
+    filter: SimpleCLI.option(z.string().optional()),
+    method: SimpleCLI.option(z.string().optional()),
+    page: pageOption(),
+    clear: SimpleCLI.flag()
+  }
+});
+const networkCommand = SimpleCLI.command({
+  description: "View captured network requests"
+}).input(networkInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
+  if (input.clear) {
+    clearNetworkLog(ctx.session);
+    console.log("Network log cleared.");
+    return;
+  }
+  const pageId = await resolvePageId(ctx.session, input.page);
+  const entries = readNetworkLog(ctx.session, {
+    last: input.last,
+    filter: input.filter,
+    method: input.method,
+    pageId
+  });
+  if (entries.length === 0) {
+    console.log("No network requests captured.");
+    return;
+  }
+  for (const entry of entries) {
+    console.log(formatNetworkEntry(entry));
+  }
+  console.log(`
 ${entries.length} request(s) shown.`);
-    }
-  ).command(
-    "actions",
-    "View captured actions",
-    (cmd) => cmd.option("last", { type: "number" }).option("filter", { type: "string" }).option("action", { type: "string" }).option("source", { type: "string" }).option("page", { type: "string" }).option("clear", { type: "boolean", default: false }),
-    async (argv) => {
-      const session = String(argv.session);
-      if (argv.clear) {
-        clearActionLog(session);
-        console.log("Action log cleared.");
-        return;
-      }
-      const pageId = await resolvePageId(
-        session,
-        argv.page ? String(argv.page) : void 0
-      );
-      const entries = readActionLog(session, {
-        last: typeof argv.last === "number" ? argv.last : void 0,
-        filter: argv.filter,
-        action: argv.action,
-        source: argv.source,
-        pageId
-      });
-      if (entries.length === 0) {
-        console.log("No actions captured.");
-        return;
-      }
-      for (const entry of entries) {
-        console.log(formatActionEntry(entry));
-      }
-      console.log(`
+});
+const actionsInput = SimpleCLI.input({
+  positionals: [],
+  named: {
+    session: sessionOption(),
+    last: integerOption(),
+    filter: SimpleCLI.option(z.string().optional()),
+    action: SimpleCLI.option(z.string().optional()),
+    source: SimpleCLI.option(z.string().optional()),
+    page: pageOption(),
+    clear: SimpleCLI.flag()
+  }
+});
+const actionsCommand = SimpleCLI.command({
+  description: "View captured actions"
+}).input(actionsInput).use(resolveSessionMiddleware).use(loadSessionStateMiddleware).handle(async ({ input, ctx }) => {
+  if (input.clear) {
+    clearActionLog(ctx.session);
+    console.log("Action log cleared.");
+    return;
+  }
+  const pageId = await resolvePageId(ctx.session, input.page);
+  const entries = readActionLog(ctx.session, {
+    last: input.last,
+    filter: input.filter,
+    action: input.action,
+    source: input.source,
+    pageId
+  });
+  if (entries.length === 0) {
+    console.log("No actions captured.");
+    return;
+  }
+  for (const entry of entries) {
+    console.log(formatActionEntry(entry));
+  }
+  console.log(`
 ${entries.length} action(s) shown.`);
-    }
-  );
-}
+});
+const logCommands = {
+  network: networkCommand,
+  actions: actionsCommand
+};
 export {
-  registerLogCommands
+  actionsCommand,
+  actionsInput,
+  logCommands,
+  networkCommand,
+  networkInput
 };

package/dist/cli/commands/shared.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import {
+  SESSION_DEFAULT,
+  readSessionStateOrThrow,
+  validateSessionName
+} from "../core/session.js";
+import {
+  SimpleCLI
+} from "../framework/simple-cli.js";
+function createSessionSchema() {
+  return z.string().default(SESSION_DEFAULT).superRefine((value, ctx) => {
+    try {
+      validateSessionName(value);
+    } catch (err) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+}
+function sessionOption(help = "Use a named session") {
+  return SimpleCLI.option(createSessionSchema(), { help });
+}
+function pageOption(help = "Target a specific page id") {
+  return SimpleCLI.option(z.string().optional(), { help });
+}
+function integerOption(help) {
+  return SimpleCLI.option(z.coerce.number().int().optional(), { help });
+}
+const resolveSessionMiddleware = async ({ input, ctx }) => {
+  return {
+    ...ctx,
+    session: input.session
+  };
+};
+const loadSessionStateMiddleware = async ({ ctx }) => {
+  return {
+    ...ctx,
+    sessionState: readSessionStateOrThrow(ctx.session)
+  };
+};
+export {
+  createSessionSchema,
+  integerOption,
+  loadSessionStateMiddleware,
+  pageOption,
+  resolveSessionMiddleware,
+  sessionOption
+};