getfilepress 0.0.0 → 0.1.0

package/packages/app/src/lib/genie/store.ts

@@ -0,0 +1,217 @@
+import {
+	copyFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	rmSync,
+	writeFileSync
+} from 'node:fs';
+import { join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import type { DesignBrief, GenieActive, GenieVersionMeta } from './types.ts';
+
+const GENIE_DIR = '.filepress-genie';
+
+export function genieRoot(siteRoot: string): string {
+	return join(siteRoot, GENIE_DIR);
+}
+
+export function versionsDir(siteRoot: string): string {
+	return join(genieRoot(siteRoot), 'versions');
+}
+
+export function versionPath(siteRoot: string, id: string): string {
+	return join(versionsDir(siteRoot), id);
+}
+
+function ensureGenieDirs(siteRoot: string) {
+	mkdirSync(versionsDir(siteRoot), { recursive: true });
+}
+
+export function newVersionId(): string {
+	const ts = new Date().toISOString().replace(/[:.]/g, '-').replace(/Z$/, 'Z');
+	return `${ts}-${randomBytes(2).toString('hex')}`;
+}
+
+export function readJson<T>(path: string, fallback: T): T {
+	if (!existsSync(path)) return fallback;
+	try {
+		return JSON.parse(readFileSync(path, 'utf8')) as T;
+	} catch {
+		return fallback;
+	}
+}
+
+export function writeJson(path: string, data: unknown) {
+	mkdirSync(join(path, '..'), { recursive: true });
+	writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+
+export function getActive(siteRoot: string): GenieActive | null {
+	return readJson<GenieActive | null>(join(genieRoot(siteRoot), 'active.json'), null);
+}
+
+export function listVersions(siteRoot: string): GenieVersionMeta[] {
+	ensureGenieDirs(siteRoot);
+	const dir = versionsDir(siteRoot);
+	if (!existsSync(dir)) return [];
+	const out: GenieVersionMeta[] = [];
+	for (const id of readdirSync(dir)) {
+		const meta = readJson<GenieVersionMeta | null>(join(dir, id, 'meta.json'), null);
+		if (meta) out.push(meta);
+	}
+	return out.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+export function readVersionBrief(siteRoot: string, id: string): DesignBrief | null {
+	return readJson<DesignBrief | null>(join(versionPath(siteRoot, id), 'design-brief.json'), null);
+}
+
+export function readVersionTheme(siteRoot: string, id: string): string | null {
+	const p = join(versionPath(siteRoot, id), 'theme.css');
+	if (!existsSync(p)) return null;
+	return readFileSync(p, 'utf8');
+}
+
+export type SnapshotInput = {
+	id?: string;
+	label: string;
+	prompt?: string;
+	parentId?: string | null;
+	brief: DesignBrief;
+	themeCss: string;
+	steers?: Array<Record<string, unknown>>;
+	/** Absolute or site-relative files to copy into version images/ as basename */
+	imageFiles?: Array<{ absPath: string; destName: string }>;
+	attribution?: string;
+};
+
+export function writeSnapshot(siteRoot: string, input: SnapshotInput): GenieVersionMeta {
+	ensureGenieDirs(siteRoot);
+	const id = input.id || newVersionId();
+	const dir = versionPath(siteRoot, id);
+	mkdirSync(join(dir, 'images'), { recursive: true });
+
+	const meta: GenieVersionMeta = {
+		id,
+		createdAt: new Date().toISOString(),
+		parentId: input.parentId ?? getActive(siteRoot)?.versionId ?? null,
+		label: input.label,
+		starred: false,
+		prompt: input.prompt || '',
+		steers: input.steers || [],
+		inspireUrls: [],
+		llm: { used: false, model: null, host: null }
+	};
+
+	writeJson(join(dir, 'meta.json'), meta);
+	writeJson(join(dir, 'design-brief.json'), input.brief);
+	writeJson(join(dir, 'config-patch.json'), {});
+	writeFileSync(join(dir, 'theme.css'), input.themeCss);
+	if (input.attribution) {
+		writeFileSync(join(dir, 'attribution.md'), input.attribution);
+	}
+	for (const img of input.imageFiles || []) {
+		if (!existsSync(img.absPath)) continue;
+		copyFileSync(img.absPath, join(dir, 'images', img.destName));
+	}
+	return meta;
+}
+
+/** Copy version theme + images into the site working tree. */
+export function activateVersion(siteRoot: string, versionId: string): GenieActive {
+	const dir = versionPath(siteRoot, versionId);
+	if (!existsSync(join(dir, 'theme.css'))) {
+		throw new Error(`Unknown Genie version: ${versionId}`);
+	}
+
+	const themeCss = readFileSync(join(dir, 'theme.css'), 'utf8');
+	writeFileSync(join(siteRoot, 'theme.css'), themeCss);
+
+	const imgDir = join(dir, 'images');
+	const staticImg = join(siteRoot, 'static', 'images');
+	mkdirSync(staticImg, { recursive: true });
+	if (existsSync(imgDir)) {
+		for (const name of readdirSync(imgDir)) {
+			copyFileSync(join(imgDir, name), join(staticImg, name));
+		}
+	}
+
+	const attr = join(dir, 'attribution.md');
+	if (existsSync(attr)) {
+		mkdirSync(join(siteRoot, '.filepress-import'), { recursive: true });
+		copyFileSync(attr, join(siteRoot, '.filepress-import', 'IMAGE_ATTRIBUTION.md'));
+	}
+
+	const active: GenieActive = {
+		versionId,
+		activatedAt: new Date().toISOString()
+	};
+	writeJson(join(genieRoot(siteRoot), 'active.json'), active);
+	return active;
+}
+
+export function deleteVersion(siteRoot: string, versionId: string) {
+	if (versionId === 'baseline') {
+		throw new Error('Cannot delete the baseline version');
+	}
+	const active = getActive(siteRoot);
+	if (active?.versionId === versionId) {
+		throw new Error('Cannot delete the active version — activate another first');
+	}
+	const dir = versionPath(siteRoot, versionId);
+	if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+}
+
+export function ensureBaseline(
+	siteRoot: string,
+	opts: { brief: DesignBrief; themeCss: string }
+): GenieVersionMeta {
+	ensureGenieDirs(siteRoot);
+	const baselineDir = versionPath(siteRoot, 'baseline');
+	if (existsSync(join(baselineDir, 'meta.json'))) {
+		return readJson<GenieVersionMeta>(join(baselineDir, 'meta.json'), {
+			id: 'baseline',
+			createdAt: new Date().toISOString(),
+			parentId: null,
+			label: 'baseline',
+			starred: true,
+			prompt: '',
+			steers: [],
+			inspireUrls: [],
+			llm: { used: false, model: null, host: null }
+		});
+	}
+
+	// Capture current static chrome images if present
+	const imageFiles: SnapshotInput['imageFiles'] = [];
+	const staticImg = join(siteRoot, 'static', 'images');
+	if (existsSync(staticImg)) {
+		for (const name of readdirSync(staticImg)) {
+			if (!/\.(jpe?g|png|webp|gif|svg)$/i.test(name)) continue;
+			imageFiles.push({ absPath: join(staticImg, name), destName: name });
+		}
+	}
+
+	const meta = writeSnapshot(siteRoot, {
+		id: 'baseline',
+		label: 'baseline',
+		prompt: 'Snapshot of working tree before Genie edits',
+		parentId: null,
+		brief: opts.brief,
+		themeCss: opts.themeCss,
+		imageFiles,
+		steers: [{ type: 'baseline' }]
+	});
+	meta.starred = true;
+	writeJson(join(baselineDir, 'meta.json'), meta);
+
+	if (!getActive(siteRoot)) {
+		writeJson(join(genieRoot(siteRoot), 'active.json'), {
+			versionId: 'baseline',
+			activatedAt: new Date().toISOString()
+		});
+	}
+	return meta;
+}

package/packages/app/src/lib/genie/types.ts

@@ -0,0 +1,61 @@
+/** Mirrors @filepress/import DesignBrief — kept local so the panel never pulls Node import code. */
+export type DesignBrief = {
+	mood: string;
+	do: string[];
+	dont: string[];
+	tokens: {
+		accent: string;
+		accentStrong: string;
+		bg?: string;
+		ink?: string;
+		inkSoft?: string;
+		surface?: string;
+		rule?: string;
+		ruleStrong?: string;
+		accentWash?: string;
+	};
+	density: 'sparse' | 'balanced' | 'dense';
+	paletteMode?: 'dark' | 'light';
+	fonts?: {
+		serif: string;
+		sans: string;
+		mono: string;
+		googleHref: string | null;
+	};
+	hero?: 'editorial' | 'bold';
+	atmosphere?: 'none' | 'noise';
+	navStyle?: 'soft' | 'uppercase-tracked';
+	elevatedCards?: boolean;
+	images?: {
+		hero?: string | null;
+		header?: string | null;
+		background?: string | null;
+		logo?: string | null;
+		portrait?: string | null;
+	};
+	cssNotes: string[];
+};
+
+export type GenieVersionMeta = {
+	id: string;
+	createdAt: string;
+	parentId: string | null;
+	label: string;
+	starred: boolean;
+	prompt: string;
+	steers: Array<Record<string, unknown>>;
+	inspireUrls: string[];
+	llm: { used: boolean; model: string | null; host: string | null };
+};
+
+export type GenieActive = {
+	versionId: string;
+	activatedAt: string;
+};
+
+export type GenieSteerPatch = {
+	label?: string;
+	prompt?: string;
+	brief?: Partial<DesignBrief>;
+	activate?: boolean;
+};

package/packages/app/src/lib/pages.server.ts

@@ -0,0 +1,7 @@
+import { createPages } from '@filepress/core/server';
+import { getPagesDir } from './site.server';
+
+/** Bound to the active site's `pages/` (missing dir → empty). */
+export const pages = createPages({
+	pagesDir: getPagesDir()
+});

package/packages/app/src/lib/site.server.ts

@@ -0,0 +1,52 @@
+import { existsSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const appRoot = dirname(fileURLToPath(new URL('../..', import.meta.url)));
+const defaultSiteRoot = resolve(appRoot, '../../sites/demo');
+
+/**
+ * Resolve the active site root from FILEPRESS_SITE_ROOT (set by scripts/filepress.mjs).
+ * Falls back to sites/demo so `svelte-kit sync` / prepare can run without a site flag.
+ */
+export function getSiteRoot(): string {
+	const raw = process.env.FILEPRESS_SITE_ROOT?.trim();
+	const root = raw
+		? isAbsolute(raw)
+			? raw
+			: resolve(process.cwd(), raw)
+		: defaultSiteRoot;
+	if (!existsSync(root)) {
+		throw new Error(`Site root does not exist: ${root}`);
+	}
+	return root;
+}
+
+/** Absolute path to the site's posts/ directory (or FILEPRESS_CONTENT_DIR override). */
+export function getContentDir(): string {
+	const override = process.env.FILEPRESS_CONTENT_DIR?.trim();
+	if (override) {
+		return isAbsolute(override) ? override : resolve(getSiteRoot(), override);
+	}
+	return join(getSiteRoot(), 'posts');
+}
+
+/** Absolute path to the site's pages/ directory (static Markdown pages). */
+export function getPagesDir(): string {
+	return join(getSiteRoot(), 'pages');
+}
+
+/** Absolute path to filepress.config.ts at the site root. */
+export function getSiteConfigPath(): string {
+	return join(getSiteRoot(), 'filepress.config.ts');
+}
+
+/** Absolute path to the site's static/ assets (may not exist yet). */
+export function getSiteStaticDir(): string {
+	return join(getSiteRoot(), 'static');
+}
+
+/** Absolute path where adapter-static writes this site's build. */
+export function getSiteBuildDir(): string {
+	return join(getSiteRoot(), 'build');
+}

package/packages/app/src/lib/theme-entry.ts

@@ -0,0 +1,7 @@
+/**
+ * Essay chrome + fonts, then site theme.
+ * Site rules use higher-specificity selectors (`:root:root`, `header.site-header …`)
+ * so they win even if Vite emits Essay CSS after the site sheet.
+ */
+import '@filepress/core/theme';
+import '$site-theme';

package/packages/app/src/routes/+layout.svelte

@@ -0,0 +1,29 @@
+<script lang="ts">
+	import '$lib/theme-entry';
+	import criticalTheme from '$critical-theme';
+	import { SiteHeader, SiteFooter } from '@filepress/core';
+	import config from '$site-config';
+	import GenieHost from '$lib/genie/GenieHost.svelte';
+
+
+	let { children } = $props();
+</script>
+
+<svelte:head>
+	{#if criticalTheme}
+		{@html `<style data-filepress-critical>${criticalTheme}</style>`}
+	{/if}
+	<link rel="icon" href="/favicon.svg" />
+	<link rel="alternate" type="application/rss+xml" title={config.title} href="/rss.xml" />
+</svelte:head>
+
+<SiteHeader site={config} />
+
+<main class="wrap">
+	{@render children()}
+</main>
+
+<SiteFooter site={config} />
+
+<!-- Dev-only Genie Mode (tree-shaken when import.meta.env.DEV is false). -->
+<GenieHost />

package/packages/app/src/routes/+layout.ts

@@ -0,0 +1,10 @@
+import { dev } from '$app/environment';
+
+// Fully static site: prerender every route at build time (D2, adapter-static).
+export const prerender = true;
+export const trailingSlash = 'never';
+
+// Production ships plain HTML (no hydration). That avoids intermittent SvelteKit
+// "500 Internal Error" pages when CDN asset hashes race during deploys or when
+// client navigation can't load __data.json. Keep CSR in `pnpm dev` for Genie.
+export const csr = dev;

package/packages/app/src/routes/+page.server.ts

@@ -0,0 +1,28 @@
+import { error } from '@sveltejs/kit';
+import type { PageServerLoad } from './$types';
+import { content } from '$lib/content.server';
+import { pages } from '$lib/pages.server';
+import config from '$site-config';
+
+export const load: PageServerLoad = async () => {
+	if (config.homePage) {
+		const page = await pages.getRenderedPage(config.homePage);
+		if (!page) {
+			error(
+				500,
+				`homePage "${config.homePage}" not found — add pages/${config.homePage}.md`
+			);
+		}
+		return {
+			mode: 'page' as const,
+			page,
+			isDraft: page.draft
+		};
+	}
+
+	const index = content.getIndexPage(1, config.postsPerPage);
+	return {
+		mode: 'posts' as const,
+		...index
+	};
+};

package/packages/app/src/routes/+page.svelte

@@ -0,0 +1,67 @@
+<script lang="ts">
+	import type { PageData } from './$types';
+	import { PostIndex, absoluteUrl, ogImageUrl, postsIndexPath } from '@filepress/core';
+	import config from '$site-config';
+
+	let { data }: { data: PageData } = $props();
+
+	const isHomePage = $derived(data.mode === 'page');
+	const page = $derived(data.mode === 'page' ? data.page : null);
+	const canonical = $derived(absoluteUrl(config, '/'));
+	const ogImage = $derived(ogImageUrl(config));
+	const description = $derived(
+		(page?.description || config.description || '').trim() || null
+	);
+</script>
+
+<svelte:head>
+	<title>{config.title}</title>
+	{#if description}
+		<meta name="description" content={description} />
+	{/if}
+	{#if isHomePage}
+		<link rel="canonical" href={canonical} />
+		<meta property="og:type" content="website" />
+		<meta property="og:title" content={config.title} />
+		{#if description}
+			<meta property="og:description" content={description} />
+		{/if}
+		<meta property="og:url" content={canonical} />
+		{#if ogImage}
+			<meta property="og:image" content={ogImage} />
+			<meta name="twitter:card" content="summary" />
+			<meta name="twitter:image" content={ogImage} />
+		{/if}
+		{#if data.mode === 'page' && data.isDraft}
+			<meta name="robots" content="noindex" />
+		{/if}
+	{/if}
+</svelte:head>
+
+{#if data.mode === 'page' && page}
+	<article class="static-page home-page">
+		<header class="page-header">
+			{#if data.isDraft}
+				<p class="draft-banner">
+					Draft — shown in local listings; excluded from production sitemap.
+				</p>
+			{/if}
+			{#if config.lede}
+				<p class="hero-lede">{config.lede}</p>
+			{/if}
+			<h1>{page.title}</h1>
+		</header>
+
+		<div class="prose">{@html page.html}</div>
+	</article>
+{:else if data.mode === 'posts'}
+	<PostIndex
+		site={config}
+		hero
+		featured={data.featured}
+		posts={data.posts}
+		page={data.page}
+		totalPages={data.totalPages}
+		indexHref={postsIndexPath(config)}
+	/>
+{/if}

package/packages/app/src/routes/[slug]/+page.server.ts

@@ -0,0 +1,20 @@
+import { error } from '@sveltejs/kit';
+import type { EntryGenerator, PageServerLoad } from './$types';
+import { pages } from '$lib/pages.server';
+
+export const prerender = true;
+
+export const entries: EntryGenerator = () => {
+	return pages.getBuildableSlugs().map((slug) => ({ slug }));
+};
+
+export const load: PageServerLoad = async ({ params }) => {
+	const page = await pages.getRenderedPage(params.slug);
+	if (!page) error(404, `Page not found: ${params.slug}`);
+
+	const isDraft = page.draft;
+	return {
+		page,
+		isDraft
+	};
+};

package/packages/app/src/routes/[slug]/+page.svelte

@@ -0,0 +1,47 @@
+<script lang="ts">
+	import type { PageData } from './$types';
+	import { absoluteUrl, ogImageUrl } from '@filepress/core';
+	import config from '$site-config';
+
+	let { data }: { data: PageData } = $props();
+
+	const page = $derived(data.page);
+	const pageTitle = $derived(`${page.title} — ${config.title}`);
+	const canonical = $derived(absoluteUrl(config, `/${page.slug}`));
+	const ogImage = $derived(ogImageUrl(config));
+</script>
+
+<svelte:head>
+	<title>{pageTitle}</title>
+	{#if page.description}
+		<meta name="description" content={page.description} />
+	{/if}
+	<link rel="canonical" href={canonical} />
+	<meta property="og:type" content="website" />
+	<meta property="og:title" content={page.title} />
+	{#if page.description}
+		<meta property="og:description" content={page.description} />
+	{/if}
+	<meta property="og:url" content={canonical} />
+	{#if ogImage}
+		<meta property="og:image" content={ogImage} />
+		<meta name="twitter:card" content="summary" />
+		<meta name="twitter:image" content={ogImage} />
+	{/if}
+	{#if data.isDraft}
+		<meta name="robots" content="noindex" />
+	{/if}
+</svelte:head>
+
+<article class="static-page">
+	<header class="page-header">
+		{#if data.isDraft}
+			<p class="draft-banner">
+				Draft — shown in local listings; excluded from production sitemap.
+			</p>
+		{/if}
+		<h1>{page.title}</h1>
+	</header>
+
+	<div class="prose">{@html page.html}</div>
+</article>

package/packages/app/src/routes/page/[n]/+page.server.ts

@@ -0,0 +1,21 @@
+import type { EntryGenerator, PageServerLoad } from './$types';
+import { error } from '@sveltejs/kit';
+import { content } from '$lib/content.server';
+import config from '$site-config';
+
+// Page 1 lives at "/"; this route covers pages 2..N only.
+export const entries: EntryGenerator = () => {
+	const count = content.getIndexPageCount(config.postsPerPage);
+	const pages: { n: string }[] = [];
+	for (let n = 2; n <= count; n++) pages.push({ n: String(n) });
+	return pages;
+};
+
+export const load: PageServerLoad = ({ params }) => {
+	const n = Number(params.n);
+	const totalPages = content.getIndexPageCount(config.postsPerPage);
+	if (!Number.isInteger(n) || n < 2 || n > totalPages) {
+		error(404, `No such page "${params.n}".`);
+	}
+	return content.getIndexPage(n, config.postsPerPage);
+};

package/packages/app/src/routes/page/[n]/+page.svelte

@@ -0,0 +1,36 @@
+<script lang="ts">
+	import type { PageData } from './$types';
+	import { PostIndex, absoluteUrl, ogImageUrl, postsIndexPath } from '@filepress/core';
+	import config from '$site-config';
+
+	let { data }: { data: PageData } = $props();
+
+	const pageTitle = $derived(`Posts — page ${data.page} — ${config.title}`);
+	const canonical = $derived(absoluteUrl(config, `/page/${data.page}`));
+	const ogImage = $derived(ogImageUrl(config));
+	const description = $derived(`More posts from ${config.title}.`);
+</script>
+
+<svelte:head>
+	<title>{pageTitle}</title>
+	<meta name="description" content={description} />
+	<link rel="canonical" href={canonical} />
+	<meta property="og:type" content="website" />
+	<meta property="og:title" content={pageTitle} />
+	<meta property="og:description" content={description} />
+	<meta property="og:url" content={canonical} />
+	{#if ogImage}
+		<meta property="og:image" content={ogImage} />
+		<meta name="twitter:card" content="summary" />
+		<meta name="twitter:image" content={ogImage} />
+	{/if}
+</svelte:head>
+
+<PostIndex
+	site={config}
+	featured={data.featured}
+	posts={data.posts}
+	page={data.page}
+	totalPages={data.totalPages}
+	indexHref={postsIndexPath(config)}
+/>

package/packages/app/src/routes/posts/[slug]/+page.server.ts

@@ -0,0 +1,24 @@
+import type { EntryGenerator, PageServerLoad } from './$types';
+import { error } from '@sveltejs/kit';
+import { content } from '$lib/content.server';
+
+// Build a page for every published post plus every draft (drafts are unlinked
+// but reachable by direct URL for preview, D7). Future-dated posts are excluded.
+export const entries: EntryGenerator = () => {
+	return content.getBuildableSlugs().map((slug) => ({ slug }));
+};
+
+export const load: PageServerLoad = async ({ params }) => {
+	const post = await content.getRenderedPost(params.slug);
+	if (!post) {
+		error(404, `No post found for "${params.slug}".`);
+	}
+	const isDraft = content.loadPostSources().some((p) => p.slug === params.slug && p.draft);
+	const adjacent = content.getAdjacentPosts(params.slug);
+	// Tag pages come from listed posts. In production that means published only,
+	// so a draft can be the only carrier of a tag. Those render unlinked;
+	// linking them would 404 and fail prerendering.
+	const paged = new Set(content.getAllTags().map((t) => t.tag));
+	const tags = post.tags.map((tag) => ({ tag, hasPage: paged.has(tag) }));
+	return { post, isDraft, adjacent, tags };
+};