@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-J5SKD6LN.js

@@ -0,0 +1,235 @@
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/tree.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { DEFAULT_WALK_IGNORE_DIRS, compileGlob, expectDefined } from "@wrongstack/core/utils";
+var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
+  ...DEFAULT_WALK_IGNORE_DIRS,
+  ".wrongstack",
+  ".ssh",
+  ".gnupg",
+  ".aws"
+]);
+var DEFAULT_MAX_ENTRIES = 5e3;
+var MAX_TREE_OUTPUT_BYTES = 256 * 1024;
+var treeTool = {
+  name: "tree",
+  category: "Filesystem",
+  description: "Display a project or subpath directory tree. Use it for structural layout; use index-backed `codebase-search` first for code understanding when it is live.",
+  usageHint: "DIRECTORY-LAYOUT EXPLORATION:\n\n- When `codebase-search` is live, use it first for symbols and concepts; use `tree` when the directory hierarchy itself matters.\n- Tune `depth` (default 3) and use `glob`/`exclude` to focus the view.\n- Prefer this over raw `bash find` or `glob` + manual reading when you need a quick structural overview.\nOutput is truncated for very large trees.",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  icon: "tree",
+  maxOutputBytes: 262144,
+  timeoutMs: 15e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Root directory to display the tree from (defaults to project root)."
+      },
+      depth: {
+        type: "integer",
+        description: "Maximum directory depth to traverse (default 3, use 0 for unlimited).",
+        minimum: 0,
+        maximum: 20
+      },
+      glob: {
+        type: "string",
+        description: "Only include files matching this glob pattern."
+      },
+      exclude: {
+        type: "array",
+        items: { type: "string" },
+        description: "List of directory names to completely ignore."
+      },
+      show_files: {
+        type: "boolean",
+        description: "Whether to show individual files (default true)."
+      },
+      show_dirs: {
+        type: "boolean",
+        description: "Whether to show directories (default true)."
+      },
+      show_hidden: {
+        type: "boolean",
+        description: "Show hidden files starting with . (default: false)"
+      },
+      max_entries: {
+        type: "integer",
+        description: `Maximum entries retained in the rendered tree (default ${DEFAULT_MAX_ENTRIES}).`,
+        minimum: 1,
+        maximum: 5e4
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = treeTool.executeStream;
+    if (!executeStream) throw new Error("treeTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("tree: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    const basePath = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+    const maxDepth = input.depth ?? 3;
+    const showFiles = input.show_files ?? true;
+    const showDirs = input.show_dirs ?? true;
+    const showHidden = input.show_hidden ?? false;
+    const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...input.exclude ?? []]);
+    const globRe = input.glob ? compileGlob(input.glob) : void 0;
+    const maxEntries = input.max_entries ?? DEFAULT_MAX_ENTRIES;
+    const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    const lines = [basePath];
+    const totals = { totalFiles: { value: 0 }, totalDirs: { value: 0 } };
+    const retention = {
+      entries: 0,
+      outputBytes: Buffer.byteLength(basePath, "utf8"),
+      maxEntries,
+      maxOutputBytes: MAX_TREE_OUTPUT_BYTES,
+      truncated: false
+    };
+    const queue = [];
+    const FLUSH_EVERY = 200;
+    let lastEmittedTotal = 0;
+    const tickProgress = () => {
+      const seen = totals.totalFiles.value + totals.totalDirs.value;
+      if (seen - lastEmittedTotal >= FLUSH_EVERY) {
+        queue.push({
+          type: "metric",
+          text: `${seen} entries`,
+          data: { files: totals.totalFiles.value, dirs: totals.totalDirs.value }
+        });
+        lastEmittedTotal = seen;
+      }
+    };
+    const walkPromise = walkDir(basePath, 0, {
+      maxDepth,
+      exclude,
+      showFiles,
+      showDirs,
+      showHidden,
+      globRe,
+      basePath,
+      lines,
+      prefix: "",
+      isLast: true,
+      totalFiles: totals.totalFiles,
+      totalDirs: totals.totalDirs,
+      onProgress: tickProgress,
+      retention,
+      signal
+    });
+    let walkDone = false;
+    void walkPromise.then(
+      () => {
+        walkDone = true;
+      },
+      () => {
+        walkDone = true;
+      }
+    );
+    while (!walkDone || queue.length > 0) {
+      if (queue.length > 0) {
+        yield expectDefined(queue.shift());
+      } else {
+        let pollTimer;
+        const poll = new Promise((r) => {
+          pollTimer = setTimeout(r, 50);
+        });
+        try {
+          await Promise.race([walkPromise, poll]).catch(() => void 0);
+        } finally {
+          if (pollTimer) clearTimeout(pollTimer);
+        }
+      }
+    }
+    await walkPromise;
+    yield {
+      type: "final",
+      output: {
+        tree: lines.join("\n"),
+        total_files: totals.totalFiles.value,
+        total_dirs: totals.totalDirs.value,
+        truncated: retention.truncated,
+        path: basePath
+      }
+    };
+  }
+};
+function matchesTreeGlob(globRe, fileName, absPath, basePath) {
+  if (globRe.test(fileName)) return true;
+  const rel = path.relative(basePath, absPath);
+  const posixRel = !rel || rel.startsWith("..") || path.isAbsolute(rel) ? absPath.split(path.sep).join("/") : rel.split(path.sep).join("/");
+  return globRe.test(posixRel);
+}
+async function walkDir(dir, depth, opts) {
+  opts.signal.throwIfAborted();
+  if (opts.retention.truncated) return;
+  const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const filtered = entries.filter((e) => {
+    if (!opts.showHidden && e.name.startsWith(".")) return false;
+    if (opts.exclude.has(e.name)) return false;
+    if (e.isFile() && opts.globRe) {
+      const abs = path.join(dir, e.name);
+      if (!matchesTreeGlob(opts.globRe, e.name, abs, opts.basePath)) return false;
+    }
+    return true;
+  });
+  let dirCount = 0;
+  let fileCount = 0;
+  for (const e of filtered) {
+    if (e.isDirectory()) dirCount++;
+    else if (e.isFile()) fileCount++;
+  }
+  opts.totalDirs.value += dirCount;
+  opts.totalFiles.value += fileCount;
+  opts.onProgress?.();
+  const items = filtered.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (let i = 0; i < items.length; i++) {
+    opts.signal.throwIfAborted();
+    if (opts.retention.truncated) return;
+    const entry = items[i];
+    if (!entry) continue;
+    const isLast = i === items.length - 1;
+    const connector = opts.isLast ? "    " : "\u2502   ";
+    const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const displayName = entry.name + (entry.isDirectory() ? "/" : "");
+    if (!opts.showDirs && entry.isDirectory()) continue;
+    if (!opts.showFiles && entry.isFile()) continue;
+    const line = opts.prefix + branch + displayName;
+    const lineBytes = Buffer.byteLength(line, "utf8") + 1;
+    if (opts.retention.entries >= opts.retention.maxEntries || opts.retention.outputBytes + lineBytes > opts.retention.maxOutputBytes) {
+      opts.retention.truncated = true;
+      return;
+    }
+    opts.lines.push(line);
+    opts.retention.entries++;
+    opts.retention.outputBytes += lineBytes;
+    if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
+      const childPrefix = opts.prefix + connector;
+      await walkDir(path.join(dir, entry.name), depth + 1, {
+        ...opts,
+        prefix: childPrefix,
+        isLast
+      });
+    }
+  }
+}
+
+export {
+  treeTool
+};
+//# sourceMappingURL=chunk-J5SKD6LN.js.map

package/dist/chunk-JRJJX3L5.js

@@ -0,0 +1,424 @@
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/e2e.ts
+import { open, readdir } from "node:fs/promises";
+import * as path from "node:path";
+async function readBoundedText(filePath, maxBytes) {
+  let handle;
+  try {
+    handle = await open(filePath, "r");
+    const info = await handle.stat();
+    if (!info.isFile() || info.size > maxBytes) return void 0;
+    const buffer = Buffer.alloc(info.size);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } catch {
+    return void 0;
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
+var CONFIG_NAMES = /* @__PURE__ */ new Map([
+  ["playwright.config.ts", "playwright"],
+  ["playwright.config.js", "playwright"],
+  ["playwright.config.mts", "playwright"],
+  ["playwright.config.mjs", "playwright"],
+  ["playwright.config.cts", "playwright"],
+  ["playwright.config.cjs", "playwright"],
+  ["cypress.config.ts", "cypress"],
+  ["cypress.config.js", "cypress"],
+  ["cypress.config.mts", "cypress"],
+  ["cypress.config.mjs", "cypress"],
+  ["cypress.config.cts", "cypress"],
+  ["cypress.config.cjs", "cypress"],
+  ["cypress.json", "cypress"]
+]);
+var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".wrongstack",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "coverage-html",
+  "playwright-report",
+  "test-results",
+  ".next"
+]);
+var MAX_SCAN_DIRECTORIES = 4e3;
+var MAX_PACKAGE_BYTES = 512 * 1024;
+var MAX_CONFIG_BYTES = 512 * 1024;
+var MAX_SPEC_SAMPLES = 20;
+function relativePath(root, target) {
+  const value = path.relative(root, target) || ".";
+  return value.split(path.sep).join("/");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function staticString(source, property) {
+  const key = escapeRegExp(property);
+  const direct = source.match(
+    new RegExp(`(?:['"]?${key}['"]?)\\s*:\\s*(['"\\x60])([^'"\\x60\\r\\n]*)\\1`)
+  );
+  if (direct?.[2] && !direct[2].includes("${")) return direct[2];
+  const sameLineFallback = source.match(
+    new RegExp(`(?:['"]?${key}['"]?)\\s*:[^\\r\\n]{0,300}?(['"\\x60])([^'"\\x60\\r\\n]*)\\1`)
+  );
+  return sameLineFallback?.[2] && !sameLineFallback[2].includes("${") ? sameLineFallback[2] : void 0;
+}
+function staticNumber(source, property) {
+  const key = escapeRegExp(property);
+  const match = source.match(new RegExp(`(?:['"]?${key}['"]?)\\s*:\\s*(\\d{2,5})\\b`));
+  return match?.[1] ? Number.parseInt(match[1], 10) : void 0;
+}
+function serverHints(framework, source) {
+  if (framework === "playwright" && /\bwebServer\s*:/.test(source)) {
+    const command = staticString(source, "command");
+    const url = staticString(source, "url");
+    const port = staticNumber(source, "port");
+    return [
+      {
+        kind: "managed",
+        ...command ? { command } : {},
+        ...url ? { url } : {},
+        ...port ? { port } : {},
+        source: "static-config",
+        incomplete: !command || !url && !port
+      }
+    ];
+  }
+  const baseUrl = staticString(source, "baseURL") ?? staticString(source, "baseUrl");
+  return baseUrl ? [{ kind: "attach", url: baseUrl, source: "static-config", incomplete: false }] : [];
+}
+function configuredSpecPattern(framework, source) {
+  if (framework === "playwright") {
+    const testDir = staticString(source, "testDir") ?? "./tests";
+    return `${testDir.replace(/\/$/, "")}/**/*.{spec,test}.{js,jsx,ts,tsx,mjs,cjs}`;
+  }
+  return staticString(source, "specPattern") ?? "cypress/{e2e,integration}/**/*.cy.{js,jsx,ts,tsx,mjs,cjs}";
+}
+async function scanWorkspace(root, maxDepth, signal) {
+  const result = {
+    configs: [],
+    packageFiles: [],
+    scannedDirectories: 0,
+    truncated: false
+  };
+  const queue = [{ directory: root, depth: 0 }];
+  while (queue.length > 0) {
+    signal.throwIfAborted();
+    const current = queue.shift();
+    if (!current) break;
+    result.scannedDirectories += 1;
+    if (result.scannedDirectories > MAX_SCAN_DIRECTORIES) {
+      result.truncated = true;
+      break;
+    }
+    let entries;
+    try {
+      entries = await readdir(current.directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      signal.throwIfAborted();
+      const absolutePath = path.join(current.directory, entry.name);
+      if (entry.isFile()) {
+        if (entry.name === "package.json") result.packageFiles.push(absolutePath);
+        const framework = CONFIG_NAMES.get(entry.name);
+        if (framework) result.configs.push({ framework, absolutePath });
+      } else if (entry.isDirectory() && current.depth < maxDepth && !SKIP_DIRECTORIES.has(entry.name) && !entry.name.startsWith("coverage-") && !entry.name.startsWith("cov-")) {
+        queue.push({ directory: absolutePath, depth: current.depth + 1 });
+      }
+    }
+  }
+  return result;
+}
+async function readPackageInfo(packagePath) {
+  try {
+    const raw = await readBoundedText(packagePath, MAX_PACKAGE_BYTES);
+    if (raw === void 0) return void 0;
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts && typeof parsed.scripts === "object" ? Object.fromEntries(
+      Object.entries(parsed.scripts).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ) : {};
+    const dependencies = /* @__PURE__ */ new Set();
+    for (const field of ["dependencies", "devDependencies", "optionalDependencies"]) {
+      const value = parsed[field];
+      if (!value || typeof value !== "object") continue;
+      for (const name of Object.keys(value)) dependencies.add(name);
+    }
+    const declared = typeof parsed.packageManager === "string" ? parsed.packageManager.split("@")[0] ?? "" : "";
+    const packageManager = ["pnpm", "npm", "yarn", "bun"].includes(declared) ? declared : void 0;
+    return { path: packagePath, scripts, dependencies, packageManager };
+  } catch {
+    return void 0;
+  }
+}
+function frameworkFromPackage(info) {
+  const found = /* @__PURE__ */ new Set();
+  if (info.dependencies.has("@playwright/test") || info.dependencies.has("playwright")) {
+    found.add("playwright");
+  }
+  if (info.dependencies.has("cypress")) found.add("cypress");
+  for (const command of Object.values(info.scripts)) {
+    if (/\bplaywright(?:\.cmd)?\b/i.test(command)) found.add("playwright");
+    if (/\bcypress(?:\.cmd)?\b/i.test(command)) found.add("cypress");
+  }
+  return [...found];
+}
+async function detectPackageManager(projectRoot, scanRoot, declared) {
+  if (declared) return declared;
+  let directory = projectRoot;
+  while (true) {
+    const names = /* @__PURE__ */ new Set();
+    try {
+      for (const entry of await readdir(directory)) names.add(entry);
+    } catch {
+    }
+    if (names.has("pnpm-lock.yaml")) return "pnpm";
+    if (names.has("yarn.lock")) return "yarn";
+    if (names.has("bun.lock") || names.has("bun.lockb")) return "bun";
+    if (names.has("package-lock.json") || names.has("npm-shrinkwrap.json")) return "npm";
+    if (directory === scanRoot) break;
+    const parent = path.dirname(directory);
+    const relativeParent = path.relative(scanRoot, parent);
+    if (parent === directory || relativeParent.startsWith("..") || path.isAbsolute(relativeParent)) {
+      break;
+    }
+    directory = parent;
+  }
+  return "npm";
+}
+function matchingScripts(info, framework) {
+  if (!info) return [];
+  const matcher = framework === "playwright" ? /\bplaywright(?:\.cmd)?\b/i : /\bcypress(?:\.cmd)?\b/i;
+  return Object.entries(info.scripts).filter(([, command]) => matcher.test(command)).map(([name]) => name).sort((a, b) => {
+    const preferred = ["test:e2e", "e2e", "e2e:test"];
+    const ai = preferred.indexOf(a);
+    const bi = preferred.indexOf(b);
+    if (ai !== -1 || bi !== -1) return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+    return a.localeCompare(b);
+  });
+}
+function executionPlan(framework, manager, root, configPath, scripts) {
+  const script = scripts[0];
+  if (script) {
+    return {
+      command: manager,
+      args: ["run", script],
+      cwd: root,
+      source: "package-script",
+      script
+    };
+  }
+  const runnerArgs = framework === "playwright" ? ["playwright", "test"] : ["cypress", "run"];
+  if (configPath) {
+    runnerArgs.push(framework === "playwright" ? "--config" : "--config-file", configPath);
+  }
+  return {
+    command: manager === "bun" ? "bunx" : manager,
+    args: manager === "bun" ? runnerArgs : manager === "npm" ? ["exec", "--", ...runnerArgs] : ["exec", ...runnerArgs],
+    cwd: root,
+    source: "framework-default"
+  };
+}
+function isSpec(framework, filename) {
+  if (framework === "cypress") return /\.cy\.(?:[cm]?[jt]sx?)$/i.test(filename);
+  return /\.(?:spec|test)\.(?:[cm]?[jt]sx?)$/i.test(filename);
+}
+async function collectSpecs(root, framework, testDirectory, signal) {
+  const roots = testDirectory ? [path.resolve(root, testDirectory)] : framework === "cypress" ? [path.join(root, "cypress", "e2e"), path.join(root, "cypress", "integration")] : [path.join(root, "tests")];
+  const samples = [];
+  let count = 0;
+  let scanned = 0;
+  const queue = [...roots];
+  while (queue.length > 0) {
+    signal.throwIfAborted();
+    const directory = queue.shift();
+    if (!directory) break;
+    scanned += 1;
+    if (scanned > MAX_SCAN_DIRECTORIES) return { count, samples, truncated: true };
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      signal.throwIfAborted();
+      const target = path.join(directory, entry.name);
+      if (entry.isDirectory() && !SKIP_DIRECTORIES.has(entry.name)) queue.push(target);
+      else if (entry.isFile() && isSpec(framework, entry.name)) {
+        count += 1;
+        if (samples.length < MAX_SPEC_SAMPLES) samples.push(relativePath(root, target));
+      }
+    }
+  }
+  return { count, samples, truncated: count > samples.length };
+}
+async function readConfig(configPath) {
+  if (!configPath) return "";
+  return await readBoundedText(configPath, MAX_CONFIG_BYTES) ?? "";
+}
+function nearestPackage(projectRoot, packagesByDirectory, scanRoot) {
+  let directory = projectRoot;
+  while (true) {
+    const found = packagesByDirectory.get(directory);
+    if (found) return found;
+    if (directory === scanRoot) return void 0;
+    const parent = path.dirname(directory);
+    if (parent === directory || relativePath(scanRoot, parent).startsWith("..")) return void 0;
+    directory = parent;
+  }
+}
+async function discoverE2EProjects(root, options) {
+  const maxDepth = Math.max(0, Math.min(options.maxDepth ?? 5, 8));
+  const scan = await scanWorkspace(root, maxDepth, options.signal);
+  const packages = (await Promise.all(scan.packageFiles.map(readPackageInfo))).filter(
+    (info) => Boolean(info)
+  );
+  const packagesByDirectory = new Map(packages.map((info) => [path.dirname(info.path), info]));
+  const candidates = /* @__PURE__ */ new Map();
+  for (const config of scan.configs) {
+    if (options.framework && options.framework !== "all" && config.framework !== options.framework) {
+      continue;
+    }
+    const projectRoot = path.dirname(config.absolutePath);
+    candidates.set(`${config.framework}:${projectRoot}`, {
+      framework: config.framework,
+      root: projectRoot,
+      configPath: config.absolutePath
+    });
+  }
+  for (const info of packages) {
+    const projectRoot = path.dirname(info.path);
+    for (const framework of frameworkFromPackage(info)) {
+      if (options.framework && options.framework !== "all" && framework !== options.framework)
+        continue;
+      const key = `${framework}:${projectRoot}`;
+      if (!candidates.has(key)) candidates.set(key, { framework, root: projectRoot });
+    }
+  }
+  const projects = [];
+  for (const candidate of candidates.values()) {
+    options.signal.throwIfAborted();
+    const info = nearestPackage(candidate.root, packagesByDirectory, root);
+    const source = await readConfig(candidate.configPath);
+    const scripts = matchingScripts(info, candidate.framework);
+    const manager = await detectPackageManager(candidate.root, root, info?.packageManager);
+    const testDirectory = candidate.framework === "playwright" ? staticString(source, "testDir") : void 0;
+    const resolvedTestDirectory = testDirectory ? path.resolve(candidate.root, testDirectory) : void 0;
+    const relativeTestDirectory = resolvedTestDirectory ? path.relative(root, resolvedTestDirectory) : void 0;
+    const unsafeTestDirectory = Boolean(
+      relativeTestDirectory && (relativeTestDirectory.startsWith("..") || path.isAbsolute(relativeTestDirectory))
+    );
+    const specs = options.includeSpecs === false || unsafeTestDirectory ? { count: 0, samples: [], truncated: false } : await collectSpecs(candidate.root, candidate.framework, testDirectory, options.signal);
+    const warnings = [];
+    if (!candidate.configPath)
+      warnings.push("Framework dependency or script found without a config file.");
+    if (candidate.configPath && !source) {
+      warnings.push("Config could not be read or exceeded the static inspection limit.");
+    }
+    if (unsafeTestDirectory) {
+      warnings.push(
+        "Configured testDir resolves outside the requested discovery root and was not scanned."
+      );
+    }
+    const hints = serverHints(candidate.framework, source);
+    if (hints.some((hint) => hint.incomplete)) {
+      warnings.push("Configured server contains dynamic values; only static hints are shown.");
+    }
+    projects.push({
+      framework: candidate.framework,
+      root: relativePath(root, candidate.root),
+      ...candidate.configPath ? { configPath: relativePath(root, candidate.configPath) } : {},
+      ...info ? { packagePath: relativePath(root, info.path) } : {},
+      packageManager: manager,
+      evidence: [
+        ...candidate.configPath ? [`config:${relativePath(root, candidate.configPath)}`] : [],
+        ...info?.dependencies.has(
+          candidate.framework === "playwright" ? "@playwright/test" : "cypress"
+        ) ? [`dependency:${candidate.framework === "playwright" ? "@playwright/test" : "cypress"}`] : [],
+        ...scripts.map((script) => `script:${script}`)
+      ],
+      scripts,
+      serverHints: hints,
+      specPattern: configuredSpecPattern(candidate.framework, source),
+      specCount: specs.count,
+      specSamples: specs.samples,
+      specsTruncated: specs.truncated,
+      execution: executionPlan(
+        candidate.framework,
+        manager,
+        relativePath(root, candidate.root),
+        candidate.configPath ? relativePath(candidate.root, candidate.configPath) : void 0,
+        scripts
+      ),
+      warnings
+    });
+  }
+  projects.sort((a, b) => a.root.localeCompare(b.root) || a.framework.localeCompare(b.framework));
+  return {
+    root,
+    projects,
+    scannedDirectories: scan.scannedDirectories,
+    scanTruncated: scan.truncated,
+    warnings: scan.truncated ? [`Discovery stopped after ${MAX_SCAN_DIRECTORIES} directories; narrow cwd or maxDepth.`] : []
+  };
+}
+var e2ePlanTool = {
+  name: "e2e_plan",
+  category: "Code Quality",
+  description: "Discover Playwright and Cypress projects and preview bounded E2E execution plans without loading configs or starting processes.",
+  usageHint: "Use before running browser E2E tests. The result identifies authoritative configs, package scripts, static server hints, specs, and exact argv. This tool never imports project config or executes commands.",
+  permission: "auto",
+  mutating: false,
+  riskTier: "safe",
+  capabilities: ["fs.read"],
+  icon: "test",
+  timeoutMs: 3e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      cwd: { type: "string", description: "Directory inside the project to inspect." },
+      framework: {
+        type: "string",
+        enum: ["all", "playwright", "cypress"],
+        description: "Optional framework filter; defaults to all."
+      },
+      maxDepth: {
+        type: "integer",
+        minimum: 0,
+        maximum: 8,
+        description: "Maximum workspace discovery depth; defaults to 5."
+      },
+      includeSpecs: {
+        type: "boolean",
+        description: "Count and sample specs; defaults to true."
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    const root = await safeResolveReal(input.cwd ?? ".", ctx);
+    return discoverE2EProjects(root, {
+      framework: input.framework,
+      maxDepth: input.maxDepth,
+      includeSpecs: input.includeSpecs,
+      signal: opts.signal
+    });
+  }
+};
+
+export {
+  discoverE2EProjects,
+  e2ePlanTool
+};
+//# sourceMappingURL=chunk-JRJJX3L5.js.map