zefiro 0.8.1 → 0.10.0

package/dist/cli-b26q1e27.js

@@ -0,0 +1,264 @@
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./cli-wckvcay0.js";
+
+// ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
+// src/utils/logger.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+var verboseEnabled = false;
+function setVerbose(enabled) {
+  verboseEnabled = enabled;
+}
+function info(msg) {
+  console.log(import_picocolors.default.blue("i") + " " + msg);
+}
+function success(msg) {
+  console.log(import_picocolors.default.green("✓") + " " + msg);
+}
+function warn(msg) {
+  console.log(import_picocolors.default.yellow("!") + " " + msg);
+}
+function error(msg) {
+  console.error(import_picocolors.default.red("✗") + " " + msg);
+}
+function verbose(msg) {
+  if (verboseEnabled) {
+    console.log(import_picocolors.default.gray("  " + msg));
+  }
+}
+function header(title) {
+  console.log(`
+` + import_picocolors.default.bold(import_picocolors.default.magenta(title)));
+  console.log(import_picocolors.default.gray("─".repeat(title.length + 4)));
+}
+function banner(version) {
+  const title = `  zefiro  v${version}`;
+  const subtitle = "  AI-powered application explorer";
+  const width = Math.max(title.length, subtitle.length) + 2;
+  const top = import_picocolors.default.cyan("┌" + "─".repeat(width) + "┐");
+  const mid1 = import_picocolors.default.cyan("│") + import_picocolors.default.bold(title) + " ".repeat(width - title.length) + import_picocolors.default.cyan("│");
+  const mid2 = import_picocolors.default.cyan("│") + import_picocolors.default.gray(subtitle) + " ".repeat(width - subtitle.length) + import_picocolors.default.cyan("│");
+  const bottom = import_picocolors.default.cyan("└" + "─".repeat(width) + "┘");
+  console.log(top);
+  console.log(mid1);
+  console.log(mid2);
+  console.log(bottom);
+}
+
+// src/browser/agent-browser.ts
+import { execSync } from "node:child_process";
+class AgentBrowser {
+  session;
+  headed;
+  constructor(opts = {}) {
+    this.session = opts.session ?? "zefiro";
+    this.headed = opts.headed ?? false;
+  }
+  exec(args, opts) {
+    const sessionArgs = ["--session", this.session];
+    const headedArgs = this.headed ? ["--headed"] : [];
+    const cmd = ["agent-browser", ...headedArgs, ...sessionArgs, ...args].join(" ");
+    verbose(`> ${cmd}`);
+    try {
+      return execSync(cmd, {
+        encoding: "utf-8",
+        timeout: opts?.timeout ?? 60000,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch (err) {
+      const stderr = err.stderr?.toString().trim() ?? "";
+      const stdout = err.stdout?.toString().trim() ?? "";
+      throw new Error(`agent-browser failed: ${stderr || stdout || err.message}`);
+    }
+  }
+  async open(url) {
+    this.exec(["open", url]);
+  }
+  async waitForLoad(strategy = "networkidle", delayMs = 1500) {
+    try {
+      this.exec(["wait", "--load", strategy], { timeout: 30000 });
+    } catch {
+      verbose("Wait for load timed out, continuing");
+    }
+    if (delayMs > 0) {
+      this.exec(["wait", String(delayMs)]);
+    }
+  }
+  async snapshot() {
+    const output = this.exec(["snapshot", "-i"]);
+    return parseSnapshot(output);
+  }
+  async screenshot(filePath) {
+    this.exec(["screenshot", filePath]);
+  }
+  async click(ref) {
+    this.exec(["click", ref]);
+  }
+  async fill(ref, text) {
+    this.exec(["fill", ref, `"${text}"`]);
+  }
+  async getAttribute(ref, attr) {
+    return this.exec(["get", "attr", ref, attr]);
+  }
+  async getUrl() {
+    return this.exec(["get", "url"]);
+  }
+  async getTitle() {
+    return this.exec(["get", "title"]);
+  }
+  async stateSave(filePath) {
+    this.exec(["state", "save", filePath]);
+  }
+  async stateLoad(filePath) {
+    this.exec(["state", "load", filePath]);
+  }
+  async close() {
+    try {
+      this.exec(["close"]);
+    } catch {}
+  }
+  async setViewport(width, height) {
+    this.exec(["set", "viewport", String(width), String(height)]);
+  }
+}
+function parseSnapshot(output) {
+  const elements = [];
+  const lines = output.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/@(e\d+)\s+\[(\w+)\]\s+"([^"]*)"/);
+    if (match) {
+      elements.push({
+        ref: `@${match[1]}`,
+        role: match[2],
+        label: match[3]
+      });
+      continue;
+    }
+    const altMatch = line.match(/@(e\d+)\s+\[(\w+)\]\s+(.*)/);
+    if (altMatch) {
+      elements.push({
+        ref: `@${altMatch[1]}`,
+        role: altMatch[2],
+        label: altMatch[3].trim().replace(/^"|"$/g, "")
+      });
+    }
+  }
+  return elements;
+}
+
+// src/browser/auth.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+var AUTH_STATE_FILE = ".qai/zefiro/auth-state.json";
+async function authenticate(browser, config) {
+  const { method, stateFile } = config.auth;
+  if (method === "state-file") {
+    const path = stateFile ?? AUTH_STATE_FILE;
+    if (!existsSync(path)) {
+      throw new Error(`Auth state file not found: ${path}`);
+    }
+    info(`Loading auth state from ${path}`);
+    await browser.stateLoad(path);
+    return path;
+  }
+  info("Opening browser for manual authentication...");
+  info("Please log in to the application, then press Enter to continue.");
+  await browser.open(config.baseUrl);
+  await browser.waitForLoad(config.waitStrategy, config.waitDelay);
+  await waitForEnter();
+  const savePath = join(process.cwd(), AUTH_STATE_FILE);
+  try {
+    const { mkdirSync } = await import("node:fs");
+    const { dirname } = await import("node:path");
+    mkdirSync(dirname(savePath), { recursive: true });
+    await browser.stateSave(savePath);
+    success(`Auth state saved to ${AUTH_STATE_FILE} (reuse with --auth-state)`);
+  } catch (err) {
+    warn(`Could not save auth state: ${err.message}`);
+  }
+  return savePath;
+}
+function waitForEnter() {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question("", () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+export { require_picocolors, setVerbose, info, success, warn, error, verbose, header, banner, AgentBrowser, authenticate };

package/dist/cli-ewbvvxm8.js

@@ -0,0 +1,145 @@
+import {
+  classifySectionType,
+  generateEdgeId,
+  generateSectionId
+} from "./cli-5w708rbb.js";
+
+// src/browser/graph-builder.ts
+function toReportNodeType(sectionType) {
+  const classified = classifySectionType(sectionType);
+  switch (classified) {
+    case "form":
+      return "page";
+    case "table":
+      return "page";
+    case "tab":
+      return "page";
+    default:
+      return classified;
+  }
+}
+var SECTION_ICONS = {
+  home: "home",
+  dashboard: "layout-dashboard",
+  settings: "settings",
+  auth: "shield",
+  login: "log-in",
+  users: "users",
+  admin: "shield-check",
+  reports: "bar-chart",
+  analytics: "trending-up"
+};
+function guessIcon(slug) {
+  for (const [key, icon] of Object.entries(SECTION_ICONS)) {
+    if (slug.includes(key))
+      return icon;
+  }
+  return;
+}
+function buildReportGraph(state) {
+  const nodes = [];
+  const edges = [];
+  const edgeSet = new Set;
+  const visitedPages = Array.from(state.pages.values()).filter((p) => p.status === "visited");
+  const slugToStableId = new Map;
+  for (const page of visitedPages) {
+    slugToStableId.set(page.slug, page.stableId);
+    nodes.push({
+      id: page.stableId,
+      sectionSlug: page.slug,
+      type: "page",
+      label: page.analysis?.pageName ?? page.title ?? page.slug,
+      description: page.analysis?.description ?? `Page at ${page.path}`,
+      route: page.path,
+      screenshotFilename: "01-default.png"
+    });
+    if (page.analysis?.sections) {
+      for (const section of page.analysis.sections) {
+        const sectionId = section.stableId ?? generateSectionId(page.slug, section.name);
+        const nodeType = toReportNodeType(section.type);
+        nodes.push({
+          id: sectionId,
+          sectionSlug: page.slug,
+          type: nodeType,
+          label: section.name,
+          description: `${section.type} section with ${section.elements.length} elements`
+        });
+        const containEdgeId = generateEdgeId(page.stableId, sectionId);
+        if (!edgeSet.has(containEdgeId)) {
+          edgeSet.add(containEdgeId);
+          edges.push({
+            id: containEdgeId,
+            source: page.stableId,
+            target: sectionId,
+            label: "contains"
+          });
+        }
+      }
+    }
+  }
+  const urlToStableId = new Map;
+  for (const page of visitedPages) {
+    urlToStableId.set(page.url, page.stableId);
+  }
+  for (const page of visitedPages) {
+    for (const linkUrl of page.outgoingLinks) {
+      const targetId = urlToStableId.get(linkUrl);
+      if (targetId && targetId !== page.stableId) {
+        const navEdgeId = generateEdgeId(page.stableId, targetId);
+        if (!edgeSet.has(navEdgeId)) {
+          edgeSet.add(navEdgeId);
+          edges.push({
+            id: navEdgeId,
+            source: page.stableId,
+            target: targetId,
+            label: "navigates"
+          });
+        }
+      }
+    }
+  }
+  const sectionGroups = buildSectionGroups(state.topology, visitedPages);
+  return { nodes, edges, sectionGroups };
+}
+function buildSectionGroups(topology, visitedPages) {
+  const groups = [];
+  const assignedSlugs = new Set;
+  for (const branch of topology) {
+    const descendantSlugs = collectSlugs(branch);
+    for (const s of descendantSlugs)
+      assignedSlugs.add(s);
+    groups.push({
+      sectionSlug: branch.slug,
+      name: branch.title || branch.slug,
+      icon: guessIcon(branch.slug)
+    });
+  }
+  for (const page of visitedPages) {
+    if (!assignedSlugs.has(page.slug)) {
+      groups.push({
+        sectionSlug: page.slug,
+        name: page.analysis?.pageName ?? page.title ?? page.slug,
+        icon: guessIcon(page.slug)
+      });
+    }
+  }
+  return groups;
+}
+function collectSlugs(node) {
+  const slugs = [node.slug];
+  for (const child of node.children) {
+    slugs.push(...collectSlugs(child));
+  }
+  return slugs;
+}
+function buildReportSections(visitedPages, sectionMarkdowns) {
+  return visitedPages.map((page, i) => ({
+    slug: page.slug,
+    name: page.analysis?.pageName ?? page.title ?? page.slug,
+    description: page.analysis?.description,
+    markdown: sectionMarkdowns.get(page.slug) ?? "",
+    sortOrder: i
+  }));
+}
+
+export { buildReportGraph, buildReportSections };

package/dist/cli-g7n2me6z.js

@@ -0,0 +1,133 @@
+import {
+  AgentBrowser,
+  authenticate,
+  error,
+  info,
+  success,
+  verbose
+} from "./cli-b26q1e27.js";
+import {
+  ensureDir,
+  writeFile
+} from "./cli-zvk8gwe4.js";
+import {
+  buildTopology,
+  extractHrefsFromElements,
+  generateSectionMarkdown,
+  normalizeUrl,
+  shouldVisit,
+  urlToSlug
+} from "./cli-6qr9gvkp.js";
+
+// src/browser/explorer.ts
+import { join } from "node:path";
+async function runExploration(config) {
+  const state = {
+    baseUrl: config.baseUrl,
+    startedAt: new Date().toISOString(),
+    pages: new Map,
+    queue: [],
+    topology: []
+  };
+  const browser = new AgentBrowser({
+    session: config.sessionName,
+    headed: config.headed || config.auth.method === "manual"
+  });
+  const visited = new Set;
+  const screenshotsDir = join(config.outputDir, "screenshots");
+  const sectionsDir = join(config.outputDir, "sections");
+  ensureDir(screenshotsDir);
+  ensureDir(sectionsDir);
+  try {
+    await authenticate(browser, config);
+    await browser.setViewport(1440, 900);
+    const startUrl = normalizeUrl(config.baseUrl, config.baseUrl);
+    state.queue.push(startUrl);
+    let pageCount = 0;
+    while (state.queue.length > 0 && pageCount < config.maxPages) {
+      const url = state.queue.shift();
+      const normalized = normalizeUrl(url, config.baseUrl);
+      if (visited.has(normalized))
+        continue;
+      if (!shouldVisit(url, config.baseUrl, config.excludePatterns, visited)) {
+        continue;
+      }
+      visited.add(normalized);
+      const slug = urlToSlug(url, config.baseUrl);
+      info(`[${pageCount + 1}/${config.maxPages}] Exploring: ${url}`);
+      const page = {
+        url: normalized,
+        path: new URL(normalized).pathname,
+        title: "",
+        slug,
+        depth: 0,
+        screenshot: "",
+        elements: [],
+        outgoingLinks: [],
+        status: "pending"
+      };
+      try {
+        await browser.open(url);
+        await browser.waitForLoad(config.waitStrategy, config.waitDelay);
+        const actualUrl = await browser.getUrl();
+        const actualNormalized = normalizeUrl(actualUrl, config.baseUrl);
+        if (actualNormalized !== normalized) {
+          page.url = actualNormalized;
+          page.path = new URL(actualNormalized).pathname;
+          page.slug = urlToSlug(actualUrl, config.baseUrl);
+          if (visited.has(actualNormalized)) {
+            verbose(`  Redirected to already-visited ${actualUrl}, skipping`);
+            continue;
+          }
+          visited.add(actualNormalized);
+        }
+        page.title = await browser.getTitle();
+        const slugDir = join(screenshotsDir, page.slug);
+        ensureDir(slugDir);
+        const screenshotPath = join(slugDir, "01-default.png");
+        await browser.screenshot(screenshotPath);
+        page.screenshot = `screenshots/${page.slug}/01-default.png`;
+        page.elements = await browser.snapshot();
+        const linkRefs = extractHrefsFromElements(page.elements);
+        for (const ref of linkRefs) {
+          try {
+            const href = await browser.getAttribute(ref, "href");
+            if (href) {
+              const linkUrl = normalizeUrl(href, actualUrl);
+              page.outgoingLinks.push(linkUrl);
+              if (shouldVisit(linkUrl, config.baseUrl, config.excludePatterns, visited)) {
+                state.queue.push(linkUrl);
+              }
+            }
+          } catch {}
+        }
+        page.depth = calculateDepth(page.path);
+        const relatedPages = Array.from(state.pages.values()).filter((p) => p.status === "visited").map((p) => ({ slug: p.slug, name: p.analysis?.pageName ?? p.title, path: p.path }));
+        const markdown = generateSectionMarkdown(page, relatedPages);
+        writeFile(join(sectionsDir, `${page.slug}.md`), markdown);
+        page.status = "visited";
+        page.visitedAt = new Date().toISOString();
+        pageCount++;
+        success(`  ${page.title || page.slug} — ${page.elements.length} elements, ${page.outgoingLinks.length} links`);
+      } catch (err) {
+        page.status = "error";
+        page.error = err.message;
+        error(`  Error: ${err.message}`);
+      }
+      state.pages.set(page.url, page);
+    }
+    state.topology = buildTopology(state.pages);
+    state.completedAt = new Date().toISOString();
+    await browser.close();
+  } catch (err) {
+    error(`Exploration failed: ${err.message}`);
+    await browser.close();
+    throw err;
+  }
+  return state;
+}
+function calculateDepth(path) {
+  const segments = path.replace(/^\/|\/$/g, "").split("/").filter(Boolean);
+  return segments.length;
+}
+export { runExploration };