@opnpress/opnpress-cli 0.1.0

package/README.md

@@ -0,0 +1,72 @@
+# OpnPressCli
+
+`opnPress` is the CLI for creating, building, and previewing OpnPress sites.
+
+## Commands
+
+- `opnPrs init` or `opnPress init` initializes the current folder.
+- `opnPrs build` or `opnPress build` builds the site.
+- `opnPrs run` or `opnPress run` builds, starts a local server, and prints the preview URL.
+
+## Scaffold Templates
+
+`opnPress init` copies human-readable templates from [`templates/`](/mnt/d/Dev/OpnPressCli/templates) into the current folder.
+
+Edit those files here to change what new sites receive by default:
+
+- [`templates/README.md`](/mnt/d/Dev/OpnPressCli/templates/README.md)
+- [`templates/site.config.yaml`](/mnt/d/Dev/OpnPressCli/templates/site.config.yaml)
+- [`templates/theme.config.yaml`](/mnt/d/Dev/OpnPressCli/templates/theme.config.yaml)
+- [`templates/navigation.yaml`](/mnt/d/Dev/OpnPressCli/templates/navigation.yaml)
+- [`templates/content/pages/index.md`](/mnt/d/Dev/OpnPressCli/templates/content/pages/index.md)
+- [`templates/.skills/`](/mnt/d/Dev/OpnPressCli/templates/.skills)
+- [`templates/.github/workflows/build-pages.yml`](/mnt/d/Dev/OpnPressCli/templates/.github/workflows/build-pages.yml)
+
+The generated workflow deploys to Cloudflare Pages and expects these repository secrets:
+
+- `CLOUDFLARE_API_TOKEN`
+- `CLOUDFLARE_ACCOUNT_ID`
+- `CLOUDFLARE_PROJECT_NAME`
+
+## Local Use
+
+From a site checkout, run:
+
+```bash
+npm install
+npm exec opnPress -- init
+npm exec opnPress -- run
+```
+
+The CLI expects the site content and config files in the current working directory.
+
+## Publishing
+
+To publish the CLI, you need:
+
+- an npm account that belongs to the `opnpress` organization and can publish `@opnpress/opnpress-cli`
+- a GitHub account with write access to this repository
+
+The release workflow in [`.github/workflows/release.yml`](/mnt/d/Dev/OpnPressCli/.github/workflows/release.yml) publishes on version tags like `v0.1.1`.
+
+Release flow:
+
+1. Create the `opnpress` npm organization in the npm UI if it does not already exist.
+2. Publish the package once from your account if npm needs the package page created before trusted publishing can be enabled.
+3. In npm package settings, add a trusted publisher for:
+   - GitHub organization or user: your GitHub account or the `OpnPress` org
+   - Repository: `OpnPressCli`
+   - Workflow file: `.github/workflows/release.yml`
+4. Merge the change you want to ship.
+5. Update `package.json` version.
+6. Create and push a tag such as `v0.1.1`.
+7. GitHub Actions runs build, test, and `npm publish --access public`.
+8. npm generates provenance automatically and GitHub creates a release for the tag.
+
+The package is org-scoped and public, so `npm` treats each `name + version` combination as permanent once published.
+
+## Sample Site
+
+See the current sample site in [OpnPress](https://github.com/OpnPress/OpnPress).
+
+The live sample site is published at [opnpress.com](https://opnpress.com/).

package/dist/build.js

@@ -0,0 +1,518 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import YAML from 'yaml';
+import { loadNavigationConfig, loadSiteConfig, loadThemeConfig } from './config.js';
+import { buildPageTitle, isPublished, loadContentSources } from './content.js';
+import { buildPageArtifact, writeRenderedPage } from './render.js';
+import { escapeHtml, ensureDir, writeFileEnsured } from './utils.js';
+async function removeIfExists(target) {
+    await fs.rm(target, { recursive: true, force: true });
+}
+async function copyPublicAssets(rootDir, distDir) {
+    const publicDir = path.join(rootDir, 'public');
+    try {
+        await fs.access(publicDir);
+    }
+    catch {
+        return;
+    }
+    await fs.cp(publicDir, distDir, { recursive: true, force: true });
+}
+function getSiteBaseUrl(domain) {
+    if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(domain)) {
+        return domain.endsWith('/') ? domain : `${domain}/`;
+    }
+    return `https://${domain.replace(/\/+$/, '')}/`;
+}
+function isExternalUrl(url) {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url) || url.startsWith('//');
+}
+function isIgnoredLink(url) {
+    return url.startsWith('#') || url.startsWith('mailto:') || url.startsWith('tel:') || url.startsWith('javascript:');
+}
+function isStaticAssetPath(pathname) {
+    return /\.(png|jpe?g|gif|webp|svg|ico|css|js|json|xml|txt)$/i.test(pathname);
+}
+function isSourceMirrorPath(pathname) {
+    return pathname === '/source.md' || pathname === '/source.html' || pathname.endsWith('/source.md') || pathname.endsWith('/source.html');
+}
+function isGeneratedDocPath(pathname) {
+    return pathname === '/fullSiteContent.md' || pathname.endsWith('/fullSiteContent.md');
+}
+function extractLinks(html) {
+    const links = [];
+    const pattern = /href="([^"]+)"/gi;
+    let match;
+    while ((match = pattern.exec(html))) {
+        links.push(match[1]);
+    }
+    return links;
+}
+function routeToOutputPath(distDir, routePath, filename) {
+    if (routePath === '/') {
+        return path.join(distDir, filename);
+    }
+    return path.join(distDir, routePath.replace(/^\//, ''), filename);
+}
+function pageJsonToText(pageJson) {
+    return JSON.stringify(pageJson, null, 2) + '\n';
+}
+function stripHtmlMarkup(input) {
+    return input
+        .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+async function readOptionalTextFile(rootDir, relativePath) {
+    const filePath = path.join(rootDir, relativePath);
+    try {
+        await fs.access(filePath);
+    }
+    catch {
+        return null;
+    }
+    return fs.readFile(filePath, 'utf8');
+}
+function normalizeBlockText(input) {
+    return input.replace(/\s+/g, ' ').trim();
+}
+function appendUniqueBlocks(target, blocks, seen) {
+    for (const block of blocks) {
+        const trimmed = block.trim();
+        const normalized = normalizeBlockText(trimmed);
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        target.push(trimmed);
+    }
+}
+function appendPageReference(target, title, routePath) {
+    target.push('---');
+    target.push(`From: [${title}](${routePath})`);
+}
+function escapeMarkdownLinkText(value) {
+    return value.replace(/\\/g, '\\\\').replace(/\[/g, '\\[').replace(/\]/g, '\\]');
+}
+function normalizePhoneHref(value) {
+    return value.trim().startsWith('tel:')
+        ? value.trim()
+        : `tel:${value.trim().replace(/[^\d+*#.,]/g, '')}`;
+}
+function formatClickLabel(value, href, fallback = value) {
+    const label = href.startsWith('http://') || href.startsWith('https://') ? value : fallback;
+    return `[${escapeMarkdownLinkText(label)}](${href})`;
+}
+function formatContactFieldLabel(kind, value) {
+    if (kind === 'email') {
+        return `[${escapeMarkdownLinkText(value)}](mailto:${value.replace(/^mailto:/i, '')})`;
+    }
+    if (kind === 'phone') {
+        const href = normalizePhoneHref(value);
+        return `[${escapeMarkdownLinkText(value)}](${href})`;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return '';
+    }
+    if (/^(?:\.{1,2}\/|\/)/.test(trimmed)) {
+        return `[Goto Page](${trimmed})`;
+    }
+    if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(trimmed)) {
+        return formatClickLabel(trimmed, trimmed, trimmed);
+    }
+    const href = isExternalUrl(trimmed) ? trimmed : `https://${trimmed}`;
+    return formatClickLabel(trimmed, href, trimmed);
+}
+function parseShortcodeConfig(body) {
+    const trimmed = body.trim();
+    if (!trimmed) {
+        return {};
+    }
+    try {
+        const parsed = YAML.parse(trimmed);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Fall through to an empty config.
+    }
+    return {};
+}
+function extractShortcodeText(body) {
+    const lines = body
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (!lines.length) {
+        return { title: '', description: '' };
+    }
+    const [title, ...rest] = lines;
+    return {
+        title,
+        description: rest.join(' ')
+    };
+}
+function inlineTextFromNode(node) {
+    if (!node || typeof node !== 'object') {
+        return '';
+    }
+    switch (node.type) {
+        case 'text':
+        case 'inlineCode':
+            return String(node.value ?? '');
+        case 'image':
+            return String(node.alt ?? node.title ?? '');
+        case 'link':
+        case 'strong':
+        case 'emphasis':
+        case 'delete':
+        case 'paragraph':
+        case 'heading':
+        case 'tableCell':
+        case 'tableRow':
+        case 'root':
+            return Array.isArray(node.children) ? node.children.map(inlineTextFromNode).join(' ') : '';
+        case 'break':
+            return ' ';
+        case 'html':
+            return stripHtmlMarkup(String(node.value ?? ''));
+        default:
+            return Array.isArray(node.children) ? node.children.map(inlineTextFromNode).join(' ') : String(node.value ?? '');
+    }
+}
+function markdownNodeToBlocks(node) {
+    if (!node || typeof node !== 'object') {
+        return [];
+    }
+    switch (node.type) {
+        case 'root':
+            return (Array.isArray(node.children) ? node.children : []).flatMap((child) => markdownNodeToBlocks(child));
+        case 'heading': {
+            const depth = Math.max(1, Math.min(6, Number(node.depth ?? 1)));
+            const text = inlineTextFromNode(node);
+            return text ? [`${'#'.repeat(depth)} ${text}`] : [];
+        }
+        case 'paragraph': {
+            const text = inlineTextFromNode(node);
+            return text ? [text] : [];
+        }
+        case 'list': {
+            const ordered = Boolean(node.ordered);
+            const start = Number(node.start ?? 1);
+            const items = Array.isArray(node.children) ? node.children : [];
+            const blocks = [];
+            items.forEach((item, index) => {
+                const marker = ordered ? `${start + index}.` : '-';
+                const itemText = inlineTextFromNode(item).trim();
+                if (itemText) {
+                    blocks.push(`${marker} ${itemText}`);
+                }
+            });
+            return blocks;
+        }
+        case 'blockquote': {
+            const text = inlineTextFromNode(node);
+            return text ? [`> ${text}`] : [];
+        }
+        case 'code': {
+            const lang = typeof node.lang === 'string' && node.lang.trim() ? node.lang.trim() : '';
+            const value = String(node.value ?? '').trimEnd();
+            return value ? [`\`\`\`${lang}\n${value}\n\`\`\``] : [];
+        }
+        case 'table': {
+            const rows = Array.isArray(node.children) ? node.children : [];
+            const blocks = rows
+                .map((row) => {
+                const cells = Array.isArray(row.children)
+                    ? row.children.map((cell) => normalizeBlockText(inlineTextFromNode(cell)))
+                    : [];
+                return cells.filter(Boolean).length ? `| ${cells.filter(Boolean).join(' | ')} |` : '';
+            })
+                .filter(Boolean);
+            return blocks;
+        }
+        case 'thematicBreak':
+            return ['---'];
+        case 'html': {
+            const text = stripHtmlMarkup(String(node.value ?? ''));
+            return text ? [text] : [];
+        }
+        default:
+            return Array.isArray(node.children) ? node.children.flatMap((child) => markdownNodeToBlocks(child)) : [];
+    }
+}
+function markdownToBlocks(markdown) {
+    const tree = unified().use(remarkParse).use(remarkGfm).parse(markdown);
+    return markdownNodeToBlocks(tree);
+}
+function summarizeShortcodeBlock(blockName, body, site) {
+    const config = parseShortcodeConfig(body);
+    const title = typeof config.title === 'string' ? config.title : '';
+    const description = typeof config.description === 'string' ? config.description : '';
+    switch (blockName) {
+        case 'cardrow':
+        case 'pagelist':
+        case 'shareable-links':
+            return [title, description].filter(Boolean);
+        case 'contact-card':
+        case 'company-info': {
+            const name = typeof config.name === 'string' ? config.name : '';
+            const tagline = typeof config.tagline === 'string' ? config.tagline : '';
+            const address = typeof config.address === 'string' ? config.address : '';
+            const hours = typeof config.hours === 'string' ? config.hours : '';
+            const website = typeof config.website === 'string' ? config.website : '';
+            const email = typeof config.email === 'string' ? config.email : '';
+            const phone = typeof config.phone === 'string' ? config.phone : '';
+            return [
+                name ? (tagline ? `${name} — ${tagline}` : name) : tagline,
+                address ? `Address: ${address}` : '',
+                hours ? `Hours: ${hours}` : '',
+                website ? `Website: ${formatContactFieldLabel('website', website)}` : '',
+                email ? `Email: ${formatContactFieldLabel('email', email)}` : '',
+                phone ? `Phone: ${formatContactFieldLabel('phone', phone)}` : ''
+            ].filter(Boolean);
+        }
+        case 'contact-links': {
+            const contact = site.integrations.contactLinks;
+            return [
+                contact.email ? `Email: ${formatContactFieldLabel('email', contact.email)}` : '',
+                contact.phone ? `Phone: ${formatContactFieldLabel('phone', contact.phone)}` : '',
+                contact.website ? `Website: ${formatContactFieldLabel('website', contact.website)}` : '',
+                contact.address ? `Address: ${contact.address}` : '',
+                contact.hours ? `Hours: ${contact.hours}` : ''
+            ].filter(Boolean);
+        }
+        case 'mailto': {
+            const email = typeof config.email === 'string' ? config.email : '';
+            return [email ? `Email: ${formatContactFieldLabel('email', email)}` : '', description].filter(Boolean);
+        }
+        case 'tel': {
+            const phone = typeof config.phone === 'string' ? config.phone : '';
+            return [phone ? `Phone: ${formatContactFieldLabel('phone', phone)}` : '', description].filter(Boolean);
+        }
+        case 'socials-links': {
+            const providers = Array.isArray(config.providers)
+                ? config.providers.filter((provider) => typeof provider === 'string')
+                : undefined;
+            const chosenProviders = providers?.length
+                ? providers.map((provider) => provider.trim().toLowerCase()).filter(Boolean)
+                : ['twitter', 'x', 'github', 'facebook', 'instagram', 'linkedin', 'youtube', 'tiktok', 'threads', 'mastodon', 'bluesky', 'website', 'email'];
+            const orderedProviders = ['twitter', 'x', 'github', 'facebook', 'instagram', 'linkedin', 'youtube', 'tiktok', 'threads', 'mastodon', 'bluesky', 'website', 'email'];
+            const blocks = [];
+            for (const provider of orderedProviders) {
+                if (!chosenProviders.includes(provider)) {
+                    continue;
+                }
+                const value = provider === 'twitter' || provider === 'x'
+                    ? site.socials.twitter ?? site.socials.x
+                    : site.socials[provider];
+                if (!value || !value.trim()) {
+                    continue;
+                }
+                blocks.push(`${provider === 'x' ? 'X' : provider.charAt(0).toUpperCase() + provider.slice(1)}: ${value.trim()}`);
+            }
+            return blocks;
+        }
+        case 'booking-calendar':
+        case 'maps':
+        case 'video':
+            return [title, description].filter(Boolean);
+        default:
+            return [title, description].filter(Boolean);
+    }
+}
+function markdownSourceToBlocks(markdown, site) {
+    const blockPattern = /:::([a-z-]+)\n([\s\S]*?)\n:::/g;
+    const blocks = [];
+    let lastIndex = 0;
+    let match;
+    while ((match = blockPattern.exec(markdown))) {
+        const textChunk = markdown.slice(lastIndex, match.index);
+        if (textChunk.trim()) {
+            blocks.push(...markdownToBlocks(textChunk));
+        }
+        blocks.push(...summarizeShortcodeBlock(match[1], match[2], site));
+        lastIndex = match.index + match[0].length;
+    }
+    const tail = markdown.slice(lastIndex);
+    if (tail.trim()) {
+        blocks.push(...markdownToBlocks(tail));
+    }
+    return blocks;
+}
+function sitemapXmlFromPages(siteDomain, pages) {
+    const baseUrl = getSiteBaseUrl(siteDomain);
+    const lines = [];
+    lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+    lines.push('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">');
+    for (const page of pages) {
+        lines.push('  <url>');
+        lines.push(`    <loc>${escapeHtml(new URL(page.routePath, baseUrl).toString())}</loc>`);
+        if (page.sourceMirrorUrl) {
+            lines.push(`    <xhtml:link rel="alternate" type="text/markdown" href="${escapeHtml(page.sourceMirrorUrl)}" />`);
+        }
+        if (page.updated) {
+            lines.push(`    <lastmod>${escapeHtml(page.updated)}</lastmod>`);
+        }
+        lines.push('  </url>');
+    }
+    lines.push('</urlset>');
+    return `${lines.join('\n')}\n`;
+}
+function llmsTextFromPages(siteName, siteDescription, pages, fullSiteContentUrl, shortcodesUrl) {
+    const markdownPages = pages.filter((page) => page.kind === 'markdown');
+    const htmlPages = pages.filter((page) => page.kind === 'html');
+    const lines = [];
+    lines.push(`# ${siteName}`);
+    if (siteDescription) {
+        lines.push(`> ${siteDescription}`);
+    }
+    lines.push('');
+    lines.push('> markdown = source-managed content mirror');
+    lines.push('> html = standalone custom HTML page');
+    lines.push('');
+    if (fullSiteContentUrl) {
+        lines.push('## Full Site Content');
+        lines.push(`- markdown | source: [fullSiteContent.md](${fullSiteContentUrl}) | reference for the entire site in one concise file`);
+        lines.push('');
+    }
+    lines.push('## Markdown Pages');
+    for (const page of markdownPages) {
+        lines.push(`- markdown | source: [source.md](${page.sourceMirrorUrl ?? '#'}) | page: [${page.title}](${page.pageUrl})${page.description ? ` | ${page.description}` : ''}`);
+    }
+    lines.push('');
+    lines.push('## Custom HTML Pages');
+    for (const page of htmlPages) {
+        lines.push(`- html | source: [source.html](${page.sourceMirrorUrl ?? '#'}) | page: [${page.title}](${page.pageUrl})${page.description ? ` | ${page.description}` : ''}`);
+    }
+    if (shortcodesUrl) {
+        lines.push('');
+        lines.push('## Shortcodes Reference');
+        lines.push(`- markdown | source: [shortcodes.md](${shortcodesUrl}) | reference for shortcode syntax and LLM-facing page structure`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function fullSiteContentMarkdownFromPages(site, pages) {
+    const lines = ['# Site Content', ''];
+    const markdownPages = pages.filter((page) => page.kind === 'markdown');
+    const htmlPages = pages.filter((page) => page.kind === 'html');
+    const seenBlocks = new Set();
+    for (const page of markdownPages) {
+        const blocks = markdownSourceToBlocks(page.body, site);
+        if (!blocks.length) {
+            continue;
+        }
+        appendPageReference(lines, page.title, page.routePath);
+        appendUniqueBlocks(lines, blocks, seenBlocks);
+        lines.push('');
+    }
+    if (htmlPages.length) {
+        for (const page of htmlPages) {
+            const text = stripHtmlMarkup(page.body);
+            if (!text) {
+                continue;
+            }
+            appendPageReference(lines, page.title, page.routePath);
+            appendUniqueBlocks(lines, [text], seenBlocks);
+            lines.push('');
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+function validateInternalLinks(html, currentRoute, siteDomain, knownRoutes) {
+    const baseUrl = new URL(currentRoute === '/' ? '/' : currentRoute, getSiteBaseUrl(siteDomain));
+    const links = extractLinks(html);
+    for (const link of links) {
+        if (isIgnoredLink(link) || isExternalUrl(link)) {
+            continue;
+        }
+        const resolved = new URL(link, baseUrl).pathname;
+        if (isStaticAssetPath(resolved) || isSourceMirrorPath(resolved) || isGeneratedDocPath(resolved)) {
+            continue;
+        }
+        const normalized = resolved === '/' ? '/' : resolved.endsWith('/') ? resolved : `${resolved}/`;
+        if (!knownRoutes.has(normalized)) {
+            throw new Error(`Broken internal link detected from ${currentRoute} to ${link} (resolved to ${normalized})`);
+        }
+    }
+}
+export async function buildSite(rootDir = process.cwd()) {
+    const distDir = path.join(rootDir, 'dist');
+    await Promise.all([removeIfExists(distDir), ensureDir(distDir)]);
+    const [site, theme, navigation, sources] = await Promise.all([
+        loadSiteConfig(rootDir),
+        loadThemeConfig(rootDir),
+        loadNavigationConfig(rootDir),
+        loadContentSources(rootDir)
+    ]);
+    const published = sources.filter(isPublished);
+    if (!published.length) {
+        throw new Error('No published content was found. Add at least one markdown or HTML page under content/.');
+    }
+    const routeMap = new Map();
+    for (const source of published) {
+        if (routeMap.has(source.routePath)) {
+            throw new Error(`Route collision detected for ${source.routePath}: ${routeMap.get(source.routePath)} and ${source.sourcePath}`);
+        }
+        routeMap.set(source.routePath, source.sourcePath);
+    }
+    const knownRoutes = new Set(published.map((source) => source.routePath));
+    const shortcodesDoc = await readOptionalTextFile(rootDir, '.skills/shortcodes.md');
+    const shortcodesUrl = shortcodesDoc ? 'shortcodes.md' : undefined;
+    const llmsPages = [];
+    const sitemapPages = [];
+    for (const source of published) {
+        const artifact = await buildPageArtifact({
+            source,
+            site,
+            theme,
+            navigation,
+            allPublishedSources: published
+        });
+        const outputPath = routeToOutputPath(distDir, source.routePath, 'index.html');
+        const jsonPath = routeToOutputPath(distDir, source.routePath, 'page.json');
+        const sourceMirrorPath = routeToOutputPath(distDir, source.routePath, artifact.sourceMirror?.path ?? 'source.md');
+        validateInternalLinks(artifact.html, source.routePath, site.site.domain, knownRoutes);
+        await writeRenderedPage(outputPath, artifact.html);
+        await writeFileEnsured(jsonPath, pageJsonToText(artifact.pageJson));
+        await writeFileEnsured(sourceMirrorPath, artifact.sourceMirror?.content ?? '');
+        llmsPages.push({
+            routePath: artifact.pageJson.routePath,
+            title: artifact.pageJson.title,
+            description: artifact.pageJson.description,
+            kind: artifact.pageJson.kind,
+            pageUrl: artifact.pageJson.url,
+            sourceMirrorUrl: artifact.sourceMirrorUrl
+        });
+        sitemapPages.push({
+            routePath: artifact.pageJson.routePath,
+            sourceMirrorUrl: artifact.sourceMirrorUrl,
+            updated: artifact.pageJson.updated
+        });
+    }
+    await copyPublicAssets(rootDir, distDir);
+    if (shortcodesDoc) {
+        await writeFileEnsured(path.join(distDir, 'shortcodes.md'), shortcodesDoc);
+    }
+    const fullSiteContentMarkdown = fullSiteContentMarkdownFromPages(site, published.map((source) => ({
+        routePath: source.routePath,
+        sourcePath: source.sourcePath,
+        kind: source.kind,
+        title: buildPageTitle(source, site.site.name),
+        body: source.body
+    })));
+    await writeFileEnsured(path.join(distDir, 'fullSiteContent.md'), fullSiteContentMarkdown);
+    await writeFileEnsured(path.join(distDir, 'llms.txt'), llmsTextFromPages(site.site.name, site.site.description, llmsPages, 'fullSiteContent.md', shortcodesUrl));
+    await writeFileEnsured(path.join(distDir, 'sitemap.xml'), sitemapXmlFromPages(site.site.domain, sitemapPages));
+    console.log(`Built ${published.length} pages into ${distDir}`);
+    console.log(`Site: ${site.site.name}`);
+    const homePage = published.find((page) => page.routePath === '/') ?? published[0];
+    console.log(`Home title: ${buildPageTitle(homePage, site.site.name)}`);
+}

package/dist/cli.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { buildSite } from './build.js';
+import { initProject } from './init.js';
+import { startPreviewServer } from './server.js';
+function usage() {
+    return `Usage:
+  opnPrs init
+  opnPrs build
+  opnPrs run
+
+Aliases:
+  opnPress init
+  opnPress build
+  opnPress run
+`;
+}
+async function runCommand(rootDir) {
+    await buildSite(rootDir);
+    const distDir = path.join(rootDir, 'dist');
+    const server = await startPreviewServer(distDir);
+    console.log(`Preview available at ${server.url}`);
+    const shutdown = async () => {
+        await server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => {
+        void shutdown();
+    });
+    process.on('SIGTERM', () => {
+        void shutdown();
+    });
+}
+async function main() {
+    const [command] = process.argv.slice(2);
+    const rootDir = process.cwd();
+    switch (command) {
+        case 'init': {
+            const initialized = await initProject(rootDir);
+            if (!initialized) {
+                console.log('OpnPress is already initialized.');
+                return;
+            }
+            console.log(`Initialized OpnPress in ${rootDir}`);
+            return;
+        }
+        case 'build':
+            await buildSite(rootDir);
+            return;
+        case 'run':
+            await runCommand(rootDir);
+            return;
+        case 'help':
+        case '--help':
+        case '-h':
+        case undefined:
+            console.log(usage());
+            return;
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.log(usage());
+            process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.stack || error.message : String(error));
+    process.exitCode = 1;
+});