meowpress 0.3.0-alpha.2 → 0.3.0-alpha.4

package/dist/src/content.js

@@ -1,7 +1,7 @@
 import { compile, run } from "@mdx-js/mdx";
 import remarkGfm from "remark-gfm";
-import { readdir, readFile, stat } from "node:fs/promises";
-import { relative, resolve, sep } from "node:path";
+import { lstat, readdir, readFile, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { Fragment, h } from "meowjsx/runtime";
 import { renderToHtml } from "meowjsx/web";
@@ -42,16 +42,24 @@ function parseDate(value) {
 function makeDateKey(value, date) {
     const text = asText(value);
     const explicitDate = text?.match(/^\d{4}-\d{2}-\d{2}/)?.[0];
-    if (explicitDate)
-        return explicitDate;
+    if (explicitDate) {
+        const parsed = new Date(`${explicitDate}T00:00:00Z`);
+        if (!Number.isNaN(parsed.getTime()) && parsed.toISOString().startsWith(explicitDate)) {
+            return explicitDate;
+        }
+    }
     if (!date)
         return "undated";
-    return new Intl.DateTimeFormat("en-CA", {
+    const parts = new Intl.DateTimeFormat("en-US", {
         timeZone: "Asia/Shanghai",
         year: "numeric",
         month: "2-digit",
         day: "2-digit",
-    }).format(date);
+    }).formatToParts(date);
+    const year = parts.find((part) => part.type === "year").value;
+    const month = parts.find((part) => part.type === "month").value;
+    const day = parts.find((part) => part.type === "day").value;
+    return `${year.padStart(4, "0")}-${month}-${day}`;
 }
 function makeTimeLabel(value, date) {
     const text = asText(value);
@@ -126,14 +134,14 @@ async function renderMdx(source, components) {
     return renderToHtml(component({ components: { ...MDX_COMPONENTS, ...components } }));
 }
 async function renderSource(source, sourcePath, components) {
-    if (sourcePath.endsWith(".md")) {
+    if (sourcePath.toLowerCase().endsWith(".md")) {
         return Bun.markdown.html(source, {
             tagFilter: true,
         });
     }
     return renderMdx(source, components);
 }
-async function collectFiles(directory) {
+async function collectFiles(directory, assetRoots, skipNestedAssets) {
     const entries = await readdir(directory, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
@@ -141,10 +149,13 @@ async function collectFiles(directory) {
             continue;
         const entryPath = resolve(directory, entry.name);
         if (entry.isDirectory()) {
-            files.push(...(await collectFiles(entryPath)));
+            if (assetRoots.has(entryPath) || (skipNestedAssets && entry.name === "assets"))
+                continue;
+            files.push(...(await collectFiles(entryPath, assetRoots, skipNestedAssets)));
             continue;
         }
-        if (CONTENT_EXTENSIONS.has(entry.name.slice(entry.name.lastIndexOf(".")))) {
+        const extension = entry.name.slice(entry.name.lastIndexOf(".")).toLowerCase();
+        if (entry.isFile() && CONTENT_EXTENSIONS.has(extension)) {
             files.push(entryPath);
         }
     }
@@ -164,39 +175,90 @@ function makeSlug(sourcePath, sectionDirectory) {
         .join("/");
 }
 function normalizeSlugPrefix(prefix) {
-    return (prefix ?? "")
+    const normalized = (prefix ?? "")
         .replaceAll("\\", "/")
         .replace(/^\/+|\/+$/g, "")
         .replaceAll(/\/+/g, "/");
+    if (normalized.split("/").some((segment) => segment === "." || segment === "..")) {
+        throw new Error(`Content slug prefix must not contain "." or "..": ${prefix}`);
+    }
+    return normalized;
 }
 function withSlugPrefix(prefix, slug) {
     const normalizedPrefix = normalizeSlugPrefix(prefix);
     return normalizedPrefix ? `${normalizedPrefix}/${slug}` : slug;
 }
-export function normalizeContentSources(input) {
+export function normalizeContentSources(input, baseDirectory = process.cwd()) {
     const sources = Array.isArray(input) ? input : [input];
     return sources.map((source) => {
         const normalized = typeof source === "string" ? { directory: source } : source;
+        const directory = resolve(baseDirectory, normalized.directory);
+        for (const mapping of [
+            normalized.postsDirectory,
+            normalized.thoughtsDirectory,
+            normalized.assetsDirectory,
+            normalized.postAssetsDirectory,
+        ]) {
+            if (mapping !== undefined)
+                sourceDirectory(directory, mapping);
+        }
         return {
-            directory: resolve(normalized.directory),
+            ...normalized,
+            directory,
             slugPrefix: normalizeSlugPrefix(normalized.slugPrefix) || undefined,
         };
     });
 }
-function duplicateContentError(kind, slug) {
-    return new Error(`Duplicate ${kind} slug "${slug}" while merging content sources.`);
+function sourceDirectory(root, path) {
+    const target = resolve(root, path);
+    const local = relative(root, target);
+    if (isAbsolute(path) || local === ".." || local.startsWith(`..${sep}`) || isAbsolute(local)) {
+        throw new Error(`Content directory must stay inside its source root: ${path}`);
+    }
+    return target;
 }
-async function loadSectionFromSource(source, kind, options) {
-    const sectionDirectory = resolve(source.directory, `${kind}s`);
-    let sourceFiles;
+/** Check every segment below a source root before walking a configured directory. */
+async function isSourceDirectory(root, target) {
     try {
-        sourceFiles = await collectFiles(sectionDirectory);
+        let path = root;
+        if (!(await lstat(path)).isDirectory())
+            return false;
+        for (const segment of relative(root, target).split(sep).filter(Boolean)) {
+            path = resolve(path, segment);
+            if (!(await lstat(path)).isDirectory())
+                return false;
+        }
+        return true;
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return [];
+            return false;
         throw error;
     }
+}
+function assetDirectory(source, directory) {
+    const mapping = directory === "assets"
+        ? source.assetsDirectory
+        : directory === "posts/assets"
+            ? source.postAssetsDirectory
+            : undefined;
+    return sourceDirectory(source.directory, mapping ?? directory);
+}
+function duplicateContentError(kind, slug) {
+    return new Error(`Duplicate ${kind} slug "${slug}" while merging content sources.`);
+}
+async function loadSectionFromSource(source, kind, options) {
+    const mapping = kind === "post" ? source.postsDirectory : source.thoughtsDirectory;
+    const sectionDirectory = sourceDirectory(source.directory, mapping ?? `${kind}s`);
+    if (!(await isSourceDirectory(source.directory, sectionDirectory)))
+        return [];
+    const assetRoots = new Set([
+        assetDirectory(source, "assets"),
+        assetDirectory(source, "posts/assets"),
+    ]);
+    if (assetRoots.has(sectionDirectory))
+        return [];
+    const sourceFiles = await collectFiles(sectionDirectory, assetRoots, mapping !== undefined);
     const items = [];
     for (const sourcePath of sourceFiles) {
         if (isDraft(sourcePath, sectionDirectory, kind))
@@ -278,7 +340,7 @@ async function collectFilesForAssets(directory) {
         if (entry.isDirectory()) {
             files.push(...(await collectFilesForAssets(entryPath)));
         }
-        else {
+        else if (entry.isFile()) {
             files.push(entryPath);
         }
     }
@@ -289,7 +351,9 @@ export async function collectContentAssets(sources, options = {}) {
     const duplicatePolicy = options.duplicate ?? "first-wins";
     const assets = new Map();
     for (const source of normalizeContentSources(sources)) {
-        const assetRoot = resolve(source.directory, directory);
+        const assetRoot = assetDirectory(source, directory);
+        if (!(await isSourceDirectory(source.directory, assetRoot)))
+            continue;
         const sourceFiles = await collectAssetFiles(assetRoot);
         for (const sourcePath of sourceFiles) {
             const localPath = relative(assetRoot, sourcePath).split(sep).join("/");

package/dist/src/fonts.js

@@ -7,7 +7,7 @@ export const FONT_DIRECTORY = "fonts";
 export const FONT_EXTERNAL = `./${FONT_DIRECTORY}/*`;
 /**
  * Resolve a package file from the site first (where a host installs its theme's fonts), then from
- * this package (which carries the default Geist).
+ * this package (which carries the default Journal fonts).
  */
 function resolveFontFile(specifier) {
     for (const from of [process.cwd(), dirname(fileURLToPath(import.meta.url))]) {

package/dist/src/identity.d.ts

@@ -14,6 +14,12 @@ export interface SiteAbout {
     linksHeading?: string;
     links?: readonly SiteProfileLink[];
 }
+/** Optional copy for the built-in 404 page. */
+export interface SiteNotFound {
+    title?: string;
+    message?: string;
+    homeLabel?: string;
+}
 /** Site-owned identity and copy. The application supplies it; the library keeps neutral defaults. */
 export interface SiteIdentity {
     /** Display name used in header, footer and document titles. */

package/dist/src/index.d.ts

@@ -2,6 +2,6 @@ export { collectContentAssets, collectAssetFiles, isDraftAsset, loadSection, nor
 export { buildSite, meowSite, type ResolvedSiteConfig, type SiteConfig } from "./build.js";
 export { aboutPage, agentMarkdown, homePage, listPage, llmText, postPage, skillPage, skillsIndexPage, thoughtPage, } from "./site.js";
 export { DEFAULT_SITE, type SiteAbout, type SiteIdentity, type SiteProfileLink } from "./identity.js";
-export { blogFonts, blogTheme, blogTokens, blogOptions } from "./theme.js";
+export { blogFonts, blogTheme } from "./theme.js";
 export type { SiteFont } from "./fonts.js";
 export { loadSkills, type LoadSkillsOptions, type Skill, type SkillFile, type SkillScope, } from "./skills.js";

package/dist/src/index.js

@@ -2,5 +2,5 @@ export { collectContentAssets, collectAssetFiles, isDraftAsset, loadSection, nor
 export { buildSite, meowSite } from "./build.js";
 export { aboutPage, agentMarkdown, homePage, listPage, llmText, postPage, skillPage, skillsIndexPage, thoughtPage, } from "./site.js";
 export { DEFAULT_SITE } from "./identity.js";
-export { blogFonts, blogTheme, blogTokens, blogOptions } from "./theme.js";
+export { blogFonts, blogTheme } from "./theme.js";
 export { loadSkills, } from "./skills.js";

package/dist/src/output.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedSiteConfig } from "./build.js";
+export declare function validateOutputDirectory(config: ResolvedSiteConfig): Promise<void>;
+/** Both agent indexes have been emitted by Meowpress since before the conventional CLI. */
+export declare function hasBuiltSite(directory: string): Promise<boolean>;
+export declare function validateBuildDestination(directory: string): Promise<void>;
+/** Move a complete build into place and preserve any previous build if that move fails. */
+export declare function publishSite(staged: string, destination: string): Promise<void>;

package/dist/src/output.js

@@ -0,0 +1,111 @@
+import { lstat, mkdtemp, readdir, realpath, rename, rm } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { normalizeContentSources } from "./content.js";
+function isMissing(error) {
+    return error.code === "ENOENT";
+}
+async function existingPath(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (!isMissing(error))
+            throw error;
+        return undefined;
+    }
+}
+/** Resolve symlinked ancestors even if the output directory has not been created yet. */
+async function filesystemPath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch (error) {
+        if (!isMissing(error))
+            throw error;
+        return join(await filesystemPath(dirname(path)), basename(path));
+    }
+}
+function containsPath(directory, path) {
+    const fromDirectory = relative(directory, path);
+    return (!isAbsolute(fromDirectory) && fromDirectory !== ".." && !fromDirectory.startsWith(`..${sep}`));
+}
+export async function validateOutputDirectory(config) {
+    const project = process.cwd();
+    const sources = normalizeContentSources(config.content);
+    const sourceRoots = [
+        project,
+        config.skillsDirectory,
+        ...sources.map((source) => source.directory),
+    ];
+    if (config.projectRootDirectory)
+        sourceRoots.push(config.projectRootDirectory);
+    const inputs = sources.flatMap((source) => [
+        resolve(source.directory, source.postsDirectory ?? "posts"),
+        resolve(source.directory, source.thoughtsDirectory ?? "thoughts"),
+        resolve(source.directory, source.assetsDirectory ?? "assets"),
+        resolve(source.directory, source.postAssetsDirectory ?? "posts/assets"),
+    ]);
+    inputs.push(join(config.skillsDirectory, "skills"), join(project, ".agents"), join(project, ".git"));
+    if (config.includeProjectSkills)
+        inputs.push(join(config.projectRootDirectory ?? config.skillsDirectory, ".agents/skills"));
+    const [output, roots, directories] = await Promise.all([
+        filesystemPath(config.outputDirectory),
+        Promise.all(sourceRoots.map(filesystemPath)),
+        Promise.all(inputs.map(filesystemPath)),
+    ]);
+    if (roots.some((root) => containsPath(output, root)) ||
+        directories.some((input) => containsPath(output, input) || containsPath(input, output))) {
+        throw new Error(`Output directory overlaps project files: ${config.outputDirectory}`);
+    }
+    const info = await existingPath(config.outputDirectory);
+    if (info && !info.isDirectory())
+        throw new Error(`Site output must be a directory: ${config.outputDirectory}`);
+}
+/** Both agent indexes have been emitted by Meowpress since before the conventional CLI. */
+export async function hasBuiltSite(directory) {
+    const markers = await Promise.all(["agents.md", "llms.txt"].map((name) => existingPath(join(directory, name))));
+    return markers.every((marker) => marker?.isFile());
+}
+export async function validateBuildDestination(directory) {
+    if (directory === resolve("dist") &&
+        (await existingPath(directory)) &&
+        (await readdir(directory)).length &&
+        !(await hasBuiltSite(directory))) {
+        throw new Error(`Refusing to replace existing files in ${directory}. Move them or choose another outputDirectory.`);
+    }
+}
+/** Move a complete build into place and preserve any previous build if that move fails. */
+export async function publishSite(staged, destination) {
+    const existing = await existingPath(destination);
+    if (!existing) {
+        await rename(staged, destination);
+        return;
+    }
+    if (!existing.isDirectory())
+        throw new Error(`Site output must be a directory: ${destination}`);
+    const backupDirectory = await mkdtemp(join(dirname(destination), ".meowpress-previous-"));
+    const backup = join(backupDirectory, basename(destination));
+    let restoreFailed = false;
+    try {
+        await rename(destination, backup);
+        try {
+            await rename(staged, destination);
+        }
+        catch (error) {
+            try {
+                await rename(backup, destination);
+            }
+            catch {
+                restoreFailed = true;
+                throw new Error(`Could not replace ${destination}. Previous output remains in ${backup}.`, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+    finally {
+        if (!restoreFailed)
+            await rm(backupDirectory, { recursive: true, force: true });
+    }
+}

package/dist/src/preview.d.ts

@@ -0,0 +1 @@
+export declare function serveSite(outputDirectory: string, port?: number): Promise<Bun.Server<undefined>>;

package/dist/src/preview.js

@@ -0,0 +1,61 @@
+import { realpath, stat } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
+async function statIfPresent(path) {
+    try {
+        return await stat(path);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return undefined;
+        throw error;
+    }
+}
+export async function serveSite(outputDirectory, port = 4173) {
+    if (!(await statIfPresent(outputDirectory))?.isDirectory()) {
+        throw new Error(`Built site not found at ${outputDirectory}. Run meowpress build first.`);
+    }
+    const root = await realpath(outputDirectory);
+    const isInside = (path) => path === root || path.startsWith(root + sep);
+    async function fileResponse(path, method, status) {
+        if (!(await statIfPresent(path))?.isFile())
+            return undefined;
+        const target = await realpath(path);
+        if (!isInside(target))
+            return undefined;
+        const file = Bun.file(target);
+        return new Response(method === "HEAD" ? null : file, {
+            status,
+            headers: { "Content-Type": file.type, "Cache-Control": "no-store" },
+        });
+    }
+    return Bun.serve({
+        hostname: "127.0.0.1",
+        port,
+        async fetch(request) {
+            if (request.method !== "GET" && request.method !== "HEAD")
+                return new Response("Method not allowed", { status: 405, headers: { Allow: "GET, HEAD" } });
+            const url = new URL(request.url);
+            let pathname;
+            try {
+                pathname = decodeURIComponent(url.pathname);
+            }
+            catch {
+                return new Response("Invalid path", { status: 400 });
+            }
+            if (pathname.includes("\0"))
+                return new Response("Invalid path", { status: 400 });
+            const target = resolve(root, `.${pathname}`);
+            if (!isInside(target))
+                return new Response("Forbidden", { status: 403 });
+            if (!pathname.endsWith("/") && (await statIfPresent(target))?.isDirectory()) {
+                url.pathname += "/";
+                return Response.redirect(url, 301);
+            }
+            const path = pathname.endsWith("/") ? join(target, "index.html") : target;
+            return ((await fileResponse(path, request.method, 200)) ??
+                (await fileResponse(join(root, "404.html"), request.method, 404)) ??
+                new Response(request.method === "HEAD" ? null : "Page not found", { status: 404 }));
+        },
+    });
+}

package/dist/src/site.d.ts

@@ -1,18 +1,19 @@
 import { type ThemeDefinition } from "meowcss";
 import { type ContentItem } from "./content.js";
-import { type SiteIdentity } from "./identity.js";
+import { type SiteIdentity, type SiteNotFound } from "./identity.js";
 import { type SitePage } from "./pages.js";
 import type { Skill } from "./skills.js";
 /** The name of the theme stylesheet the package writes by default. */
 export declare const DEFAULT_THEME_STYLESHEET = "blog-theme.css";
 export declare function homePage(items: ContentItem[], theme?: ThemeDefinition, site?: SiteIdentity, stylesheet?: string): string;
 export declare function listPage(kind: "post" | "thought", items: ContentItem[], theme?: ThemeDefinition, site?: SiteIdentity, stylesheet?: string): string;
+export declare function notFoundPage(copy: SiteNotFound, theme: ThemeDefinition, site: SiteIdentity, stylesheet: string): string;
 export declare function postPage(item: ContentItem, posts: ContentItem[], thoughts: ContentItem[], theme?: ThemeDefinition, site?: SiteIdentity, stylesheet?: string): string;
 export declare function thoughtPage(item: ContentItem, theme?: ThemeDefinition, site?: SiteIdentity, stylesheet?: string): string;
 export declare function aboutPage(theme?: ThemeDefinition, site?: SiteIdentity, stylesheet?: string): string;
 export declare function skillsIndexPage(skills: Skill[], theme?: ThemeDefinition, site?: SiteIdentity, stylesheet?: string): string;
 export declare function skillPage(skill: Skill, theme?: ThemeDefinition, site?: SiteIdentity, stylesheet?: string): string;
-export declare function agentMarkdown(posts: ContentItem[], thoughts: ContentItem[], site?: SiteIdentity, pages?: readonly SitePage[]): string;
+export declare function agentMarkdown(posts: ContentItem[], thoughts: ContentItem[], site?: SiteIdentity, pages?: readonly SitePage[], mappedSections?: boolean): string;
 export declare function llmText(posts: ContentItem[], thoughts: ContentItem[], site?: SiteIdentity, pages?: readonly SitePage[], agentGuide?: string): string;
 /**
  * Every page's Markdown in one file, after the same summary and guide as llms.txt. Pages without