contentbit 0.1.0 → 0.2.0

package/dist/bin.js

@@ -320,6 +320,323 @@ var init_parser = __esm({
   }
 });
 
+// ../core/dist/frontmatter.js
+function stripFrontmatter(source) {
+  const match = FM_RE.exec(source);
+  if (!match)
+    return source;
+  return match[0].replace(/[^\n]+/g, "") + source.slice(match[0].length);
+}
+function extractFrontmatter(source) {
+  const match = source.match(FM_RE);
+  if (!match)
+    return null;
+  const blockLines = match[0].replace(/\r?\n$/, "").split(/\r?\n/);
+  const inner = blockLines.slice(1, -1);
+  const { data, keys } = parseYamlSubset(inner);
+  return { raw: inner.join("\n"), data, keys, lines: { start: 1, end: blockLines.length } };
+}
+function parseYamlSubset(lines) {
+  const data = {};
+  const keys = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#") || /^[ \t]/.test(line)) {
+      i++;
+      continue;
+    }
+    const m = line.match(KEY_RE2);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const [, key, rawValue] = m;
+    const value = rawValue.trim();
+    i++;
+    const indented = [];
+    while (i < lines.length && /^[ \t]/.test(lines[i]) && lines[i].trim() !== "") {
+      indented.push(lines[i]);
+      i++;
+    }
+    keys.push(key);
+    data[key] = parseValue(value, indented);
+  }
+  return { data, keys };
+}
+function parseValue(value, indented) {
+  if (/^[|>][+-]?$/.test(value))
+    return dedent(indented).join("\n");
+  if (value === "") {
+    if (indented.length === 0)
+      return null;
+    const items = dedent(indented);
+    if (items.every((l) => l.startsWith("- ")))
+      return items.map((l) => parseScalar(l.slice(2).trim()));
+    return items.join("\n");
+  }
+  return parseScalar(value);
+}
+function dedent(lines) {
+  const indent = Math.min(...lines.map((l) => l.match(/^[ \t]*/)[0].length));
+  return lines.map((l) => l.slice(indent));
+}
+function parseScalar(value) {
+  if (value === "" || value === "null" || value === "~")
+    return null;
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (/^[+-]?\d+$/.test(value))
+    return Number.parseInt(value, 10);
+  if (/^[+-]?\d*\.\d+$/.test(value))
+    return Number.parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value.slice(1, -1);
+    }
+  }
+  if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+    return value.slice(1, -1).replace(/''/g, "'");
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (inner === "")
+      return [];
+    return splitInlineItems(inner).map((item) => parseScalar(item.trim()));
+  }
+  return value;
+}
+function splitInlineItems(inner) {
+  const items = [];
+  let current = "";
+  let quote = null;
+  for (const ch of inner) {
+    if (quote) {
+      current += ch;
+      if (ch === quote)
+        quote = null;
+    } else if (ch === '"' || ch === "'") {
+      current += ch;
+      quote = ch;
+    } else if (ch === ",") {
+      items.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  items.push(current);
+  return items;
+}
+var FM_RE, KEY_RE2;
+var init_frontmatter = __esm({
+  "../core/dist/frontmatter.js"() {
+    "use strict";
+    FM_RE = /^---[ \t]*\r?\n(?:[\s\S]*?\r?\n)?---[ \t]*(?:\r?\n|$)/;
+    KEY_RE2 = /^([A-Za-z0-9_.-]+):(.*)$/;
+  }
+});
+
+// ../core/dist/analyze.js
+function utf8Length(source) {
+  let bytes = 0;
+  for (const ch of source) {
+    const cp = ch.codePointAt(0);
+    bytes += cp <= 127 ? 1 : cp <= 2047 ? 2 : cp <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function analyzeDocument(source, options = {}) {
+  const frontmatter = extractFrontmatter(source);
+  const { document } = parseDocument(stripFrontmatter(source));
+  const outline = [];
+  const blocks = { total: 0, byName: {}, maxDepth: 0, instances: [] };
+  const links = {
+    total: 0,
+    external: 0,
+    internal: 0,
+    domains: [],
+    items: []
+  };
+  const images = { total: 0, missingAlt: 0 };
+  const code2 = { fences: 0, languages: [], inlineSpans: 0 };
+  const structure = { listItems: 0, tables: 0, blockquotes: 0 };
+  const languages = /* @__PURE__ */ new Set();
+  const domains = /* @__PURE__ */ new Set();
+  let words = 0;
+  function addWords(count) {
+    words += count;
+    const section = outline[outline.length - 1];
+    if (section)
+      section.words += count;
+  }
+  function recordLink(url2, text, line) {
+    const external = EXTERNAL_URL_RE.test(url2);
+    links.total++;
+    if (external) {
+      links.external++;
+      const host = url2.match(/^(?:https?:)?\/\/(?:[^/?#@]*@)?([^/?#:]+)/i);
+      if (host)
+        domains.add(host[1].toLowerCase());
+    } else {
+      links.internal++;
+    }
+    links.items.push({ url: url2, text, line, external });
+  }
+  function inlineToProse(text, line) {
+    return text.replace(CODE_SPAN_RE, () => {
+      code2.inlineSpans++;
+      return " ";
+    }).replace(IMAGE_RE, (_, alt) => {
+      images.total++;
+      if (alt.trim() === "")
+        images.missingAlt++;
+      return " ";
+    }).replace(LINK_RE, (_, label, url2) => {
+      recordLink(url2, label, line);
+      return label;
+    }).replace(AUTOLINK_RE, (_, url2) => {
+      recordLink(url2, url2, line);
+      return " ";
+    });
+  }
+  function countWords(text) {
+    return text.split(/\s+/).filter((token) => /[\p{L}\p{N}]/u.test(token)).length;
+  }
+  function scanMarkdown(value, startLine) {
+    let fence = null;
+    let inBlockquote = false;
+    let prevLineHasPipe = false;
+    const lines = value.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNo = startLine + i;
+      const trimmed = line.trim();
+      const fenceMatch = trimmed.match(CODE_FENCE_RE2);
+      if (fence !== null) {
+        if (fenceMatch && fenceMatch[1][0] === fence[0] && fenceMatch[1].length >= fence.length) {
+          fence = null;
+        }
+        continue;
+      }
+      if (fenceMatch) {
+        fence = fenceMatch[1];
+        code2.fences++;
+        const lang = fenceMatch[2].trim().split(/\s+/)[0];
+        if (lang)
+          languages.add(lang);
+        inBlockquote = false;
+        prevLineHasPipe = false;
+        continue;
+      }
+      if (trimmed === "") {
+        inBlockquote = false;
+        prevLineHasPipe = false;
+        continue;
+      }
+      const heading = trimmed.match(HEADING_RE);
+      if (heading) {
+        const raw = heading[2].replace(/\s+#+\s*$/, "");
+        const text = inlineToProse(raw, lineNo).replace(/\s+/g, " ").trim();
+        outline.push({ level: heading[1].length, text, line: lineNo, words: 0 });
+        addWords(countWords(text));
+        inBlockquote = false;
+        prevLineHasPipe = false;
+        continue;
+      }
+      let content = trimmed;
+      if (content.startsWith(">")) {
+        if (!inBlockquote) {
+          structure.blockquotes++;
+          inBlockquote = true;
+        }
+        content = content.replace(/^(>\s*)+/, "");
+      } else {
+        inBlockquote = false;
+      }
+      if (LIST_ITEM_RE.test(content)) {
+        structure.listItems++;
+        content = content.replace(LIST_ITEM_RE, "");
+      }
+      if (content.includes("|")) {
+        if (TABLE_SEPARATOR_RE.test(content) && content.includes("-") && prevLineHasPipe) {
+          structure.tables++;
+        }
+        prevLineHasPipe = true;
+        content = inlineToProse(content, lineNo).replaceAll("|", " ");
+      } else {
+        prevLineHasPipe = false;
+        content = inlineToProse(content, lineNo);
+      }
+      addWords(countWords(content));
+    }
+  }
+  function walk(nodes, depth) {
+    for (const node of nodes) {
+      if (node.type === "block") {
+        blocks.total++;
+        blocks.byName[node.name] = (blocks.byName[node.name] ?? 0) + 1;
+        blocks.maxDepth = Math.max(blocks.maxDepth, depth);
+        blocks.instances.push({ name: node.name, line: node.openPosition.start.line, depth });
+        walk(node.children, depth + 1);
+      } else {
+        scanMarkdown(node.value, node.position.start.line);
+      }
+    }
+  }
+  walk(document.children, 1);
+  code2.languages = [...languages];
+  links.domains = [...domains].sort();
+  const sourceLines = source === "" ? 0 : source.split("\n").length - (source.endsWith("\n") ? 1 : 0);
+  return {
+    file: {
+      path: options.path ?? null,
+      bytes: utf8Length(source),
+      lines: sourceLines
+    },
+    frontmatter: frontmatter ? {
+      present: true,
+      keys: frontmatter.keys,
+      data: frontmatter.data,
+      lines: frontmatter.lines
+    } : { present: false, keys: [], data: {}, lines: null },
+    length: {
+      words,
+      characters: source.length,
+      readingMinutes: Math.ceil(words / 200),
+      approxTokens: Math.ceil(source.length / 4)
+    },
+    outline,
+    blocks,
+    links,
+    images,
+    code: code2,
+    structure
+  };
+}
+var CODE_FENCE_RE2, HEADING_RE, LIST_ITEM_RE, TABLE_SEPARATOR_RE, CODE_SPAN_RE, IMAGE_RE, LINK_RE, AUTOLINK_RE, EXTERNAL_URL_RE;
+var init_analyze = __esm({
+  "../core/dist/analyze.js"() {
+    "use strict";
+    init_frontmatter();
+    init_parser();
+    CODE_FENCE_RE2 = /^(`{3,}|~{3,})(.*)$/;
+    HEADING_RE = /^(#{1,6})\s+(.*)$/;
+    LIST_ITEM_RE = /^\s*(?:[-*+]|\d+[.)])\s+/;
+    TABLE_SEPARATOR_RE = /^\|?[\s:|-]+$/;
+    CODE_SPAN_RE = /`[^`]+`/g;
+    IMAGE_RE = /!\[([^\]]*)\]\(([^)]*)\)/g;
+    LINK_RE = /\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+    AUTOLINK_RE = /<(https?:\/\/[^>\s]+)>/g;
+    EXTERNAL_URL_RE = /^(?:https?:)?\/\//i;
+  }
+});
+
 // ../core/dist/position.js
 function bodyLineRange(node, bodyLineIndex) {
   const bodyLines = node.body.split("\n");
@@ -340,6 +657,45 @@ var init_position = __esm({
 });
 
 // ../core/dist/authoring.js
+function typeLabel(def) {
+  switch (def.type) {
+    case "enum":
+      return `one of ${Object.values(def.entries ?? {}).join("|")}`;
+    case "literal":
+      return `one of ${(def.values ?? []).map(String).join("|")}`;
+    case "union":
+      return `one of ${(def.options ?? []).map((o) => typeLabel(o.def).replace(/^one of /, "")).join("|")}`;
+    default:
+      return def.type;
+  }
+}
+function describeProps(schema) {
+  const root = schema.def;
+  if (root.type !== "object" || !root.shape)
+    return [];
+  const lines = [];
+  for (const [name, field] of Object.entries(root.shape)) {
+    let current = field;
+    let optional2 = false;
+    let defaultValue;
+    let description = current.description;
+    while (["optional", "default", "nullable"].includes(current.def.type)) {
+      optional2 = true;
+      if (current.def.type === "default") {
+        const dv = current.def.defaultValue;
+        defaultValue = typeof dv === "function" ? dv() : dv;
+      }
+      if (!current.def.innerType)
+        break;
+      current = current.def.innerType;
+      description ??= current.description;
+    }
+    const presence = defaultValue !== void 0 ? `(optional, default: ${String(defaultValue)})` : optional2 ? "(optional)" : "(required)";
+    const suffix = description ? ` \u2014 ${description}` : "";
+    lines.push(`- ${name}: ${typeLabel(current.def)} ${presence}${suffix}`);
+  }
+  return lines;
+}
 function generateAuthoringGuide(defs, opts = {}) {
   const includeExamples = opts.includeExamples ?? true;
   const includeAvoid = opts.includeAvoidRules ?? true;
@@ -349,6 +705,11 @@ function generateAuthoringGuide(defs, opts = {}) {
   for (const def of defs) {
     const lines = [`## ${def.name}`, ""];
     lines.push(def.childOnly ? `${def.description} (child block \u2014 only inside a parent that allows it)` : def.description);
+    if (def.props) {
+      const props = describeProps(def.props);
+      if (props.length > 0)
+        lines.push("", "Props:", ...props);
+    }
     lines.push("", `Content: ${def.content.describe()}`);
     if (def.authoring.useWhen.length > 0) {
       lines.push("", "Use when:", ...def.authoring.useWhen.map((u) => `- ${u}`));
@@ -742,6 +1103,8 @@ var init_dist = __esm({
     "use strict";
     init_diagnostics();
     init_parser();
+    init_frontmatter();
+    init_analyze();
     init_registry();
     init_content_models();
     init_validate();
@@ -6655,13 +7018,13 @@ var init_he = __esm({
         // no unit
       };
       const typeEntry = (t) => t ? TypeNames[t] : void 0;
-      const typeLabel = (t) => {
+      const typeLabel2 = (t) => {
         const e = typeEntry(t);
         if (e)
           return e.label;
         return t ?? TypeNames.unknown.label;
       };
-      const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
+      const withDefinite = (t) => `\u05D4${typeLabel2(t)}`;
       const verbFor = (t) => {
         const e = typeEntry(t);
         const gender = e?.gender ?? "m";
@@ -6711,7 +7074,7 @@ var init_he = __esm({
         switch (issue2.code) {
           case "invalid_type": {
             const expectedKey = issue2.expected;
-            const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel(expectedKey);
+            const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel2(expectedKey);
             const receivedType = parsedType(issue2.input);
             const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;
             if (/^[A-Z]/.test(issue2.expected)) {
@@ -16154,7 +16517,17 @@ import { pathToFileURL } from "node:url";
 async function loadRegistry(registryPath) {
   const registry2 = createBlockRegistry().use(genericBlocks());
   if (registryPath) {
-    const mod = await import(pathToFileURL(registryPath).href);
+    let mod;
+    try {
+      mod = await import(pathToFileURL(registryPath).href);
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+        throw new Error(
+          `Importing a TypeScript registry needs Node 22.18+ (native type stripping): ${registryPath}`
+        );
+      }
+      throw err;
+    }
     if (!Array.isArray(mod.default)) {
       throw new Error(
         `--registry module must default-export an array of block definitions: ${registryPath}`
@@ -16172,16 +16545,372 @@ var init_load_registry = __esm({
   }
 });
 
+// src/commands/agents.ts
+var agents_exports = {};
+__export(agents_exports, {
+  agentsCommand: () => agentsCommand,
+  installAgentIntegration: () => installAgentIntegration
+});
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+function upsertBlock(existing) {
+  const start = existing.indexOf(START);
+  const end = existing.indexOf(END);
+  if (start !== -1 && end !== -1) {
+    return existing.slice(0, start) + AGENTS_MD_BLOCK + existing.slice(end + END.length);
+  }
+  if (existing.trim() === "") return `${AGENTS_MD_BLOCK}
+`;
+  return `${existing.replace(/\n*$/, "\n\n")}${AGENTS_MD_BLOCK}
+`;
+}
+async function installAgentIntegration(cwd, options, io) {
+  const claude = options.claude ?? existsSync(join(cwd, ".claude"));
+  const agentsMd = options.agentsMd ?? true;
+  if (agentsMd) {
+    const path = join(cwd, "AGENTS.md");
+    let existing = "";
+    try {
+      existing = await readFile(path, "utf8");
+    } catch {
+    }
+    const created = existing === "";
+    await writeFile(path, upsertBlock(existing), "utf8");
+    io.stdout(`${created ? "created" : "updated"}: AGENTS.md (contentbit block)`);
+  }
+  if (claude) {
+    const skills = [
+      ["contentbit-author", AUTHOR_SKILL],
+      ["contentbit-audit", AUDIT_SKILL]
+    ];
+    for (const [name, content] of skills) {
+      const dir = join(cwd, ".claude/skills", name);
+      await mkdir(dir, { recursive: true });
+      await writeFile(join(dir, "SKILL.md"), content, "utf8");
+      io.stdout(`installed: .claude/skills/${name}/SKILL.md`);
+    }
+  }
+}
+async function agentsCommand(args, io) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      claude: { type: "boolean", default: false },
+      "no-agents-md": { type: "boolean", default: false },
+      cwd: { type: "string", default: process.cwd() }
+    }
+  });
+  await installAgentIntegration(
+    values.cwd,
+    {
+      claude: values.claude || void 0,
+      // false means "detect", not "skip"
+      agentsMd: !values["no-agents-md"]
+    },
+    io
+  );
+  return 0;
+}
+var TEMPLATE_VERSION, AUTHOR_SKILL, AUDIT_SKILL, AGENTS_MD_BLOCK, START, END;
+var init_agents = __esm({
+  "src/commands/agents.ts"() {
+    "use strict";
+    TEMPLATE_VERSION = 1;
+    AUTHOR_SKILL = `---
+name: contentbit-author
+description: |
+  Write or edit contentbit Markdown content (directive blocks like :::callout).
+  Use when asked to create or modify content documents in a project that uses
+  contentbit \u2014 blog posts, docs pages, changelogs, any Markdown covered by
+  \`contentbit validate\`.
+version: ${TEMPLATE_VERSION}
+---
+
+# Writing contentbit content
+
+contentbit documents are plain Markdown plus directive blocks
+(\`:::name{props} ... :::\`). Every block has a schema. Never guess block names,
+props, or body shapes \u2014 fetch the live guide from the project's registry first.
+
+## Find the project conventions
+
+Check \`package.json\` for a \`content:check\` script. It holds the canonical
+validate invocation for this project: the content glob and, if present, the
+\`--registry <path>\` flag pointing at custom block definitions. Reuse both
+below. No script? Default to \`content/**/*.md\` with no \`--registry\` flag.
+
+## The loop
+
+1. **Fetch the authoring guide** (always \u2014 it covers this project's custom blocks):
+
+   \`\`\`sh
+   contentbit instructions --audience llm [--registry <path from content:check>]
+   \`\`\`
+
+   Read it before writing. It documents every available block: props, body
+   shape, and when to use or avoid it.
+
+2. **Write the document.** Plain Markdown everywhere; blocks only where the
+   guide's use-when guidance fits. Keep frontmatter consistent with sibling
+   documents in the same folder.
+
+3. **Validate and fix until clean:**
+
+   \`\`\`sh
+   contentbit validate <file> [--registry <path>]
+   \`\`\`
+
+   Diagnostics print to stderr as \`file:line:col severity CODE message\`, often
+   with a \`hint:\` line suggesting the fix. Exit 0 means clean; exit 1 means
+   errors remain. Fix every diagnostic and re-run. Never finish with a failing
+   validate.
+
+## Failure modes
+
+- \`contentbit\` not found or no registry resolvable: the project is not set up.
+  Say so and suggest \`npx contentbit@latest init\` \u2014 do not invent block syntax.
+- A block you want does not exist: use plain Markdown, or ask whether to define
+  a custom block in the registry. Never emit an unregistered block name.
+`;
+    AUDIT_SKILL = `---
+name: contentbit-audit
+description: |
+  Audit contentbit Markdown content health using document stats. Use when asked
+  to audit, review, or find improvements across content \u2014 thin pages, missing
+  structure, validation issues \u2014 in a project that uses contentbit.
+version: ${TEMPLATE_VERSION}
+---
+
+# Auditing contentbit content
+
+\`contentbit stats\` analyzes documents and prints JSON to stdout. It is a read
+tool: it always exits 0, even when documents have validation errors.
+
+## Gather
+
+Check \`package.json\` for the \`content:check\` script to find this project's
+content glob and \`--registry\` flag, then:
+
+\`\`\`sh
+contentbit stats "content/**/*.md" [--registry <path>]
+\`\`\`
+
+One matched file prints a single stats object; multiple files print an array.
+Each entry includes the file path, frontmatter data, a heading \`outline\` with
+per-section word counts, \`blocks.byName\` usage counts, \`links.domains\`, and
+a \`validation\` summary (\`errors\`/\`warnings\`).
+
+## Interpret
+
+Prioritize findings in this order:
+
+1. **Validation errors and warnings** \u2014 broken content ships broken pages.
+2. **Thin documents** \u2014 outline sections with very low word counts.
+3. **Block-less documents** \u2014 \`blocks.byName\` empty where sibling documents
+   use blocks; structure (steps, callouts, comparisons, faq) may be missing.
+4. **Missing or inconsistent frontmatter** compared to sibling documents.
+5. **Structural imbalance** \u2014 skipped heading levels, single-section walls of text.
+
+## Report
+
+Report findings per file with concrete suggestions, ordered by priority. Do not
+edit files during the audit. To fix a finding, follow the contentbit-author
+skill (fetch the guide, edit, validate until clean) \u2014 offer that as a follow-up.
+`;
+    AGENTS_MD_BLOCK = `<!-- contentbit:start -->
+
+## contentbit content (generated \u2014 edits inside this block are overwritten)
+
+This project validates Markdown content with contentbit. Documents are plain
+Markdown plus directive blocks (\`:::name{props} ... :::\`), each with a schema.
+The \`content:check\` script in package.json holds the canonical validate
+command \u2014 the content glob and the \`--registry\` flag \u2014 reuse its arguments.
+
+When writing or editing content:
+
+1. Fetch the live authoring guide first \u2014 never guess block syntax:
+   \`contentbit instructions --audience llm [--registry <path>]\`
+2. Write plain Markdown; use blocks where the guide's use-when guidance fits.
+3. Validate until clean (exit 0): \`contentbit validate <file> [--registry <path>]\`.
+   Diagnostics print as \`file:line:col severity CODE message\` with fix hints.
+
+When auditing content health:
+
+- \`contentbit stats "content/**/*.md" [--registry <path>]\` prints JSON stats
+  and always exits 0: outline word counts, block usage, link domains, and
+  validation error/warning counts. Flag validation issues, thin documents, and
+  block-less pages first.
+
+If \`contentbit\` is unavailable, suggest \`npx contentbit@latest init\` instead
+of inventing block syntax.
+
+<!-- contentbit:end -->`;
+    START = "<!-- contentbit:start -->";
+    END = "<!-- contentbit:end -->";
+  }
+});
+
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
   initCommand: () => initCommand
 });
 import { spawn } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { parseArgs } from "node:util";
-function detectPackageManager() {
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { parseArgs as parseArgs2 } from "node:util";
+function blockComponentsTemplate(styled) {
+  const body = styled ? `  return (
+    <figure className="my-6 border-s-2 ps-4">
+      <blockquote className="text-lg italic">{ctx.renderMarkdown(data.markdown)}</blockquote>
+      <figcaption className="text-muted-foreground mt-2 text-sm">
+        \u2014 {String(node.props.author)}
+        {node.props.role ? \`, \${String(node.props.role)}\` : null}
+      </figcaption>
+    </figure>
+  )` : `  return (
+    <figure style={{ margin: '1.5rem 0', borderLeft: '2px solid #d4d4d4', paddingLeft: '1rem' }}>
+      <blockquote style={{ fontStyle: 'italic' }}>{ctx.renderMarkdown(data.markdown)}</blockquote>
+      <figcaption style={{ marginTop: '0.5rem', fontSize: '0.875rem', opacity: 0.7 }}>
+        \u2014 {String(node.props.author)}
+        {node.props.role ? \`, \${String(node.props.role)}\` : null}
+      </figcaption>
+    </figure>
+  )`;
+  return `import type { BlockComponent, BlockComponentProps } from '@contentbit/react'
+
+// One React component per custom block, keyed by block name. Definitions
+// live in ./registry.ts \u2014 add a block there, add its component here, and
+// the rest of the app never changes.
+function QuoteBlock({ node, ctx }: BlockComponentProps) {
+  const data = node.data as { markdown: string }
+${body}
+}
+
+export const blockComponents: Record<string, BlockComponent> = {
+  quote: QuoteBlock,
+}
+`;
+}
+function reactComponent(styled, mdWired, blocksImport) {
+  const mdImport = mdWired ? "import ReactMarkdown from 'react-markdown'\n" : "";
+  const mdProp = mdWired ? "\n      renderMarkdown={(md) => <ReactMarkdown>{md}</ReactMarkdown>}" : `
+      // TODO: plug your Markdown library in here, e.g. react-markdown.
+      // One function renders all prose: https://contentbit.dev/docs/guides/markdown
+      // renderMarkdown={(md) => <Markdown source={md} />}`;
+  const rendererImport = styled ? `
+// The styled pack installed by shadcn. Yours to edit.
+import { ContentRenderer } from '@/components/content-blocks/content-renderer'` : "";
+  const renderer = styled ? "ContentRenderer" : "ContentBlocks";
+  const reactImport = styled ? "" : "import { ContentBlocks } from '@contentbit/react'\n";
+  return `'use client'
+
+import { genericBlocks } from '@contentbit/blocks'
+import { createBlockRegistry, parseDocument, validateDocument } from '@contentbit/core'
+${reactImport}${mdImport}${rendererImport}
+// Everything block-related lives in the blocks/ folder: definitions in
+// registry.ts (shared with the validate CLI), components in components.tsx.
+import customBlocks from '${blocksImport}/registry'
+import { blockComponents } from '${blocksImport}/components'
+
+const registry = createBlockRegistry().use(genericBlocks()).use(customBlocks)
+
+export function Content({ source }: { source: string }) {
+  const result = validateDocument(parseDocument(source), registry)
+  return (
+    <${renderer}
+      document={result.document}
+      components={blockComponents}${mdProp}
+    />
+  )
+}
+`;
+}
+function htmlRenderScript(md) {
+  const wiring = md === "marked" ? `import { marked } from 'marked'
+
+const renderMarkdown = (md) => marked.parse(md, { async: false })` : md === "markdown-it" ? `import MarkdownIt from 'markdown-it'
+
+const mdIt = new MarkdownIt() // html: false by default \u2014 raw HTML stays escaped
+const renderMarkdown = (md) => mdIt.render(md)` : `// TODO: plug a Markdown library in here (marked, markdown-it, remark).
+const renderMarkdown = undefined`;
+  return `// Render content/example.md to example.html. Run: node scripts/render-example.mjs
+import { genericBlocks } from '@contentbit/blocks'
+import { createBlockRegistry, parseDocument, validateDocument } from '@contentbit/core'
+import { renderToHtml } from '@contentbit/html'
+import { readFile, writeFile } from 'node:fs/promises'
+${wiring}
+
+const source = await readFile('content/example.md', 'utf8')
+const registry = createBlockRegistry().use(genericBlocks())
+const result = validateDocument(parseDocument(source), registry)
+const html = renderToHtml(result.document, { renderMarkdown })
+await writeFile('example.html', html, 'utf8')
+console.log('wrote example.html')
+`;
+}
+function detectFramework(cwd, deps) {
+  if ((deps["@tanstack/react-start"] || deps["@tanstack/react-router"]) && existsSync2(join2(cwd, "src/routes"))) {
+    return {
+      framework: "tanstack",
+      componentPath: "src/components/content-blocks.tsx",
+      pagePath: "src/routes/example.tsx"
+    };
+  }
+  if (deps.next) {
+    const appDir = existsSync2(join2(cwd, "src/app")) ? "src/app" : "app";
+    if (existsSync2(join2(cwd, appDir))) {
+      return {
+        framework: "next",
+        componentPath: "components/content-blocks.tsx",
+        pagePath: `${appDir}/example/page.tsx`
+      };
+    }
+  }
+  return { framework: null, componentPath: "components/content-blocks.tsx", pagePath: null };
+}
+function astroPage(styled) {
+  const importLine = styled ? "import ContentRenderer from '../components/content-blocks/content-renderer.astro'" : "import { ContentBlocks } from '@contentbit/astro/components'";
+  const renderer = styled ? "ContentRenderer" : "ContentBlocks";
+  return `---
+import { genericBlocks } from '@contentbit/blocks'
+import { createBlockRegistry, parseDocument, validateDocument } from '@contentbit/core'
+import { getEntry } from 'astro:content'
+
+${importLine}
+
+// Definitions in blocks/registry.ts are shared with the validate CLI.
+import customBlocks from '../../blocks/registry'
+import QuoteBlock from '../../blocks/QuoteBlock.astro'
+
+// Entry ids are the file path relative to the collection base, minus ".md".
+const entry = await getEntry('articles', 'example')
+if (!entry?.body) throw new Error('Entry "example" not found in the articles collection.')
+
+const registry = createBlockRegistry().use(genericBlocks()).use(customBlocks)
+// Static pages render at build time, so invalid blocks fail the build here.
+const result = validateDocument(parseDocument(entry.body), registry)
+---
+
+<main style="max-width: 42rem; margin: 0 auto; padding: 3rem 1.5rem;">
+  <${renderer} document={result.document} components={{ quote: QuoteBlock }} />
+</main>
+`;
+}
+function detectPackageManager(cwd) {
+  const locks = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["package-lock.json", "npm"]
+  ];
+  for (const [file2, pm] of locks) {
+    if (existsSync2(join2(cwd, file2))) return pm;
+  }
   const agent = process.env.npm_config_user_agent ?? "";
   for (const pm of ["pnpm", "yarn", "bun"]) {
     if (agent.startsWith(pm)) return pm;
@@ -16192,6 +16921,12 @@ function installArgs(pm, dev, pkgs) {
   const add = pm === "npm" ? "install" : "add";
   return dev ? [add, "-D", ...pkgs] : [add, ...pkgs];
 }
+function dlxCommand(pm) {
+  if (pm === "pnpm") return ["pnpm", ["dlx"]];
+  if (pm === "yarn") return ["yarn", ["dlx"]];
+  if (pm === "bun") return ["bunx", []];
+  return ["npx", ["--yes"]];
+}
 function runInstall(pm, args, cwd) {
   return new Promise((resolve) => {
     const child = spawn(pm, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
@@ -16199,37 +16934,62 @@ function runInstall(pm, args, cwd) {
     child.on("error", () => resolve(1));
   });
 }
+async function installStyledPack(cwd, pack, noInstall, io) {
+  const componentsJsonPath = join2(cwd, "components.json");
+  const componentsJson = JSON.parse(await readFile2(componentsJsonPath, "utf8"));
+  componentsJson.registries ??= {};
+  if (!componentsJson.registries["@contentbit"]) {
+    componentsJson.registries["@contentbit"] = "https://contentbit.dev/r/{name}.json";
+    await writeFile2(componentsJsonPath, `${JSON.stringify(componentsJson, null, 2)}
+`, "utf8");
+    io.stdout("added @contentbit registry to components.json");
+  }
+  if (noInstall) {
+    io.stdout(`skipped: shadcn add ${pack}`);
+    return true;
+  }
+  const [bin, prefix] = dlxCommand(detectPackageManager(cwd));
+  io.stdout(`installing the styled pack: shadcn add ${pack}`);
+  const code2 = await runInstall(bin, [...prefix, "shadcn@latest", "add", pack, "--yes"], cwd);
+  if (code2 !== 0) io.stderr("styled pack install failed; falling back to headless defaults");
+  return code2 === 0;
+}
 async function scaffold(path, content) {
   try {
-    await readFile(path, "utf8");
+    await readFile2(path, "utf8");
     return "skipped";
   } catch {
-    await mkdir(join(path, ".."), { recursive: true });
-    await writeFile(path, content, "utf8");
+    await mkdir2(join2(path, ".."), { recursive: true });
+    await writeFile2(path, content, "utf8");
     return "created";
   }
 }
 async function initCommand(args, io) {
-  const { values } = parseArgs({
+  const { values } = parseArgs2({
     args,
     options: {
       target: { type: "string", short: "t" },
+      md: { type: "string" },
       yes: { type: "boolean", short: "y", default: false },
       cwd: { type: "string", default: process.cwd() },
-      "no-install": { type: "boolean", default: false }
+      "no-install": { type: "boolean", default: false },
+      "no-page": { type: "boolean", default: false },
+      "no-styled": { type: "boolean", default: false },
+      "no-agents": { type: "boolean", default: false }
     }
   });
   const cwd = values.cwd;
   let pkg;
-  const pkgPath = join(cwd, "package.json");
+  const pkgPath = join2(cwd, "package.json");
   try {
-    pkg = JSON.parse(await readFile(pkgPath, "utf8"));
+    pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
   } catch {
     io.stderr("No package.json found. Run this inside a project (npm init first).");
     return 1;
   }
   const hasReact = Boolean(pkg.dependencies?.react ?? pkg.devDependencies?.react);
-  const detected = hasReact ? "react" : "html";
+  const hasAstro = Boolean(pkg.dependencies?.astro ?? pkg.devDependencies?.astro);
+  const detected = hasAstro ? "astro" : hasReact ? "react" : "html";
   let target;
   if (values.target) {
     if (!TARGETS.includes(values.target)) {
@@ -16244,6 +17004,7 @@ async function initCommand(args, io) {
       initialValue: detected,
       options: [
         { value: "react", label: "React", hint: "ContentBlocks component" },
+        { value: "astro", label: "Astro", hint: "content collections + .astro components" },
         { value: "html", label: "Static HTML", hint: "renderToHtml, no framework" },
         { value: "markdown", label: "Plain Markdown", hint: "fallback rendering only" }
       ]
@@ -16253,13 +17014,39 @@ async function initCommand(args, io) {
   } else {
     target = detected;
   }
-  const runtime = ["@contentbit/core", "@contentbit/blocks"];
+  const choices = MD_CHOICES[target];
+  let md;
+  if (values.md) {
+    if (!choices.includes(values.md)) {
+      io.stderr(`Unknown markdown library "${values.md}". Use one of: ${choices.join(", ")}`);
+      return 2;
+    }
+    md = values.md;
+  } else if (choices.length > 1 && !values.yes && process.stdin.isTTY && process.stdout.isTTY) {
+    const { isCancel, select } = await import("@clack/prompts");
+    const answer = await select({
+      message: "Markdown library for prose rendering?",
+      initialValue: choices[0],
+      options: choices.map((c) => ({
+        value: c,
+        label: c,
+        hint: c === "none" ? "wire one yourself later" : "installed and wired for you"
+      }))
+    });
+    if (isCancel(answer)) return 1;
+    md = answer;
+  } else {
+    md = choices[0];
+  }
+  const runtime = ["@contentbit/core", "@contentbit/blocks", "zod"];
   if (target === "react") runtime.push("@contentbit/react");
   if (target === "html") runtime.push("@contentbit/html");
+  if (target === "astro") runtime.push("@contentbit/astro");
+  if (md !== "none") runtime.push(md);
   if (values["no-install"]) {
     io.stdout(`skipped install: ${runtime.join(" ")} + contentbit (dev)`);
   } else {
-    const pm = detectPackageManager();
+    const pm = detectPackageManager(cwd);
     io.stdout(`installing with ${pm}: ${runtime.join(" ")}`);
     if (await runInstall(pm, installArgs(pm, false, runtime), cwd) !== 0) {
       io.stderr("install failed");
@@ -16271,68 +17058,142 @@ async function initCommand(args, io) {
     }
   }
   const files = [
-    ["blocks/registry.mjs", REGISTRY_TEMPLATE],
+    ["blocks/registry.ts", REGISTRY_TEMPLATE],
     ["content/example.md", EXAMPLE_CONTENT]
   ];
-  if (target === "react") files.push(["components/content-blocks.tsx", REACT_COMPONENT]);
+  const layout = detectFramework(cwd, { ...pkg.dependencies, ...pkg.devDependencies });
+  let styled = false;
+  const componentsJsonPath = join2(cwd, "components.json");
+  if (target === "react" && !values["no-styled"] && existsSync2(componentsJsonPath)) {
+    styled = await installStyledPack(cwd, "@contentbit/generic-pack", values["no-install"], io);
+  }
+  if (target === "react") {
+    const depth = layout.componentPath.split("/").length - 1;
+    const blocksImport = `${"../".repeat(depth)}blocks`;
+    files.push(["blocks/components.tsx", blockComponentsTemplate(styled)]);
+    files.push([
+      layout.componentPath,
+      reactComponent(styled, md === "react-markdown", blocksImport)
+    ]);
+    if (!values["no-page"] && layout.pagePath) {
+      files.push([layout.pagePath, layout.framework === "tanstack" ? TANSTACK_PAGE : NEXT_PAGE]);
+    }
+  }
+  if (target === "html") {
+    files.push([
+      "scripts/render-example.mjs",
+      htmlRenderScript(md)
+    ]);
+  }
+  if (target === "astro") {
+    let astroStyled = false;
+    if (!values["no-styled"] && existsSync2(componentsJsonPath)) {
+      astroStyled = await installStyledPack(cwd, "@contentbit/astro-pack", values["no-install"], io);
+    }
+    files.push(["blocks/QuoteBlock.astro", ASTRO_QUOTE_BLOCK]);
+    const configCandidates = ["ts", "mts", "mjs", "js"].flatMap((ext) => [
+      `src/content.config.${ext}`,
+      `src/content/config.${ext}`
+    ]);
+    const existingConfig = configCandidates.find((p) => existsSync2(join2(cwd, p)));
+    if (existingConfig) {
+      io.stdout(`content config exists (${existingConfig}); add this collection manually:`);
+      io.stdout(ASTRO_CONTENT_CONFIG);
+      io.stdout('the example page expects the "articles" collection above');
+    } else {
+      files.push(["src/content.config.ts", ASTRO_CONTENT_CONFIG]);
+    }
+    if (!values["no-page"]) files.push(["src/pages/example.astro", astroPage(astroStyled)]);
+  }
   for (const [rel, content] of files) {
-    const result = await scaffold(join(cwd, rel), content);
+    const result = await scaffold(join2(cwd, rel), content);
     io.stdout(`${result}: ${rel}`);
   }
-  const fresh = JSON.parse(await readFile(pkgPath, "utf8"));
+  const fresh = JSON.parse(await readFile2(pkgPath, "utf8"));
   fresh.scripts ??= {};
   if (!fresh.scripts["content:check"]) {
-    fresh.scripts["content:check"] = 'contentbit validate "content/**/*.md" --registry ./blocks/registry.mjs';
-    await writeFile(pkgPath, `${JSON.stringify(fresh, null, 2)}
+    fresh.scripts["content:check"] = 'contentbit validate "content/**/*.md" --registry ./blocks/registry.ts';
+    await writeFile2(pkgPath, `${JSON.stringify(fresh, null, 2)}
 `, "utf8");
     io.stdout("added script: content:check");
   }
-  const registry2 = await loadRegistry();
+  let registry2;
+  try {
+    registry2 = await loadRegistry(join2(cwd, "blocks/registry.ts"));
+  } catch {
+    registry2 = await loadRegistry();
+  }
   const guide = registry2.toAuthoringGuide({ audience: "llm", includeExamples: true });
-  await writeFile(join(cwd, "contentbit-guide.md"), guide, "utf8");
+  await writeFile2(join2(cwd, "contentbit-guide.md"), guide, "utf8");
   io.stdout("created: contentbit-guide.md (LLM authoring instructions)");
+  if (!values["no-agents"]) {
+    await installAgentIntegration(cwd, {}, io);
+    io.stdout("Agent integration installed \u2014 try asking your agent:");
+    io.stdout('  "write a blog post about X" or "audit my content"');
+  }
   io.stdout("");
   io.stdout("Done. Next steps:");
-  io.stdout(`  1. Validate the starter content: ${detectPackageManager()} run content:check`);
+  io.stdout(`  1. Validate the starter content: ${detectPackageManager(cwd)} run content:check`);
   if (target === "react") {
-    io.stdout('  2. Render it: import { Content } from "./components/content-blocks"');
+    if (!values["no-page"] && layout.pagePath) {
+      io.stdout("  2. Start the dev server and open /example to see the article rendered.");
+    } else {
+      io.stdout('  2. Render it: import { Content } from "./components/content-blocks"');
+      io.stdout("     <Content source={...content/example.md as a string} />");
+    }
     io.stdout("  3. Styled components: pnpm dlx shadcn@latest add @contentbit/generic-pack");
+  } else if (target === "astro") {
+    io.stdout("  2. Start the dev server and open /example to see the article rendered.");
+    io.stdout("  3. Styled components: pnpm dlx shadcn@latest add @contentbit/astro-pack");
   } else if (target === "html") {
-    io.stdout("  2. Render it: contentbit render content/example.md --target html");
+    io.stdout("  2. Render it: node scripts/render-example.mjs && open example.html");
   } else {
     io.stdout("  2. Render it: contentbit render content/example.md --target markdown");
   }
   io.stdout("  Docs: https://contentbit.dev/docs");
   return 0;
 }
-var TARGETS, REGISTRY_TEMPLATE, EXAMPLE_CONTENT, REACT_COMPONENT;
+var TARGETS, MD_CHOICES, REGISTRY_TEMPLATE, EXAMPLE_CONTENT, TANSTACK_PAGE, NEXT_PAGE, ASTRO_CONTENT_CONFIG, ASTRO_QUOTE_BLOCK;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_load_registry();
-    TARGETS = ["react", "html", "markdown"];
-    REGISTRY_TEMPLATE = `// Custom blocks for this project. The CLI and your app share this module:
+    init_agents();
+    TARGETS = ["react", "html", "markdown", "astro"];
+    MD_CHOICES = {
+      react: ["react-markdown", "none"],
+      html: ["marked", "markdown-it", "none"],
+      markdown: ["none"],
+      // @contentbit/astro ships its own marked-based default; nothing to install.
+      astro: ["none"]
+    };
+    REGISTRY_TEMPLATE = `// Custom block definitions for this project. The CLI and your app share
+// this module \u2014 Node 22.18+ imports TypeScript directly:
 //
-//   contentbit validate "content/**/*.md" --registry ./blocks/registry.mjs
+//   contentbit validate "content/**/*.md" --registry ./blocks/registry.ts
 //
-// Define blocks with @contentbit/core and default-export them as an array.
+// Definitions stay framework-free (the CLI and every render target use
+// them); React components live next door in blocks/components.tsx.
 // Docs: https://contentbit.dev/docs/guides/custom-blocks
-//
-// import { defineBlock, pipeRows } from '@contentbit/core'
-// import { z } from 'zod'
-//
-// const pricingTable = defineBlock({
-//   name: 'pricing-table',
-//   description: 'Compares product plans.',
-//   props: z.object({ currency: z.enum(['usd', 'eur']).default('usd') }),
-//   content: pipeRows({ columns: ['plan', 'price'], minRows: 2 }),
-//   authoring: {
-//     useWhen: ['Comparing pricing plans'],
-//     example: ':::pricing-table\\n- Starter | $0\\n- Pro | $12/mo\\n:::',
-//   },
-// })
+import { defineBlock, markdownBody, type BlockDefinition } from '@contentbit/core'
+import { z } from 'zod'
 
-export default []
+export const quote = defineBlock({
+  name: 'quote',
+  description: 'A pull quote with an author.',
+  props: z.object({
+    author: z.string().min(1),
+    role: z.string().optional(),
+  }),
+  content: markdownBody({ minLength: 3 }),
+  authoring: {
+    useWhen: ['Quoting a person to support a point'],
+    avoidWhen: ['Highlighting your own remark, use callout instead'],
+    example: ':::quote{author="Ada Lovelace"}\\nThe Analytical Engine weaves algebraic patterns.\\n:::',
+  },
+})
+
+export default [quote] satisfies BlockDefinition<unknown>[]
 `;
     EXAMPLE_CONTENT = `# Hello, Content Blocks
 
@@ -16347,24 +17208,74 @@ Run the validate script and you will get file:line:col diagnostics.
 2. Run \`contentbit validate "content/**/*.md"\`.
 3. Render it with the target you picked at init.
 :::
+
+This one is a **custom block**, defined in \`blocks/registry.ts\` and rendered
+by the \`QuoteBlock\` component, in about twenty lines:
+
+:::quote{author="Ada Lovelace" role="Notes on the Analytical Engine, 1843"}
+The Analytical Engine weaves algebraic patterns just as the Jacquard loom
+weaves flowers and leaves.
+:::
 `;
-    REACT_COMPONENT = `import { genericBlocks } from '@contentbit/blocks'
-import { createBlockRegistry, parseDocument, validateDocument } from '@contentbit/core'
-import { ContentBlocks } from '@contentbit/react'
+    TANSTACK_PAGE = `import { createFileRoute } from '@tanstack/react-router'
 
-const registry = createBlockRegistry().use(genericBlocks())
+import { Content } from '../components/content-blocks'
+// Vite's ?raw import inlines the Markdown as a string at build time.
+import source from '../../content/example.md?raw'
 
-export function Content({ source }: { source: string }) {
-  const result = validateDocument(parseDocument(source), registry)
+export const Route = createFileRoute('/example')({ component: ExamplePage })
+
+function ExamplePage() {
   return (
-    <ContentBlocks
-      document={result.document}
-      // TODO: plug your Markdown library in here, e.g. react-markdown.
-      // One function renders all prose: https://contentbit.dev/docs/guides/markdown
-      // renderMarkdown={(md) => <Markdown source={md} />}
-    />
+    <main style={{ maxWidth: '42rem', margin: '0 auto', padding: '3rem 1.5rem' }}>
+      <Content source={source} />
+    </main>
   )
 }
+`;
+    NEXT_PAGE = `import { readFile } from 'node:fs/promises'
+
+// If your project has no "@/" path alias, switch to a relative import.
+import { Content } from '@/components/content-blocks'
+
+export default async function ExamplePage() {
+  const source = await readFile('content/example.md', 'utf8')
+  return (
+    <main style={{ maxWidth: '42rem', margin: '0 auto', padding: '3rem 1.5rem' }}>
+      <Content source={source} />
+    </main>
+  )
+}
+`;
+    ASTRO_CONTENT_CONFIG = `import { defineCollection } from 'astro:content'
+import { glob } from 'astro/loaders'
+
+export const collections = {
+  articles: defineCollection({
+    // Astro's builtin Markdown loader. Entry bodies are parsed and validated
+    // where they render (see src/pages/example.astro); \`contentbit validate\`
+    // covers the same files in CI.
+    loader: glob({ pattern: '**/*.md', base: './content' }),
+  }),
+}
+`;
+    ASTRO_QUOTE_BLOCK = `---
+// The Astro component for the custom \`quote\` block defined in blocks/registry.ts.
+// Block props arrive as component props; nested content arrives via <slot />.
+interface Props {
+  author: string
+  role?: string
+}
+
+const { author, role } = Astro.props
+---
+
+<figure style="margin: 1.5rem 0; border-left: 2px solid #d4d4d4; padding-left: 1rem;">
+  <blockquote style="font-style: italic;"><slot /></blockquote>
+  <figcaption style="margin-top: 0.5rem; font-size: 0.875rem; opacity: 0.7;">
+    \u2014 {author}{role ? \`, \${role}\` : null}
+  </figcaption>
+</figure>
 `;
   }
 });
@@ -16374,11 +17285,11 @@ var validate_exports = {};
 __export(validate_exports, {
   validateCommand: () => validateCommand
 });
-import { readFile as readFile2 } from "node:fs/promises";
-import { parseArgs as parseArgs2 } from "node:util";
+import { readFile as readFile3 } from "node:fs/promises";
+import { parseArgs as parseArgs3 } from "node:util";
 import { glob } from "tinyglobby";
 async function validateCommand(args, io) {
-  const { values, positionals } = parseArgs2({
+  const { values, positionals } = parseArgs3({
     args,
     allowPositionals: true,
     options: {
@@ -16399,8 +17310,8 @@ async function validateCommand(args, io) {
   let errors = 0;
   let warnings = 0;
   for (const file2 of files.sort()) {
-    const source = await readFile2(file2, "utf8");
-    const result = validateDocument(parseDocument(source), registry2);
+    const source = await readFile3(file2, "utf8");
+    const result = validateDocument(parseDocument(stripFrontmatter(source)), registry2);
     for (const d of result.diagnostics) {
       io.stderr(formatDiagnostic(d, file2));
       if (d.severity === "error") errors++;
@@ -16420,6 +17331,63 @@ var init_validate2 = __esm({
   }
 });
 
+// src/commands/stats.ts
+var stats_exports = {};
+__export(stats_exports, {
+  statsCommand: () => statsCommand
+});
+import { readFile as readFile4 } from "node:fs/promises";
+import { parseArgs as parseArgs4 } from "node:util";
+import { glob as glob2 } from "tinyglobby";
+async function fileStats(file2, registry2) {
+  const source = await readFile4(file2, "utf8");
+  const stats = analyzeDocument(source, { path: file2 });
+  if (registry2) {
+    const result = validateDocument(parseDocument(stripFrontmatter(source)), registry2);
+    let errors = 0;
+    let warnings = 0;
+    for (const d of result.diagnostics) {
+      if (d.severity === "error") errors++;
+      else if (d.severity === "warning") warnings++;
+    }
+    stats.validation = { errors, warnings };
+  }
+  return stats;
+}
+async function statsCommand(args, io) {
+  const { values, positionals } = parseArgs4({
+    args,
+    allowPositionals: true,
+    options: {
+      registry: { type: "string" },
+      "no-validate": { type: "boolean", default: false }
+    }
+  });
+  if (positionals.length === 0) {
+    io.stderr("stats: provide at least one file or glob.");
+    return 2;
+  }
+  const files = await glob2(positionals, { absolute: true });
+  if (files.length === 0) {
+    io.stderr(`stats: no files matched ${positionals.join(" ")}`);
+    return 2;
+  }
+  const registry2 = values["no-validate"] ? null : await loadRegistry(values.registry);
+  const all = [];
+  for (const file2 of files.sort()) {
+    all.push(await fileStats(file2, registry2));
+  }
+  io.stdout(JSON.stringify(all.length === 1 ? all[0] : all, null, 2));
+  return 0;
+}
+var init_stats = __esm({
+  "src/commands/stats.ts"() {
+    "use strict";
+    init_dist();
+    init_load_registry();
+  }
+});
+
 // ../html/dist/escape.js
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -16500,12 +17468,18 @@ var init_blocks = __esm({
 });
 
 // ../html/dist/render.js
-function defaultMarkdown(md) {
+function fallbackMarkdown(md) {
   return md.trim().split(/\n{2,}/).map((p) => `<p>${escapeHtml(p)}</p>`).join("\n");
 }
+function invalidBlockHtml(node, prefix) {
+  return `<div class="${prefix}invalid" data-cb-invalid="${escapeHtml(node.name)}"><pre>${escapeHtml(node.body)}</pre></div>`;
+}
+function unrenderableBlockError(name) {
+  return new Error(`Cannot render block "${name}": not validated or no renderer registered.`);
+}
 function renderToHtml(document, opts = {}) {
   const prefix = opts.classPrefix ?? "cb-";
-  const renderMarkdown = opts.renderMarkdown ?? defaultMarkdown;
+  const renderMarkdown = opts.renderMarkdown ?? fallbackMarkdown;
   const renderers = { ...genericHtmlRenderers, ...opts.renderers };
   const onInvalid = opts.onInvalid ?? "fallback";
   const ctx = {
@@ -16519,13 +17493,11 @@ function renderToHtml(document, opts = {}) {
         const renderer = renderers[node.name];
         if (renderer && isValidatedBlock(node))
           return renderer(node, ctx);
-        if (onInvalid === "strict") {
-          throw new Error(`Cannot render block "${node.name}": not validated or no renderer registered.`);
-        }
-        if (onInvalid === "annotated") {
-          return `<div class="${prefix}invalid" data-cb-invalid="${escapeHtml(node.name)}"><pre>${escapeHtml(node.body)}</pre></div>`;
-        }
-        return defaultMarkdown(node.body);
+        if (onInvalid === "strict")
+          throw unrenderableBlockError(node.name);
+        if (onInvalid === "annotated")
+          return invalidBlockHtml(node, prefix);
+        return fallbackMarkdown(node.body);
       }).join("\n");
     }
   };
@@ -16553,10 +17525,10 @@ var render_exports = {};
 __export(render_exports, {
   renderCommand: () => renderCommand
 });
-import { readFile as readFile3 } from "node:fs/promises";
-import { parseArgs as parseArgs3 } from "node:util";
+import { readFile as readFile5 } from "node:fs/promises";
+import { parseArgs as parseArgs5 } from "node:util";
 async function renderCommand(args, io) {
-  const { values, positionals } = parseArgs3({
+  const { values, positionals } = parseArgs5({
     args,
     allowPositionals: true,
     options: {
@@ -16571,7 +17543,7 @@ async function renderCommand(args, io) {
     return 2;
   }
   const registry2 = await loadRegistry(values.registry);
-  const source = await readFile3(file2, "utf8");
+  const source = await readFile5(file2, "utf8");
   const result = validateDocument(parseDocument(source), registry2);
   if (!result.ok) {
     for (const d of result.diagnostics) io.stderr(formatDiagnostic(d, file2));
@@ -16597,9 +17569,9 @@ var instructions_exports = {};
 __export(instructions_exports, {
   instructionsCommand: () => instructionsCommand
 });
-import { parseArgs as parseArgs4 } from "node:util";
+import { parseArgs as parseArgs6 } from "node:util";
 async function instructionsCommand(args, io) {
-  const { values } = parseArgs4({
+  const { values } = parseArgs6({
     args,
     options: {
       audience: { type: "string", default: "llm" },
@@ -16629,9 +17601,9 @@ var docs_exports = {};
 __export(docs_exports, {
   docsCommand: () => docsCommand
 });
-import { parseArgs as parseArgs5 } from "node:util";
+import { parseArgs as parseArgs7 } from "node:util";
 async function docsCommand(args, io) {
-  const { values } = parseArgs5({
+  const { values } = parseArgs7({
     args,
     options: {
       registry: { type: "string" },
@@ -16652,23 +17624,27 @@ var init_docs = __esm({
 });
 
 // src/bin.ts
-import { writeFile as writeFile2 } from "node:fs/promises";
+import { writeFile as writeFile3 } from "node:fs/promises";
 
 // src/run.ts
-var USAGE = `Usage: contentbit <init|validate|render|instructions|docs> [options]
+var USAGE = `Usage: contentbit <init|validate|stats|render|instructions|docs|agents> [options]
 
-  init [-t react|html|markdown] [-y] [--no-install]
+  init [-t react|html|markdown|astro] [--md ...] [-y] [--no-install] [--no-page] [--no-agents]
+  agents [--claude] [--no-agents-md]
 
   validate <globs...> [--registry <module.mjs>] [--strict-warnings]
+  stats <globs...> [--registry <module.mjs>] [--no-validate]
   render <file> --target html|markdown [--registry <module.mjs>] [--out <file>]
   instructions [--audience llm|human] [--no-examples] [--registry <module.mjs>] [--out <file>]
   docs [--registry <module.mjs>] [--out <file>]`;
 var commands = {
   init: async () => (await Promise.resolve().then(() => (init_init(), init_exports))).initCommand,
   validate: async () => (await Promise.resolve().then(() => (init_validate2(), validate_exports))).validateCommand,
+  stats: async () => (await Promise.resolve().then(() => (init_stats(), stats_exports))).statsCommand,
   render: async () => (await Promise.resolve().then(() => (init_render2(), render_exports))).renderCommand,
   instructions: async () => (await Promise.resolve().then(() => (init_instructions(), instructions_exports))).instructionsCommand,
-  docs: async () => (await Promise.resolve().then(() => (init_docs(), docs_exports))).docsCommand
+  docs: async () => (await Promise.resolve().then(() => (init_docs(), docs_exports))).docsCommand,
+  agents: async () => (await Promise.resolve().then(() => (init_agents(), agents_exports))).agentsCommand
 };
 async function run(argv, io) {
   const [name, ...rest] = argv;
@@ -16690,6 +17666,6 @@ async function run(argv, io) {
 var code = await run(process.argv.slice(2), {
   stdout: (s) => console.log(s),
   stderr: (s) => console.error(s),
-  writeFile: (path, content) => writeFile2(path, content, "utf8")
+  writeFile: (path, content) => writeFile3(path, content, "utf8")
 });
 process.exit(code);