@sourcepress/server 0.1.0

package/src/__tests__/content.test.ts

@@ -0,0 +1,202 @@
+import type { CollectionDefinition, ContentFile } from "@sourcepress/core";
+import { Hono } from "hono";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { EngineContext } from "../engine.js";
+import { errorHandler } from "../middleware/error-handler.js";
+import { contentRoutes } from "../routes/content.js";
+
+const mockPosts: ContentFile[] = [
+	{
+		collection: "posts",
+		slug: "hello-world",
+		path: "content/posts/hello-world.mdx",
+		frontmatter: { title: "Hello World", draft: false },
+		body: "# Hello World\n\nThis is a test post.",
+	},
+	{
+		collection: "posts",
+		slug: "second-post",
+		path: "content/posts/second-post.mdx",
+		frontmatter: { title: "Second Post", draft: true },
+		body: "# Second Post\n\nAnother post.",
+	},
+];
+
+const mockCollections: Record<string, CollectionDefinition> = {
+	posts: {
+		name: "Blog Posts",
+		path: "content/posts",
+		format: "mdx",
+		fields: { title: { type: "string", required: true } },
+	},
+};
+
+function createMockEngine(): EngineContext {
+	return {
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		config: {} as any,
+		github: {
+			createBranch: vi.fn().mockResolvedValue("abc123"),
+			createOrUpdateFile: vi.fn().mockResolvedValue({ sha: "def456", commit_sha: "ghi789" }),
+			createPR: vi
+				.fn()
+				.mockResolvedValue({ number: 42, html_url: "https://github.com/test/pr/42" }),
+			getFile: vi.fn().mockResolvedValue({ sha: "existing-sha" }),
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		knowledge: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		knowledgeStore: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		cache: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		budget: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		provider: {} as any,
+		listContent: vi.fn().mockImplementation(async (collection: string) => {
+			if (collection === "posts") return mockPosts;
+			return [];
+		}),
+		getContent: vi.fn().mockImplementation(async (collection: string, slug: string) => {
+			if (collection === "posts") return mockPosts.find((p) => p.slug === slug) ?? null;
+			return null;
+		}),
+		getCollectionDef: vi.fn().mockImplementation((collection: string) => {
+			return mockCollections[collection] ?? null;
+		}),
+		listCollections: vi.fn().mockReturnValue(["posts"]),
+	};
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", contentRoutes(engine));
+	return app;
+}
+
+describe("Content routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	describe("GET /api/content", () => {
+		it("returns all content across collections", async () => {
+			const res = await app.request("/api/content");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(2);
+			expect(body.items[0].slug).toBe("hello-world");
+		});
+	});
+
+	describe("GET /api/content/:collection", () => {
+		it("returns content for a valid collection", async () => {
+			const res = await app.request("/api/content/posts");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(2);
+			expect(body.collection.name).toBe("Blog Posts");
+		});
+
+		it("returns 404 for unknown collection", async () => {
+			const res = await app.request("/api/content/unknown");
+			expect(res.status).toBe(404);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.code).toBe("COLLECTION_NOT_FOUND");
+		});
+	});
+
+	describe("GET /api/content/:collection/:slug", () => {
+		it("returns a single content file", async () => {
+			const res = await app.request("/api/content/posts/hello-world");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.slug).toBe("hello-world");
+			expect(body.body).toContain("Hello World");
+		});
+
+		it("returns 404 for unknown slug", async () => {
+			const res = await app.request("/api/content/posts/nonexistent");
+			expect(res.status).toBe(404);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.code).toBe("CONTENT_NOT_FOUND");
+		});
+	});
+
+	describe("POST /api/content/:collection", () => {
+		it("creates content and returns PR", async () => {
+			const res = await app.request("/api/content/posts", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					slug: "new-post",
+					frontmatter: { title: "New Post" },
+					body: "# New Post\n\nContent here.",
+				}),
+			});
+			expect(res.status).toBe(201);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.created).toBe(true);
+			expect(body.pr.number).toBe(42);
+		});
+
+		it("returns 400 for missing slug", async () => {
+			const res = await app.request("/api/content/posts", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ body: "content" }),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+
+	describe("PUT /api/content/:collection/:slug", () => {
+		it("updates content and returns PR", async () => {
+			const res = await app.request("/api/content/posts/hello-world", {
+				method: "PUT",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					frontmatter: { title: "Updated Title" },
+					body: "# Updated\n\nNew content.",
+				}),
+			});
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.updated).toBe(true);
+			expect(body.pr.number).toBe(42);
+		});
+	});
+
+	describe("DELETE /api/content/:collection/:slug", () => {
+		it("deletes content and returns PR", async () => {
+			const res = await app.request("/api/content/posts/hello-world", {
+				method: "DELETE",
+			});
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.deleted).toBe(true);
+			expect(body.pr.number).toBe(42);
+		});
+
+		it("returns 404 for unknown slug", async () => {
+			const res = await app.request("/api/content/posts/nonexistent", {
+				method: "DELETE",
+			});
+			expect(res.status).toBe(404);
+		});
+	});
+});

package/src/__tests__/engine.test.ts

@@ -0,0 +1,86 @@
+import type { SourcePressConfig } from "@sourcepress/core";
+import { InMemoryKnowledgeStore } from "@sourcepress/knowledge";
+import { describe, expect, it } from "vitest";
+import { createEngine } from "../engine.js";
+
+const testConfig: SourcePressConfig = {
+	repository: { owner: "test", repo: "site", branch: "main" },
+	ai: { provider: "anthropic", model: "claude-sonnet-4-5-20250514" },
+	collections: {
+		posts: {
+			name: "Blog Posts",
+			path: "content/posts",
+			format: "mdx",
+			fields: {
+				title: { type: "string", required: true },
+			},
+		},
+		team: {
+			name: "Team",
+			path: "content/team",
+			format: "yaml",
+			fields: {
+				name: { type: "string", required: true },
+			},
+		},
+	},
+	knowledge: { path: "knowledge/", graph: { backend: "local" } },
+	intent: { path: "intent/" },
+};
+
+describe("createEngine", () => {
+	it("creates engine context with all required properties", async () => {
+		const engine = await createEngine({
+			config: testConfig,
+			githubToken: "test-token",
+			knowledgeStore: new InMemoryKnowledgeStore(),
+		});
+
+		expect(engine.config).toBe(testConfig);
+		expect(engine.github).toBeDefined();
+		expect(engine.knowledge).toBeDefined();
+		expect(engine.knowledgeStore).toBeDefined();
+		expect(engine.cache).toBeDefined();
+		expect(engine.budget).toBeDefined();
+		expect(engine.provider).toBeDefined();
+	});
+
+	it("listCollections returns configured collection names", async () => {
+		const engine = await createEngine({
+			config: testConfig,
+			githubToken: "test-token",
+			knowledgeStore: new InMemoryKnowledgeStore(),
+		});
+
+		const collections = engine.listCollections();
+		expect(collections).toContain("posts");
+		expect(collections).toContain("team");
+		expect(collections.length).toBe(2);
+	});
+
+	it("getCollectionDef returns definition for valid collection", async () => {
+		const engine = await createEngine({
+			config: testConfig,
+			githubToken: "test-token",
+			knowledgeStore: new InMemoryKnowledgeStore(),
+		});
+
+		const def = engine.getCollectionDef("posts");
+		expect(def).toBeDefined();
+		// biome-ignore lint/style/noNonNullAssertion: asserted defined on line above
+		expect(def!.name).toBe("Blog Posts");
+		// biome-ignore lint/style/noNonNullAssertion: asserted defined on line above
+		expect(def!.format).toBe("mdx");
+	});
+
+	it("getCollectionDef returns null for unknown collection", async () => {
+		const engine = await createEngine({
+			config: testConfig,
+			githubToken: "test-token",
+			knowledgeStore: new InMemoryKnowledgeStore(),
+		});
+
+		const def = engine.getCollectionDef("nonexistent");
+		expect(def).toBeNull();
+	});
+});

package/src/__tests__/eval.test.ts

@@ -0,0 +1,343 @@
+import { Hono } from "hono";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { EngineContext } from "../engine.js";
+import { errorHandler } from "../middleware/error-handler.js";
+import { evalRoutes } from "../routes/eval.js";
+
+// Mock @sourcepress/ai
+vi.mock("@sourcepress/ai", async () => {
+	const actual = await vi.importActual("@sourcepress/ai");
+	return {
+		...actual,
+		judge: vi.fn().mockResolvedValue({
+			score: 82,
+			reasoning: "Good match.",
+			usage: {
+				input_tokens: 1000,
+				output_tokens: 100,
+				estimated_cost_usd: 0.004,
+				function_name: "judge",
+				timestamp: new Date().toISOString(),
+			},
+		}),
+		EvalRunner: vi.fn().mockImplementation(() => ({
+			run: vi.fn().mockResolvedValue({
+				iterations: [
+					{
+						id: "eval-case-study-1",
+						content_type: "case-study",
+						prompt_version: "v1",
+						score: 82,
+						status: "keep",
+						reasoning: "Good match.",
+						iteration: 1,
+						generated_content: "# Case Study\n\nContent.",
+						timestamp: new Date().toISOString(),
+						total_usage: {
+							input_tokens: 3000,
+							output_tokens: 500,
+							estimated_cost_usd: 0.016,
+							function_name: "eval-run",
+							timestamp: new Date().toISOString(),
+						},
+					},
+				],
+				final_score: 82,
+				final_status: "keep",
+				final_content: "# Case Study\n\nContent.",
+				final_prompt: "Write a case study.",
+				prompt_improved: false,
+				total_usage: {
+					input_tokens: 3000,
+					output_tokens: 500,
+					estimated_cost_usd: 0.016,
+					function_name: "eval-run",
+					timestamp: new Date().toISOString(),
+				},
+			}),
+			judgeOnly: vi.fn().mockResolvedValue({
+				score: 72,
+				reasoning: "Decent.",
+				usage: {
+					input_tokens: 1000,
+					output_tokens: 100,
+					estimated_cost_usd: 0.004,
+					function_name: "judge",
+					timestamp: new Date().toISOString(),
+				},
+			}),
+		})),
+	};
+});
+
+function createMockEngine(): EngineContext {
+	return {
+		config: {
+			evals: { threshold: 70 },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} as any,
+		github: {
+			getTree: vi.fn().mockResolvedValue([
+				{ path: "evals/prompts/case-study.md", sha: "abc", type: "blob" },
+				{ path: "evals/prompts/blog-post.md", sha: "def", type: "blob" },
+				{ path: "evals/standards/case-study.mdx", sha: "ghi", type: "blob" },
+				{ path: "evals/standards/blog-post.mdx", sha: "jkl", type: "blob" },
+			]),
+			getFile: vi.fn().mockImplementation(async (path: string) => {
+				if (path === "evals/results.tsv") {
+					return {
+						path,
+						sha: "sha1",
+						content:
+							"date\tcontent_type\tprompt_version\tscore\tstatus\treasoning\n2026-04-04\tcase-study\tv1\t52\tdiscard\tGeneric\n2026-04-04\tcase-study\tv2\t82\tkeep\tGood",
+						encoding: "utf-8",
+					};
+				}
+				if (path === "evals/prompts/case-study.md") {
+					return {
+						path,
+						sha: "sha2",
+						content: "Write a compelling case study with specific metrics.",
+						encoding: "utf-8",
+					};
+				}
+				if (path === "evals/judge.md") {
+					return {
+						path,
+						sha: "sha3",
+						content: "Score content 0-100. Focus on specificity, tone, and accuracy.",
+						encoding: "utf-8",
+					};
+				}
+				if (path === "evals/standards/case-study.mdx") {
+					return {
+						path,
+						sha: "sha4",
+						content: "# Perfect Case Study\n\nDetailed metrics and client quotes.",
+						encoding: "utf-8",
+					};
+				}
+				return null;
+			}),
+			createOrUpdateFile: vi.fn().mockResolvedValue({
+				sha: "new-sha",
+				commit_sha: "commit-sha",
+			}),
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		knowledge: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		knowledgeStore: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		cache: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		budget: {} as any,
+		provider: { provider: "anthropic", model: "claude-sonnet-4-5-20250514" },
+		listContent: vi.fn().mockResolvedValue([]),
+		getContent: vi.fn().mockResolvedValue(null),
+		getCollectionDef: vi.fn().mockReturnValue(null),
+		listCollections: vi.fn().mockReturnValue([]),
+	};
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", evalRoutes(engine));
+	return app;
+}
+
+describe("Eval routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	describe("POST /api/eval/judge", () => {
+		it("judges a draft against gold standard", async () => {
+			const res = await app.request("/api/eval/judge", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					draft: "# Case Study\n\nWe helped a client.",
+					gold_standard: "# Perfect Case Study\n\nMetrics included.",
+					judge_prompt: "Score 0-100.",
+				}),
+			});
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.score).toBeDefined();
+			expect(body.reasoning).toBeDefined();
+		});
+
+		it("returns 400 for missing fields", async () => {
+			const res = await app.request("/api/eval/judge", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ draft: "test" }),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+
+	describe("POST /api/eval/run", () => {
+		it("runs the full eval loop", async () => {
+			const res = await app.request("/api/eval/run", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					content_type: "case-study",
+					knowledge_context: "Acme migrated 12 services.",
+					gold_standard: "# Perfect Case Study",
+					judge_prompt: "Score 0-100.",
+					generation_prompt: "Write a case study.",
+				}),
+			});
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.final_score).toBeDefined();
+			expect(body.final_status).toBeDefined();
+			expect(body.iterations).toBeInstanceOf(Array);
+		});
+
+		it("returns 400 for missing required fields", async () => {
+			const res = await app.request("/api/eval/run", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ content_type: "case-study" }),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+
+	describe("GET /api/eval/results", () => {
+		it("returns parsed eval results from TSV", async () => {
+			const res = await app.request("/api/eval/results");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(2);
+			expect(body.items[0].content_type).toBe("case-study");
+		});
+
+		it("filters by content_type query param", async () => {
+			const res = await app.request("/api/eval/results?content_type=case-study");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(2);
+		});
+
+		it("returns empty when results file not found", async () => {
+			vi.mocked(engine.github.getFile).mockResolvedValueOnce(null);
+			const res = await app.request("/api/eval/results");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(0);
+		});
+	});
+
+	describe("GET /api/eval/prompts", () => {
+		it("returns list of generation prompts", async () => {
+			const res = await app.request("/api/eval/prompts");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(2);
+			expect(body.items[0].name).toBe("case-study");
+		});
+	});
+
+	describe("GET /api/eval/prompts/:name", () => {
+		it("returns a specific generation prompt", async () => {
+			const res = await app.request("/api/eval/prompts/case-study");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.name).toBe("case-study");
+			expect(body.content).toContain("metrics");
+		});
+
+		it("returns 404 for unknown prompt", async () => {
+			vi.mocked(engine.github.getFile).mockResolvedValueOnce(null);
+			const res = await app.request("/api/eval/prompts/nonexistent");
+			expect(res.status).toBe(404);
+		});
+	});
+
+	describe("PUT /api/eval/prompts/:name", () => {
+		it("updates a generation prompt", async () => {
+			const res = await app.request("/api/eval/prompts/case-study", {
+				method: "PUT",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					content: "Improved prompt: write a case study with metrics and quotes.",
+				}),
+			});
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.updated).toBe(true);
+		});
+
+		it("returns 400 for missing content", async () => {
+			const res = await app.request("/api/eval/prompts/case-study", {
+				method: "PUT",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({}),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+
+	describe("GET /api/eval/judge-prompt", () => {
+		it("returns the judge.md prompt", async () => {
+			const res = await app.request("/api/eval/judge-prompt");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.content).toContain("Score");
+		});
+
+		it("returns 404 when judge.md not found", async () => {
+			vi.mocked(engine.github.getFile).mockResolvedValueOnce(null);
+			const res = await app.request("/api/eval/judge-prompt");
+			expect(res.status).toBe(404);
+		});
+	});
+
+	describe("GET /api/eval/standards", () => {
+		it("returns list of gold standard files", async () => {
+			const res = await app.request("/api/eval/standards");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.total).toBe(2);
+			expect(body.items[0].name).toBe("case-study");
+		});
+	});
+
+	describe("GET /api/eval/standards/:name", () => {
+		it("returns a specific gold standard", async () => {
+			const res = await app.request("/api/eval/standards/case-study");
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const body = (await res.json()) as any;
+			expect(body.name).toBe("case-study");
+			expect(body.content).toContain("Perfect");
+		});
+
+		it("returns 404 for unknown standard", async () => {
+			vi.mocked(engine.github.getFile).mockImplementation(async () => null);
+			const res = await app.request("/api/eval/standards/nonexistent");
+			expect(res.status).toBe(404);
+		});
+	});
+});