@vpxa/kb 0.1.1

package/packages/tools/dist/onboard.js

@@ -0,0 +1,1139 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+import {
+  DependencyAnalyzer,
+  DiagramGenerator,
+  EntryPointAnalyzer,
+  extractRegexCallGraph,
+  extractTsCallGraph,
+  PatternAnalyzer,
+  StructureAnalyzer,
+  SymbolAnalyzer
+} from "@kb/analyzers";
+const DISPLAY_TITLES = {
+  structure: "Project Structure",
+  dependencies: "Dependencies",
+  "entry-points": "Entry Points",
+  symbols: "Symbols",
+  patterns: "Patterns",
+  diagram: "C4 Container Diagram",
+  "code-map": "Code Map (Module Graph)",
+  "config-values": "Configuration Values",
+  "synthesis-guide": "Synthesis Guide"
+};
+function buildSynthesisGuide(steps, mode, projectName, dataMap) {
+  const lines = [`Analysis baselines for **${projectName}** have been generated.`];
+  if (mode === "generate") {
+    lines.push(
+      "Individual results are in the sibling `.md` and `.json` files in this directory.",
+      ""
+    );
+  } else {
+    lines.push("Results are stored in the KB vector store.", "");
+  }
+  const symbolsData = dataMap.get("symbols");
+  const depsData = dataMap.get("dependencies");
+  const patternsData = dataMap.get("patterns");
+  const entryData = dataMap.get("entry-points");
+  const totalSymbols = symbolsData?.totalCount ?? 0;
+  const exportedSymbols = symbolsData?.exportedCount ?? 0;
+  const totalImports = depsData?.totalImports ?? 0;
+  const entryCount = entryData?.total ?? 0;
+  const patternList = patternsData?.patterns ?? [];
+  const patternNames = patternList.map((p) => p.pattern);
+  const isSpring = patternNames.some((p) => p.startsWith("Spring"));
+  const isCdk = patternNames.includes("AWS CDK") || patternNames.includes("CDK IaC");
+  const isMaven = patternNames.includes("Maven");
+  const isServerless = patternNames.includes("Serverless") || entryCount > 3;
+  const externalPkgs = depsData?.external ? Object.keys(depsData.external) : [];
+  const isNode = externalPkgs.some(
+    (d) => ["express", "fastify", "next", "react", "vitest", "jest"].includes(d)
+  ) || totalImports > 0;
+  const isMonorepo = externalPkgs.some((d) => ["turbo", "lerna", "nx"].includes(d)) || patternNames.includes("Monorepo");
+  lines.push("### Project Profile", "");
+  lines.push(
+    `- **${totalSymbols} symbols** (${exportedSymbols} exported), **${totalImports} imports**, **${entryCount} entry ${entryCount === 1 ? "point" : "points"}**`
+  );
+  if (patternNames.length > 0) {
+    lines.push(`- **Detected**: ${patternNames.slice(0, 8).join(", ")}`);
+  }
+  lines.push("");
+  if (totalSymbols === 0 && totalImports === 0 && entryCount === 0) {
+    lines.push(
+      "> **Note:** This project appears to be empty or contains no analyzable source code.",
+      "> Run onboard again after adding source files."
+    );
+    return lines.join("\n");
+  }
+  const completed = steps.filter((s) => s.status === "success");
+  const failed = steps.filter((s) => s.status === "failed");
+  lines.push("### Completed Analyses", "");
+  for (const step of completed) {
+    const title = DISPLAY_TITLES[step.name] ?? step.name;
+    const size = step.output.length > 1e3 ? `${Math.round(step.output.length / 1024)}KB` : `${step.output.length}B`;
+    const ext = ".md";
+    if (mode === "generate") {
+      lines.push(`- \u2713 [${title}](./${step.name}${ext}) (${size})`);
+    } else {
+      lines.push(`- \u2713 ${title} (${size})`);
+    }
+  }
+  if (failed.length > 0) {
+    lines.push("", "### Failed Analyses", "");
+    for (const step of failed) {
+      lines.push(`- \u2717 ${step.name}: ${step.error}`);
+    }
+  }
+  lines.push(
+    "",
+    "### Recommended Reading Order",
+    "",
+    "1. **Start with** `synthesis-guide.md` (this file) \u2192 `entry-points.md` \u2192 `patterns.md`",
+    "2. **Module graph** via `code-map.md` \u2014 cross-package call edges with function names",
+    "3. **Architecture** via `diagram.md` (C4 Container) \u2192 `dependencies.md`",
+    "4. **Browse structure** via `structure.md` for file layout",
+    "5. **API surface** via `symbols.md` \u2014 file paths + exported symbols (capped at 80KB)",
+    "6. **Reference**: `config-values.md` (config reference)",
+    "",
+    "> **Size guidance:** Total output is ~"
+  );
+  const totalKB = completed.reduce((sum, s) => sum + s.output.length, 0) / 1024;
+  lines[lines.length - 1] += `${Math.round(totalKB)}KB. Focus on code-map.md + entry-points.md + diagram.md (~${Math.round((completed.find((s) => s.name === "code-map")?.output.length ?? 0) / 1024 + (completed.find((s) => s.name === "entry-points")?.output.length ?? 0) / 1024 + (completed.find((s) => s.name === "diagram")?.output.length ?? 0) / 1024)}KB) for maximum signal-to-token ratio.`;
+  lines.push(
+    "",
+    "### Synthesize Knowledge",
+    "",
+    "Produce the following `kb_remember` entries:",
+    ""
+  );
+  lines.push("1. **Architecture Summary** (category: `architecture`)");
+  if (isMonorepo) {
+    lines.push("   - Package boundaries, dependency graph between packages");
+    lines.push("   - Shared vs service-specific code");
+  } else if (isServerless) {
+    lines.push("   - Lambda functions, triggers, event flow");
+    lines.push("   - Infrastructure patterns (queues, tables, APIs)");
+  } else if (isSpring) {
+    lines.push("   - Controller \u2192 Service \u2192 Repository layers");
+    lines.push("   - Spring configuration and profiles");
+  } else {
+    lines.push("   - Layer structure, dependency flow");
+    lines.push("   - Key design decisions");
+  }
+  lines.push("");
+  lines.push("2. **Domain Model** (category: `architecture`)");
+  lines.push("   - Key entities/types and their relationships");
+  lines.push("   - Data flow from entry points through processing");
+  lines.push("");
+  lines.push("3. **Conventions** (category: `conventions`)");
+  lines.push("   - Naming patterns, file organization, testing approach");
+  if (isCdk) lines.push("   - CDK construct patterns and stack organization");
+  if (isNode) lines.push("   - Build tooling, package manager, module system");
+  if (isMaven) lines.push("   - Maven module structure, dependency management");
+  lines.push(
+    "",
+    "### Using KB Tools",
+    "",
+    "This project has a KB MCP server with tools for search, analysis, memory, and more.",
+    "Add the KB tools to your agent configuration so every session benefits from them.",
+    "",
+    "**Add to `.github/copilot-instructions.md`** or `AGENTS.md`:",
+    "",
+    "```markdown",
+    "## KB Tools",
+    "",
+    `Before starting any task on **${projectName}**, use these MCP tools:`,
+    "",
+    "| Action | Tool | Example |",
+    "|--------|------|---------|",
+    `| Search code & decisions | \`kb_search\` | \`kb_search({ query: "..." })\` |`,
+    '| Find symbol definition | `kb_symbol` | `kb_symbol({ name: "ClassName" })` |',
+    '| Trace call chains | `kb_trace` | `kb_trace({ symbol: "fn", file: "path" })` |',
+    '| Impact of a change | `kb_blast_radius` | `kb_blast_radius({ changed_files: ["..."] })` |',
+    '| Persist what you learn | `kb_remember` | `kb_remember({ title: "...", category: "decisions" })` |',
+    "| Typecheck + lint | `kb_check` | `kb_check({})` |",
+    "| Run tests | `kb_test_run` | `kb_test_run({})` |",
+    "```",
+    "",
+    "**Add to each `.github/agents/*.agent.md`** (Skills Reference table):",
+    "",
+    "```markdown",
+    "| Context | Skill | Details |",
+    "|---------|-------|---------|",
+    "| KB search, analysis, memory | `kb` | `path/to/skills/kb/SKILL.md` |",
+    "```",
+    "",
+    "The KB skill teaches agents the full tool set:",
+    "",
+    "| Category | Tools | Purpose |",
+    "|----------|-------|---------|",
+    "| Search & Discovery | `kb_search`, `kb_find`, `kb_symbol`, `kb_trace` | Find code, symbols, data flow |",
+    "| Code Analysis | `kb_analyze_*`, `kb_blast_radius` | Structure, deps, patterns, impact |",
+    "| Knowledge | `kb_remember`, `kb_read`, `kb_update`, `kb_forget` | Persistent cross-session memory |",
+    "| Execution | `kb_check`, `kb_test_run`, `kb_eval` | Typecheck, lint, test, run code |",
+    "| Refactoring | `kb_rename`, `kb_codemod`, `kb_dead_symbols` | Safe renames, transforms, cleanup |",
+    "| Web & API | `kb_web_fetch`, `kb_web_search`, `kb_http` | Research, API testing |",
+    "| Context | `kb_workset`, `kb_stash`, `kb_checkpoint` | Manage working sets, save progress |",
+    "",
+    "**Workflow pattern \u2014 use on every task:**",
+    "",
+    "```",
+    `kb_search({ query: "your task keywords" })            # Recall prior decisions`,
+    `kb_scope_map({ task: "what you are doing" })           # Get a reading plan`,
+    "# ... do the work ...",
+    `kb_remember({ title: "What I learned", category: "decisions" })  # Persist`,
+    "```"
+  );
+  return lines.join("\n");
+}
+const TEST_SEGMENTS = /* @__PURE__ */ new Set([
+  "test",
+  "tests",
+  "__tests__",
+  "spec",
+  "specs",
+  "__mocks__",
+  "__fixtures__",
+  "fixtures",
+  "test-utils"
+]);
+function isTestPath(filePath) {
+  const segments = filePath.replace(/\\/g, "/").split("/");
+  return segments.some((s) => TEST_SEGMENTS.has(s)) || /\.(test|spec)\.[jt]sx?$/.test(filePath) || /Test\.java$/.test(filePath);
+}
+function buildCodeMap(dataMap, projectName, callGraph) {
+  const depsData = dataMap.get("dependencies");
+  const symbolsData = dataMap.get("symbols");
+  const entryData = dataMap.get("entry-points");
+  const lines = [`## Code Map: ${projectName}
+`];
+  if (!depsData && !symbolsData) {
+    lines.push("No dependency or symbol data available.");
+    return lines.join("\n");
+  }
+  const reverseGraph = depsData?.reverseGraph ?? {};
+  const symbols = symbolsData?.symbols ?? [];
+  const entryPoints = entryData?.entryPoints ?? [];
+  const exportsByFile = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    if (!sym.exported) continue;
+    const fp = sym.filePath.replace(/\\/g, "/");
+    if (isTestPath(fp)) continue;
+    const existing = exportsByFile.get(fp);
+    if (existing) {
+      existing.push({ name: sym.name, kind: sym.kind });
+    } else {
+      exportsByFile.set(fp, [{ name: sym.name, kind: sym.kind }]);
+    }
+  }
+  const normReverse = /* @__PURE__ */ new Map();
+  for (const [file, importers] of Object.entries(reverseGraph)) {
+    const nf = file.replace(/\\/g, "/");
+    const resolved = resolveExtensionlessPath(nf, exportsByFile);
+    const srcImporters = importers.map((i) => i.replace(/\\/g, "/")).filter((i) => !isTestPath(i));
+    if (srcImporters.length === 0) continue;
+    const existing = normReverse.get(resolved);
+    if (existing) {
+      for (const imp of srcImporters) existing.add(imp);
+    } else {
+      normReverse.set(resolved, new Set(srcImporters));
+    }
+  }
+  const entryLookup = /* @__PURE__ */ new Map();
+  for (const ep of entryPoints) {
+    entryLookup.set(ep.filePath.replace(/\\/g, "/"), { name: ep.name, trigger: ep.trigger });
+  }
+  const crossCalls = /* @__PURE__ */ new Map();
+  const crossCalledBy = /* @__PURE__ */ new Map();
+  if (callGraph) {
+    for (const [from, targets] of callGraph) {
+      if (isTestPath(from)) continue;
+      const fromPkg = getPackageKey(from);
+      for (const [to, syms] of targets) {
+        if (isTestPath(to)) continue;
+        const toPkg = getPackageKey(to);
+        if (fromPkg === toPkg) continue;
+        let outMap = crossCalls.get(from);
+        if (!outMap) {
+          outMap = /* @__PURE__ */ new Map();
+          crossCalls.set(from, outMap);
+        }
+        outMap.set(to, syms);
+        const callers = crossCalledBy.get(to);
+        const entry = { file: from, symbols: syms };
+        if (callers) {
+          callers.push(entry);
+        } else {
+          crossCalledBy.set(to, [entry]);
+        }
+      }
+    }
+  }
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const fp of entryLookup.keys()) allFiles.add(fp);
+  for (const fp of crossCalls.keys()) allFiles.add(fp);
+  for (const fp of crossCalledBy.keys()) allFiles.add(fp);
+  if (!callGraph) {
+    for (const fp of exportsByFile.keys()) {
+      const importers = normReverse.get(fp);
+      if (importers && importers.size >= 3) allFiles.add(fp);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const fp of allFiles) {
+    const group = getPackageKey(fp);
+    const arr = groups.get(group);
+    if (arr) {
+      arr.push(fp);
+    } else {
+      groups.set(group, [fp]);
+    }
+  }
+  const sortedGroups = [...groups.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  const graphType = callGraph ? "AST call graph" : "import analysis";
+  const crossCount = callGraph ? `, ${crossCalls.size} cross-package callers` : "";
+  lines.push(`**${allFiles.size} key modules** (${graphType}${crossCount})
+`);
+  lines.push(
+    "**Legend:** \u26A1 Entry point | \u{1F4E4} Exports | \u2192 Calls (outgoing) | \u2190 Called by (incoming) | \u27A1 Used by (import)\n"
+  );
+  for (const [group, files] of sortedGroups) {
+    files.sort();
+    lines.push(`### ${group}/
+`);
+    for (const fp of files) {
+      const exports = exportsByFile.get(fp);
+      const entry = entryLookup.get(fp);
+      const outCalls = crossCalls.get(fp);
+      const inCalls = crossCalledBy.get(fp);
+      const importedBySet = normReverse.get(fp);
+      const shortPath = fp.startsWith(`${group}/`) ? fp.slice(group.length + 1) : fp;
+      lines.push(`**${shortPath}**`);
+      if (entry) {
+        lines.push(`  \u26A1 Entry: \`${entry.name}\`${entry.trigger ? ` (${entry.trigger})` : ""}`);
+      }
+      if (exports && exports.length > 0) {
+        const compact = exports.slice(0, 8).map((e) => `${e.name}`).join(", ");
+        const more = exports.length > 8 ? ` (+${exports.length - 8})` : "";
+        lines.push(`  \u{1F4E4} ${compact}${more}`);
+      }
+      if (outCalls && outCalls.size > 0) {
+        const sorted = [...outCalls.entries()].sort((a, b) => b[1].length - a[1].length);
+        for (const [target, syms] of sorted.slice(0, 4)) {
+          const shortTarget = target.startsWith(`${group}/`) ? target.slice(group.length + 1) : target;
+          lines.push(
+            `  \u2192 ${shortTarget}: ${syms.slice(0, 5).join(", ")}${syms.length > 5 ? "\u2026" : ""}`
+          );
+        }
+        if (sorted.length > 4) lines.push(`  \u2192 +${sorted.length - 4} more targets`);
+      }
+      if (inCalls && inCalls.length > 0) {
+        for (const c of inCalls.slice(0, 4)) {
+          const shortCaller = c.file.startsWith(`${group}/`) ? c.file.slice(group.length + 1) : c.file;
+          lines.push(
+            `  \u2190 ${shortCaller}: ${c.symbols.slice(0, 4).join(", ")}${c.symbols.length > 4 ? "\u2026" : ""}`
+          );
+        }
+        if (inCalls.length > 4) lines.push(`  \u2190 +${inCalls.length - 4} more callers`);
+      } else if (!callGraph && importedBySet && importedBySet.size > 0) {
+        const importedBy = [...importedBySet].filter((i) => !isTestPath(i));
+        if (importedBy.length <= 3) {
+          lines.push(`  \u27A1 Used by: ${importedBy.join(", ")}`);
+        } else {
+          lines.push(
+            `  \u27A1 Used by: ${importedBy.slice(0, 3).join(", ")} (+${importedBy.length - 3} more)`
+          );
+        }
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function getPackageKey(fp) {
+  const parts = fp.split("/");
+  if (parts.length >= 2 && ["packages", "services", "providers", "apps", "libs"].includes(parts[0])) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  const javaIdx = parts.indexOf("java");
+  const kotlinIdx = parts.indexOf("kotlin");
+  const langIdx = javaIdx >= 0 ? javaIdx : kotlinIdx;
+  if (langIdx >= 0 && langIdx + 2 < parts.length) {
+    const afterLang = parts.slice(langIdx + 1);
+    if (["com", "org", "net", "io", "dev"].includes(afterLang[0]) && afterLang.length >= 3) {
+      return afterLang.slice(0, 3).join("/");
+    }
+    return afterLang.slice(0, 2).join("/");
+  }
+  if (parts[0] === "src" && parts.length >= 3) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+function buildDiagrams(callGraph, dataMap, projectName) {
+  const symbolsData = dataMap.get("symbols");
+  const entryData = dataMap.get("entry-points");
+  const depsData = dataMap.get("dependencies");
+  const pkgEdges = /* @__PURE__ */ new Map();
+  for (const [from, targets] of callGraph) {
+    if (isTestPath(from)) continue;
+    for (const [to, syms] of targets) {
+      if (isTestPath(to)) continue;
+      const fromPkg = getPackageKey(from);
+      const toPkg = getPackageKey(to);
+      if (fromPkg === toPkg) continue;
+      const key = `${fromPkg}|${toPkg}`;
+      pkgEdges.set(key, (pkgEdges.get(key) ?? 0) + syms.length);
+    }
+  }
+  if (pkgEdges.size === 0)
+    return "## Architecture Diagram\n\nNo cross-package dependencies detected.";
+  const pkgNodes = /* @__PURE__ */ new Set();
+  for (const key of pkgEdges.keys()) {
+    const [from, to] = key.split("|");
+    pkgNodes.add(from);
+    pkgNodes.add(to);
+  }
+  const exportsByPkg = /* @__PURE__ */ new Map();
+  if (symbolsData?.symbols) {
+    for (const sym of symbolsData.symbols) {
+      if (!sym.exported) continue;
+      const fp = sym.filePath.replace(/\\/g, "/");
+      if (isTestPath(fp)) continue;
+      const pkg = getPackageKey(fp);
+      exportsByPkg.set(pkg, (exportsByPkg.get(pkg) ?? 0) + 1);
+    }
+  }
+  const entryByPkg = /* @__PURE__ */ new Map();
+  if (entryData?.entryPoints) {
+    for (const ep of entryData.entryPoints) {
+      const fp = ep.filePath.replace(/\\/g, "/");
+      const pkg = getPackageKey(fp);
+      const existing = entryByPkg.get(pkg);
+      if (existing) {
+        existing.count++;
+        if (ep.trigger) existing.triggers.add(ep.trigger);
+      } else {
+        entryByPkg.set(pkg, { count: 1, triggers: new Set(ep.trigger ? [ep.trigger] : []) });
+      }
+    }
+  }
+  const extSystems = [];
+  if (depsData?.external) {
+    const external = depsData.external;
+    const awsServices = {
+      "client-dynamodb": { id: "dynamodb", name: "DynamoDB" },
+      "lib-dynamodb": { id: "dynamodb", name: "DynamoDB" },
+      "client-sqs": { id: "sqs", name: "SQS" },
+      "client-ses": { id: "ses", name: "SES" },
+      "client-sesv2": { id: "ses", name: "SES" },
+      "client-s3": { id: "s3", name: "S3" },
+      "client-eventbridge": { id: "eventbridge", name: "EventBridge" },
+      "client-sns": { id: "sns", name: "SNS" },
+      "client-secrets-manager": { id: "secrets", name: "Secrets Manager" },
+      "client-scheduler": { id: "scheduler", name: "EventBridge Scheduler" },
+      "client-apigatewaymanagementapi": { id: "apigw", name: "API Gateway" },
+      "client-cloudwatch": { id: "cloudwatch", name: "CloudWatch" }
+    };
+    const seen = /* @__PURE__ */ new Set();
+    for (const depName of Object.keys(external)) {
+      for (const [suffix, info] of Object.entries(awsServices)) {
+        if (depName.includes(suffix) && !seen.has(info.id)) {
+          seen.add(info.id);
+          extSystems.push(info);
+        }
+      }
+    }
+    extSystems.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const pkg of [...pkgNodes].sort()) {
+    const boundary = pkg.split("/")[0];
+    const arr = boundaries.get(boundary);
+    if (arr) arr.push(pkg);
+    else boundaries.set(boundary, [pkg]);
+  }
+  const langByPkg = /* @__PURE__ */ new Map();
+  if (symbolsData?.symbols) {
+    const extCounts = /* @__PURE__ */ new Map();
+    for (const sym of symbolsData.symbols) {
+      const fp = sym.filePath.replace(/\\/g, "/");
+      const pkg = getPackageKey(fp);
+      const ext = fp.match(/\.[^./]+$/)?.[0] || "";
+      if (!extCounts.has(pkg)) extCounts.set(pkg, /* @__PURE__ */ new Map());
+      const counts = extCounts.get(pkg);
+      counts.set(ext, (counts.get(ext) ?? 0) + 1);
+    }
+    const EXT_LANG = {
+      ".ts": "TypeScript",
+      ".tsx": "TypeScript",
+      ".js": "JavaScript",
+      ".jsx": "JavaScript",
+      ".java": "Java",
+      ".kt": "Kotlin",
+      ".scala": "Scala",
+      ".py": "Python",
+      ".go": "Go",
+      ".rs": "Rust",
+      ".cs": "C#",
+      ".rb": "Ruby",
+      ".php": "PHP",
+      ".swift": "Swift"
+    };
+    for (const [pkg, counts] of extCounts) {
+      let maxExt = "";
+      let maxCount = 0;
+      for (const [ext, count] of counts) {
+        if (count > maxCount) {
+          maxCount = count;
+          maxExt = ext;
+        }
+      }
+      langByPkg.set(pkg, EXT_LANG[maxExt] || "TypeScript");
+    }
+  }
+  const nodeId = (pkg) => pkg.replace(/[^a-zA-Z0-9]/g, "_");
+  const lines = [];
+  lines.push("```mermaid");
+  lines.push("C4Container");
+  lines.push(`    title C4 Container: ${projectName}`);
+  lines.push("");
+  const descFor = (pkg) => {
+    const parts = [];
+    const entry = entryByPkg.get(pkg);
+    if (entry) {
+      parts.push(`${entry.count} handlers`);
+      if (entry.triggers.size > 0) parts.push([...entry.triggers].join(", "));
+    }
+    const exports = exportsByPkg.get(pkg);
+    if (exports) parts.push(`${exports} exports`);
+    return parts.join(" \xB7 ") || "";
+  };
+  const techFor = (pkg) => {
+    const lang = langByPkg.get(pkg) || "TypeScript";
+    if (pkg.startsWith("infra")) return `CDK/${lang}`;
+    if (entryByPkg.has(pkg)) {
+      const entry = entryByPkg.get(pkg);
+      const hasSqs = entry?.triggers.has("SQS") || entry?.triggers.has("SNS");
+      if (hasSqs || entry?.triggers.has("API Gateway")) return `Lambda/${lang}`;
+      if (entry?.triggers.has("HTTP Server") || entry?.triggers.has("HTTP Endpoint"))
+        return `Spring Boot/${lang}`;
+    }
+    return lang;
+  };
+  for (const [boundary, pkgs] of [...boundaries.entries()].sort()) {
+    const genericBoundaries = /* @__PURE__ */ new Set(["com", "org", "net", "io", "dev", "src"]);
+    const boundaryLabel = genericBoundaries.has(boundary) ? projectName.charAt(0).toUpperCase() + projectName.slice(1) : boundary.charAt(0).toUpperCase() + boundary.slice(1);
+    if (pkgs.length === 1 && pkgs[0] === boundary) {
+      const pkg = pkgs[0];
+      lines.push(`    Container(${nodeId(pkg)}, "${pkg}", "${techFor(pkg)}", "${descFor(pkg)}")`);
+    } else {
+      lines.push(`    System_Boundary(${nodeId(boundary)}_boundary, "${boundaryLabel}") {`);
+      for (const pkg of pkgs) {
+        const shortName = pkg.split("/").slice(1).join("/") || pkg;
+        lines.push(
+          `        Container(${nodeId(pkg)}, "${shortName}", "${techFor(pkg)}", "${descFor(pkg)}")`
+        );
+      }
+      lines.push("    }");
+    }
+    lines.push("");
+  }
+  if (extSystems.length > 0) {
+    for (const ext of extSystems) {
+      lines.push(`    System_Ext(ext_${ext.id}, "${ext.name}", "AWS")`);
+    }
+    lines.push("");
+  }
+  const sortedEdges = [...pkgEdges.entries()].sort((a, b) => b[1] - a[1]);
+  for (const [key, count] of sortedEdges.slice(0, 30)) {
+    const [from, to] = key.split("|");
+    lines.push(`    Rel(${nodeId(from)}, ${nodeId(to)}, "Uses", "${count} calls")`);
+  }
+  lines.push("```");
+  const c4Diagram = `## C4 Container Diagram
+
+${lines.join("\n")}`;
+  const flowLines = [];
+  flowLines.push("```mermaid");
+  flowLines.push("graph TB");
+  const allTriggers = /* @__PURE__ */ new Set();
+  for (const [, info] of entryByPkg) {
+    for (const t of info.triggers) allTriggers.add(t);
+  }
+  if (allTriggers.size > 0) {
+    flowLines.push('    subgraph Triggers["External Triggers"]');
+    for (const trigger of [...allTriggers].sort()) {
+      const tId = `trigger_${trigger.replace(/[^a-zA-Z0-9]/g, "_")}`;
+      flowLines.push(`        ${tId}(("${trigger}"))`);
+    }
+    flowLines.push("    end");
+    flowLines.push("");
+  }
+  const servicePkgs = [...pkgNodes].filter((p) => entryByPkg.has(p)).sort();
+  const libraryPkgs = [...pkgNodes].filter((p) => !entryByPkg.has(p)).sort();
+  if (servicePkgs.length > 0) {
+    flowLines.push('    subgraph Services["Service Layer"]');
+    for (const pkg of servicePkgs) {
+      const id = `flow_${nodeId(pkg)}`;
+      const shortName = pkg.includes("/") ? pkg.split("/").pop() ?? pkg : pkg;
+      const entry = entryByPkg.get(pkg);
+      flowLines.push(`        ${id}["${shortName} (${entry?.count ?? 0} handlers)"]`);
+    }
+    flowLines.push("    end");
+    flowLines.push("");
+  }
+  if (libraryPkgs.length > 0) {
+    flowLines.push('    subgraph Libraries["Shared Libraries"]');
+    for (const pkg of libraryPkgs) {
+      const id = `flow_${nodeId(pkg)}`;
+      const shortName = pkg.includes("/") ? pkg.split("/").pop() ?? pkg : pkg;
+      flowLines.push(`        ${id}["${shortName}"]`);
+    }
+    flowLines.push("    end");
+    flowLines.push("");
+  }
+  if (extSystems.length > 0) {
+    flowLines.push('    subgraph External["AWS Services"]');
+    for (const ext of extSystems) {
+      flowLines.push(`        flow_ext_${ext.id}[("${ext.name}")]`);
+    }
+    flowLines.push("    end");
+    flowLines.push("");
+  }
+  for (const pkg of servicePkgs) {
+    const entry = entryByPkg.get(pkg);
+    if (!entry) continue;
+    const svcId = `flow_${nodeId(pkg)}`;
+    for (const trigger of entry.triggers) {
+      const tId = `trigger_${trigger.replace(/[^a-zA-Z0-9]/g, "_")}`;
+      flowLines.push(`    ${tId} --> ${svcId}`);
+    }
+  }
+  const svcToLib = sortedEdges.filter(([key]) => {
+    const [from, to] = key.split("|");
+    return entryByPkg.has(from) && !entryByPkg.has(to);
+  });
+  for (const [key, count] of svcToLib.slice(0, 15)) {
+    const [from, to] = key.split("|");
+    flowLines.push(`    flow_${nodeId(from)} -->|${count}| flow_${nodeId(to)}`);
+  }
+  const libToLib = sortedEdges.filter(([key]) => {
+    const [from, to] = key.split("|");
+    return !entryByPkg.has(from) && !entryByPkg.has(to);
+  });
+  for (const [key, count] of libToLib.slice(0, 10)) {
+    const [from, to] = key.split("|");
+    flowLines.push(`    flow_${nodeId(from)} -->|${count}| flow_${nodeId(to)}`);
+  }
+  flowLines.push("```");
+  const flowDiagram = `## Architectural Flow
+
+${flowLines.join("\n")}`;
+  const sections = [`# Architecture Diagrams: ${projectName}
+`];
+  sections.push(c4Diagram);
+  sections.push(flowDiagram);
+  return sections.join("\n\n---\n\n");
+}
+function resolveExtensionlessPath(nf, exportsByFile) {
+  if (exportsByFile.has(nf)) return nf;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    if (exportsByFile.has(`${nf}${ext}`)) return `${nf}${ext}`;
+  }
+  if (exportsByFile.has(`${nf}/index.ts`)) return `${nf}/index.ts`;
+  return nf;
+}
+const CONFIG_EXCLUDES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "cdk.out",
+  "__pycache__",
+  ".venv",
+  "target",
+  "obj",
+  ".gradle"
+]);
+const CONFIG_FILE_PATTERNS = [
+  { glob: /\.env(?:\.\w+)?$/, type: "env" },
+  { glob: /\.env\.example$/, type: "env" },
+  { glob: /package\.json$/, type: "package-json" },
+  { glob: /^(?:app|config|settings|default)\.(?:json|ya?ml|toml)$/i, type: "config" },
+  { glob: /docker-compose\.ya?ml$/, type: "docker" },
+  { glob: /cdk\.json$/, type: "cdk" },
+  { glob: /turbo\.json$/, type: "tooling" },
+  { glob: /application\.(?:properties|ya?ml)$/i, type: "spring" },
+  { glob: /settings\.py$/, type: "django" },
+  { glob: /\.flaskenv$/, type: "env" },
+  { glob: /appsettings\.(?:\w+\.)?json$/i, type: "dotnet" }
+];
+async function extractConfigValues(rootPath, projectName) {
+  const configs = [];
+  const configFiles = await collectConfigFiles(rootPath);
+  const KB_SKIP = /kb\.config\.json$/;
+  for (const filePath of configFiles) {
+    try {
+      const relPath = relative(rootPath, filePath).replace(/\\/g, "/");
+      if (KB_SKIP.test(relPath)) continue;
+      const content = await readFile(filePath, "utf-8");
+      const fileType = identifyConfigType(filePath);
+      const depth = relPath.split("/").length - 1;
+      if (depth > 1 && fileType === "tooling") continue;
+      const values = parseConfigValues(content, fileType);
+      if (values.length > 0) {
+        configs.push({ file: relPath, type: fileType, values });
+      }
+    } catch {
+    }
+  }
+  return formatConfigMarkdown(configs, projectName);
+}
+async function collectConfigFiles(rootPath) {
+  const files = [];
+  const walk = async (dir, depth) => {
+    if (depth > 3) return;
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (CONFIG_EXCLUDES.has(entry.name)) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith(".")) {
+          await walk(fullPath, depth + 1);
+        } else if (entry.isFile()) {
+          if (CONFIG_FILE_PATTERNS.some((p) => p.glob.test(entry.name))) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch {
+    }
+  };
+  await walk(rootPath, 0);
+  return files;
+}
+function identifyConfigType(filePath) {
+  const name = basename(filePath);
+  for (const p of CONFIG_FILE_PATTERNS) {
+    if (p.glob.test(name)) return p.type;
+  }
+  return "unknown";
+}
+const SENSITIVE_KEYS = /(?:secret|password|token|key|api.?key|auth|credential|private)/i;
+function parseConfigValues(content, type) {
+  const values = [];
+  if (type === "env") {
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      const rawValue = trimmed.slice(eqIdx + 1).trim();
+      const sensitive = SENSITIVE_KEYS.test(key);
+      values.push({ key, value: sensitive ? "***" : rawValue, sensitive });
+    }
+  } else if (type === "package-json") {
+    try {
+      const pkg = JSON.parse(content);
+      if (pkg.scripts) {
+        for (const [key, value] of Object.entries(pkg.scripts)) {
+          values.push({ key: `scripts.${key}`, value: String(value), sensitive: false });
+        }
+      }
+      if (pkg.engines) {
+        for (const [key, value] of Object.entries(pkg.engines)) {
+          values.push({ key: `engines.${key}`, value: String(value), sensitive: false });
+        }
+      }
+    } catch {
+    }
+  } else if (type === "spring") {
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("---")) continue;
+      const match = trimmed.match(/^([\w.[\]-]+)\s*[=:]\s*(.*)$/);
+      if (match) {
+        const key = match[1];
+        const rawValue = match[2].trim();
+        const sensitive = SENSITIVE_KEYS.test(key);
+        values.push({ key, value: sensitive ? "***" : rawValue, sensitive });
+      }
+    }
+  } else if (type === "json" || type === "config" || type === "cdk" || type === "tooling" || type === "dotnet") {
+    try {
+      const obj = JSON.parse(content);
+      flattenJson(obj, "", values, 0);
+    } catch {
+    }
+  } else if (type === "django") {
+    for (const line of content.split("\n")) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)\s*=\s*(.+)$/);
+      if (match) {
+        const key = match[1];
+        const rawValue = match[2].trim();
+        const sensitive = SENSITIVE_KEYS.test(key);
+        values.push({
+          key,
+          value: sensitive ? "***" : rawValue.slice(0, 100),
+          sensitive
+        });
+      }
+    }
+  }
+  return values;
+}
+function flattenJson(obj, prefix, values, depth) {
+  if (depth > 3) return;
+  if (obj === null || obj === void 0) return;
+  if (typeof obj === "object" && !Array.isArray(obj)) {
+    for (const [key, val] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof val === "object" && val !== null && !Array.isArray(val)) {
+        flattenJson(val, fullKey, values, depth + 1);
+      } else {
+        const sensitive = SENSITIVE_KEYS.test(key);
+        const strVal = Array.isArray(val) ? `[${val.length} items]` : String(val);
+        values.push({ key: fullKey, value: sensitive ? "***" : strVal.slice(0, 120), sensitive });
+      }
+    }
+  }
+}
+function formatConfigMarkdown(configs, projectName) {
+  const lines = [];
+  lines.push(`## Configuration Values: ${projectName}
+`);
+  if (configs.length === 0) {
+    lines.push("No configuration files detected.");
+    return lines.join("\n");
+  }
+  lines.push(`**${configs.length} config files** found
+`);
+  const byType = /* @__PURE__ */ new Map();
+  for (const c of configs) {
+    if (!byType.has(c.type)) byType.set(c.type, []);
+    byType.get(c.type)?.push(c);
+  }
+  for (const [type, entries] of byType) {
+    if (type === "package-json" && entries.length > 2) {
+      lines.push(`### ${type}
+`);
+      const root = entries.find((e) => e.file === "package.json");
+      if (root) {
+        lines.push(`#### ${root.file}
+`);
+        lines.push("| Key | Value | Sensitive |");
+        lines.push("|-----|-------|-----------|");
+        for (const v of root.values.slice(0, 50)) {
+          const escaped = v.value.replace(/\|/g, "\\|");
+          lines.push(`| ${v.key} | ${escaped} | ${v.sensitive ? "\u26A0\uFE0F yes" : "no"} |`);
+        }
+        lines.push("");
+      }
+      const subEntries = entries.filter((e) => e.file !== "package.json");
+      if (subEntries.length > 0) {
+        const scriptFreq = /* @__PURE__ */ new Map();
+        for (const entry of subEntries) {
+          for (const v of entry.values) {
+            const k = `${v.key}=${v.value}`;
+            scriptFreq.set(k, (scriptFreq.get(k) ?? 0) + 1);
+          }
+        }
+        const commonThreshold = Math.max(2, Math.floor(subEntries.length * 0.5));
+        lines.push(`#### Sub-packages (${subEntries.length} packages)
+`);
+        const commonScripts = [...scriptFreq.entries()].filter(([, count]) => count >= commonThreshold).map(([kv]) => {
+          const [key, ...rest] = kv.split("=");
+          return { key, value: rest.join("=") };
+        });
+        if (commonScripts.length > 0) {
+          lines.push("**Common scripts** (shared by most sub-packages):\n");
+          lines.push("| Key | Value |");
+          lines.push("|-----|-------|");
+          for (const s of commonScripts) {
+            lines.push(`| ${s.key} | ${s.value.replace(/\|/g, "\\|")} |`);
+          }
+          lines.push("");
+        }
+        const uniqueByPkg = /* @__PURE__ */ new Map();
+        for (const entry of subEntries) {
+          const unique = entry.values.filter((v) => {
+            const k = `${v.key}=${v.value}`;
+            return (scriptFreq.get(k) ?? 0) < commonThreshold;
+          });
+          if (unique.length === 0) continue;
+          const fingerprint = unique.map((v) => `${v.key}=${v.value}`).sort().join("||");
+          const existing = uniqueByPkg.get(fingerprint);
+          if (existing) {
+            existing.files.push(entry.file);
+          } else {
+            uniqueByPkg.set(fingerprint, {
+              files: [entry.file],
+              entries: unique.map((v) => ({ key: v.key, value: v.value }))
+            });
+          }
+        }
+        for (const [, group] of uniqueByPkg) {
+          if (group.files.length > 1) {
+            lines.push(
+              `**${group.files.length} packages** (${group.files.map((f) => f.split("/").slice(-2, -1)[0] || f).join(", ")}):`
+            );
+          } else {
+            lines.push(`**${group.files[0]}**:`);
+          }
+          lines.push("| Key | Value |");
+          lines.push("|-----|-------|");
+          for (const v of group.entries) {
+            lines.push(`| ${v.key} | ${v.value.replace(/\|/g, "\\|")} |`);
+          }
+          lines.push("");
+        }
+      }
+      continue;
+    }
+    if (entries.length > 3) {
+      const valueSets = entries.map(
+        (e) => e.values.map((v) => `${v.key}=${v.value}`).sort().join("||")
+      );
+      const mostCommon = valueSets.sort(
+        (a, b) => valueSets.filter((v) => v === b).length - valueSets.filter((v) => v === a).length
+      )[0];
+      const identicalCount = valueSets.filter((v) => v === mostCommon).length;
+      if (identicalCount > 2) {
+        lines.push(`### ${type}
+`);
+        const representative = entries[valueSets.indexOf(mostCommon)];
+        const identicalFiles = entries.filter((_, i) => valueSets[i] === mostCommon).map((e) => e.file);
+        const differentEntries = entries.filter((_, i) => valueSets[i] !== mostCommon);
+        lines.push(`**${identicalFiles.length} identical files**: ${identicalFiles.join(", ")}
+`);
+        lines.push("| Key | Value | Sensitive |");
+        lines.push("|-----|-------|-----------|");
+        for (const v of representative.values.slice(0, 30)) {
+          const escaped = v.value.replace(/\|/g, "\\|");
+          lines.push(`| ${v.key} | ${escaped} | ${v.sensitive ? "\u26A0\uFE0F yes" : "no"} |`);
+        }
+        lines.push("");
+        for (const entry of differentEntries) {
+          lines.push(`#### ${entry.file}
+`);
+          lines.push("| Key | Value | Sensitive |");
+          lines.push("|-----|-------|-----------|");
+          for (const v of entry.values.slice(0, 30)) {
+            const escaped = v.value.replace(/\|/g, "\\|");
+            lines.push(`| ${v.key} | ${escaped} | ${v.sensitive ? "\u26A0\uFE0F yes" : "no"} |`);
+          }
+          lines.push("");
+        }
+        continue;
+      }
+    }
+    lines.push(`### ${type}
+`);
+    for (const entry of entries) {
+      lines.push(`#### ${entry.file}
+`);
+      lines.push("| Key | Value | Sensitive |");
+      lines.push("|-----|-------|-----------|");
+      for (const v of entry.values.slice(0, 50)) {
+        const escaped = v.value.replace(/\|/g, "\\|");
+        lines.push(`| ${v.key} | ${escaped} | ${v.sensitive ? "\u26A0\uFE0F yes" : "no"} |`);
+      }
+      if (entry.values.length > 50) {
+        lines.push(`
+_...and ${entry.values.length - 50} more values._`);
+      }
+      lines.push("");
+    }
+  }
+  const sensitiveCount = configs.reduce(
+    (sum, c) => sum + c.values.filter((v) => v.sensitive).length,
+    0
+  );
+  if (sensitiveCount > 0) {
+    lines.push(`
+**\u26A0\uFE0F ${sensitiveCount} sensitive values detected** (values masked).`);
+  }
+  return lines.join("\n");
+}
+async function onboard(options) {
+  const totalStart = Date.now();
+  const rootPath = resolve(options.path);
+  const projectName = basename(rootPath);
+  const mode = options.mode ?? "memory";
+  const outDir = options.outDir ?? join(rootPath, ".ai", "kb");
+  const structureAnalyzer = new StructureAnalyzer();
+  const dependencyAnalyzer = new DependencyAnalyzer();
+  const symbolAnalyzer = new SymbolAnalyzer();
+  const patternAnalyzer = new PatternAnalyzer();
+  const entryPointAnalyzer = new EntryPointAnalyzer();
+  const diagramGenerator = new DiagramGenerator();
+  const tasks = [
+    {
+      name: "structure",
+      fn: () => structureAnalyzer.analyze(rootPath, { format: "markdown", maxDepth: 3, sourceOnly: true })
+    },
+    {
+      name: "dependencies",
+      fn: () => dependencyAnalyzer.analyze(rootPath, { format: "markdown" })
+    },
+    { name: "entry-points", fn: () => entryPointAnalyzer.analyze(rootPath) },
+    { name: "symbols", fn: () => symbolAnalyzer.analyze(rootPath, { format: "markdown" }) },
+    { name: "patterns", fn: () => patternAnalyzer.analyze(rootPath) },
+    {
+      name: "diagram",
+      fn: () => diagramGenerator.analyze(rootPath, { diagramType: "architecture" })
+    }
+  ];
+  const settled = await Promise.allSettled(
+    tasks.map(async (task) => {
+      const taskStart = Date.now();
+      const result = await task.fn();
+      return { name: task.name, result, durationMs: Date.now() - taskStart };
+    })
+  );
+  const steps = [];
+  const outputs = /* @__PURE__ */ new Map();
+  const dataMap = /* @__PURE__ */ new Map();
+  for (const entry of settled) {
+    if (entry.status === "fulfilled") {
+      const { name, result, durationMs } = entry.value;
+      const analysisResult = result;
+      steps.push({ name, status: "success", output: analysisResult.output, durationMs });
+      outputs.set(name, analysisResult.output);
+      dataMap.set(name, analysisResult.data);
+    } else {
+      const reason = entry.reason;
+      const idx = settled.indexOf(entry);
+      const name = tasks[idx].name;
+      steps.push({
+        name,
+        status: "failed",
+        output: "",
+        durationMs: 0,
+        error: reason.message
+      });
+    }
+  }
+  const callGraphStart = Date.now();
+  let callGraph = null;
+  try {
+    let result = await extractTsCallGraph(rootPath);
+    if (!result || result.edges.length === 0) {
+      result = await extractRegexCallGraph(rootPath);
+    }
+    if (result && result.edges.length > 0) {
+      callGraph = /* @__PURE__ */ new Map();
+      for (const edge of result.edges) {
+        let targets = callGraph.get(edge.from);
+        if (!targets) {
+          targets = /* @__PURE__ */ new Map();
+          callGraph.set(edge.from, targets);
+        }
+        const existing = targets.get(edge.to);
+        if (existing) {
+          for (const s of edge.symbols) {
+            if (!existing.includes(s)) existing.push(s);
+          }
+        } else {
+          targets.set(edge.to, [...edge.symbols]);
+        }
+      }
+    }
+  } catch {
+  }
+  const callGraphDurationMs = Date.now() - callGraphStart;
+  const codeMapStart = Date.now();
+  const codeMap = buildCodeMap(dataMap, projectName, callGraph);
+  const codeMapDurationMs = Date.now() - codeMapStart + callGraphDurationMs;
+  steps.push({
+    name: "code-map",
+    status: "success",
+    output: codeMap,
+    durationMs: codeMapDurationMs
+  });
+  outputs.set("code-map", codeMap);
+  if (callGraph && callGraph.size > 0) {
+    const enhancedDiagram = buildDiagrams(callGraph, dataMap, projectName);
+    const diagramStep = steps.find((s) => s.name === "diagram");
+    if (diagramStep) {
+      diagramStep.output = enhancedDiagram;
+      outputs.set("diagram", enhancedDiagram);
+    }
+  }
+  const configStart = Date.now();
+  const configValues = await extractConfigValues(rootPath, projectName);
+  const configDurationMs = Date.now() - configStart;
+  steps.push({
+    name: "config-values",
+    status: "success",
+    output: configValues,
+    durationMs: configDurationMs
+  });
+  outputs.set("config-values", configValues);
+  const synthesisGuide = buildSynthesisGuide(steps, mode, projectName, dataMap);
+  steps.push({
+    name: "synthesis-guide",
+    status: "success",
+    output: synthesisGuide,
+    durationMs: 0
+  });
+  outputs.set("synthesis-guide", synthesisGuide);
+  if (mode === "generate") {
+    if (existsSync(outDir)) {
+      for (const file of readdirSync(outDir)) {
+        if (file.endsWith(".md") || file.endsWith(".json")) {
+          rmSync(join(outDir, file), { force: true });
+        }
+      }
+    }
+    mkdirSync(outDir, { recursive: true });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const [name, output] of outputs) {
+      const fileName = `${name}.md`;
+      const filePath = join(outDir, fileName);
+      const cleaned = output.replaceAll(rootPath, projectName);
+      const timestamp = `<!-- Generated: ${now} -->
+<!-- Project: ${projectName} -->
+<!-- Source: ${rootPath} -->
+
+`;
+      writeFileSync(filePath, timestamp + cleaned, "utf-8");
+    }
+    const indexLines = [
+      `<!-- Generated: ${now} -->`,
+      `<!-- Project: ${projectName} -->`,
+      `<!-- Source: ${rootPath} -->`,
+      "",
+      `# ${projectName} \u2014 Codebase Knowledge`,
+      "",
+      "## Contents",
+      ""
+    ];
+    for (const step of steps) {
+      const fileName = `${step.name}.md`;
+      const title = DISPLAY_TITLES[step.name] ?? step.name;
+      const status = step.status === "success" ? "\u2713" : "\u2717";
+      const timing = step.durationMs > 0 ? ` (${step.durationMs}ms)` : "";
+      indexLines.push(`- ${status} [${title}](./${fileName})${timing}`);
+    }
+    indexLines.push("");
+    writeFileSync(join(outDir, "README.md"), indexLines.join("\n"), "utf-8");
+  }
+  return {
+    path: rootPath,
+    mode,
+    steps,
+    outDir: mode === "generate" ? outDir : void 0,
+    totalDurationMs: Date.now() - totalStart
+  };
+}
+export {
+  onboard
+};
+//# sourceMappingURL=onboard.js.map