@crafter/cli-tree 0.1.0

package/dist/chunk-ykze151b.js

@@ -0,0 +1,770 @@
+import {
+  parseHelp,
+  parseHelpRecursive
+} from "./chunk-5aahbfr2.js";
+
+// src/archaeology/types.ts
+function toCLINode(node) {
+  const base = { name: node.name };
+  if (node.description)
+    base.description = node.description;
+  if (node.aliases)
+    base.aliases = node.aliases;
+  if (node.subcommands)
+    base.subcommands = node.subcommands.map(toCLINode);
+  if (node.flags)
+    base.flags = node.flags.map((f) => ({ ...f }));
+  if (node.args)
+    base.args = node.args.map((a) => ({ ...a }));
+  return base;
+}
+function fromCLINode(node, source = { type: "help", confidence: 1 }) {
+  const base = { name: node.name, source };
+  if (node.description)
+    base.description = node.description;
+  if (node.aliases)
+    base.aliases = node.aliases;
+  if (node.subcommands)
+    base.subcommands = node.subcommands.map((s) => fromCLINode(s, source));
+  if (node.flags)
+    base.flags = node.flags.map((f) => ({ ...f, source }));
+  if (node.args)
+    base.args = node.args.map((a) => ({ ...a, source }));
+  return base;
+}
+// src/archaeology/prompts.ts
+function surveyPrompt(ctx) {
+  return `You are a CLI archaeologist. Your task is to produce a hypothesis map of the \`${ctx.cli}\` CLI based on your training knowledge.
+
+${ctx.version ? `Version: ${ctx.version}
+` : ""}Do not invoke the CLI yet. This is survey phase — hypothesize what families of commands exist and what subcommands belong to each family.
+
+Output STRICT JSON matching this schema:
+
+\`\`\`json
+{
+  "cli": "${ctx.cli}",
+  "description": "<one-line description of the CLI>",
+  "families": [
+    {
+      "name": "<family name, e.g. 'container management'>",
+      "description": "<one line>",
+      "subcommands": ["<subcommand-name>", ...]
+    }
+  ],
+  "topLevelFlags": ["--global-flag-1", "--global-flag-2"]
+}
+\`\`\`
+
+Rules:
+- Group related subcommands into families (container, image, network, auth, config, etc).
+- List ONLY subcommand names — no descriptions in this phase.
+- Include hidden/experimental commands you know about.
+- topLevelFlags = flags that work on the root (e.g. --version, --help, --config).
+- Output ONLY the JSON, no prose before or after.`;
+}
+function excavationPrompt(ctx, subcommandPath) {
+  const cmd = [ctx.cli, ...subcommandPath].join(" ");
+  return `You are a CLI archaeologist, currently excavating the \`${cmd}\` subcommand.
+
+You will validate your hypothesis by running the real CLI. Use the Bash tool to run:
+
+\`${cmd} --help\`
+
+Then parse its output and produce a structured description of this subcommand.
+
+Output STRICT JSON matching this schema:
+
+\`\`\`json
+{
+  "command": ${JSON.stringify([ctx.cli, ...subcommandPath])},
+  "exists": true|false,
+  "description": "<description from help output>",
+  "subcommands": [
+    { "name": "<sub>", "description": "<desc>" }
+  ],
+  "flags": [
+    {
+      "name": "flag-name",
+      "short": "f",
+      "type": "boolean|string|number|enum",
+      "description": "<desc>",
+      "required": false
+    }
+  ],
+  "args": [
+    { "name": "input", "required": true, "variadic": false }
+  ]
+}
+\`\`\`
+
+Rules:
+- If the command does not exist or --help fails, set exists: false and return empty arrays.
+- Extract every flag and arg from the help output.
+- Do NOT invent anything — only what is in the actual help text.
+- Output ONLY the JSON.`;
+}
+function deepDivePrompt(ctx, subcommandPath) {
+  const cmd = [ctx.cli, ...subcommandPath].join(" ");
+  return `You are a CLI archaeologist. You already excavated \`${cmd}\` from --help.
+
+Now dig deeper: based on your training knowledge, what flags exist for this command that are NOT documented in --help? Focus on:
+- Hidden flags (work but undocumented)
+- Experimental flags (marked as experimental in source code)
+- Deprecated flags (still functional but hidden)
+- Flags that only appear in man pages or shell completion scripts
+
+Output STRICT JSON:
+
+\`\`\`json
+{
+  "command": ${JSON.stringify([ctx.cli, ...subcommandPath])},
+  "hiddenFlags": [
+    {
+      "name": "flag-name",
+      "short": "f",
+      "type": "boolean|string|number|enum",
+      "hidden": true,
+      "description": "<what it does>",
+      "source": "source-code|man-page|completion|community-known"
+    }
+  ],
+  "deprecatedFlags": [
+    {
+      "name": "old-flag",
+      "description": "Deprecated in favor of --new-flag",
+      "replacement": "new-flag"
+    }
+  ],
+  "examples": [
+    "${cmd} --example-use-case"
+  ]
+}
+\`\`\`
+
+Rules:
+- Only suggest flags you are confident about. Confidence > 70%.
+- Prefer flags you have seen in real usage, PRs, issues, or man pages.
+- If unsure, omit. This phase is about quality, not quantity.
+- Output ONLY the JSON.`;
+}
+function cartographyPrompt(ctx, subcommandPath) {
+  const cmd = [ctx.cli, ...subcommandPath].join(" ");
+  return `You are a CLI archaeologist mapping flag interactions for \`${cmd}\`.
+
+Identify constraints between flags:
+- Mutually exclusive (cannot use together)
+- Requires (using A requires B)
+- Implies (using A sets B automatically)
+
+Output STRICT JSON:
+
+\`\`\`json
+{
+  "command": ${JSON.stringify([ctx.cli, ...subcommandPath])},
+  "constraints": [
+    {
+      "type": "mutually-exclusive|requires|implies",
+      "flags": ["--flag-a", "--flag-b"],
+      "description": "<human explanation>"
+    }
+  ]
+}
+\`\`\`
+
+Rules:
+- Only list constraints you are confident about.
+- Reference real flags from the --help output, not hypothetical ones.
+- Output ONLY the JSON.`;
+}
+function validationInstructions(cli) {
+  return `You are validating an archaeology result for \`${cli}\`.
+
+For each command/flag proposed by the LLM survey phase, you must:
+
+1. Run \`<cli> <subcommand> --help\` via the Bash tool.
+2. Parse the real help output.
+3. Mark each flag as:
+   - "verified" — appears in --help, can confirm it exists
+   - "rejected" — does NOT appear in --help, LLM hallucinated
+   - "unconfirmed" — not in --help but LLM may still be correct (hidden flags)
+
+Return a validation report. Flags marked "rejected" must be removed from the final tree.
+Flags marked "unconfirmed" are kept only if --include-unverified is set.`;
+}
+function extractJsonFromLlmResponse(response) {
+  const fenced = response.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  const raw = fenced ? fenced[1] : response;
+  const trimmed = raw.trim();
+  return JSON.parse(trimmed);
+}
+// src/archaeology/validate.ts
+async function runHelpCommand(binary, subcommandPath) {
+  try {
+    const proc = Bun.spawn([binary, ...subcommandPath, "--help"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const timeout = setTimeout(() => proc.kill(), 5000);
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    clearTimeout(timeout);
+    await proc.exited;
+    const output = stdout || stderr;
+    return output.trim() ? output : null;
+  } catch {
+    return null;
+  }
+}
+async function validateSubcommandExists(binary, subcommandPath) {
+  const output = await runHelpCommand(binary, subcommandPath);
+  if (!output)
+    return false;
+  const lower = output.toLowerCase();
+  const hasError = /unknown (command|subcommand)|command not found|no such command/.test(lower) || /is not a \w+ command/.test(lower) || /invalid (command|subcommand)/.test(lower) || /error: unrecognized/.test(lower);
+  return !hasError;
+}
+async function validateSurvey(binary, survey) {
+  const confirmed = [];
+  const rejected = [];
+  const allSubs = survey.families.flatMap((f) => f.subcommands);
+  const unique = Array.from(new Set(allSubs));
+  const BATCH = 5;
+  for (let i = 0;i < unique.length; i += BATCH) {
+    const batch = unique.slice(i, i + BATCH);
+    const results = await Promise.all(batch.map(async (sub) => ({ sub, exists: await validateSubcommandExists(binary, [sub]) })));
+    for (const { sub, exists } of results) {
+      if (exists)
+        confirmed.push(sub);
+      else
+        rejected.push(sub);
+    }
+  }
+  return { confirmed, rejected };
+}
+async function excavateCommand(binary, subcommandPath) {
+  const output = await runHelpCommand(binary, subcommandPath);
+  if (!output)
+    return null;
+  const name = subcommandPath[subcommandPath.length - 1] ?? binary;
+  return parseHelp(name, output);
+}
+async function validateDeepDive(binary, proposal) {
+  const subcommandPath = proposal.command.slice(1);
+  const realHelp = await runHelpCommand(binary, subcommandPath);
+  if (!realHelp) {
+    return {
+      command: proposal.command,
+      exists: false,
+      verifiedFlags: [],
+      rejectedFlags: proposal.flags.map((f) => f.name),
+      unconfirmedFlags: [],
+      error: "Command did not produce help output"
+    };
+  }
+  const parsed = parseHelp(subcommandPath[subcommandPath.length - 1] ?? binary, realHelp);
+  const realFlagNames = new Set(parsed.flags?.map((f) => f.name) ?? []);
+  const verifiedFlags = [];
+  const rejectedFlags = [];
+  const unconfirmedFlags = [];
+  for (const flag of proposal.flags) {
+    if (realFlagNames.has(flag.name)) {
+      verifiedFlags.push(flag.name);
+    } else if (flag.hidden || flag.deprecated) {
+      unconfirmedFlags.push(flag.name);
+    } else {
+      rejectedFlags.push(flag.name);
+    }
+  }
+  return {
+    command: proposal.command,
+    exists: true,
+    verifiedFlags,
+    rejectedFlags,
+    unconfirmedFlags,
+    rawHelp: realHelp
+  };
+}
+function summarizeValidation(verdicts) {
+  let verified = 0;
+  let rejected = 0;
+  let unconfirmed = 0;
+  const hallucinations = [];
+  for (const v of verdicts) {
+    verified += v.verifiedFlags.length;
+    rejected += v.rejectedFlags.length;
+    unconfirmed += v.unconfirmedFlags.length;
+    for (const flag of v.rejectedFlags) {
+      hallucinations.push(`${v.command.join(" ")} --${flag}`);
+    }
+  }
+  return {
+    totalProposed: verified + rejected + unconfirmed,
+    verified,
+    rejected,
+    unconfirmed,
+    hallucinations
+  };
+}
+// src/archaeology/merge.ts
+var SOURCE_PRIORITY = {
+  user: 100,
+  help: 90,
+  "llm-validated": 70,
+  man: 60,
+  completion: 55,
+  "llm-cartography": 40,
+  "llm-deep-dive": 35,
+  "llm-survey": 20
+};
+function sourceRank(source) {
+  if (!source)
+    return 0;
+  return SOURCE_PRIORITY[source.type] ?? 0;
+}
+function mergeNodes(a, b) {
+  if (a.name !== b.name) {
+    throw new Error(`Cannot merge nodes with different names: ${a.name} vs ${b.name}`);
+  }
+  const highPriority = sourceRank(a.source) >= sourceRank(b.source) ? a : b;
+  const lowPriority = highPriority === a ? b : a;
+  const merged = {
+    name: a.name,
+    source: highPriority.source
+  };
+  merged.description = highPriority.description ?? lowPriority.description;
+  if (highPriority.aliases || lowPriority.aliases) {
+    const set = new Set([...highPriority.aliases ?? [], ...lowPriority.aliases ?? []]);
+    merged.aliases = Array.from(set);
+  }
+  merged.hidden = highPriority.hidden ?? lowPriority.hidden;
+  merged.deprecated = highPriority.deprecated ?? lowPriority.deprecated;
+  merged.experimental = highPriority.experimental ?? lowPriority.experimental;
+  merged.flags = mergeFlags(highPriority.flags ?? [], lowPriority.flags ?? []);
+  if (merged.flags.length === 0)
+    delete merged.flags;
+  merged.args = mergeArgs(highPriority.args ?? [], lowPriority.args ?? []);
+  if (merged.args.length === 0)
+    delete merged.args;
+  merged.subcommands = mergeSubcommands(highPriority.subcommands ?? [], lowPriority.subcommands ?? []);
+  if (merged.subcommands.length === 0)
+    delete merged.subcommands;
+  if (highPriority.constraints || lowPriority.constraints) {
+    merged.constraints = [...highPriority.constraints ?? [], ...lowPriority.constraints ?? []];
+  }
+  if (highPriority.examples || lowPriority.examples) {
+    merged.examples = dedupeExamples([...highPriority.examples ?? [], ...lowPriority.examples ?? []]);
+  }
+  return merged;
+}
+function mergeFlags(primary, secondary) {
+  const byName = new Map;
+  for (const flag of primary) {
+    byName.set(flag.name, flag);
+  }
+  for (const flag of secondary) {
+    const existing = byName.get(flag.name);
+    if (!existing) {
+      byName.set(flag.name, flag);
+    } else {
+      byName.set(flag.name, mergeFlag(existing, flag));
+    }
+  }
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function mergeFlag(a, b) {
+  const high = sourceRank(a.source) >= sourceRank(b.source) ? a : b;
+  const low = high === a ? b : a;
+  return {
+    ...low,
+    ...high,
+    description: high.description ?? low.description,
+    short: high.short ?? low.short,
+    examples: [...high.examples ?? [], ...low.examples ?? []],
+    excludes: Array.from(new Set([...high.excludes ?? [], ...low.excludes ?? []])),
+    requires: Array.from(new Set([...high.requires ?? [], ...low.requires ?? []]))
+  };
+}
+function mergeArgs(primary, secondary) {
+  const byName = new Map;
+  for (const arg of primary)
+    byName.set(arg.name, arg);
+  for (const arg of secondary) {
+    if (!byName.has(arg.name))
+      byName.set(arg.name, arg);
+  }
+  return Array.from(byName.values());
+}
+function mergeSubcommands(primary, secondary) {
+  const byName = new Map;
+  for (const sub of primary)
+    byName.set(sub.name, sub);
+  for (const sub of secondary) {
+    const existing = byName.get(sub.name);
+    if (!existing) {
+      byName.set(sub.name, sub);
+    } else {
+      byName.set(sub.name, mergeNodes(existing, sub));
+    }
+  }
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function dedupeExamples(examples) {
+  const byCommand = new Map;
+  for (const ex of examples) {
+    const existing = byCommand.get(ex.command);
+    if (!existing || sourceRank(ex.source) > sourceRank(existing.source)) {
+      byCommand.set(ex.command, ex);
+    }
+  }
+  return Array.from(byCommand.values());
+}
+function filterUnverified(node) {
+  const copy = { ...node };
+  if (copy.flags) {
+    copy.flags = copy.flags.filter((f) => {
+      const rank = sourceRank(f.source);
+      return rank >= SOURCE_PRIORITY["llm-validated"];
+    });
+    if (copy.flags.length === 0)
+      delete copy.flags;
+  }
+  if (copy.subcommands) {
+    copy.subcommands = copy.subcommands.filter((s) => {
+      const rank = sourceRank(s.source);
+      return rank >= SOURCE_PRIORITY["llm-validated"];
+    }).map(filterUnverified);
+    if (copy.subcommands.length === 0)
+      delete copy.subcommands;
+  }
+  return copy;
+}
+// src/archaeology/cache.ts
+function getCacheDir(opts) {
+  if (opts?.cacheDir)
+    return opts.cacheDir;
+  const home = process.env.HOME ?? "";
+  if (!home)
+    throw new Error("HOME is not set; cannot determine cache directory");
+  return `${home}/.clitree/cache`;
+}
+function cachePath(cli, opts) {
+  const dir = getCacheDir(opts);
+  const safe = cli.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `${dir}/${safe}.json`;
+}
+async function loadCache(cli, opts) {
+  const path = cachePath(cli, opts);
+  const file = Bun.file(path);
+  const exists = await file.exists();
+  if (!exists)
+    return null;
+  try {
+    const data = await file.json();
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function saveCache(cli, cache, opts) {
+  const dir = getCacheDir(opts);
+  await ensureDir(dir);
+  const path = cachePath(cli, opts);
+  await Bun.write(path, JSON.stringify(cache, null, 2));
+}
+async function invalidateCache(cli, opts) {
+  const path = cachePath(cli, opts);
+  const file = Bun.file(path);
+  if (await file.exists()) {
+    await Bun.$`rm ${path}`.quiet();
+  }
+}
+function isCacheStale(cache, currentVersion, ttlDays) {
+  if (currentVersion && cache.cliVersion && cache.cliVersion !== currentVersion) {
+    return true;
+  }
+  if (ttlDays) {
+    const created = new Date(cache.createdAt).getTime();
+    const now = Date.now();
+    const ageDays = (now - created) / (1000 * 60 * 60 * 24);
+    if (ageDays > ttlDays)
+      return true;
+  }
+  return false;
+}
+async function detectCliVersion(binary) {
+  const candidates = ["--version", "-v", "version"];
+  for (const arg of candidates) {
+    try {
+      const proc = Bun.spawn([binary, arg], { stdout: "pipe", stderr: "pipe" });
+      const timeout = setTimeout(() => proc.kill(), 3000);
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      clearTimeout(timeout);
+      await proc.exited;
+      const output = (stdout || stderr).trim();
+      const match = output.match(/v?\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?/);
+      if (match)
+        return match[0];
+    } catch {}
+  }
+  return;
+}
+async function ensureDir(dir) {
+  try {
+    await Bun.$`mkdir -p ${dir}`.quiet();
+  } catch {}
+}
+function createEmptyCache(cli, tree, cliVersion) {
+  return {
+    cli,
+    cliVersion,
+    createdAt: new Date().toISOString(),
+    tree,
+    phases: {
+      survey: false,
+      excavation: false,
+      deepDive: false,
+      cartography: false
+    }
+  };
+}
+// src/archaeology/delegate.ts
+class NullDelegate {
+  name = "null";
+  available = false;
+}
+
+class BridgeFileDelegate {
+  name = "bridge-file";
+  available = true;
+  requestsPath;
+  responsesPath;
+  timeoutMs;
+  constructor(opts = {}) {
+    const tmp = process.env.TMPDIR ?? "/tmp";
+    this.requestsPath = opts.requestsPath ?? `${tmp}/clitree-requests.jsonl`;
+    this.responsesPath = opts.responsesPath ?? `${tmp}/clitree-responses.jsonl`;
+    this.timeoutMs = opts.timeoutMs ?? 120000;
+  }
+  async survey(cli, version) {
+    const id = crypto.randomUUID();
+    await this.writeRequest({ id, kind: "survey", cli, version });
+    const response = await this.awaitResponse(id);
+    return response;
+  }
+  async proposeHiddenFlags(cli, subcommand) {
+    const id = crypto.randomUUID();
+    await this.writeRequest({ id, kind: "deep-dive", cli, subcommand });
+    const response = await this.awaitResponse(id);
+    return response;
+  }
+  async proposeConstraints(cli, subcommand) {
+    const id = crypto.randomUUID();
+    await this.writeRequest({ id, kind: "cartography", cli, subcommand });
+    const response = await this.awaitResponse(id);
+    return response.constraints ?? [];
+  }
+  async writeRequest(req) {
+    const existing = await this.readFile(this.requestsPath);
+    const line = JSON.stringify(req) + `
+`;
+    await Bun.write(this.requestsPath, existing + line, { createPath: true });
+  }
+  async awaitResponse(id) {
+    const start = Date.now();
+    while (Date.now() - start < this.timeoutMs) {
+      const text = await this.readFile(this.responsesPath);
+      const lines = text.split(`
+`).filter((l) => l.trim());
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.id === id)
+            return parsed.result;
+        } catch {}
+      }
+      await new Promise((r) => setTimeout(r, 250));
+    }
+    throw new Error(`Timed out waiting for delegate response to request ${id}`);
+  }
+  async readFile(path) {
+    try {
+      const file = Bun.file(path);
+      if (!await file.exists())
+        return "";
+      return await file.text();
+    } catch {
+      return "";
+    }
+  }
+}
+
+class InlineDelegate {
+  handlers;
+  name = "inline";
+  available = true;
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+  async survey(cli, version) {
+    if (!this.handlers.survey)
+      throw new Error("InlineDelegate: survey handler not provided");
+    return this.handlers.survey(cli, version);
+  }
+  async proposeHiddenFlags(cli, subcommand) {
+    if (!this.handlers.proposeHiddenFlags)
+      throw new Error("InlineDelegate: proposeHiddenFlags handler not provided");
+    return this.handlers.proposeHiddenFlags(cli, subcommand);
+  }
+  async proposeConstraints(cli, subcommand) {
+    if (!this.handlers.proposeConstraints)
+      throw new Error("InlineDelegate: proposeConstraints handler not provided");
+    return this.handlers.proposeConstraints(cli, subcommand);
+  }
+}
+// src/archaeology/orchestrator.ts
+async function runArchaeology(binary, delegate = new NullDelegate, opts = {}) {
+  const report = opts.onProgress ?? (() => {});
+  const phases = {
+    survey: opts.phases?.survey ?? true,
+    excavation: opts.phases?.excavation ?? true,
+    deepDive: opts.phases?.deepDive ?? true,
+    cartography: opts.phases?.cartography ?? false
+  };
+  report({ phase: "cache", message: "Checking cache..." });
+  const version = await detectCliVersion(binary);
+  if (!opts.skipCache) {
+    const cached = await loadCache(binary, { cacheDir: opts.cacheDir });
+    if (cached && !isCacheStale(cached, version, 30)) {
+      report({ phase: "done", message: "Loaded from cache" });
+      return {
+        tree: cached.tree,
+        stats: { helpCommands: 0, llmProposed: 0, verified: 0, rejected: 0, unconfirmed: 0, hallucinations: [] },
+        fromCache: true
+      };
+    }
+  }
+  report({ phase: "excavation", message: `Parsing ${binary} --help recursively...` });
+  const helpTree = await parseHelpRecursive(binary, [], opts.maxHelpDepth ?? 2);
+  const helpSource = { type: "help", confidence: 1, verifiedAt: new Date().toISOString() };
+  const tree = fromCLINode(helpTree, helpSource);
+  const helpCommandCount = countCommands(tree);
+  let llmProposed = 0;
+  const allVerdicts = [];
+  if (delegate.available && phases.survey && delegate.survey) {
+    report({ phase: "survey", message: "Delegate hypothesis survey..." });
+    try {
+      const survey = await delegate.survey(binary, version);
+      const existingCommands = new Set(tree.subcommands?.map((s) => s.name) ?? []);
+      const { confirmed } = await validateSurvey(binary, survey);
+      const llmSurveySource = { type: "llm-validated", confidence: 0.8, verifiedAt: new Date().toISOString() };
+      for (const sub of confirmed) {
+        if (!existingCommands.has(sub)) {
+          llmProposed += 1;
+          const excavated = await excavateCommand(binary, [sub]);
+          if (excavated) {
+            const enriched = fromCLINode(excavated, llmSurveySource);
+            if (!tree.subcommands)
+              tree.subcommands = [];
+            tree.subcommands.push(enriched);
+          }
+        }
+      }
+    } catch (e) {
+      report({ phase: "survey", message: `Survey failed: ${e.message}` });
+    }
+  }
+  if (delegate.available && phases.deepDive && delegate.proposeHiddenFlags && tree.subcommands) {
+    const topCommands = tree.subcommands.slice(0, 10);
+    report({ phase: "deep-dive", message: `Deep dive into ${topCommands.length} subcommands...` });
+    for (const sub of topCommands) {
+      try {
+        const proposal = await delegate.proposeHiddenFlags(binary, [sub.name]);
+        const verdict = await validateDeepDive(binary, proposal);
+        allVerdicts.push(verdict);
+        const verifiedSet = new Set(verdict.verifiedFlags);
+        const unconfirmedSet = new Set(verdict.unconfirmedFlags);
+        for (const flag of proposal.flags ?? []) {
+          if (verifiedSet.has(flag.name) || opts.includeUnverified && unconfirmedSet.has(flag.name)) {
+            llmProposed += 1;
+            const source = {
+              type: verifiedSet.has(flag.name) ? "llm-validated" : "llm-deep-dive",
+              confidence: verifiedSet.has(flag.name) ? 0.9 : 0.6,
+              verifiedAt: new Date().toISOString()
+            };
+            if (!sub.flags)
+              sub.flags = [];
+            const existing = sub.flags.find((f) => f.name === flag.name);
+            if (!existing) {
+              sub.flags.push({
+                name: flag.name,
+                short: flag.short,
+                type: flag.type,
+                description: flag.description,
+                hidden: flag.hidden,
+                deprecated: flag.deprecated,
+                source
+              });
+            }
+          }
+        }
+      } catch (e) {
+        report({ phase: "deep-dive", message: `Deep dive failed for ${sub.name}: ${e.message}` });
+      }
+    }
+  }
+  if (delegate.available && phases.cartography && delegate.proposeConstraints && tree.subcommands) {
+    report({ phase: "cartography", message: "Mapping flag constraints..." });
+    for (const sub of tree.subcommands.slice(0, 5)) {
+      try {
+        const constraints = await delegate.proposeConstraints(binary, [sub.name]);
+        if (constraints.length > 0) {
+          sub.constraints = constraints;
+        }
+      } catch {}
+    }
+  }
+  report({ phase: "merge", message: "Finalizing tree..." });
+  const summary = summarizeValidation(allVerdicts);
+  if (!opts.skipCache) {
+    const cache = createEmptyCache(binary, tree, version);
+    cache.phases = {
+      survey: phases.survey,
+      excavation: true,
+      deepDive: phases.deepDive,
+      cartography: phases.cartography
+    };
+    await saveCache(binary, cache, { cacheDir: opts.cacheDir });
+  }
+  report({ phase: "done", message: "Archaeology complete" });
+  return {
+    tree,
+    stats: {
+      helpCommands: helpCommandCount,
+      llmProposed,
+      verified: summary.verified,
+      rejected: summary.rejected,
+      unconfirmed: summary.unconfirmed,
+      hallucinations: summary.hallucinations
+    },
+    fromCache: false
+  };
+}
+function countCommands(node) {
+  let count = 1;
+  if (node.subcommands)
+    for (const s of node.subcommands)
+      count += countCommands(s);
+  return count;
+}
+function enrichedToTree(enriched) {
+  return toCLINode(enriched);
+}
+export { toCLINode, fromCLINode, surveyPrompt, excavationPrompt, deepDivePrompt, cartographyPrompt, validationInstructions, extractJsonFromLlmResponse, runHelpCommand, validateSubcommandExists, validateSurvey, excavateCommand, validateDeepDive, summarizeValidation, mergeNodes, filterUnverified, loadCache, saveCache, invalidateCache, isCacheStale, detectCliVersion, createEmptyCache, NullDelegate, BridgeFileDelegate, InlineDelegate, runArchaeology, enrichedToTree };
+
+//# debugId=7B12E24C921CA3F964756E2164756E21