@sourcepress/core 0.1.0

package/dist/validate.d.ts

@@ -0,0 +1,361 @@
+import { z } from "zod";
+export interface ValidationResult {
+    success: boolean;
+    data?: unknown;
+    errors: string[];
+}
+declare const configSchema: z.ZodObject<{
+    repository: z.ZodObject<{
+        owner: z.ZodString;
+        repo: z.ZodString;
+        branch: z.ZodString;
+        content_path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        owner: string;
+        repo: string;
+        branch: string;
+        content_path?: string | undefined;
+    }, {
+        owner: string;
+        repo: string;
+        branch: string;
+        content_path?: string | undefined;
+    }>;
+    ai: z.ZodObject<{
+        provider: z.ZodEnum<["anthropic", "openai", "local"]>;
+        model: z.ZodString;
+        daily_limit_usd: z.ZodOptional<z.ZodNumber>;
+        warn_at_usd: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "anthropic" | "openai" | "local";
+        model: string;
+        daily_limit_usd?: number | undefined;
+        warn_at_usd?: number | undefined;
+    }, {
+        provider: "anthropic" | "openai" | "local";
+        model: string;
+        daily_limit_usd?: number | undefined;
+        warn_at_usd?: number | undefined;
+    }>;
+    collections: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        format: z.ZodEnum<["mdx", "md", "yaml", "json"]>;
+        fields: z.ZodRecord<z.ZodString, z.ZodType<any, z.ZodTypeDef, any>>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        name: string;
+        format: "mdx" | "md" | "yaml" | "json";
+        fields: Record<string, any>;
+    }, {
+        path: string;
+        name: string;
+        format: "mdx" | "md" | "yaml" | "json";
+        fields: Record<string, any>;
+    }>>;
+    knowledge: z.ZodObject<{
+        path: z.ZodString;
+        graph: z.ZodObject<{
+            backend: z.ZodEnum<["local", "vectorize", "turso"]>;
+        }, "strip", z.ZodTypeAny, {
+            backend: "local" | "vectorize" | "turso";
+        }, {
+            backend: "local" | "vectorize" | "turso";
+        }>;
+        ingestion: z.ZodOptional<z.ZodObject<{
+            scraping: z.ZodOptional<z.ZodObject<{
+                respectRobotsTxt: z.ZodOptional<z.ZodBoolean>;
+                rateLimitMs: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            }, {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            scraping?: {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            } | undefined;
+        }, {
+            scraping?: {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            } | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        graph: {
+            backend: "local" | "vectorize" | "turso";
+        };
+        ingestion?: {
+            scraping?: {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        path: string;
+        graph: {
+            backend: "local" | "vectorize" | "turso";
+        };
+        ingestion?: {
+            scraping?: {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            } | undefined;
+        } | undefined;
+    }>;
+    intent: z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>;
+    media: z.ZodOptional<z.ZodObject<{
+        storage: z.ZodEnum<["git", "r2", "s3"]>;
+        path: z.ZodString;
+        registry: z.ZodString;
+        allowedTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        maxSizeMb: z.ZodOptional<z.ZodNumber>;
+        transform: z.ZodOptional<z.ZodObject<{
+            formats: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            sizes: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            formats?: string[] | undefined;
+            sizes?: number[] | undefined;
+        }, {
+            formats?: string[] | undefined;
+            sizes?: number[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        storage: "git" | "r2" | "s3";
+        registry: string;
+        allowedTypes?: string[] | undefined;
+        maxSizeMb?: number | undefined;
+        transform?: {
+            formats?: string[] | undefined;
+            sizes?: number[] | undefined;
+        } | undefined;
+    }, {
+        path: string;
+        storage: "git" | "r2" | "s3";
+        registry: string;
+        allowedTypes?: string[] | undefined;
+        maxSizeMb?: number | undefined;
+        transform?: {
+            formats?: string[] | undefined;
+            sizes?: number[] | undefined;
+        } | undefined;
+    }>>;
+    jobs: z.ZodOptional<z.ZodObject<{
+        backend: z.ZodEnum<["in-process", "queue", "durable-objects"]>;
+    }, "strip", z.ZodTypeAny, {
+        backend: "in-process" | "queue" | "durable-objects";
+    }, {
+        backend: "in-process" | "queue" | "durable-objects";
+    }>>;
+    evals: z.ZodOptional<z.ZodObject<{
+        threshold: z.ZodNumber;
+        auto_approve: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        threshold: number;
+        auto_approve?: boolean | undefined;
+    }, {
+        threshold: number;
+        auto_approve?: boolean | undefined;
+    }>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodEnum<["github-pr", "api", "auto"]>;
+        rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<["pr", "direct"]>>>;
+        auto_approve: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            min_score: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            min_score: number;
+        }, {
+            enabled: boolean;
+            min_score: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "github-pr" | "api" | "auto";
+        rules: Record<string, "pr" | "direct">;
+        auto_approve?: {
+            enabled: boolean;
+            min_score: number;
+        } | undefined;
+    }, {
+        provider: "github-pr" | "api" | "auto";
+        auto_approve?: {
+            enabled: boolean;
+            min_score: number;
+        } | undefined;
+        rules?: Record<string, "pr" | "direct"> | undefined;
+    }>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodEnum<["github", "api-key", "custom"]>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "github" | "api-key" | "custom";
+    }, {
+        provider: "github" | "api-key" | "custom";
+    }>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        backend: z.ZodEnum<["sqlite", "d1", "memory"]>;
+    }, "strip", z.ZodTypeAny, {
+        backend: "sqlite" | "d1" | "memory";
+    }, {
+        backend: "sqlite" | "d1" | "memory";
+    }>>;
+    sync: z.ZodOptional<z.ZodObject<{
+        reconciliation_interval: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reconciliation_interval: string;
+    }, {
+        reconciliation_interval: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    repository: {
+        owner: string;
+        repo: string;
+        branch: string;
+        content_path?: string | undefined;
+    };
+    ai: {
+        provider: "anthropic" | "openai" | "local";
+        model: string;
+        daily_limit_usd?: number | undefined;
+        warn_at_usd?: number | undefined;
+    };
+    collections: Record<string, {
+        path: string;
+        name: string;
+        format: "mdx" | "md" | "yaml" | "json";
+        fields: Record<string, any>;
+    }>;
+    knowledge: {
+        path: string;
+        graph: {
+            backend: "local" | "vectorize" | "turso";
+        };
+        ingestion?: {
+            scraping?: {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            } | undefined;
+        } | undefined;
+    };
+    intent: {
+        path: string;
+    };
+    media?: {
+        path: string;
+        storage: "git" | "r2" | "s3";
+        registry: string;
+        allowedTypes?: string[] | undefined;
+        maxSizeMb?: number | undefined;
+        transform?: {
+            formats?: string[] | undefined;
+            sizes?: number[] | undefined;
+        } | undefined;
+    } | undefined;
+    jobs?: {
+        backend: "in-process" | "queue" | "durable-objects";
+    } | undefined;
+    evals?: {
+        threshold: number;
+        auto_approve?: boolean | undefined;
+    } | undefined;
+    approval?: {
+        provider: "github-pr" | "api" | "auto";
+        rules: Record<string, "pr" | "direct">;
+        auto_approve?: {
+            enabled: boolean;
+            min_score: number;
+        } | undefined;
+    } | undefined;
+    auth?: {
+        provider: "github" | "api-key" | "custom";
+    } | undefined;
+    cache?: {
+        backend: "sqlite" | "d1" | "memory";
+    } | undefined;
+    sync?: {
+        reconciliation_interval: string;
+    } | undefined;
+}, {
+    repository: {
+        owner: string;
+        repo: string;
+        branch: string;
+        content_path?: string | undefined;
+    };
+    ai: {
+        provider: "anthropic" | "openai" | "local";
+        model: string;
+        daily_limit_usd?: number | undefined;
+        warn_at_usd?: number | undefined;
+    };
+    collections: Record<string, {
+        path: string;
+        name: string;
+        format: "mdx" | "md" | "yaml" | "json";
+        fields: Record<string, any>;
+    }>;
+    knowledge: {
+        path: string;
+        graph: {
+            backend: "local" | "vectorize" | "turso";
+        };
+        ingestion?: {
+            scraping?: {
+                respectRobotsTxt?: boolean | undefined;
+                rateLimitMs?: number | undefined;
+            } | undefined;
+        } | undefined;
+    };
+    intent: {
+        path: string;
+    };
+    media?: {
+        path: string;
+        storage: "git" | "r2" | "s3";
+        registry: string;
+        allowedTypes?: string[] | undefined;
+        maxSizeMb?: number | undefined;
+        transform?: {
+            formats?: string[] | undefined;
+            sizes?: number[] | undefined;
+        } | undefined;
+    } | undefined;
+    jobs?: {
+        backend: "in-process" | "queue" | "durable-objects";
+    } | undefined;
+    evals?: {
+        threshold: number;
+        auto_approve?: boolean | undefined;
+    } | undefined;
+    approval?: {
+        provider: "github-pr" | "api" | "auto";
+        auto_approve?: {
+            enabled: boolean;
+            min_score: number;
+        } | undefined;
+        rules?: Record<string, "pr" | "direct"> | undefined;
+    } | undefined;
+    auth?: {
+        provider: "github" | "api-key" | "custom";
+    } | undefined;
+    cache?: {
+        backend: "sqlite" | "d1" | "memory";
+    } | undefined;
+    sync?: {
+        reconciliation_interval: string;
+    } | undefined;
+}>;
+export declare function validateConfig(raw: unknown): ValidationResult;
+export { configSchema };
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,WAAW,gBAAgB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AA2DD,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDhB,CAAC;AAEH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAS7D;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validate.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+// 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.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) {
+    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 };
+//# sourceMappingURL=validate.js.map

package/dist/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@sourcepress/core",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}

package/src/__tests__/schema.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { collectionToZod } from "../schema.js";
+import type { CollectionDefinition } from "../types.js";
+
+describe("collectionToZod", () => {
+	it("creates a Zod schema from a collection definition", () => {
+		const collection: CollectionDefinition = {
+			name: "Posts",
+			path: "content/posts",
+			format: "mdx",
+			fields: {
+				title: { type: "string", required: true },
+				draft: { type: "boolean", default: true },
+				views: { type: "number" },
+			},
+		};
+
+		const schema = collectionToZod(collection);
+		const valid = schema.safeParse({ title: "Hello", draft: false, views: 10 });
+		expect(valid.success).toBe(true);
+
+		const invalid = schema.safeParse({ draft: true });
+		expect(invalid.success).toBe(false);
+	});
+
+	it("handles relation fields", () => {
+		const collection: CollectionDefinition = {
+			name: "Posts",
+			path: "content/posts",
+			format: "mdx",
+			fields: {
+				title: { type: "string", required: true },
+				author: { type: "relation-one", collection: "team" },
+				tags: { type: "relation-many", collection: "tags" },
+			},
+		};
+
+		const schema = collectionToZod(collection);
+		const valid = schema.safeParse({ title: "Hello", author: "anna", tags: ["tech", "ai"] });
+		expect(valid.success).toBe(true);
+	});
+
+	it("handles image fields", () => {
+		const collection: CollectionDefinition = {
+			name: "Posts",
+			path: "content/posts",
+			format: "mdx",
+			fields: {
+				hero: { type: "image", required: true },
+				gallery: { type: "image", multiple: true },
+			},
+		};
+
+		const schema = collectionToZod(collection);
+		const valid = schema.safeParse({
+			hero: "/assets/hero.webp",
+			gallery: ["/assets/1.webp", "/assets/2.webp"],
+		});
+		expect(valid.success).toBe(true);
+	});
+});

package/src/__tests__/validate.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { validateConfig } from "../validate.js";
+
+describe("validateConfig", () => {
+	it("accepts a valid minimal config", () => {
+		const config = {
+			repository: { owner: "acme", repo: "site", branch: "main" },
+			ai: { provider: "anthropic" as const, model: "claude-sonnet-4-5-20250514" },
+			collections: {},
+			knowledge: { path: "knowledge/", graph: { backend: "local" as const } },
+			intent: { path: "intent/" },
+			media: { storage: "git" as const, path: "assets/", registry: "media.json" },
+			jobs: { backend: "in-process" as const },
+			evals: { threshold: 70 },
+			approval: { provider: "github-pr" as const, rules: {} },
+			auth: { provider: "github" as const },
+			cache: { backend: "sqlite" as const },
+			sync: { reconciliation_interval: "1h" },
+		};
+		const result = validateConfig(config);
+		expect(result.success).toBe(true);
+	});
+
+	it("rejects config missing repository", () => {
+		const result = validateConfig({} as unknown);
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(result.errors.length).toBeGreaterThan(0);
+		}
+	});
+
+	it("rejects invalid ai provider", () => {
+		const config = {
+			repository: { owner: "acme", repo: "site", branch: "main" },
+			ai: { provider: "invalid-provider", model: "gpt-4" },
+			collections: {},
+			knowledge: { path: "knowledge/", graph: { backend: "local" } },
+			intent: { path: "intent/" },
+		};
+		const result = validateConfig(config as unknown);
+		expect(result.success).toBe(false);
+	});
+});

package/src/config.ts

@@ -0,0 +1,42 @@
+import type {
+	BooleanField,
+	CollectionDefinition,
+	ImageField,
+	NumberField,
+	RelationManyField,
+	RelationOneField,
+	SourcePressConfig,
+	StringField,
+} from "./types.js";
+
+export function defineConfig(config: SourcePressConfig): SourcePressConfig {
+	return config;
+}
+
+export function collection(def: CollectionDefinition): CollectionDefinition {
+	return def;
+}
+
+export const field = {
+	string(opts: Omit<StringField, "type"> = {}): StringField {
+		return { type: "string", ...opts };
+	},
+	boolean(opts: Omit<BooleanField, "type"> = {}): BooleanField {
+		return { type: "boolean", ...opts };
+	},
+	number(opts: Omit<NumberField, "type"> = {}): NumberField {
+		return { type: "number", ...opts };
+	},
+	image(opts: Omit<ImageField, "type"> = {}): ImageField {
+		return { type: "image", ...opts };
+	},
+};
+
+export const relation = {
+	one(collectionName: string, opts: { required?: boolean } = {}): RelationOneField {
+		return { type: "relation-one", collection: collectionName, ...opts };
+	},
+	many(collectionName: string, opts: { required?: boolean } = {}): RelationManyField {
+		return { type: "relation-many", collection: collectionName, ...opts };
+	},
+};