@sourcepress/astro 0.1.0

package/src/client.ts

@@ -0,0 +1,54 @@
+import type { ComponentDefinition, ContentListResponse, SchemaResponse } from "./types.js";
+
+export class EngineClientError extends Error {
+	constructor(
+		message: string,
+		public readonly status: number,
+		public readonly body: string,
+	) {
+		super(message);
+		this.name = "EngineClientError";
+	}
+}
+
+export class EngineClient {
+	constructor(private readonly engineUrl: string) {}
+
+	async fetchSchema(): Promise<SchemaResponse> {
+		const res = await fetch(`${this.engineUrl}/api/schema`);
+		if (!res.ok) {
+			const body = await res.text();
+			throw new EngineClientError(`fetchSchema failed with status ${res.status}`, res.status, body);
+		}
+		return res.json() as Promise<SchemaResponse>;
+	}
+
+	async fetchContent(collection: string): Promise<ContentListResponse> {
+		const res = await fetch(`${this.engineUrl}/api/content/${collection}`);
+		if (!res.ok) {
+			const body = await res.text();
+			throw new EngineClientError(
+				`fetchContent(${collection}) failed with status ${res.status}`,
+				res.status,
+				body,
+			);
+		}
+		return res.json() as Promise<ContentListResponse>;
+	}
+
+	async registerComponents(components: Record<string, ComponentDefinition>): Promise<void> {
+		const res = await fetch(`${this.engineUrl}/api/schema/components`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(components),
+		});
+		if (!res.ok) {
+			const body = await res.text();
+			throw new EngineClientError(
+				`registerComponents failed with status ${res.status}`,
+				res.status,
+				body,
+			);
+		}
+	}
+}

package/src/component-registry.ts

@@ -0,0 +1,19 @@
+import type { EngineClient } from "./client.js";
+import type { ComponentDefinition } from "./types.js";
+
+export class ComponentRegistry {
+	constructor(
+		private client: EngineClient,
+		private components: Record<string, ComponentDefinition>,
+	) {}
+
+	/** POST components to engine so AI clients can query them */
+	async register(): Promise<void> {
+		await this.client.registerComponents(this.components);
+	}
+
+	/** Return component definitions for local dev endpoint */
+	getSchema(): Record<string, ComponentDefinition> {
+		return this.components;
+	}
+}

package/src/content-syncer.ts

@@ -0,0 +1,110 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { EngineClient } from "./client.js";
+
+export interface SyncResult {
+	synced: number;
+	collections: Record<string, number>;
+	errors: string[];
+}
+
+export interface FsOperations {
+	mkdir: (path: string, options?: { recursive?: boolean }) => Promise<void>;
+	writeFile: (path: string, content: string, encoding: string) => Promise<void>;
+}
+
+function serializeFrontmatter(frontmatter: Record<string, unknown>): string {
+	const lines: string[] = [];
+	for (const [key, value] of Object.entries(frontmatter)) {
+		if (typeof value === "string") {
+			// Quote strings that contain special YAML characters
+			const needsQuotes = /[:#\[\]{}&*!,|>'"?]/.test(value) || value.includes("\n");
+			lines.push(needsQuotes ? `${key}: ${JSON.stringify(value)}` : `${key}: ${value}`);
+		} else if (value === null || value === undefined) {
+			lines.push(`${key}: null`);
+		} else if (typeof value === "boolean" || typeof value === "number") {
+			lines.push(`${key}: ${value}`);
+		} else {
+			lines.push(`${key}: ${JSON.stringify(value)}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+export class ContentSyncer {
+	private fs: FsOperations;
+
+	constructor(
+		private client: EngineClient,
+		private srcDir: string,
+		private contentDir: string,
+		fs?: FsOperations,
+	) {
+		this.fs = fs ?? {
+			mkdir: async (path, options) => {
+				await mkdir(path, options);
+			},
+			writeFile: (path, content, encoding) => writeFile(path, content, encoding as BufferEncoding),
+		};
+	}
+
+	async sync(collections: string[]): Promise<SyncResult> {
+		const result: SyncResult = {
+			synced: 0,
+			collections: {},
+			errors: [],
+		};
+
+		for (const collection of collections) {
+			let count = 0;
+			try {
+				const contentList = await this.client.fetchContent(collection);
+				const collectionDir = join(this.srcDir, this.contentDir, collection);
+
+				await this.fs.mkdir(collectionDir, { recursive: true });
+
+				for (const item of contentList.items) {
+					try {
+						const ext = this.resolveExtension(item.path);
+						const filePath = join(collectionDir, `${item.slug}.${ext}`);
+						const fileContent = this.renderFile(item.frontmatter, item.body, ext);
+						await this.fs.writeFile(filePath, fileContent, "utf-8");
+						count++;
+					} catch (err) {
+						const msg = err instanceof Error ? err.message : String(err);
+						result.errors.push(`${collection}/${item.slug}: ${msg}`);
+					}
+				}
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				result.errors.push(`${collection}: ${msg}`);
+			}
+
+			result.collections[collection] = count;
+			result.synced += count;
+		}
+
+		return result;
+	}
+
+	private resolveExtension(path: string): string {
+		const match = path.match(/\.([a-z]+)$/i);
+		if (match) {
+			const ext = match[1].toLowerCase();
+			if (["mdx", "md", "yaml", "yml", "json"].includes(ext)) return ext;
+		}
+		return "mdx";
+	}
+
+	private renderFile(frontmatter: Record<string, unknown>, body: string, ext: string): string {
+		if (ext === "json") {
+			return `${JSON.stringify({ ...frontmatter, body }, null, 2)}\n`;
+		}
+		if (ext === "yaml" || ext === "yml") {
+			return `${serializeFrontmatter({ ...frontmatter, body })}\n`;
+		}
+		// mdx / md
+		const fm = serializeFrontmatter(frontmatter);
+		return `---\n${fm}\n---\n${body}`;
+	}
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { default as sourcepress } from "./integration.js";
+export { default } from "./integration.js";
+export { EngineClient } from "./client.js";
+export { generateContentConfig } from "./schema-generator.js";
+export { ComponentRegistry } from "./component-registry.js";
+export { ContentSyncer } from "./content-syncer.js";
+export type { SourcePressAstroOptions, ComponentDefinition } from "./types.js";
+export type { SyncResult } from "./content-syncer.js";

package/src/integration.ts

@@ -0,0 +1,61 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { AstroIntegration } from "astro";
+import { EngineClient } from "./client.js";
+import { ComponentRegistry } from "./component-registry.js";
+import { ContentSyncer } from "./content-syncer.js";
+import { generateContentConfig } from "./schema-generator.js";
+import type { SourcePressAstroOptions } from "./types.js";
+
+export default function sourcepress(options: SourcePressAstroOptions): AstroIntegration {
+	return {
+		name: "@sourcepress/astro",
+		hooks: {
+			"astro:config:setup": async ({ config, logger }) => {
+				const client = new EngineClient(options.engine);
+				const contentDir = options.contentDir ?? "content";
+				const configPath = options.configPath ?? "src/content.config.ts";
+
+				try {
+					// 1. Fetch schema from engine
+					logger.info("Fetching schema from engine...");
+					const schemaResponse = await client.fetchSchema();
+
+					// 2. Generate content.config.ts and write to configPath
+					// Cast to CollectionDefinition shape — fields may be unknown but generateContentConfig handles it
+					const collections = schemaResponse.collections as Parameters<
+						typeof generateContentConfig
+					>[0];
+					const configSource = generateContentConfig(collections, contentDir);
+					const configFullPath = join(config.root.pathname, configPath);
+					await writeFile(configFullPath, configSource, "utf-8");
+					logger.info(`Generated ${configPath}`);
+
+					// 3. Sync content files via ContentSyncer
+					const srcDir = config.srcDir.pathname;
+					const syncer = new ContentSyncer(client, srcDir, contentDir);
+					const collectionNames = Object.keys(schemaResponse.collections);
+					const syncResult = await syncer.sync(collectionNames);
+					logger.info(
+						`Synced ${syncResult.synced} files across ${collectionNames.length} collections`,
+					);
+					if (syncResult.errors.length > 0) {
+						for (const err of syncResult.errors) {
+							logger.warn(`Sync warning: ${err}`);
+						}
+					}
+
+					// 4. Register components if provided
+					if (options.components && Object.keys(options.components).length > 0) {
+						const registry = new ComponentRegistry(client, options.components);
+						await registry.register();
+						logger.info(`Registered ${Object.keys(options.components).length} components`);
+					}
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					logger.warn(`SourcePress sync failed: ${message}. Continuing without sync.`);
+				}
+			},
+		},
+	};
+}

package/src/schema-generator.ts

@@ -0,0 +1,80 @@
+import type { CollectionDefinition, FieldDefinition } from "@sourcepress/core";
+
+function fieldToZodCode(fieldDef: FieldDefinition): string {
+	switch (fieldDef.type) {
+		case "string": {
+			if (fieldDef.default !== undefined) {
+				return `z.string().default(${JSON.stringify(fieldDef.default)})`;
+			}
+			if (!fieldDef.required) return "z.string().optional()";
+			return "z.string()";
+		}
+		case "boolean": {
+			if (!fieldDef.required) return "z.boolean().optional()";
+			return "z.boolean()";
+		}
+		case "number": {
+			if (!fieldDef.required) return "z.number().optional()";
+			return "z.number()";
+		}
+		case "image": {
+			if (fieldDef.multiple) {
+				if (!fieldDef.required) return "z.array(z.string()).optional()";
+				return "z.array(z.string())";
+			}
+			if (!fieldDef.required) return "z.string().optional()";
+			return "z.string()";
+		}
+		case "relation-one": {
+			if (!fieldDef.required) return "z.string().optional()";
+			return "z.string()";
+		}
+		case "relation-many": {
+			if (!fieldDef.required) return "z.array(z.string()).optional()";
+			return "z.array(z.string())";
+		}
+	}
+}
+
+function collectionToSchemaCode(collection: CollectionDefinition, contentDir: string): string {
+	const lines: string[] = [];
+	for (const [fieldName, fieldDef] of Object.entries(collection.fields)) {
+		lines.push(`    ${fieldName}: ${fieldToZodCode(fieldDef)},`);
+	}
+	const pattern = collection.format === "json" ? "**/*.json" : collection.format === "yaml" ? "**/*.{yaml,yml}" : "**/*.{md,mdx}";
+	return `defineCollection({\n  loader: glob({ pattern: "${pattern}", base: "src/${contentDir}/${collection.name}" }),\n  schema: z.object({\n${lines.join("\n")}\n  }),\n})`;
+}
+
+export function generateContentConfig(
+	collections: Record<string, CollectionDefinition>,
+	contentDir = "content",
+): string {
+	const entries = Object.entries(collections);
+
+	if (entries.length === 0) {
+		return [
+			`import { defineCollection, z } from 'astro:content';`,
+			"",
+			"export const collections = {};",
+			"",
+		].join("\n");
+	}
+
+	const collectionBlocks = entries.map(([name, def]) => {
+		return `const ${name} = ${collectionToSchemaCode(def, contentDir)};`;
+	});
+
+	const exportsMap = entries.map(([name]) => `  ${name},`).join("\n");
+
+	return [
+		`import { defineCollection, z } from 'astro:content';`,
+		`import { glob } from 'astro/loaders';`,
+		"",
+		collectionBlocks.join("\n\n"),
+		"",
+		"export const collections = {",
+		exportsMap,
+		"};",
+		"",
+	].join("\n");
+}

package/src/types.ts

@@ -0,0 +1,40 @@
+export interface ComponentDefinition {
+	description: string;
+	props: Record<string, string>;
+}
+
+export interface SourcePressAstroOptions {
+	/** URL of the Content Engine, e.g. 'http://localhost:3000' */
+	engine: string;
+	/** UI components available for AI content generation */
+	components?: Record<string, ComponentDefinition>;
+	/** Directory to sync content into, relative to Astro srcDir. Default: 'content' */
+	contentDir?: string;
+	/** Path to generate content.config.ts. Default: 'src/content.config.ts' */
+	configPath?: string;
+}
+
+/** Schema response from GET /api/schema */
+export interface SchemaResponse {
+	collections: Record<
+		string,
+		{
+			name: string;
+			path: string;
+			format: string;
+			fields: Record<string, unknown>;
+		}
+	>;
+	total: number;
+}
+
+/** Content list response from GET /api/content/:collection */
+export interface ContentListResponse {
+	items: Array<{
+		slug: string;
+		path: string;
+		frontmatter: Record<string, unknown>;
+		body: string;
+	}>;
+	total: number;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "../../../tsconfig.json",
+	"compilerOptions": {
+		"outDir": "dist",
+		"rootDir": "src"
+	},
+	"include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		include: ["src/__tests__/**/*.test.ts"],
+	},
+});