@sourcepress/core 0.1.0

package/src/index.ts

@@ -0,0 +1,32 @@
+export { defineConfig, collection, field, relation } from "./config.js";
+export { validateConfig, type ValidationResult } from "./validate.js";
+export { collectionToZod } from "./schema.js";
+export type {
+	SourcePressConfig,
+	CollectionDefinition,
+	FieldDefinition,
+	StringField,
+	BooleanField,
+	NumberField,
+	ImageField,
+	RelationOneField,
+	RelationManyField,
+	Provenance,
+	ContentFile,
+	KnowledgeFile,
+	Entity,
+	GraphEdge,
+	JobDefinition,
+	JobFilter,
+	JobStatus,
+	MediaRef,
+	MediaRegistry,
+	MediaUploadInput,
+	MediaConfig,
+	ContentChange,
+	ApprovalRequest,
+	ApprovalStatus,
+	StatusChangeHandler,
+	ApprovalProvider,
+	ApprovalRules,
+} from "./types.js";

package/src/schema.ts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import type { CollectionDefinition, FieldDefinition } from "./types.js";
+
+function fieldToZod(fieldDef: FieldDefinition): z.ZodType {
+	switch (fieldDef.type) {
+		case "string": {
+			let schema: z.ZodType = z.string();
+			if (fieldDef.default !== undefined)
+				schema = schema.pipe(z.string().default(fieldDef.default));
+			if (!fieldDef.required) schema = z.string().optional();
+			return schema;
+		}
+		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) {
+				const schema = z.array(z.string());
+				if (!fieldDef.required) return schema.optional();
+				return schema;
+			}
+			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": {
+			const schema = z.array(z.string());
+			if (!fieldDef.required) return schema.optional();
+			return schema;
+		}
+	}
+}
+
+export function collectionToZod(
+	collection: CollectionDefinition,
+): z.ZodObject<Record<string, z.ZodType>> {
+	const shape: Record<string, z.ZodType> = {};
+
+	for (const [fieldName, fieldDef] of Object.entries(collection.fields)) {
+		shape[fieldName] = fieldToZod(fieldDef);
+	}
+
+	return z.object(shape);
+}

package/src/types.ts

@@ -0,0 +1,300 @@
+// Content field types
+export interface StringField {
+	type: "string";
+	required?: boolean;
+	default?: string;
+}
+
+export interface BooleanField {
+	type: "boolean";
+	required?: boolean;
+	default?: boolean;
+}
+
+export interface NumberField {
+	type: "number";
+	required?: boolean;
+	default?: number;
+}
+
+export interface ImageField {
+	type: "image";
+	required?: boolean;
+	multiple?: boolean;
+}
+
+export interface RelationOneField {
+	type: "relation-one";
+	collection: string;
+	required?: boolean;
+}
+
+export interface RelationManyField {
+	type: "relation-many";
+	collection: string;
+	required?: boolean;
+}
+
+export type FieldDefinition =
+	| StringField
+	| BooleanField
+	| NumberField
+	| ImageField
+	| RelationOneField
+	| RelationManyField;
+
+// Collection definition
+export interface CollectionDefinition {
+	name: string;
+	path: string;
+	format: "mdx" | "md" | "yaml" | "json";
+	fields: Record<string, FieldDefinition>;
+}
+
+// Full SourcePress config
+export interface SourcePressConfig {
+	repository: {
+		owner: string;
+		repo: string;
+		branch: string;
+		content_path?: string;
+	};
+
+	ai: {
+		provider: "anthropic" | "openai" | "local";
+		model: string;
+		daily_limit_usd?: number;
+		warn_at_usd?: number;
+	};
+
+	collections: Record<string, CollectionDefinition>;
+
+	knowledge: {
+		path: string;
+		graph: {
+			backend: "local" | "vectorize" | "turso";
+		};
+		ingestion?: {
+			scraping?: {
+				respectRobotsTxt?: boolean;
+				rateLimitMs?: number;
+			};
+		};
+	};
+
+	intent: {
+		path: string;
+	};
+
+	media?: {
+		storage: "git" | "r2" | "s3";
+		path: string;
+		registry: string;
+		allowedTypes?: string[];
+		maxSizeMb?: number;
+		transform?: {
+			formats?: string[];
+			sizes?: number[];
+		};
+	};
+
+	jobs?: {
+		backend: "in-process" | "queue" | "durable-objects";
+	};
+
+	evals?: {
+		threshold: number;
+		auto_approve?: boolean;
+	};
+
+	approval?: ApprovalRules;
+
+	auth?: {
+		provider: "github" | "api-key" | "custom";
+	};
+
+	cache?: {
+		backend: "sqlite" | "d1" | "memory";
+	};
+
+	sync?: {
+		reconciliation_interval: string;
+	};
+}
+
+// Content change submitted for approval
+export interface ContentChange {
+	collection: string;
+	slug: string;
+	path: string;
+	action: "create" | "update" | "delete";
+	content: string;
+	frontmatter: Record<string, unknown>;
+	provenance: Provenance;
+}
+
+// Approval request — tracks a pending change
+export interface ApprovalRequest {
+	id: string;
+	change: ContentChange;
+	status: "pending" | "approved" | "rejected";
+	submitted_at: string;
+	submitted_by: string;
+	reviewed_by?: string;
+	reviewed_at?: string;
+	review_comment?: string;
+	pr_url?: string;
+	pr_number?: number;
+}
+
+// Approval status change handler
+export type ApprovalStatus = "pending" | "approved" | "rejected";
+export type StatusChangeHandler = (id: string, status: ApprovalStatus, by: string) => void;
+
+// Approval provider interface — pluggable
+export interface ApprovalProvider {
+	submit(change: ContentChange): Promise<ApprovalRequest>;
+	status(id: string): Promise<ApprovalStatus>;
+	approve(id: string, by: string, comment?: string): Promise<void>;
+	reject(id: string, by: string, reason: string): Promise<void>;
+	pending(): Promise<ApprovalRequest[]>;
+	onStatusChange(callback: StatusChangeHandler): void;
+}
+
+// Approval rules config
+export interface ApprovalRules {
+	provider: "github-pr" | "api" | "auto";
+	rules: Record<string, "pr" | "direct">;
+	auto_approve?: {
+		enabled: boolean;
+		min_score: number;
+	};
+}
+
+/**
+ * Provenance metadata for content traceability.
+ * Satisfies EU AI Act transparency requirements:
+ * - AI attribution (generated_by, prompt_version)
+ * - Human oversight (approved_by, approved_at)
+ * - Source traceability (source_files)
+ * - Quality assessment (eval_score)
+ */
+export interface Provenance {
+	generated_by: string;
+	generated_at: string;
+	source_files: string[];
+	prompt_version?: string;
+	eval_score?: number;
+	approved_by?: string;
+	approved_at?: string;
+}
+
+// Content file representation
+export interface ContentFile {
+	collection: string;
+	slug: string;
+	path: string;
+	frontmatter: Record<string, unknown>;
+	body: string;
+	provenance?: Provenance;
+}
+
+// Knowledge file representation
+export interface KnowledgeFile {
+	path: string;
+	type: string;
+	quality: "structured" | "draft" | "thoughts";
+	quality_score: number;
+	entities: Entity[];
+	ingested_at: string;
+	source: "manual" | "url" | "document" | "transcript" | "scrape";
+	source_url?: string;
+	body: string;
+}
+
+// Entity in knowledge graph
+export interface Entity {
+	type: string;
+	name: string;
+	aliases?: string[];
+}
+
+// Graph edge
+export interface GraphEdge {
+	from: string;
+	to: string;
+	relation_type: string;
+	weight: number;
+}
+
+// Job definition — what gets enqueued
+export interface JobDefinition {
+	type: string;
+	params: Record<string, unknown>;
+}
+
+// Job filter for listing
+export interface JobFilter {
+	status?: JobStatus["status"];
+	type?: string;
+	limit?: number;
+}
+
+// Job status — tracks lifecycle of a background job
+export interface JobStatus {
+	job_id: string;
+	type: string;
+	status: "queued" | "running" | "completed" | "failed" | "cancelled";
+	progress: { completed: number; total: number; failed: number };
+	created_at: string;
+	started_at?: string;
+	completed_at?: string;
+	result?: unknown;
+	error?: string;
+}
+
+// Media reference — stored in media.json registry
+export interface MediaRef {
+	path: string;
+	content_type: string;
+	size_bytes: number;
+	hash: string;
+	width?: number;
+	height?: number;
+	format?: string;
+	alt?: string;
+	source: "uploaded" | "ai-generated" | "scraped" | "stock";
+	generated_by?: string;
+	prompt?: string;
+	uploaded_at: string;
+	uploaded_by: string;
+	variants?: Record<string, string>;
+}
+
+// Media registry — the full media.json file
+export type MediaRegistry = Record<string, MediaRef>;
+
+// Media upload input
+export interface MediaUploadInput {
+	file: Buffer;
+	path: string;
+	content_type: string;
+	alt?: string;
+	source: MediaRef["source"];
+	generated_by?: string;
+	prompt?: string;
+	uploaded_by: string;
+}
+
+// Media storage config (from SourcePressConfig.media)
+export interface MediaConfig {
+	storage: "git" | "r2" | "s3";
+	path: string;
+	registry: string;
+	allowedTypes?: string[];
+	maxSizeMb?: number;
+	transform?: {
+		formats?: string[];
+		sizes?: number[];
+	};
+}

package/src/validate.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+
+export interface ValidationResult {
+	success: boolean;
+	data?: unknown;
+	errors: string[];
+}
+
+// Build the full Zod schema for SourcePressConfig
+const repositorySchema = z.object({
+	owner: z.string().min(1),
+	repo: z.string().min(1),
+	branch: z.string().min(1),
+	content_path: z.string().optional(),
+});
+
+const aiSchema = z.object({
+	provider: z.enum(["anthropic", "openai", "local"]),
+	model: z.string().min(1),
+	daily_limit_usd: z.number().optional(),
+	warn_at_usd: z.number().optional(),
+});
+
+const fieldSchema: z.ZodType = z.lazy(() =>
+	z.union([
+		z.object({
+			type: z.literal("string"),
+			required: z.boolean().optional(),
+			default: z.string().optional(),
+		}),
+		z.object({
+			type: z.literal("boolean"),
+			required: z.boolean().optional(),
+			default: z.boolean().optional(),
+		}),
+		z.object({
+			type: z.literal("number"),
+			required: z.boolean().optional(),
+			default: z.number().optional(),
+		}),
+		z.object({
+			type: z.literal("image"),
+			required: z.boolean().optional(),
+			multiple: z.boolean().optional(),
+		}),
+		z.object({
+			type: z.literal("relation-one"),
+			collection: z.string(),
+			required: z.boolean().optional(),
+		}),
+		z.object({
+			type: z.literal("relation-many"),
+			collection: z.string(),
+			required: z.boolean().optional(),
+		}),
+	]),
+);
+
+const collectionSchema = z.object({
+	name: z.string().min(1),
+	path: z.string().min(1),
+	format: z.enum(["mdx", "md", "yaml", "json"]),
+	fields: z.record(fieldSchema),
+});
+
+const configSchema = z.object({
+	repository: repositorySchema,
+	ai: aiSchema,
+	collections: z.record(collectionSchema),
+	knowledge: z.object({
+		path: z.string().min(1),
+		graph: z.object({
+			backend: z.enum(["local", "vectorize", "turso"]),
+		}),
+		ingestion: z
+			.object({
+				scraping: z
+					.object({
+						respectRobotsTxt: z.boolean().optional(),
+						rateLimitMs: z.number().optional(),
+					})
+					.optional(),
+			})
+			.optional(),
+	}),
+	intent: z.object({ path: z.string().min(1) }),
+	media: z
+		.object({
+			storage: z.enum(["git", "r2", "s3"]),
+			path: z.string(),
+			registry: z.string(),
+			allowedTypes: z.array(z.string()).optional(),
+			maxSizeMb: z.number().optional(),
+			transform: z
+				.object({
+					formats: z.array(z.string()).optional(),
+					sizes: z.array(z.number()).optional(),
+				})
+				.optional(),
+		})
+		.optional(),
+	jobs: z.object({ backend: z.enum(["in-process", "queue", "durable-objects"]) }).optional(),
+	evals: z.object({ threshold: z.number(), auto_approve: z.boolean().optional() }).optional(),
+	approval: z
+		.object({
+			provider: z.enum(["github-pr", "api", "auto"]),
+			rules: z.record(z.enum(["pr", "direct"])).default({}),
+			auto_approve: z
+				.object({
+					enabled: z.boolean(),
+					min_score: z.number().min(0).max(100),
+				})
+				.optional(),
+		})
+		.optional(),
+	auth: z.object({ provider: z.enum(["github", "api-key", "custom"]) }).optional(),
+	cache: z.object({ backend: z.enum(["sqlite", "d1", "memory"]) }).optional(),
+	sync: z.object({ reconciliation_interval: z.string() }).optional(),
+});
+
+export function validateConfig(raw: unknown): ValidationResult {
+	const result = configSchema.safeParse(raw);
+	if (result.success) {
+		return { success: true, data: result.data, errors: [] };
+	}
+	return {
+		success: false,
+		errors: result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
+	};
+}
+
+export { configSchema };

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"],
+	},
+});