mdorigin 0.1.0

package/README.md

@@ -0,0 +1,29 @@
+# mdorigin
+
+`mdorigin` is a markdown-first publishing engine.
+
+It treats markdown as the only source of truth, serves raw `.md` directly for agents, and renders `.html` views for humans from the same directory tree.
+
+## Install
+
+```bash
+npm install mdorigin
+```
+
+## Development
+
+```bash
+npm install
+npm run check
+npm run dev -- --root docs/site
+npm run build:index -- --root docs/site
+```
+
+## Docs
+
+- Getting started: [`docs/site/guides/getting-started.md`](docs/site/guides/getting-started.md)
+- Routing model: [`docs/site/concepts/routing.md`](docs/site/concepts/routing.md)
+- Directory indexes: [`docs/site/concepts/directory-indexes.md`](docs/site/concepts/directory-indexes.md)
+- Configuration: [`docs/site/reference/configuration.md`](docs/site/reference/configuration.md)
+- CLI: [`docs/site/reference/cli.md`](docs/site/reference/cli.md)
+- Cloudflare deployment: [`docs/site/guides/cloudflare.md`](docs/site/guides/cloudflare.md)

package/dist/adapters/cloudflare.d.ts

@@ -0,0 +1,17 @@
+import { type ContentEntryKind } from '../core/content-store.js';
+import type { ResolvedSiteConfig } from '../core/site-config.js';
+export interface CloudflareManifestEntry {
+    path: string;
+    kind: ContentEntryKind;
+    mediaType: string;
+    text?: string;
+    base64?: string;
+}
+export interface CloudflareManifest {
+    entries: CloudflareManifestEntry[];
+    siteConfig?: ResolvedSiteConfig;
+}
+export interface ExportedHandlerLike {
+    fetch(request: Request): Promise<Response>;
+}
+export declare function createCloudflareWorker(manifest: CloudflareManifest): ExportedHandlerLike;

package/dist/adapters/cloudflare.js

@@ -0,0 +1,53 @@
+import { MemoryContentStore, } from '../core/content-store.js';
+import { handleSiteRequest } from '../core/request-handler.js';
+export function createCloudflareWorker(manifest) {
+    const store = new MemoryContentStore(manifest.entries.map((entry) => {
+        if (entry.kind === 'text') {
+            return {
+                path: entry.path,
+                kind: 'text',
+                mediaType: entry.mediaType,
+                text: entry.text ?? '',
+            };
+        }
+        return {
+            path: entry.path,
+            kind: 'binary',
+            mediaType: entry.mediaType,
+            bytes: decodeBase64(entry.base64 ?? ''),
+        };
+    }));
+    return {
+        async fetch(request) {
+            const url = new URL(request.url);
+            const siteResponse = await handleSiteRequest(store, url.pathname, {
+                draftMode: 'exclude',
+                siteConfig: manifest.siteConfig ?? {
+                    siteTitle: 'mdorigin',
+                    showDate: true,
+                    showSummary: true,
+                    theme: 'paper',
+                    template: 'document',
+                    topNav: [],
+                    showHomeIndex: true,
+                    siteTitleConfigured: false,
+                    siteDescriptionConfigured: false,
+                },
+            });
+            const headers = new Headers(siteResponse.headers);
+            const body = siteResponse.body instanceof Uint8Array
+                ? new Blob([Uint8Array.from(siteResponse.body)], {
+                    type: siteResponse.headers['content-type'],
+                })
+                : siteResponse.body ?? '';
+            return new Response(body, {
+                status: siteResponse.status,
+                headers,
+            });
+        },
+    };
+}
+function decodeBase64(value) {
+    const decoded = atob(value);
+    return Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+}

package/dist/adapters/node.d.ts

@@ -0,0 +1,11 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+import type { ContentStore } from '../core/content-store.js';
+import type { ResolvedSiteConfig } from '../core/site-config.js';
+export interface NodeAdapterOptions {
+    rootDir: string;
+    draftMode: 'include' | 'exclude';
+    siteConfig: ResolvedSiteConfig;
+}
+export declare function createFileSystemContentStore(rootDir: string): ContentStore;
+export declare function createNodeRequestListener(options: NodeAdapterOptions): (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare function createNodeServer(options: NodeAdapterOptions): import("http").Server<typeof IncomingMessage, typeof ServerResponse>;

package/dist/adapters/node.js

@@ -0,0 +1,115 @@
+import { createServer } from 'node:http';
+import { readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { getMediaTypeForPath, isLikelyTextPath, normalizeContentPath, normalizeDirectoryPath, } from '../core/content-store.js';
+import { handleSiteRequest } from '../core/request-handler.js';
+export function createFileSystemContentStore(rootDir) {
+    const resolvedRootDir = path.resolve(rootDir);
+    return {
+        async get(contentPath) {
+            const normalizedPath = normalizeContentPath(contentPath);
+            if (normalizedPath === null) {
+                return null;
+            }
+            const filePath = path.resolve(resolvedRootDir, normalizedPath);
+            if (!filePath.startsWith(`${resolvedRootDir}${path.sep}`) && filePath !== resolvedRootDir) {
+                return null;
+            }
+            try {
+                const mediaType = getMediaTypeForPath(normalizedPath);
+                if (isLikelyTextPath(normalizedPath)) {
+                    const text = await readFile(filePath, 'utf8');
+                    return {
+                        path: normalizedPath,
+                        kind: 'text',
+                        mediaType,
+                        text,
+                    };
+                }
+                const bytes = new Uint8Array(await readFile(filePath));
+                return {
+                    path: normalizedPath,
+                    kind: 'binary',
+                    mediaType,
+                    bytes,
+                };
+            }
+            catch (error) {
+                if (isNodeNotFound(error)) {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        async listDirectory(contentPath) {
+            const normalizedPath = normalizeDirectoryPath(contentPath);
+            if (normalizedPath === null) {
+                return null;
+            }
+            const directoryPath = path.resolve(resolvedRootDir, normalizedPath);
+            if (!directoryPath.startsWith(`${resolvedRootDir}${path.sep}`) &&
+                directoryPath !== resolvedRootDir) {
+                return null;
+            }
+            try {
+                const entries = await readdir(directoryPath, { withFileTypes: true });
+                return entries
+                    .filter((entry) => !entry.name.startsWith('.'))
+                    .map((entry) => ({
+                    name: entry.name,
+                    path: normalizedPath === ''
+                        ? entry.name
+                        : `${normalizedPath}/${entry.name}`,
+                    kind: entry.isDirectory() ? 'directory' : 'file',
+                }))
+                    .sort((left, right) => {
+                    if (left.kind !== right.kind) {
+                        return left.kind === 'directory' ? -1 : 1;
+                    }
+                    return left.name.localeCompare(right.name);
+                });
+            }
+            catch (error) {
+                if (isNodeNotFound(error)) {
+                    return null;
+                }
+                throw error;
+            }
+        },
+    };
+}
+export function createNodeRequestListener(options) {
+    const store = createFileSystemContentStore(options.rootDir);
+    return async function onRequest(request, response) {
+        try {
+            const url = new URL(request.url ?? '/', 'http://localhost');
+            const siteResponse = await handleSiteRequest(store, url.pathname, {
+                draftMode: options.draftMode,
+                siteConfig: options.siteConfig,
+            });
+            response.statusCode = siteResponse.status;
+            for (const [headerName, headerValue] of Object.entries(siteResponse.headers)) {
+                response.setHeader(headerName, headerValue);
+            }
+            if (siteResponse.body instanceof Uint8Array) {
+                response.end(Buffer.from(siteResponse.body));
+                return;
+            }
+            response.end(siteResponse.body ?? '');
+        }
+        catch (error) {
+            response.statusCode = 500;
+            response.setHeader('content-type', 'text/plain; charset=utf-8');
+            response.end(error instanceof Error ? error.message : 'Unexpected server error');
+        }
+    };
+}
+export function createNodeServer(options) {
+    return createServer(createNodeRequestListener(options));
+}
+function isNodeNotFound(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}

package/dist/cli/build-cloudflare.d.ts

@@ -0,0 +1 @@
+export declare function runBuildCloudflareCommand(argv: string[]): Promise<void>;

package/dist/cli/build-cloudflare.js

@@ -0,0 +1,48 @@
+import path from 'node:path';
+import { createFileSystemContentStore } from '../adapters/node.js';
+import { writeCloudflareBundle } from '../cloudflare.js';
+import { applySiteConfigFrontmatterDefaults, loadSiteConfig, } from '../core/site-config.js';
+export async function runBuildCloudflareCommand(argv) {
+    const args = parseArgs(argv);
+    if (!args.root) {
+        console.error('Usage: mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config mdorigin.config.json]');
+        process.exitCode = 1;
+        return;
+    }
+    const rootDir = path.resolve(args.root);
+    const loadedSiteConfig = await loadSiteConfig({
+        cwd: process.cwd(),
+        rootDir,
+        configPath: args.config,
+    });
+    const store = createFileSystemContentStore(rootDir);
+    const siteConfig = await applySiteConfigFrontmatterDefaults(store, loadedSiteConfig);
+    const result = await writeCloudflareBundle({
+        rootDir,
+        outDir: path.resolve(args.out ?? 'dist/cloudflare'),
+        siteConfig,
+    });
+    console.log(`cloudflare worker written to ${result.workerFile}`);
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const nextValue = argv[index + 1];
+        if (argument === '--root' && nextValue) {
+            result.root = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--out' && nextValue) {
+            result.out = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--config' && nextValue) {
+            result.config = nextValue;
+            index += 1;
+        }
+    }
+    return result;
+}

package/dist/cli/build-index.d.ts

@@ -0,0 +1 @@
+export declare function runBuildIndexCommand(argv: string[]): Promise<void>;

package/dist/cli/build-index.js

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import { buildDirectoryIndexes } from '../index-builder.js';
+export async function runBuildIndexCommand(argv) {
+    const args = parseArgs(argv);
+    if (!args.root && !args.dir) {
+        console.error('Usage: mdorigin build index (--root <content-dir> | --dir <content-dir>)');
+        process.exitCode = 1;
+        return;
+    }
+    const result = await buildDirectoryIndexes({
+        rootDir: args.root ? path.resolve(args.root) : undefined,
+        dir: args.dir ? path.resolve(args.dir) : undefined,
+    });
+    console.log(`updated ${result.updatedFiles.length} index file(s)`);
+    if (result.skippedDirectories.length > 0) {
+        console.log(`skipped ${result.skippedDirectories.length} director${result.skippedDirectories.length === 1 ? 'y' : 'ies'} without index.md`);
+    }
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const nextValue = argv[index + 1];
+        if (argument === '--root' && nextValue) {
+            result.root = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--dir' && nextValue) {
+            result.dir = nextValue;
+            index += 1;
+        }
+    }
+    return result;
+}

package/dist/cli/dev.d.ts

@@ -0,0 +1 @@
+export declare function runDevCommand(argv: string[]): Promise<void>;

package/dist/cli/dev.js

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import { createFileSystemContentStore, createNodeServer } from '../adapters/node.js';
+import { applySiteConfigFrontmatterDefaults, loadSiteConfig, } from '../core/site-config.js';
+export async function runDevCommand(argv) {
+    const args = parseArgs(argv);
+    if (!args.root) {
+        console.error('Usage: mdorigin dev --root <content-dir> [--port 3000] [--config mdorigin.config.json]');
+        process.exitCode = 1;
+        return;
+    }
+    const rootDir = path.resolve(args.root);
+    const port = args.port ?? 3000;
+    const loadedSiteConfig = await loadSiteConfig({
+        cwd: process.cwd(),
+        rootDir,
+        configPath: args.config,
+    });
+    const store = createFileSystemContentStore(rootDir);
+    const siteConfig = await applySiteConfigFrontmatterDefaults(store, loadedSiteConfig);
+    const server = createNodeServer({
+        rootDir,
+        draftMode: 'include',
+        siteConfig,
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, () => resolve());
+    });
+    console.log(`mdorigin dev server listening on http://localhost:${port}`);
+    console.log(`content root: ${rootDir}`);
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const nextValue = argv[index + 1];
+        if (argument === '--root' && nextValue) {
+            result.root = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--port' && nextValue) {
+            result.port = Number.parseInt(nextValue, 10);
+            index += 1;
+            continue;
+        }
+        if (argument === '--config' && nextValue) {
+            result.config = nextValue;
+            index += 1;
+        }
+    }
+    return result;
+}

package/dist/cli/init-cloudflare.d.ts

@@ -0,0 +1 @@
+export declare function runInitCloudflareCommand(argv: string[]): Promise<void>;

package/dist/cli/init-cloudflare.js

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { initCloudflareProject } from '../cloudflare.js';
+export async function runInitCloudflareCommand(argv) {
+    const args = parseArgs(argv);
+    const projectDir = path.resolve(args.dir ?? '.');
+    const workerEntry = path.resolve(projectDir, args.entry ?? 'dist/cloudflare/worker.mjs');
+    const siteTitle = args.name ? undefined : await inferSiteTitleFromWorkerEntry(workerEntry);
+    const result = await initCloudflareProject({
+        projectDir,
+        workerEntry,
+        workerName: args.name,
+        siteTitle,
+        compatibilityDate: args.compatibilityDate,
+        force: args.force,
+    });
+    console.log(`wrangler config written to ${result.configFile}`);
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        const nextValue = argv[index + 1];
+        if (argument === '--dir' && nextValue) {
+            result.dir = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--entry' && nextValue) {
+            result.entry = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--name' && nextValue) {
+            result.name = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--compatibility-date' && nextValue) {
+            result.compatibilityDate = nextValue;
+            index += 1;
+            continue;
+        }
+        if (argument === '--force') {
+            result.force = true;
+        }
+    }
+    return result;
+}
+async function inferSiteTitleFromWorkerEntry(workerEntry) {
+    try {
+        const source = await readFile(workerEntry, 'utf8');
+        const match = source.match(/"siteTitle":\s*"([^"]+)"/);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cli/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/main.js

@@ -0,0 +1,38 @@
+import { runBuildIndexCommand } from './build-index.js';
+import { runBuildCloudflareCommand } from './build-cloudflare.js';
+import { runDevCommand } from './dev.js';
+import { runInitCloudflareCommand } from './init-cloudflare.js';
+async function main() {
+    const [command, subcommand, ...rest] = process.argv.slice(2);
+    if (command === 'dev') {
+        await runDevCommand([subcommand, ...rest].filter(isDefined));
+        return;
+    }
+    if (command === 'build' && subcommand === 'cloudflare') {
+        await runBuildCloudflareCommand(rest);
+        return;
+    }
+    if (command === 'build' && subcommand === 'index') {
+        await runBuildIndexCommand(rest);
+        return;
+    }
+    if (command === 'init' && subcommand === 'cloudflare') {
+        await runInitCloudflareCommand(rest);
+        return;
+    }
+    console.error([
+        'Usage:',
+        '  mdorigin dev --root <content-dir> [--port 3000] [--config mdorigin.config.json]',
+        '  mdorigin build index (--root <content-dir> | --dir <content-dir>)',
+        '  mdorigin build cloudflare --root <content-dir> [--out ./dist/cloudflare] [--config mdorigin.config.json]',
+        '  mdorigin init cloudflare [--dir .] [--entry ./dist/cloudflare/worker.mjs] [--name <worker-name>] [--compatibility-date 2026-03-20] [--force]',
+    ].join('\n'));
+    process.exitCode = 1;
+}
+void main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});
+function isDefined(value) {
+    return value !== undefined;
+}

package/dist/cloudflare-runtime.d.ts

@@ -0,0 +1,2 @@
+export { createCloudflareWorker } from './adapters/cloudflare.js';
+export type { CloudflareManifest, CloudflareManifestEntry, ExportedHandlerLike, } from './adapters/cloudflare.js';

package/dist/cloudflare-runtime.js

@@ -0,0 +1 @@
+export { createCloudflareWorker } from './adapters/cloudflare.js';

package/dist/cloudflare.d.ts

@@ -0,0 +1,31 @@
+import type { CloudflareManifest, CloudflareManifestEntry } from './adapters/cloudflare.js';
+import { createCloudflareWorker } from './adapters/cloudflare.js';
+import type { ResolvedSiteConfig } from './core/site-config.js';
+export { createCloudflareWorker };
+export type { CloudflareManifest, CloudflareManifestEntry };
+export interface BuildCloudflareManifestOptions {
+    rootDir: string;
+    siteConfig: ResolvedSiteConfig;
+}
+export interface WriteCloudflareBundleOptions {
+    rootDir: string;
+    outDir: string;
+    siteConfig: ResolvedSiteConfig;
+    packageImport?: string;
+}
+export interface InitCloudflareProjectOptions {
+    projectDir: string;
+    workerEntry: string;
+    workerName?: string;
+    siteTitle?: string;
+    compatibilityDate?: string;
+    force?: boolean;
+}
+export declare function buildCloudflareManifest(options: BuildCloudflareManifestOptions): Promise<CloudflareManifest>;
+export declare function writeCloudflareBundle(options: WriteCloudflareBundleOptions): Promise<{
+    manifest: CloudflareManifest;
+    workerFile: string;
+}>;
+export declare function initCloudflareProject(options: InitCloudflareProjectOptions): Promise<{
+    configFile: string;
+}>;

package/dist/cloudflare.js

@@ -0,0 +1,130 @@
+import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { createCloudflareWorker } from './adapters/cloudflare.js';
+import { getMediaTypeForPath, isLikelyTextPath, normalizeContentPath, } from './core/content-store.js';
+export { createCloudflareWorker };
+export async function buildCloudflareManifest(options) {
+    const rootDir = path.resolve(options.rootDir);
+    const files = await listFiles(rootDir);
+    const entries = [];
+    for (const filePath of files) {
+        const relativePath = path.relative(rootDir, filePath).replaceAll(path.sep, '/');
+        const normalizedPath = normalizeContentPath(relativePath);
+        if (normalizedPath === null) {
+            continue;
+        }
+        const mediaType = getMediaTypeForPath(normalizedPath);
+        if (isLikelyTextPath(normalizedPath)) {
+            entries.push({
+                path: normalizedPath,
+                kind: 'text',
+                mediaType,
+                text: await readFile(filePath, 'utf8'),
+            });
+            continue;
+        }
+        entries.push({
+            path: normalizedPath,
+            kind: 'binary',
+            mediaType,
+            base64: (await readFile(filePath)).toString('base64'),
+        });
+    }
+    entries.sort((left, right) => left.path.localeCompare(right.path));
+    return {
+        entries,
+        siteConfig: options.siteConfig,
+    };
+}
+export async function writeCloudflareBundle(options) {
+    const outDir = path.resolve(options.outDir);
+    const manifest = await buildCloudflareManifest({
+        rootDir: options.rootDir,
+        siteConfig: options.siteConfig,
+    });
+    const packageImport = options.packageImport ?? 'mdorigin/cloudflare-runtime';
+    const workerFile = path.join(outDir, 'worker.mjs');
+    const workerSource = [
+        `import { createCloudflareWorker } from '${packageImport}';`,
+        '',
+        `const manifest = ${JSON.stringify(manifest, null, 2)};`,
+        '',
+        'export default createCloudflareWorker(manifest);',
+        '',
+    ].join('\n');
+    await mkdir(outDir, { recursive: true });
+    await writeFile(workerFile, workerSource, 'utf8');
+    return {
+        manifest,
+        workerFile,
+    };
+}
+export async function initCloudflareProject(options) {
+    const projectDir = path.resolve(options.projectDir);
+    const configFile = path.join(projectDir, 'wrangler.jsonc');
+    const existing = await pathExists(configFile);
+    if (existing && !options.force) {
+        throw new Error(`Refusing to overwrite ${configFile}. Re-run with --force to replace it.`);
+    }
+    const workerName = options.workerName ??
+        slugifyWorkerName(options.siteTitle) ??
+        'mdorigin-site';
+    const compatibilityDate = options.compatibilityDate ?? '2026-03-20';
+    const wranglerConfig = [
+        '{',
+        '  "$schema": "./node_modules/wrangler/config-schema.json",',
+        `  "name": ${JSON.stringify(workerName)},`,
+        `  "main": ${JSON.stringify(toPosixPath(path.relative(projectDir, options.workerEntry)))},`,
+        `  "compatibility_date": ${JSON.stringify(compatibilityDate)},`,
+        '  "compatibility_flags": ["nodejs_compat"]',
+        '}',
+        '',
+    ].join('\n');
+    await mkdir(projectDir, { recursive: true });
+    await writeFile(configFile, wranglerConfig, 'utf8');
+    return { configFile };
+}
+async function listFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(fullPath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+function toPosixPath(filePath) {
+    return filePath.replaceAll(path.sep, '/');
+}
+function slugifyWorkerName(value) {
+    if (!value) {
+        return null;
+    }
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-');
+    return slug === '' ? null : slug;
+}