contentbit 0.1.0 → 0.2.0

package/dist/commands/init.js

@@ -1,32 +1,83 @@
 import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseArgs } from 'node:util';
 import { loadRegistry } from '../load-registry.js';
-const TARGETS = ['react', 'html', 'markdown'];
-const REGISTRY_TEMPLATE = `// Custom blocks for this project. The CLI and your app share this module:
+import { installAgentIntegration } from './agents.js';
+const TARGETS = ['react', 'html', 'markdown', 'astro'];
+/** Markdown library choices per target; the first entry is the default. */
+const 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'],
+};
+const REGISTRY_TEMPLATE = `// Custom block definitions for this project. The CLI and your app share
+// this module — 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:::',
-//   },
-// })
-
-export default []
+import { defineBlock, markdownBody, type BlockDefinition } from '@contentbit/core'
+import { z } from 'zod'
+
+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>[]
+`;
+/** blocks/components.tsx — React components for custom blocks, next to their definitions. */
+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">
+        — {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 }}>
+        — {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 — 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,
+}
 `;
+}
 const EXAMPLE_CONTENT = `# Hello, Content Blocks
 
 Regular Markdown works everywhere. Blocks add validated structure:
@@ -40,26 +91,205 @@ 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.
+:::
 `;
-const REACT_COMPONENT = `import { genericBlocks } from '@contentbit/blocks'
+/** The wrapper component: styled pack or headless, with or without a Markdown lib. */
+function reactComponent(styled, mdWired, blocksImport) {
+    const mdImport = mdWired ? "import ReactMarkdown from 'react-markdown'\n" : '';
+    const mdProp = mdWired
+        ? '\n      renderMarkdown={(md) => <ReactMarkdown>{md}</ReactMarkdown>}'
+        : `\n      // 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
+        ? `\n// 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'
-import { ContentBlocks } from '@contentbit/react'
+${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())
+const registry = createBlockRegistry().use(genericBlocks()).use(customBlocks)
 
 export function Content({ source }: { source: string }) {
   const result = validateDocument(parseDocument(source), registry)
   return (
-    <ContentBlocks
+    <${renderer}
       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} />}
+      components={blockComponents}${mdProp}
     />
   )
 }
 `;
-function detectPackageManager() {
+}
+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 — 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')
+`;
+}
+/** Where the component and example page belong for the detected framework. */
+function detectFramework(cwd, deps) {
+    if ((deps['@tanstack/react-start'] || deps['@tanstack/react-router']) &&
+        existsSync(join(cwd, 'src/routes'))) {
+        return {
+            framework: 'tanstack',
+            componentPath: 'src/components/content-blocks.tsx',
+            pagePath: 'src/routes/example.tsx',
+        };
+    }
+    if (deps.next) {
+        const appDir = existsSync(join(cwd, 'src/app')) ? 'src/app' : 'app';
+        if (existsSync(join(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 };
+}
+const TANSTACK_PAGE = `import { createFileRoute } from '@tanstack/react-router'
+
+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 const Route = createFileRoute('/example')({ component: ExamplePage })
+
+function ExamplePage() {
+  return (
+    <main style={{ maxWidth: '42rem', margin: '0 auto', padding: '3rem 1.5rem' }}>
+      <Content source={source} />
+    </main>
+  )
+}
+`;
+const 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>
+  )
+}
+`;
+const 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' }),
+  }),
+}
+`;
+const 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;">
+    — {author}{role ? \`, \${role}\` : null}
+  </figcaption>
+</figure>
+`;
+/** The example page: styled pack renderer or the headless ContentBlocks. */
+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) {
+    // The project's lockfile outranks however the CLI itself was launched.
+    const locks = [
+        ['pnpm-lock.yaml', 'pnpm'],
+        ['yarn.lock', 'yarn'],
+        ['bun.lock', 'bun'],
+        ['bun.lockb', 'bun'],
+        ['package-lock.json', 'npm'],
+    ];
+    for (const [file, pm] of locks) {
+        if (existsSync(join(cwd, file)))
+            return pm;
+    }
     const agent = process.env.npm_config_user_agent ?? '';
     for (const pm of ['pnpm', 'yarn', 'bun']) {
         if (agent.startsWith(pm))
@@ -71,6 +301,15 @@ 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' });
@@ -78,6 +317,27 @@ function runInstall(pm, args, cwd) {
         child.on('error', () => resolve(1));
     });
 }
+/** Wire the @contentbit shadcn registry and install a styled pack. Returns true on success. */
+async function installStyledPack(cwd, pack, noInstall, io) {
+    const componentsJsonPath = join(cwd, 'components.json');
+    const componentsJson = JSON.parse(await readFile(componentsJsonPath, 'utf8'));
+    componentsJson.registries ??= {};
+    if (!componentsJson.registries['@contentbit']) {
+        componentsJson.registries['@contentbit'] = 'https://contentbit.dev/r/{name}.json';
+        await writeFile(componentsJsonPath, `${JSON.stringify(componentsJson, null, 2)}\n`, '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 code = await runInstall(bin, [...prefix, 'shadcn@latest', 'add', pack, '--yes'], cwd);
+    if (code !== 0)
+        io.stderr('styled pack install failed; falling back to headless defaults');
+    return code === 0;
+}
 /** Write a file unless it already exists; returns what happened for the summary. */
 async function scaffold(path, content) {
     try {
@@ -95,9 +355,13 @@ export async function initCommand(args, io) {
         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-page': { type: 'boolean', default: false },
+            'no-styled': { type: 'boolean', default: false },
+            'no-agents': { type: 'boolean', default: false },
         },
     });
     const cwd = values.cwd;
@@ -113,7 +377,8 @@ export async function initCommand(args, io) {
     }
     // Resolve the render target: flag > prompt (interactive) > detection.
     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)) {
@@ -129,6 +394,7 @@ export 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' },
             ],
@@ -140,17 +406,50 @@ export async function initCommand(args, io) {
     else {
         target = detected;
     }
+    // Resolve the Markdown library: flag > prompt (interactive) > target default.
+    // The default gives working prose rendering out of the box; 'none' opts out.
+    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];
+    }
     // Install runtime packages plus the CLI as a dev dependency.
-    const runtime = ['@contentbit/core', '@contentbit/blocks'];
+    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');
@@ -163,11 +462,60 @@ export async function initCommand(args, io) {
     }
     // Scaffold project files; never overwrite.
     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 });
+    // shadcn project? Pull the styled component pack from the contentbit registry.
+    let styled = false;
+    const componentsJsonPath = join(cwd, 'components.json');
+    if (target === 'react' && !values['no-styled'] && existsSync(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),
+        ]);
+        // A visible page in the framework's own routing convention.
+        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'] && existsSync(componentsJsonPath)) {
+            astroStyled = await installStyledPack(cwd, '@contentbit/astro-pack', values['no-install'], io);
+        }
+        files.push(['blocks/QuoteBlock.astro', ASTRO_QUOTE_BLOCK]);
+        // Every config filename Astro resolves (src/content.config.* plus the
+        // legacy src/content/config.* location), so we never scaffold a second
+        // config that Astro would silently ignore.
+        const configCandidates = ['ts', 'mts', 'mjs', 'js'].flatMap((ext) => [
+            `src/content.config.${ext}`,
+            `src/content/config.${ext}`,
+        ]);
+        const existingConfig = configCandidates.find((p) => existsSync(join(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);
         io.stdout(`${result}: ${rel}`);
@@ -177,24 +525,48 @@ export async function initCommand(args, io) {
     fresh.scripts ??= {};
     if (!fresh.scripts['content:check']) {
         fresh.scripts['content:check'] =
-            'contentbit validate "content/**/*.md" --registry ./blocks/registry.mjs';
+            'contentbit validate "content/**/*.md" --registry ./blocks/registry.ts';
         await writeFile(pkgPath, `${JSON.stringify(fresh, null, 2)}\n`, 'utf8');
         io.stdout('added script: content:check');
     }
     // Generate the LLM authoring guide from the registry, ready to paste into a prompt.
-    const registry = await loadRegistry();
+    let registry;
+    try {
+        // Include the scaffolded custom blocks so the guide covers them too.
+        registry = await loadRegistry(join(cwd, 'blocks/registry.ts'));
+    }
+    catch {
+        registry = await loadRegistry(); // packages not installed yet (--no-install)
+    }
     const guide = registry.toAuthoringGuide({ audience: 'llm', includeExamples: true });
     await writeFile(join(cwd, 'contentbit-guide.md'), guide, 'utf8');
     io.stdout('created: contentbit-guide.md (LLM authoring instructions)');
+    // Coding-agent integration: an AGENTS.md block for every agent, plus Claude
+    // Code skills when a .claude/ directory exists. `contentbit agents` refreshes.
+    if (!values['no-agents']) {
+        await installAgentIntegration(cwd, {}, io);
+        io.stdout('Agent integration installed — 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');

package/dist/commands/stats.d.ts

@@ -0,0 +1,3 @@
+import type { Io } from '../run.js';
+export declare function statsCommand(args: string[], io: Io): Promise<number>;
+//# sourceMappingURL=stats.d.ts.map

package/dist/commands/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../src/commands/stats.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,WAAW,CAAA;AAuBnC,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA2B1E"}

package/dist/commands/stats.js

@@ -0,0 +1,49 @@
+import { analyzeDocument, parseDocument, stripFrontmatter, validateDocument, } from '@contentbit/core';
+import { readFile } from 'node:fs/promises';
+import { parseArgs } from 'node:util';
+import { glob } from 'tinyglobby';
+import { loadRegistry } from '../load-registry.js';
+async function fileStats(file, registry) {
+    const source = await readFile(file, 'utf8');
+    const stats = analyzeDocument(source, { path: file });
+    if (registry) {
+        const result = validateDocument(parseDocument(stripFrontmatter(source)), registry);
+        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;
+}
+export async function statsCommand(args, io) {
+    const { values, positionals } = parseArgs({
+        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 glob(positionals, { absolute: true });
+    if (files.length === 0) {
+        io.stderr(`stats: no files matched ${positionals.join(' ')}`);
+        return 2;
+    }
+    const registry = values['no-validate'] ? null : await loadRegistry(values.registry);
+    const all = [];
+    for (const file of files.sort()) {
+        all.push(await fileStats(file, registry));
+    }
+    // A single file keeps the flat object shape; multiple files emit an array.
+    io.stdout(JSON.stringify(all.length === 1 ? all[0] : all, null, 2));
+    return 0;
+}

package/dist/commands/validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,WAAW,CAAA;AAInC,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAmC7E"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,WAAW,CAAA;AAInC,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAsC7E"}

package/dist/commands/validate.js

@@ -1,4 +1,4 @@
-import { formatDiagnostic, parseDocument, validateDocument } from '@contentbit/core';
+import { formatDiagnostic, parseDocument, stripFrontmatter, validateDocument, } from '@contentbit/core';
 import { readFile } from 'node:fs/promises';
 import { parseArgs } from 'node:util';
 import { glob } from 'tinyglobby';
@@ -26,7 +26,10 @@ export async function validateCommand(args, io) {
     let warnings = 0;
     for (const file of files.sort()) {
         const source = await readFile(file, 'utf8');
-        const result = validateDocument(parseDocument(source), registry);
+        // Frontmatter is metadata, not content: blanked (positions preserved) so
+        // block syntax inside YAML never produces diagnostics — matching what
+        // frontmatter-aware consumers like Astro validate from entry bodies.
+        const result = validateDocument(parseDocument(stripFrontmatter(source)), registry);
         for (const d of result.diagnostics) {
             io.stderr(formatDiagnostic(d, file));
             if (d.severity === 'error')

package/dist/load-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-registry.d.ts","sourceRoot":"","sources":["../src/load-registry.ts"],"names":[],"mappings":"AACA,OAAO,EAA6C,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAGhG,+EAA+E;AAC/E,wBAAsB,YAAY,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAchF"}
+{"version":3,"file":"load-registry.d.ts","sourceRoot":"","sources":["../src/load-registry.ts"],"names":[],"mappings":"AACA,OAAO,EAA6C,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAGhG,+EAA+E;AAC/E,wBAAsB,YAAY,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAsBhF"}