beacon-docs 0.1.0

package/dist/cli.js

@@ -0,0 +1,1493 @@
+#!/usr/bin/env node
+import fs4 from 'fs-extra';
+import path2 from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+import fg from 'fast-glob';
+import matter from 'gray-matter';
+import { cac } from 'cac';
+import * as p from '@clack/prompts';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function configPath(projectRoot) {
+  return path2.join(projectRoot, "docs", "_meta", "beacon.config.json");
+}
+async function readConfig(projectRoot) {
+  const p2 = configPath(projectRoot);
+  if (!await fs4.pathExists(p2)) {
+    throw new Error(
+      `Could not find docs/_meta/beacon.config.json at ${projectRoot}. Run \`beacon init\` first.`
+    );
+  }
+  return await fs4.readJson(p2);
+}
+async function writeConfig(projectRoot, config) {
+  const p2 = configPath(projectRoot);
+  await fs4.ensureDir(path2.dirname(p2));
+  const json = JSON.stringify(config, null, 2) + "\n";
+  await fs4.writeFile(p2, json, "utf8");
+}
+var init_config = __esm({
+  "src/core/config.ts"() {
+  }
+});
+
+// src/core/categories.ts
+function metaFor(category) {
+  return CATEGORY_META[category];
+}
+function isArchivable(category) {
+  return CATEGORY_META[category].archivable;
+}
+var CATEGORY_META;
+var init_categories = __esm({
+  "src/core/categories.ts"() {
+    CATEGORY_META = {
+      reference: {
+        category: "reference",
+        location: "reference",
+        suffix: ".pattern.md",
+        archivable: false,
+        datePrefix: false
+      },
+      architecture: {
+        category: "architecture",
+        location: "architecture",
+        suffix: ".architecture.md",
+        archivable: false,
+        datePrefix: false
+      },
+      adr: {
+        category: "adr",
+        location: "adr",
+        suffix: ".md",
+        archivable: false,
+        datePrefix: false,
+        numberedPrefix: "ADR-"
+      },
+      plans: {
+        category: "plans",
+        location: "plans",
+        suffix: ".plan.md",
+        archivable: true,
+        datePrefix: false
+      },
+      backlog: {
+        category: "backlog",
+        location: "backlog",
+        suffix: ".todo.md",
+        archivable: false,
+        datePrefix: false
+      },
+      evaluations: {
+        category: "evaluations",
+        location: "evaluations",
+        suffix: ".eval.md",
+        archivable: false,
+        datePrefix: true
+      },
+      compliance: {
+        category: "compliance",
+        location: "compliance",
+        suffix: ".md",
+        archivable: false,
+        datePrefix: false
+      },
+      business: {
+        category: "business",
+        location: "business",
+        suffix: ".business.md",
+        archivable: false,
+        datePrefix: false
+      },
+      modules: {
+        category: "modules",
+        location: "modules",
+        suffix: ".module.md",
+        archivable: false,
+        datePrefix: false
+      },
+      integrations: {
+        category: "integrations",
+        location: "integrations",
+        suffix: ".guide.md",
+        archivable: false,
+        datePrefix: false
+      },
+      operations: {
+        category: "operations",
+        location: "operations",
+        suffix: ".guide.md",
+        archivable: false,
+        datePrefix: false
+      },
+      roadmaps: {
+        category: "roadmaps",
+        location: "roadmaps",
+        suffix: ".roadmap.md",
+        archivable: true,
+        datePrefix: false
+      }
+    };
+  }
+});
+function docsDir(root) {
+  return path2.join(root, "docs");
+}
+function metaDir(root) {
+  return path2.join(docsDir(root), "_meta");
+}
+function conventionPath(root) {
+  return path2.join(metaDir(root), "convention.md");
+}
+function categoryDir(root, category) {
+  return path2.join(docsDir(root), category);
+}
+function archiveDir(root, category) {
+  return path2.join(categoryDir(root, category), "_archive");
+}
+function rootFile(root, name) {
+  return path2.join(root, name);
+}
+var init_paths = __esm({
+  "src/core/paths.ts"() {
+  }
+});
+function resolveTemplateDir() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidate = path2.join(here, "templates");
+  if (fs4.existsSync(candidate)) return candidate;
+  return path2.join(here, "..", "templates");
+}
+function renderMasterReadme(config) {
+  const tpl = fs4.readFileSync(path2.join(TEMPLATE_DIR, "readme-master.md.ejs"), "utf8");
+  const has = (c) => config.categories.includes(c);
+  return ejs.render(tpl, { projectType: config.projectType, has }, { rmWhitespace: false });
+}
+function renderCategoryReadme(category) {
+  const tpl = fs4.readFileSync(path2.join(TEMPLATE_DIR, "readme-category.md.ejs"), "utf8");
+  const m = metaFor(category);
+  const d = CATEGORY_DESCRIPTIONS[category];
+  return ejs.render(tpl, {
+    title: d.title,
+    description: d.description,
+    suffix: m.suffix,
+    numberedPrefix: m.numberedPrefix,
+    datePrefix: m.datePrefix,
+    archivable: m.archivable
+  });
+}
+var TEMPLATE_DIR, CATEGORY_DESCRIPTIONS;
+var init_readme = __esm({
+  "src/generators/readme.ts"() {
+    init_categories();
+    TEMPLATE_DIR = resolveTemplateDir();
+    CATEGORY_DESCRIPTIONS = {
+      reference: { title: "reference/", description: "Replicable technical patterns \u2014 *how* something is done." },
+      architecture: { title: "architecture/", description: "System structure and layering decisions." },
+      adr: { title: "adr/", description: "Architecture Decision Records \u2014 *why* a choice was made." },
+      plans: { title: "plans/", description: "Active work with checked TODOs." },
+      backlog: { title: "backlog/", description: "Future work items not yet planned." },
+      evaluations: { title: "evaluations/", description: "Date-prefixed audits and state snapshots." },
+      compliance: { title: "compliance/", description: "Regulatory and normative documents." },
+      business: { title: "business/", description: "Business model, pricing, product strategy." },
+      modules: { title: "modules/", description: "Domain modules and their functional behavior." },
+      integrations: { title: "integrations/", description: "External service setup and configuration." },
+      operations: { title: "operations/", description: "Runbooks, deploy guides, troubleshooting." },
+      roadmaps: { title: "roadmaps/", description: "Multi-sprint planning (longer than `plans/`)." }
+    };
+  }
+});
+
+// src/generators/_header.ts
+var HEADER;
+var init_header = __esm({
+  "src/generators/_header.ts"() {
+    HEADER = "<!-- generated by beacon \u2014 do not edit. Edit docs/_meta/convention.md and run `beacon sync`. -->";
+  }
+});
+
+// src/generators/ai-rules.ts
+function buildUniversalRules() {
+  return [
+    "## Universal rules",
+    "",
+    "1. **One doc = one category.** Never duplicate across folders.",
+    "2. **Status via folder, never filename.** Closed plan \u2192 `_archive/`, never `*_DONE.md` or `*_v2.md`.",
+    "3. **kebab-case for all filenames.** No camelCase, no snake_case, no spaces.",
+    "4. **README required in every category folder.**",
+    "5. **ADRs are append-only.** Supersede with a new ADR; never edit an accepted one.",
+    "6. **Evaluations are immutable snapshots.** To revise, create a new dated file.",
+    "7. **Plans archive to `_archive/` when done.** Move them, never rename.",
+    "8. **Generated AI files (this one) must match `docs/_meta/convention.md`.** Run `beacon sync` after editing the convention.",
+    "9. **Don't create folders outside the convention.** Run `beacon enable <addon>` or propose an ADR."
+  ].join("\n");
+}
+function buildProjectSpecificRules(config) {
+  const lines = ["## Project-specific rules", ""];
+  let any = false;
+  for (const c of config.categories) {
+    if (PROJECT_SPECIFIC_RULES[c]) {
+      lines.push(PROJECT_SPECIFIC_RULES[c]);
+      any = true;
+    }
+  }
+  if (!any) {
+    lines.push("- (none for this project)");
+  }
+  return lines.join("\n");
+}
+function buildDecisionTable(config) {
+  const lines = [
+    "## Where does X go?",
+    "",
+    "| Question | Folder |",
+    "|---|---|"
+  ];
+  for (const c of config.categories) {
+    if (DECISION_ROWS[c]) lines.push(DECISION_ROWS[c]);
+  }
+  return lines.join("\n");
+}
+var PROJECT_SPECIFIC_RULES, DECISION_ROWS;
+var init_ai_rules = __esm({
+  "src/generators/ai-rules.ts"() {
+    init_categories();
+    PROJECT_SPECIFIC_RULES = {
+      compliance: "- **`compliance/`** \u2014 regulatory docs only. Link from related modules/architecture; never duplicate.",
+      modules: "- **`modules/`** \u2014 domain logic per module. Technical patterns extracted from a module go in `reference/`, not here.",
+      integrations: "- **`integrations/*.guide.md`** \u2014 setup for external services (Stripe, email, etc.). Code patterns for *using* them go in `reference/`.",
+      business: "- **`business/*.business.md`** \u2014 strategy, pricing, product model. No technical content.",
+      operations: "- **`operations/*.guide.md`** \u2014 deploy guides, admin runbooks, troubleshooting. Post-mortems go in `evaluations/`.",
+      roadmaps: "- **`roadmaps/*.roadmap.md`** \u2014 multi-sprint planning. Individual sprint work goes in `plans/`."
+    };
+    DECISION_ROWS = {
+      reference: '| "How is X done technically?" | `reference/` |',
+      architecture: '| "How is the system structured?" | `architecture/` |',
+      adr: '| "Why was X decided?" | `adr/` |',
+      modules: '| "What does module X do?" | `modules/` |',
+      compliance: '| "Does X comply with regulation Y?" | `compliance/` |',
+      integrations: '| "How do I set up service X?" | `integrations/` |',
+      operations: '| "How do I deploy/administer X?" | `operations/` |',
+      business: '| "What is the business model?" | `business/` |',
+      plans: '| "What is being built right now?" | `plans/` |',
+      roadmaps: '| "What is planned for next quarter?" | `roadmaps/` |',
+      backlog: '| "What is on the future backlog?" | `backlog/` |',
+      evaluations: '| "What was the state at date X?" | `evaluations/` |'
+    };
+  }
+});
+
+// src/generators/claude.ts
+function renderClaudeMd(config) {
+  return [
+    HEADER,
+    "",
+    "# Documentation Convention",
+    "",
+    "> Project type: **" + config.projectType + "**. Full convention: [`docs/_meta/convention.md`](docs/_meta/convention.md).",
+    "",
+    buildUniversalRules(),
+    "",
+    buildProjectSpecificRules(config),
+    "",
+    buildDecisionTable(config),
+    ""
+  ].join("\n");
+}
+var init_claude = __esm({
+  "src/generators/claude.ts"() {
+    init_header();
+    init_ai_rules();
+  }
+});
+
+// src/generators/agents.ts
+function renderAgentsMd(config) {
+  return [
+    HEADER,
+    "",
+    "# AGENTS.md \u2014 Documentation Convention",
+    "",
+    "> Read by OpenAI Codex / GitHub Copilot. Full convention: [`docs/_meta/convention.md`](docs/_meta/convention.md).",
+    "",
+    buildUniversalRules(),
+    "",
+    buildProjectSpecificRules(config),
+    "",
+    buildDecisionTable(config),
+    ""
+  ].join("\n");
+}
+var init_agents = __esm({
+  "src/generators/agents.ts"() {
+    init_header();
+    init_ai_rules();
+  }
+});
+
+// src/generators/gemini.ts
+function renderGeminiMd(config) {
+  return [
+    HEADER,
+    "",
+    "# GEMINI.md \u2014 Documentation Convention",
+    "",
+    "> Read by Gemini CLI. Full convention: [`docs/_meta/convention.md`](docs/_meta/convention.md).",
+    "",
+    buildUniversalRules(),
+    "",
+    buildProjectSpecificRules(config),
+    "",
+    buildDecisionTable(config),
+    ""
+  ].join("\n");
+}
+var init_gemini = __esm({
+  "src/generators/gemini.ts"() {
+    init_header();
+    init_ai_rules();
+  }
+});
+
+// src/generators/cursor.ts
+function renderCursorRules(config) {
+  return [
+    HEADER,
+    "",
+    buildUniversalRules(),
+    "",
+    buildProjectSpecificRules(config),
+    ""
+  ].join("\n");
+}
+function renderCursorMdc(config) {
+  const front = [
+    "---",
+    "description: Beacon documentation convention \u2014 where docs go and how they're named.",
+    'globs: ["docs/**/*.md"]',
+    "alwaysApply: true",
+    "---"
+  ].join("\n");
+  return [
+    front,
+    "",
+    HEADER,
+    "",
+    buildUniversalRules(),
+    "",
+    buildProjectSpecificRules(config),
+    ""
+  ].join("\n");
+}
+var init_cursor = __esm({
+  "src/generators/cursor.ts"() {
+    init_header();
+    init_ai_rules();
+  }
+});
+
+// src/commands/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  runSync: () => runSync
+});
+async function runSync(opts) {
+  const config = await readConfig(opts.root);
+  if (config.agents.includes("claude")) {
+    await fs4.writeFile(rootFile(opts.root, "CLAUDE.md"), renderClaudeMd(config), "utf8");
+  }
+  if (config.agents.includes("codex")) {
+    await fs4.writeFile(rootFile(opts.root, "AGENTS.md"), renderAgentsMd(config), "utf8");
+  }
+  if (config.agents.includes("gemini")) {
+    await fs4.writeFile(rootFile(opts.root, "GEMINI.md"), renderGeminiMd(config), "utf8");
+  }
+  if (config.agents.includes("cursor")) {
+    await fs4.writeFile(rootFile(opts.root, ".cursorrules"), renderCursorRules(config), "utf8");
+    const mdcDir = path2.join(opts.root, ".cursor", "rules");
+    await fs4.ensureDir(mdcDir);
+    await fs4.writeFile(path2.join(mdcDir, "beacon.mdc"), renderCursorMdc(config), "utf8");
+  }
+}
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    init_config();
+    init_paths();
+    init_claude();
+    init_agents();
+    init_gemini();
+    init_cursor();
+  }
+});
+async function nextAdrNumber(root) {
+  const dir = categoryDir(root, "adr");
+  if (!await fs4.pathExists(dir)) return "001";
+  const files = await fs4.readdir(dir);
+  let max = 0;
+  for (const f of files) {
+    const m = ADR_FILE.exec(f);
+    if (m) {
+      const n = parseInt(m[1], 10);
+      if (n > max) max = n;
+    }
+  }
+  return String(max + 1).padStart(3, "0");
+}
+var ADR_FILE;
+var init_adr_numbering = __esm({
+  "src/core/adr-numbering.ts"() {
+    init_paths();
+    ADR_FILE = /^ADR-(\d{3})-.+\.md$/;
+  }
+});
+function resolveTemplateDir3() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidate = path2.join(here, "templates", "frontmatter");
+  if (fs4.existsSync(candidate)) return candidate;
+  return path2.join(here, "..", "templates", "frontmatter");
+}
+function renderDoc(input) {
+  const tplPath = path2.join(TEMPLATE_DIR3, `${input.type}.md.ejs`);
+  const tpl = fs4.readFileSync(tplPath, "utf8");
+  return ejs.render(tpl, input);
+}
+var TEMPLATE_DIR3;
+var init_doc = __esm({
+  "src/generators/doc.ts"() {
+    TEMPLATE_DIR3 = resolveTemplateDir3();
+  }
+});
+
+// src/commands/new.ts
+var new_exports = {};
+__export(new_exports, {
+  runNew: () => runNew
+});
+async function runNew(input) {
+  if (!KEBAB.test(input.slug)) {
+    throw new Error(`Slug must be kebab-case: "${input.slug}".`);
+  }
+  const config = await readConfig(input.root);
+  const category = input.type === "guide" && input.category ? input.category : DOC_TYPE_TO_CATEGORY[input.type];
+  if (!config.categories.includes(category)) {
+    throw new Error(
+      `Category "${category}" is not enabled. Run \`beacon enable ${category}\` first.`
+    );
+  }
+  const meta = metaFor(category);
+  const dir = categoryDir(input.root, category);
+  let filename;
+  let number;
+  if (meta.numberedPrefix) {
+    number = await nextAdrNumber(input.root);
+    filename = `${meta.numberedPrefix}${number}-${input.slug}.md`;
+  } else if (meta.datePrefix) {
+    filename = `${input.today}-${input.slug}${meta.suffix}`;
+  } else {
+    filename = `${input.slug}${meta.suffix}`;
+  }
+  const filePath = path2.join(dir, filename);
+  if (await fs4.pathExists(filePath)) {
+    throw new Error(`File already exists: ${filePath}`);
+  }
+  const content = renderDoc({
+    type: input.type,
+    title: input.slug,
+    today: input.today,
+    number
+  });
+  await fs4.writeFile(filePath, content, "utf8");
+  return filePath;
+}
+var DOC_TYPE_TO_CATEGORY, KEBAB;
+var init_new = __esm({
+  "src/commands/new.ts"() {
+    init_config();
+    init_categories();
+    init_paths();
+    init_adr_numbering();
+    init_doc();
+    DOC_TYPE_TO_CATEGORY = {
+      plan: "plans",
+      adr: "adr",
+      pattern: "reference",
+      eval: "evaluations",
+      architecture: "architecture",
+      module: "modules",
+      guide: "integrations",
+      // ambiguous — caller can override via `category` field
+      roadmap: "roadmaps",
+      todo: "backlog",
+      business: "business",
+      compliance: "compliance"
+    };
+    KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+  }
+});
+
+// src/commands/archive.ts
+var archive_exports = {};
+__export(archive_exports, {
+  runArchive: () => runArchive
+});
+async function runArchive(input) {
+  const category = TYPE_TO_CATEGORY[input.type];
+  if (!category) {
+    throw new Error(`Type "${input.type}" cannot be archived. Only plan and roadmap support archiving.`);
+  }
+  const meta = metaFor(category);
+  if (!meta.archivable) {
+    throw new Error(`Category "${category}" cannot be archived.`);
+  }
+  const filename = `${input.slug}${meta.suffix}`;
+  const source = path2.join(categoryDir(input.root, category), filename);
+  if (!await fs4.pathExists(source)) {
+    throw new Error(`File not found: ${source}`);
+  }
+  const warnings = [];
+  const body = await fs4.readFile(source, "utf8");
+  if (/- \[ \]/.test(body)) {
+    warnings.push("Unchecked TODOs remain in the document.");
+    if (!input.force) {
+      throw new Error(
+        "Document has unchecked TODOs. Re-run with --force to archive anyway."
+      );
+    }
+  }
+  const dest = path2.join(archiveDir(input.root, category), filename);
+  await fs4.ensureDir(path2.dirname(dest));
+  await fs4.move(source, dest, { overwrite: false });
+  return { source, destination: dest, warnings };
+}
+var TYPE_TO_CATEGORY;
+var init_archive = __esm({
+  "src/commands/archive.ts"() {
+    init_categories();
+    init_paths();
+    TYPE_TO_CATEGORY = {
+      plan: "plans",
+      roadmap: "roadmaps"
+    };
+  }
+});
+
+// src/commands/toggle.ts
+var toggle_exports = {};
+__export(toggle_exports, {
+  runDisable: () => runDisable,
+  runEnable: () => runEnable
+});
+async function runEnable(opts) {
+  const cfg = await readConfig(opts.root);
+  const addon = opts.addon;
+  if (!cfg.categories.includes(addon)) {
+    cfg.categories.push(addon);
+    await writeConfig(opts.root, cfg);
+  }
+  const dir = categoryDir(opts.root, addon);
+  await fs4.ensureDir(dir);
+  const readme = path2.join(dir, "README.md");
+  if (!await fs4.pathExists(readme)) {
+    await fs4.writeFile(readme, renderCategoryReadme(addon), "utf8");
+  }
+  if (isArchivable(addon)) {
+    await fs4.ensureDir(archiveDir(opts.root, addon));
+  }
+  await runSync({ root: opts.root });
+}
+async function runDisable(opts) {
+  const cfg = await readConfig(opts.root);
+  const dir = categoryDir(opts.root, opts.addon);
+  if (await fs4.pathExists(dir)) {
+    const entries = await fs4.readdir(dir);
+    const hasContent = entries.some(
+      (e) => e !== "README.md" && e !== "_archive"
+    );
+    if (hasContent && !opts.force) {
+      throw new Error(
+        `Folder ${dir} contains documents. Re-run with --force to disable anyway (files are kept on disk).`
+      );
+    }
+  }
+  cfg.categories = cfg.categories.filter((c) => c !== opts.addon);
+  await writeConfig(opts.root, cfg);
+  await runSync({ root: opts.root });
+}
+var init_toggle = __esm({
+  "src/commands/toggle.ts"() {
+    init_config();
+    init_paths();
+    init_categories();
+    init_readme();
+    init_sync();
+  }
+});
+async function walkDocs(root) {
+  const base = docsDir(root);
+  const matches = await fg(["**/*.md"], {
+    cwd: base,
+    dot: false,
+    onlyFiles: true
+  });
+  return matches.map((rel) => {
+    const segments = rel.split("/");
+    const category = segments[0] === "_meta" ? "_meta" : segments[0];
+    return {
+      absolutePath: path2.join(base, rel),
+      relativePath: rel,
+      // relative to docs/, matches test expectation
+      category,
+      basename: path2.basename(rel),
+      isReadme: path2.basename(rel) === "README.md",
+      isArchived: segments.includes("_archive")
+    };
+  });
+}
+var init_walker = __esm({
+  "src/linter/walker.ts"() {
+    init_paths();
+  }
+});
+
+// src/linter/index.ts
+async function runLint(opts) {
+  const config = await readConfig(opts.root);
+  const files = await walkDocs(opts.root);
+  const ctx = { root: opts.root, config, files };
+  const findings = [];
+  for (const rule12 of opts.rules) {
+    const result = await rule12.check(ctx);
+    findings.push(...result);
+  }
+  const counts = { error: 0, warning: 0, suggestion: 0 };
+  for (const f of findings) counts[f.severity]++;
+  return {
+    findings,
+    errorCount: counts.error,
+    warningCount: counts.warning,
+    suggestionCount: counts.suggestion
+  };
+}
+var init_linter = __esm({
+  "src/linter/index.ts"() {
+    init_config();
+    init_walker();
+  }
+});
+
+// src/linter/reporter.ts
+function formatText(findings) {
+  const lines = [];
+  const groups = { error: [], warning: [], suggestion: [] };
+  for (const f of findings) groups[f.severity].push(f);
+  function block(title, items) {
+    lines.push(`${title} (${items.length})`);
+    for (const f of items) {
+      const loc = f.file ? ` ${f.file}` : "";
+      lines.push(`  [${f.rule}]${loc} \u2014 ${f.message}`);
+    }
+    lines.push("");
+  }
+  block("Errors", groups.error);
+  block("Warnings", groups.warning);
+  block("Suggestions", groups.suggestion);
+  return lines.join("\n");
+}
+function formatJson(findings) {
+  return JSON.stringify(findings, null, 2);
+}
+var init_reporter = __esm({
+  "src/linter/reporter.ts"() {
+  }
+});
+
+// src/linter/rules/suffix-location.ts
+var SUFFIX_TO_CATEGORY, rule;
+var init_suffix_location = __esm({
+  "src/linter/rules/suffix-location.ts"() {
+    init_categories();
+    SUFFIX_TO_CATEGORY = {};
+    for (const [, m] of Object.entries(CATEGORY_META)) {
+      if (m.suffix !== ".md") SUFFIX_TO_CATEGORY[m.suffix] = m.location;
+    }
+    rule = {
+      name: "suffix-location",
+      severity: "error",
+      check(ctx) {
+        const findings = [];
+        for (const f of ctx.files) {
+          if (f.isReadme) continue;
+          for (const [suffix, expectedDir] of Object.entries(SUFFIX_TO_CATEGORY)) {
+            if (f.basename.endsWith(suffix) && f.category !== expectedDir) {
+              findings.push({
+                severity: "error",
+                rule: "suffix-location",
+                file: f.relativePath,
+                message: `File with suffix "${suffix}" must live in docs/${expectedDir}/ (found in docs/${f.category}/).`
+              });
+            }
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+
+// src/linter/rules/kebab-case.ts
+var KEBAB_OR_ADR, rule2;
+var init_kebab_case = __esm({
+  "src/linter/rules/kebab-case.ts"() {
+    KEBAB_OR_ADR = /^(ADR-\d{3}-)?[a-z0-9]+(-[a-z0-9]+)*(\.[a-z]+)*\.md$/;
+    rule2 = {
+      name: "kebab-case",
+      severity: "error",
+      check(ctx) {
+        const findings = [];
+        for (const f of ctx.files) {
+          if (f.isReadme) continue;
+          if (!KEBAB_OR_ADR.test(f.basename)) {
+            findings.push({
+              severity: "error",
+              rule: "kebab-case",
+              file: f.relativePath,
+              message: `Filename "${f.basename}" must be kebab-case (lowercase, hyphen-separated).`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+
+// src/linter/rules/eval-date-prefix.ts
+var DATE_PREFIX, rule3;
+var init_eval_date_prefix = __esm({
+  "src/linter/rules/eval-date-prefix.ts"() {
+    DATE_PREFIX = /^\d{4}-\d{2}-\d{2}-.+\.eval\.md$/;
+    rule3 = {
+      name: "eval-date-prefix",
+      severity: "error",
+      check(ctx) {
+        const findings = [];
+        for (const f of ctx.files) {
+          if (!f.basename.endsWith(".eval.md")) continue;
+          if (!DATE_PREFIX.test(f.basename)) {
+            findings.push({
+              severity: "error",
+              rule: "eval-date-prefix",
+              file: f.relativePath,
+              message: `Eval file "${f.basename}" must start with YYYY-MM-DD-.`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+
+// src/linter/rules/readme-present.ts
+var rule4;
+var init_readme_present = __esm({
+  "src/linter/rules/readme-present.ts"() {
+    rule4 = {
+      name: "readme-present",
+      severity: "error",
+      check(ctx) {
+        const present = /* @__PURE__ */ new Set();
+        for (const f of ctx.files) {
+          if (f.isReadme && !f.isArchived) present.add(f.category);
+        }
+        const findings = [];
+        for (const c of ctx.config.categories) {
+          if (!present.has(c)) {
+            findings.push({
+              severity: "error",
+              rule: "readme-present",
+              message: `docs/${c}/README.md is required.`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+var rule5;
+var init_ai_files_sync = __esm({
+  "src/linter/rules/ai-files-sync.ts"() {
+    init_claude();
+    init_agents();
+    init_gemini();
+    init_cursor();
+    rule5 = {
+      name: "ai-files-sync",
+      severity: "error",
+      async check(ctx) {
+        const findings = [];
+        const checks = [
+          { agent: "claude", filename: "CLAUDE.md", render: () => renderClaudeMd(ctx.config) },
+          { agent: "codex", filename: "AGENTS.md", render: () => renderAgentsMd(ctx.config) },
+          { agent: "gemini", filename: "GEMINI.md", render: () => renderGeminiMd(ctx.config) },
+          { agent: "cursor", filename: ".cursorrules", render: () => renderCursorRules(ctx.config) },
+          { agent: "cursor", filename: ".cursor/rules/beacon.mdc", render: () => renderCursorMdc(ctx.config) }
+        ];
+        for (const c of checks) {
+          if (!ctx.config.agents.includes(c.agent)) continue;
+          const file = path2.join(ctx.root, c.filename);
+          if (!await fs4.pathExists(file)) {
+            findings.push({
+              severity: "error",
+              rule: "ai-files-sync",
+              file: c.filename,
+              message: `${c.filename} missing. Run \`beacon sync\`.`
+            });
+            continue;
+          }
+          const actual = await fs4.readFile(file, "utf8");
+          const expected = c.render();
+          if (actual !== expected) {
+            findings.push({
+              severity: "error",
+              rule: "ai-files-sync",
+              file: c.filename,
+              message: `${c.filename} is out of sync with docs/_meta/convention.md. Run \`beacon sync\`.`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+var rule6;
+var init_duplicate_titles = __esm({
+  "src/linter/rules/duplicate-titles.ts"() {
+    rule6 = {
+      name: "duplicate-titles",
+      severity: "warning",
+      async check(ctx) {
+        const titleMap = /* @__PURE__ */ new Map();
+        for (const f of ctx.files) {
+          if (f.isReadme || f.isArchived) continue;
+          const content = await fs4.readFile(f.absolutePath, "utf8");
+          const m = /^#\s+(.+)$/m.exec(content);
+          if (!m) continue;
+          const title = m[1].trim();
+          const arr = titleMap.get(title) ?? [];
+          arr.push(f.relativePath);
+          titleMap.set(title, arr);
+        }
+        const findings = [];
+        for (const [title, files] of titleMap) {
+          if (files.length > 1) {
+            findings.push({
+              severity: "warning",
+              rule: "duplicate-titles",
+              message: `Title "${title}" appears in: ${files.join(", ")}`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+var LIMIT, rule7;
+var init_long_files = __esm({
+  "src/linter/rules/long-files.ts"() {
+    LIMIT = 1e3;
+    rule7 = {
+      name: "long-files",
+      severity: "warning",
+      async check(ctx) {
+        const findings = [];
+        for (const f of ctx.files) {
+          const content = await fs4.readFile(f.absolutePath, "utf8");
+          const lines = content.split("\n").length;
+          if (lines > LIMIT) {
+            findings.push({
+              severity: "warning",
+              rule: "long-files",
+              file: f.relativePath,
+              message: `File has ${lines} lines (>${LIMIT}). Consider splitting.`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+
+// src/linter/rules/folder-size.ts
+var LIMIT2, rule8;
+var init_folder_size = __esm({
+  "src/linter/rules/folder-size.ts"() {
+    LIMIT2 = 30;
+    rule8 = {
+      name: "folder-size",
+      severity: "warning",
+      check(ctx) {
+        const counts = /* @__PURE__ */ new Map();
+        for (const f of ctx.files) {
+          if (f.isReadme || f.isArchived) continue;
+          counts.set(f.category, (counts.get(f.category) ?? 0) + 1);
+        }
+        const findings = [];
+        for (const [cat, count] of counts) {
+          if (count > LIMIT2) {
+            findings.push({
+              severity: "warning",
+              rule: "folder-size",
+              message: `docs/${cat}/ has ${count} files (>${LIMIT2}). Consider organizing into subfolders.`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+
+// src/linter/rules/adr-numbering.ts
+var ADR_FILE2, rule9;
+var init_adr_numbering2 = __esm({
+  "src/linter/rules/adr-numbering.ts"() {
+    ADR_FILE2 = /^ADR-(\d{3})-.+\.md$/;
+    rule9 = {
+      name: "adr-numbering",
+      severity: "warning",
+      check(ctx) {
+        const numbers = [];
+        for (const f of ctx.files) {
+          if (f.category !== "adr") continue;
+          const m = ADR_FILE2.exec(f.basename);
+          if (m) numbers.push(parseInt(m[1], 10));
+        }
+        numbers.sort((a, b) => a - b);
+        const findings = [];
+        for (let i = 1; i < numbers.length; i++) {
+          const prev = numbers[i - 1];
+          const cur = numbers[i];
+          if (cur > prev + 1) {
+            for (let n = prev + 1; n < cur; n++) {
+              findings.push({
+                severity: "warning",
+                rule: "adr-numbering",
+                message: `ADR-${String(n).padStart(3, "0")} is missing. Intentional gaps (rejected/superseded) are OK; otherwise renumber.`
+              });
+            }
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+var STALE_MS, rule10;
+var init_stale_plans = __esm({
+  "src/linter/rules/stale-plans.ts"() {
+    STALE_MS = 30 * 24 * 60 * 60 * 1e3;
+    rule10 = {
+      name: "stale-plans",
+      severity: "suggestion",
+      async check(ctx) {
+        const findings = [];
+        const now = Date.now();
+        for (const f of ctx.files) {
+          if (f.category !== "plans" || f.isArchived || f.isReadme) continue;
+          const stat = await fs4.stat(f.absolutePath);
+          if (now - stat.mtimeMs > STALE_MS) {
+            findings.push({
+              severity: "suggestion",
+              rule: "stale-plans",
+              file: f.relativePath,
+              message: `Plan not modified in >30 days. If complete, archive it.`
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+var rule11;
+var init_adr_status = __esm({
+  "src/linter/rules/adr-status.ts"() {
+    rule11 = {
+      name: "adr-status",
+      severity: "suggestion",
+      async check(ctx) {
+        const findings = [];
+        for (const f of ctx.files) {
+          if (f.category !== "adr" || f.isReadme) continue;
+          const content = await fs4.readFile(f.absolutePath, "utf8");
+          const fm = matter(content).data;
+          if (!fm.status) {
+            findings.push({
+              severity: "suggestion",
+              rule: "adr-status",
+              file: f.relativePath,
+              message: "ADR missing `status:` frontmatter (proposed/accepted/superseded/rejected)."
+            });
+          }
+        }
+        return findings;
+      }
+    };
+  }
+});
+
+// src/commands/lint.ts
+var lint_exports = {};
+__export(lint_exports, {
+  runLintCommand: () => runLintCommand
+});
+async function runLintCommand(opts) {
+  const result = await runLint({ root: opts.root, rules: RULES });
+  let exitCode = 0;
+  if (result.errorCount > 0) exitCode = 1;
+  if (opts.strict && result.warningCount > 0) exitCode = 1;
+  const output = opts.json ? formatJson(result.findings) : formatText(result.findings);
+  return { exitCode, output };
+}
+var RULES;
+var init_lint = __esm({
+  "src/commands/lint.ts"() {
+    init_linter();
+    init_reporter();
+    init_suffix_location();
+    init_kebab_case();
+    init_eval_date_prefix();
+    init_readme_present();
+    init_ai_files_sync();
+    init_duplicate_titles();
+    init_long_files();
+    init_folder_size();
+    init_adr_numbering2();
+    init_stale_plans();
+    init_adr_status();
+    RULES = [
+      rule,
+      rule2,
+      rule3,
+      rule4,
+      rule5,
+      rule6,
+      rule7,
+      rule8,
+      rule9,
+      rule10,
+      rule11
+    ];
+  }
+});
+
+// src/core/project-types.ts
+var PROJECT_TYPES = [
+  "web-app",
+  "backend-service",
+  "library",
+  "cli-tool",
+  "mobile-app",
+  "monorepo",
+  "custom"
+];
+var CORE_CATEGORIES = [
+  "reference",
+  "architecture",
+  "adr",
+  "plans",
+  "backlog",
+  "evaluations"
+];
+var ADDON_CATEGORIES = [
+  "compliance",
+  "business",
+  "modules",
+  "integrations",
+  "operations",
+  "roadmaps"
+];
+var DEFAULTS_BY_TYPE = {
+  "web-app": [
+    ...CORE_CATEGORIES,
+    "business",
+    "integrations",
+    "operations",
+    "roadmaps"
+  ],
+  "backend-service": [
+    ...CORE_CATEGORIES,
+    "integrations",
+    "operations",
+    "roadmaps"
+  ],
+  library: [...CORE_CATEGORIES],
+  "cli-tool": [...CORE_CATEGORIES, "operations"],
+  "mobile-app": [
+    ...CORE_CATEGORIES,
+    "business",
+    "integrations",
+    "operations",
+    "roadmaps"
+  ],
+  monorepo: [
+    ...CORE_CATEGORIES,
+    "modules",
+    "integrations",
+    "operations",
+    "roadmaps"
+  ],
+  custom: []
+};
+function defaultCategoriesFor(type) {
+  return [...DEFAULTS_BY_TYPE[type]];
+}
+function isValidProjectType(value) {
+  return PROJECT_TYPES.includes(value);
+}
+
+// src/generators/scaffold.ts
+init_config();
+init_categories();
+init_paths();
+init_readme();
+
+// src/generators/convention.ts
+init_categories();
+function resolveTemplateDir2() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidate = path2.join(here, "templates");
+  if (fs4.existsSync(candidate)) return candidate;
+  return path2.join(here, "..", "templates");
+}
+var TEMPLATE_DIR2 = resolveTemplateDir2();
+var CATEGORY_DESCRIPTIONS2 = {
+  reference: "Replicable technical patterns.",
+  architecture: "System structure and layering decisions.",
+  adr: "Architecture Decision Records.",
+  plans: "Active work with TODOs.",
+  backlog: "Future items waiting to be sprinted.",
+  evaluations: "Date-prefixed audits and snapshots.",
+  compliance: "Regulatory and normative docs.",
+  business: "Business model and product strategy.",
+  modules: "Domain modules and their behavior.",
+  integrations: "External service setup.",
+  operations: "Runbooks and deploy guides.",
+  roadmaps: "Multi-sprint planning."
+};
+function renderConvention(config) {
+  const tpl = fs4.readFileSync(path2.join(TEMPLATE_DIR2, "convention.md.ejs"), "utf8");
+  const suffixes = {};
+  const suffixNotes = {};
+  for (const c of config.categories) {
+    suffixes[c] = CATEGORY_META[c].suffix;
+    if (CATEGORY_META[c].numberedPrefix) suffixNotes[c] = `Auto-numbered (${CATEGORY_META[c].numberedPrefix}NNN-).`;
+    if (CATEGORY_META[c].datePrefix) suffixNotes[c] = "Requires `YYYY-MM-DD-` prefix.";
+  }
+  return ejs.render(tpl, {
+    projectType: config.projectType,
+    categories: config.categories,
+    descriptions: CATEGORY_DESCRIPTIONS2,
+    suffixes,
+    suffixNotes
+  });
+}
+
+// src/generators/scaffold.ts
+async function scaffoldStructure(root, config) {
+  await fs4.ensureDir(metaDir(root));
+  for (const category of config.categories) {
+    const dir = categoryDir(root, category);
+    await fs4.ensureDir(dir);
+    if (isArchivable(category)) {
+      await fs4.ensureDir(archiveDir(root, category));
+    }
+    const readmePath = path2.join(dir, "README.md");
+    if (!await fs4.pathExists(readmePath)) {
+      await fs4.writeFile(readmePath, renderCategoryReadme(category), "utf8");
+    }
+  }
+  const masterReadmePath = path2.join(docsDir(root), "README.md");
+  if (!await fs4.pathExists(masterReadmePath)) {
+    await fs4.writeFile(masterReadmePath, renderMasterReadme(config), "utf8");
+  }
+  const convention = conventionPath(root);
+  if (!await fs4.pathExists(convention)) {
+    await fs4.writeFile(convention, renderConvention(config), "utf8");
+  }
+  await writeConfig(root, config);
+}
+async function addDocsLintScript(projectRoot) {
+  const p2 = path2.join(projectRoot, "package.json");
+  if (!await fs4.pathExists(p2)) return;
+  const pkg = await fs4.readJson(p2);
+  pkg.scripts ??= {};
+  if (!pkg.scripts["docs:lint"]) {
+    pkg.scripts["docs:lint"] = "beacon lint";
+    await fs4.writeFile(p2, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  }
+}
+var AGENT_FILES = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  "GEMINI.md",
+  ".cursorrules"
+];
+var INTEGRATIONS_HINTS = [
+  "stripe",
+  "@stripe/stripe-js",
+  "mailgun-js",
+  "twilio",
+  "@sendgrid/mail",
+  "resend"
+];
+var DATABASE_HINTS = [
+  "@prisma/client",
+  "prisma",
+  "drizzle-orm",
+  "mongoose",
+  "typeorm",
+  "knex",
+  "sequelize"
+];
+async function detectContext(root) {
+  const pkgPath = path2.join(root, "package.json");
+  const tsconfigPath = path2.join(root, "tsconfig.json");
+  const gitPath = path2.join(root, ".git");
+  const hasPackageJson = await fs4.pathExists(pkgPath);
+  const hasTsconfig = await fs4.pathExists(tsconfigPath);
+  const hasGit = await fs4.pathExists(gitPath);
+  let dependencies = [];
+  if (hasPackageJson) {
+    const pkg = await fs4.readJson(pkgPath);
+    dependencies = [
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {})
+    ];
+  }
+  const existingAgentFiles = [];
+  for (const f of AGENT_FILES) {
+    if (await fs4.pathExists(path2.join(root, f))) {
+      existingAgentFiles.push(f);
+    }
+  }
+  const suggestedAddons = [];
+  if (dependencies.some((d) => INTEGRATIONS_HINTS.includes(d))) {
+    suggestedAddons.push("integrations");
+  }
+  const suggestedSubfolders = [];
+  if (dependencies.some((d) => DATABASE_HINTS.includes(d))) {
+    suggestedSubfolders.push("reference/database");
+  }
+  return {
+    hasPackageJson,
+    hasTsconfig,
+    hasGit,
+    dependencies,
+    existingAgentFiles,
+    suggestedAddons,
+    suggestedSubfolders
+  };
+}
+
+// src/commands/init.ts
+var ALL_CATEGORIES = /* @__PURE__ */ new Set([...CORE_CATEGORIES, ...ADDON_CATEGORIES]);
+async function runInit(options) {
+  if (!isValidProjectType(options.type)) {
+    throw new Error(
+      `Unknown project type: "${options.type}". Valid types: ${PROJECT_TYPES.join(", ")}.`
+    );
+  }
+  for (const c of [...options.with, ...options.without]) {
+    if (!ALL_CATEGORIES.has(c)) {
+      throw new Error(
+        `Unknown category: "${c}". Valid categories: ${[...ALL_CATEGORIES].join(", ")}.`
+      );
+    }
+  }
+  const defaults = defaultCategoriesFor(options.type);
+  const finalSet = new Set(defaults);
+  for (const c of options.with) finalSet.add(c);
+  for (const c of options.without) finalSet.delete(c);
+  const config = {
+    version: "1.0",
+    projectType: options.type,
+    categories: [...finalSet],
+    agents: options.agents,
+    language: options.language
+  };
+  await scaffoldStructure(options.root, config);
+  await addDocsLintScript(options.root);
+  const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  await runSync2({ root: options.root });
+  return config;
+}
+async function runInitInteractive(opts) {
+  p.intro("Beacon \u2014 initialize docs convention");
+  const ctx = await detectContext(opts.root);
+  const type = await p.select({
+    message: "Project type?",
+    options: [
+      { value: "web-app", label: "Web Application (full-stack, SaaS)" },
+      { value: "backend-service", label: "Backend Service / API" },
+      { value: "library", label: "Library / SDK / Package" },
+      { value: "cli-tool", label: "CLI Tool" },
+      { value: "mobile-app", label: "Mobile App" },
+      { value: "monorepo", label: "Monorepo / Workspace" },
+      { value: "custom", label: "Custom (no defaults)" }
+    ]
+  });
+  if (p.isCancel(type)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const defaults = defaultCategoriesFor(type);
+  const categoryOptions = [...CORE_CATEGORIES, ...ADDON_CATEGORIES].map((c) => ({
+    value: c,
+    label: c,
+    hint: ctx.suggestedAddons.includes(c) ? "suggested by detection" : void 0
+  }));
+  const categories = await p.multiselect({
+    message: "Which categories to enable?",
+    options: categoryOptions,
+    initialValues: defaults,
+    required: false
+  });
+  if (p.isCancel(categories)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const agents = await p.multiselect({
+    message: "Which AI agents do you use?",
+    options: [
+      { value: "claude", label: "Claude Code" },
+      { value: "cursor", label: "Cursor" },
+      { value: "codex", label: "Codex / Copilot (AGENTS.md)" },
+      { value: "gemini", label: "Gemini CLI" }
+    ],
+    initialValues: ["claude", "cursor"],
+    required: true
+  });
+  if (p.isCancel(agents)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  if (ctx.existingAgentFiles.length > 0) {
+    const action = await p.select({
+      message: `Existing files found (${ctx.existingAgentFiles.join(", ")}). What do you want to do?`,
+      options: [
+        { value: "merge", label: "Merge \u2014 keep existing content, append Beacon section" },
+        { value: "replace", label: "Replace \u2014 overwrite with Beacon content" },
+        { value: "skip", label: "Skip \u2014 leave them untouched" }
+      ]
+    });
+    if (p.isCancel(action)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  const config = await runInit({
+    root: opts.root,
+    type,
+    with: categories.filter((c) => !defaults.includes(c)),
+    without: defaults.filter((c) => !categories.includes(c)),
+    agents,
+    language: "en"});
+  p.outro(`Beacon docs scaffolded at ${opts.root}/docs/`);
+  return config;
+}
+
+// src/cli.ts
+var cli = cac("beacon");
+cli.command("init", "Initialize Beacon docs convention in this project").option("--yes", "Run non-interactively").option("--type <type>", "Project type (web-app, backend-service, library, cli-tool, mobile-app, monorepo, custom)").option("--with <categories>", "Categories to add beyond defaults (comma-separated)").option("--without <categories>", "Categories to remove from defaults (comma-separated)").option("--agents <agents>", "AI agents to support (comma-separated: claude,cursor,codex,gemini)").option("--language <lang>", "Docs language", { default: "en" }).action(async (opts) => {
+  const root = process.cwd();
+  if (opts.yes) {
+    if (!opts.type) {
+      console.error("Error: --type is required when using --yes.");
+      process.exit(1);
+    }
+    await runInit({
+      root,
+      type: opts.type,
+      with: splitList(opts.with),
+      without: splitList(opts.without),
+      agents: splitList(opts.agents).length ? splitList(opts.agents) : ["claude", "cursor"],
+      language: opts.language ?? "en"});
+  } else {
+    await runInitInteractive({ root });
+  }
+});
+cli.command("sync", "Regenerate AI rule files from docs/_meta/convention.md").action(async () => {
+  const { runSync: runSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  await runSync2({ root: process.cwd() });
+  console.log("\u2714 AI rule files regenerated.");
+});
+cli.command("new <type> <slug>", "Create a new doc with correct location and naming").option("--category <cat>", "Disambiguate for `guide` (integrations|operations)").action(async (type, slug, opts) => {
+  const { runNew: runNew2 } = await Promise.resolve().then(() => (init_new(), new_exports));
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const file = await runNew2({
+    root: process.cwd(),
+    type,
+    slug,
+    today,
+    category: opts.category
+  });
+  console.log(`\u2714 Created ${path2.relative(process.cwd(), file)}`);
+});
+cli.command("archive <type> <slug>", "Move a completed plan or roadmap to _archive/").option("--force", "Archive even if unchecked TODOs remain").action(async (type, slug, opts) => {
+  const { runArchive: runArchive2 } = await Promise.resolve().then(() => (init_archive(), archive_exports));
+  const result = await runArchive2({
+    root: process.cwd(),
+    type,
+    slug,
+    force: !!opts.force
+  });
+  if (result.warnings.length) {
+    for (const w of result.warnings) console.warn(`\u26A0 ${w}`);
+  }
+  console.log(`\u2714 Archived to ${path2.relative(process.cwd(), result.destination)}`);
+});
+cli.command("enable <addon>", "Enable an add-on category").action(async (addon) => {
+  const { runEnable: runEnable2 } = await Promise.resolve().then(() => (init_toggle(), toggle_exports));
+  await runEnable2({ root: process.cwd(), addon });
+  console.log(`\u2714 Enabled ${addon}.`);
+});
+cli.command("disable <addon>", "Disable an add-on category").option("--force", "Disable even if the folder has documents").action(async (addon, opts) => {
+  const { runDisable: runDisable2 } = await Promise.resolve().then(() => (init_toggle(), toggle_exports));
+  await runDisable2({ root: process.cwd(), addon, force: !!opts.force });
+  console.log(`\u2714 Disabled ${addon}.`);
+});
+cli.command("lint", "Validate the docs tree against the convention").option("--strict", "Escalate warnings to errors").option("--json", "Emit JSON output").action(async (opts) => {
+  const { runLintCommand: runLintCommand2 } = await Promise.resolve().then(() => (init_lint(), lint_exports));
+  const result = await runLintCommand2({
+    root: process.cwd(),
+    strict: !!opts.strict,
+    json: !!opts.json
+  });
+  process.stdout.write(result.output);
+  if (!opts.json && !result.output.endsWith("\n")) process.stdout.write("\n");
+  process.exit(result.exitCode);
+});
+cli.help();
+cli.version("0.0.0");
+cli.parse();
+function splitList(s) {
+  if (!s) return [];
+  return s.split(",").map((x) => x.trim()).filter(Boolean);
+}
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map