zefiro 0.8.0 → 0.9.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-cymqw41r.js

@@ -0,0 +1,119 @@
+import {
+  exports_external
+} from "./cli-z2krvkcq.js";
+
+// src/config/schema.ts
+function nested(shape) {
+  const inner = exports_external.object(shape);
+  return exports_external.preprocess((val) => val ?? {}, inner);
+}
+var PathsSchema = exports_external.object({
+  workingDir: exports_external.string().default(".qai/zefiro"),
+  outputDir: exports_external.string().default("app-report")
+});
+var BrowserSchema = exports_external.object({
+  sessionName: exports_external.string().default("zefiro"),
+  headed: exports_external.boolean().default(false),
+  viewport: exports_external.object({
+    width: exports_external.number().default(1440),
+    height: exports_external.number().default(900)
+  }).default({ width: 1440, height: 900 }),
+  waitStrategy: exports_external.enum(["networkidle", "load", "domcontentloaded"]).default("networkidle"),
+  waitDelay: exports_external.number().default(1500),
+  maxPages: exports_external.number().default(100),
+  pageTimeout: exports_external.number().default(30000),
+  excludePatterns: exports_external.array(exports_external.string()).default([])
+});
+var AuthSchema = exports_external.object({
+  method: exports_external.enum(["state-file", "manual"]).default("manual"),
+  stateFile: exports_external.string().nullable().default(null)
+});
+var QaiConfigSchema = exports_external.object({
+  baseUrl: exports_external.string().nullable().default(null),
+  paths: nested(PathsSchema.shape),
+  browser: nested(BrowserSchema.shape),
+  auth: nested(AuthSchema.shape),
+  contextFile: exports_external.string().default(".qai/zefiro/context.md")
+});
+function defineConfig(config) {
+  return config;
+}
+
+// src/config/loader.ts
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+var CONFIG_DIR = ".qai/zefiro";
+var LEGACY_CONFIG_DIR = ".e2e-ai";
+var CONFIG_FILENAMES = ["config.ts", "config.js", "config.mjs"];
+var cachedConfig = null;
+var cachedProjectRoot = null;
+function findConfigDir(startDir) {
+  let dir = resolve(startDir);
+  const root = dirname(dir) === dir ? dir : undefined;
+  while (true) {
+    for (const configDir of [CONFIG_DIR, LEGACY_CONFIG_DIR]) {
+      const candidate = join(dir, configDir);
+      if (existsSync(join(candidate, "agents")) || existsSync(join(candidate, "context.md"))) {
+        return dir;
+      }
+      if (configDir === CONFIG_DIR && existsSync(candidate)) {
+        return dir;
+      }
+      for (const name of CONFIG_FILENAMES) {
+        if (existsSync(join(candidate, name))) {
+          return dir;
+        }
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir || dir === root)
+      return null;
+    dir = parent;
+  }
+}
+function getProjectRoot() {
+  if (cachedProjectRoot)
+    return cachedProjectRoot;
+  const found = findConfigDir(process.cwd());
+  cachedProjectRoot = found ?? process.cwd();
+  return cachedProjectRoot;
+}
+function getPackageRoot() {
+  let dir = import.meta.dirname;
+  while (!existsSync(join(dir, "package.json"))) {
+    const parent = dirname(dir);
+    if (parent === dir)
+      return dir;
+    dir = parent;
+  }
+  return dir;
+}
+async function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  const projectRoot = getProjectRoot();
+  let userConfig = {};
+  for (const configDir of [CONFIG_DIR, LEGACY_CONFIG_DIR]) {
+    const dir = join(projectRoot, configDir);
+    let found = false;
+    for (const name of CONFIG_FILENAMES) {
+      const configPath = join(dir, name);
+      if (existsSync(configPath)) {
+        try {
+          const fileUrl = pathToFileURL(configPath).href;
+          const mod = await import(fileUrl);
+          userConfig = mod.default ?? mod;
+          found = true;
+          break;
+        } catch {}
+      }
+    }
+    if (found)
+      break;
+  }
+  cachedConfig = QaiConfigSchema.parse(userConfig);
+  return cachedConfig;
+}
+
+export { defineConfig, CONFIG_DIR, getProjectRoot, getPackageRoot, loadConfig };

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 };

package/dist/cli.js

@@ -4,24 +4,26 @@ import {
   getPackageRoot,
   getProjectRoot,
   loadConfig
-} from "./cli-m3fv379v.js";
+} from "./cli-cymqw41r.js";
 import"./cli-z2krvkcq.js";
 import {
   dist_default2 as dist_default,
   dist_default3 as dist_default2,
   dist_default9 as dist_default3
 } from "./cli-eyd8t0cw.js";
+import {
+  runExploration
+} from "./cli-g7n2me6z.js";
 import {
   banner,
   error,
   header,
   info,
   require_picocolors,
-  runExploration,
   setVerbose,
   success,
   warn
-} from "./cli-qb5kgwe4.js";
+} from "./cli-b26q1e27.js";
 import {
   ensureDir,
   writeFile
@@ -29,7 +31,7 @@ import {
 import {
   generateIndexHtml,
   generateReadme
-} from "./cli-07avh830.js";
+} from "./cli-6qr9gvkp.js";
 import {
   __commonJS,
   __require,
@@ -3117,13 +3119,9 @@ function registerAuth(program2) {
 // src/commands/mcp.ts
 var import_picocolors3 = __toESM(require_picocolors(), 1);
 var TOOLS = [
-  "zefiro_scan_codebase           — scan project test infrastructure",
-  "zefiro_scan_ast                — deep AST scan: routes, components, hooks",
-  "zefiro_scan_ast_detail         — drill into a specific AST category",
-  "zefiro_extract_state_variables — V4: extract state variables from AST",
-  "zefiro_build_v4_graph          — V4: build formal model from AST + state",
-  "zefiro_build_qa_map            — validate + write QA map (V2/V3/V4)",
-  "zefiro_read_qa_map             — read existing QA map file"
+  "zefiro_explore              — explore a web application via BFS",
+  "zefiro_read_docs            — read generated documentation",
+  "zefiro_scan_codebase        — scan project test infrastructure"
 ];
 var DESKTOP_CONFIG = JSON.stringify({
   mcpServers: {
@@ -3216,11 +3214,6 @@ async function migrateFromLegacy(projectRoot, nonInteractive) {
       cpSync(astSrc, join4(newPath, "ast-scan.json"));
       migrated++;
     }
-    const qamapSrc = join4(legacyPath, "qa-map.json");
-    if (existsSync2(qamapSrc)) {
-      cpSync(qamapSrc, join4(newPath, "qa-map.json"));
-      migrated++;
-    }
     success(`Migrated ${migrated} item(s) from ${LEGACY_DIR}/ to ${CONFIG_DIR}/`);
     if (!nonInteractive) {
       const remove = await dist_default({
@@ -3242,7 +3235,8 @@ async function migrateFromLegacy(projectRoot, nonInteractive) {
 }
 
 // src/commands/init.ts
-var SKILLS_TARGET = ".claude/skills/zefiro";
+var SKILLS_TARGET_BASE = ".claude/skills";
+var SKILL_DIRS = ["zefiro", "zefiro-copilot"];
 function registerInit(program2) {
   program2.command("init").description("Initialize zefiro configuration for your project").option("--non-interactive", "Skip interactive prompts, use defaults").action(async (cmdOpts) => {
     try {
@@ -3340,40 +3334,52 @@ ${qaiBlock}
   success(`Environment variables written to .env`);
 }
 async function copySkillsToLocal(projectRoot, packageRoot, nonInteractive) {
-  const sourceDir = join5(packageRoot, "skills", "zefiro");
-  const targetDir = join5(projectRoot, SKILLS_TARGET);
-  if (!existsSync3(sourceDir)) {
+  const sourceBase = join5(packageRoot, "skills");
+  const targetBase = join5(projectRoot, SKILLS_TARGET_BASE);
+  if (!existsSync3(sourceBase)) {
     warn("Could not read package skills directory");
     return 0;
   }
-  const files = collectMarkdownFiles(sourceDir, sourceDir);
-  if (files.length === 0)
+  let totalSourceFiles = [];
+  let totalExistingFiles = 0;
+  for (const skillDir of SKILL_DIRS) {
+    const sourceDir = join5(sourceBase, skillDir);
+    if (!existsSync3(sourceDir))
+      continue;
+    const files = collectMarkdownFiles(sourceDir, sourceDir);
+    for (const f of files)
+      totalSourceFiles.push({ dir: skillDir, relPath: f });
+  }
+  if (totalSourceFiles.length === 0)
     return 0;
-  const targetExists = existsSync3(targetDir);
-  if (targetExists) {
-    const existingFiles = collectMarkdownFiles(targetDir, targetDir);
-    if (existingFiles.length > 0) {
-      if (nonInteractive) {
-        info(`Skill files already exist in ${SKILLS_TARGET}/, skipping`);
-        return 0;
-      }
-      const { confirm } = await import("./index-0yaea7f8.js");
-      const overwrite = await confirm({
-        message: `Update skills to latest version? (${files.length} files, currently ${existingFiles.length} in ${SKILLS_TARGET}/)`,
-        default: true
-      });
-      if (!overwrite) {
-        info("Skipping skill copy");
-        return 0;
-      }
+  for (const skillDir of SKILL_DIRS) {
+    const targetDir = join5(targetBase, skillDir);
+    if (existsSync3(targetDir)) {
+      totalExistingFiles += collectMarkdownFiles(targetDir, targetDir).length;
+    }
+  }
+  if (totalExistingFiles > 0) {
+    if (nonInteractive) {
+      info(`Skill files already exist in ${SKILLS_TARGET_BASE}/, skipping`);
+      return 0;
+    }
+    const { confirm } = await import("./index-0yaea7f8.js");
+    const overwrite = await confirm({
+      message: `Update skills to latest version? (${totalSourceFiles.length} files, currently ${totalExistingFiles} in ${SKILLS_TARGET_BASE}/)`,
+      default: true
+    });
+    if (!overwrite) {
+      info("Skipping skill copy");
+      return 0;
     }
   }
-  for (const relPath of files) {
-    const content = readFileSync3(join5(sourceDir, relPath), "utf-8");
-    writeFile(join5(targetDir, relPath), content);
+  for (const { dir, relPath } of totalSourceFiles) {
+    const content = readFileSync3(join5(sourceBase, dir, relPath), "utf-8");
+    writeFile(join5(targetBase, dir, relPath), content);
   }
-  success(`Skills copied to ${SKILLS_TARGET}/ (${files.length} files)`);
-  return files.length;
+  const skillNames = SKILL_DIRS.join(", ");
+  success(`Skills copied to ${SKILLS_TARGET_BASE}/ [${skillNames}] (${totalSourceFiles.length} files)`);
+  return totalSourceFiles.length;
 }
 function collectMarkdownFiles(dir, baseDir) {
   const results = [];
@@ -3411,7 +3417,7 @@ var hasFlags = userArgs.some((a) => a.startsWith("-"));
 var cols = process.stdout.columns || 80;
 var rows = process.stdout.rows || 24;
 if (!hasCommand && !hasFlags && process.stdout.isTTY && cols >= 60 && rows >= 20) {
-  const { launchTui } = await import("./App-3e6t6c8c.js");
+  const { launchTui } = await import("./App-bh752tgg.js");
   await launchTui(program2);
 } else {
   program2.parse();

package/dist/explorer-g6bmbak1.js

@@ -0,0 +1,10 @@
+import {
+  runExploration
+} from "./cli-g7n2me6z.js";
+import"./cli-b26q1e27.js";
+import"./cli-zvk8gwe4.js";
+import"./cli-6qr9gvkp.js";
+import"./cli-wckvcay0.js";
+export {
+  runExploration
+};