@sourcepress/server 0.1.0

package/src/routes/eval.ts

@@ -0,0 +1,262 @@
+import { EvalRunner, judge } from "@sourcepress/ai";
+import type { EvalRunConfig } from "@sourcepress/ai";
+import { Hono } from "hono";
+import type { EngineContext } from "../engine.js";
+import { SourcePressError } from "../middleware/error-handler.js";
+import { handleRouteError } from "../middleware/route-error-handler.js";
+
+export function evalRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	app.onError(handleRouteError);
+
+	// POST /eval/judge — single judge pass on content
+	app.post("/eval/judge", async (c) => {
+		const body = await c.req.json<{
+			draft: string;
+			gold_standard: string;
+			judge_prompt: string;
+			intent?: string;
+		}>();
+
+		if (!body.draft || !body.gold_standard || !body.judge_prompt) {
+			throw new SourcePressError(
+				400,
+				"INVALID_INPUT",
+				"draft, gold_standard, and judge_prompt are required",
+			);
+		}
+
+		const result = await judge(
+			{
+				draft: body.draft,
+				gold_standard: body.gold_standard,
+				judge_prompt: body.judge_prompt,
+				intent: body.intent,
+			},
+			engine.provider,
+			engine.budget,
+		);
+
+		return c.json({
+			score: result.score,
+			reasoning: result.reasoning,
+			usage: result.usage,
+		});
+	});
+
+	// POST /eval/run — full generate-judge-improve loop
+	app.post("/eval/run", async (c) => {
+		const body = await c.req.json<{
+			content_type: string;
+			knowledge_context: string;
+			gold_standard: string;
+			judge_prompt: string;
+			generation_prompt: string;
+			intent?: string;
+			threshold?: number;
+			max_iterations?: number;
+			collection_schema?: Record<string, unknown>;
+		}>();
+
+		if (
+			!body.content_type ||
+			!body.knowledge_context ||
+			!body.gold_standard ||
+			!body.judge_prompt ||
+			!body.generation_prompt
+		) {
+			throw new SourcePressError(
+				400,
+				"INVALID_INPUT",
+				"content_type, knowledge_context, gold_standard, judge_prompt, and generation_prompt are required",
+			);
+		}
+
+		const threshold =
+			body.threshold ??
+			(engine.config.evals as { threshold?: number } | undefined)?.threshold ??
+			70;
+		const maxIterations = body.max_iterations ?? 3;
+
+		const config: EvalRunConfig = {
+			content_type: body.content_type,
+			knowledge_context: body.knowledge_context,
+			gold_standard: body.gold_standard,
+			judge_prompt: body.judge_prompt,
+			generation_prompt: body.generation_prompt,
+			intent: body.intent,
+			threshold,
+			max_iterations: maxIterations,
+			collection_schema: body.collection_schema,
+		};
+
+		const runner = new EvalRunner(engine.provider, engine.budget);
+		const result = await runner.run(config);
+
+		// Log result to results.tsv
+		try {
+			const resultsPath = "evals/results.tsv";
+			const existing = await engine.github.getFile(resultsPath);
+			const header = "date\tcontent_type\tprompt_version\tscore\tstatus\treasoning";
+			const row = `${new Date().toISOString()}\t${body.content_type}\tdefault\t${result.final_score}\t${result.final_status}\t${(result.iterations[result.iterations.length - 1]?.reasoning ?? "").replace(/\t/g, " ")}`;
+			const content = existing ? `${existing.content.trimEnd()}\n${row}\n` : `${header}\n${row}\n`;
+			await engine.github.createOrUpdateFile(
+				resultsPath,
+				content,
+				"eval: log result",
+				undefined,
+				existing?.sha,
+			);
+		} catch {
+			// Non-critical — don't fail the eval if logging fails
+		}
+
+		return c.json(result);
+	});
+
+	// GET /eval/results — list eval results from evals/results.tsv in the repo
+	app.get("/eval/results", async (c) => {
+		const resultsPath = "evals/results.tsv";
+		const file = await engine.github.getFile(resultsPath);
+
+		if (!file) {
+			return c.json({ items: [], total: 0 });
+		}
+
+		const lines = file.content.trim().split("\n");
+		if (lines.length <= 1) {
+			return c.json({ items: [], total: 0 });
+		}
+
+		// Parse TSV: date, content_type, prompt_version, score, status, reasoning
+		const headers = lines[0].split("\t");
+		const items = lines.slice(1).map((line) => {
+			const values = line.split("\t");
+			const obj: Record<string, string> = {};
+			for (let i = 0; i < headers.length; i++) {
+				obj[headers[i].trim()] = values[i]?.trim() ?? "";
+			}
+			return obj;
+		});
+
+		// Filter by content_type if provided
+		const contentType = c.req.query("content_type");
+		const filtered = contentType
+			? items.filter((item) => item.content_type === contentType)
+			: items;
+
+		return c.json({ items: filtered, total: filtered.length });
+	});
+
+	// GET /eval/prompts — list generation prompts from evals/prompts/ in the repo
+	app.get("/eval/prompts", async (c) => {
+		const tree = await engine.github.getTree();
+		const promptFiles = tree
+			.filter((entry) => entry.path.startsWith("evals/prompts/") && entry.type === "blob")
+			.map((entry) => ({
+				path: entry.path,
+				name: entry.path.replace("evals/prompts/", "").replace(/\.(md|txt)$/, ""),
+			}));
+
+		return c.json({ items: promptFiles, total: promptFiles.length });
+	});
+
+	// GET /eval/prompts/:name — get a single generation prompt
+	app.get("/eval/prompts/:name", async (c) => {
+		const name = c.req.param("name");
+		const filePath = `evals/prompts/${name}.md`;
+		const file = await engine.github.getFile(filePath);
+
+		if (!file) {
+			throw new SourcePressError(404, "PROMPT_NOT_FOUND", `Generation prompt "${name}" not found`);
+		}
+
+		return c.json({
+			name,
+			path: file.path,
+			content: file.content,
+		});
+	});
+
+	// PUT /eval/prompts/:name — update a generation prompt (direct commit, self-improving)
+	app.put("/eval/prompts/:name", async (c) => {
+		const name = c.req.param("name");
+		const filePath = `evals/prompts/${name}.md`;
+		const body = await c.req.json<{ content: string }>();
+
+		if (!body.content) {
+			throw new SourcePressError(400, "INVALID_INPUT", "content is required");
+		}
+
+		const existing = await engine.github.getFile(filePath);
+		const existingSha = existing?.sha;
+
+		const result = await engine.github.createOrUpdateFile(
+			filePath,
+			body.content,
+			`update(eval): improve ${name} generation prompt`,
+			undefined,
+			existingSha,
+		);
+
+		return c.json({
+			updated: true,
+			path: filePath,
+			commit_sha: result.commit_sha,
+		});
+	});
+
+	// GET /eval/standards — list gold standard files
+	app.get("/eval/standards", async (c) => {
+		const tree = await engine.github.getTree();
+		const standardFiles = tree
+			.filter((entry) => entry.path.startsWith("evals/standards/") && entry.type === "blob")
+			.map((entry) => ({
+				path: entry.path,
+				name: entry.path.replace("evals/standards/", "").replace(/\.(mdx|md)$/, ""),
+			}));
+
+		return c.json({ items: standardFiles, total: standardFiles.length });
+	});
+
+	// GET /eval/standards/:name — get a single gold standard
+	app.get("/eval/standards/:name", async (c) => {
+		const name = c.req.param("name");
+		// Try .mdx first, then .md
+		let file = await engine.github.getFile(`evals/standards/${name}.mdx`);
+		if (!file) {
+			file = await engine.github.getFile(`evals/standards/${name}.md`);
+		}
+
+		if (!file) {
+			throw new SourcePressError(404, "STANDARD_NOT_FOUND", `Gold standard "${name}" not found`);
+		}
+
+		return c.json({
+			name,
+			path: file.path,
+			content: file.content,
+		});
+	});
+
+	// GET /eval/judge-prompt — get the judge.md prompt
+	app.get("/eval/judge-prompt", async (c) => {
+		const file = await engine.github.getFile("evals/judge.md");
+
+		if (!file) {
+			throw new SourcePressError(
+				404,
+				"JUDGE_PROMPT_NOT_FOUND",
+				"evals/judge.md not found in repository",
+			);
+		}
+
+		return c.json({
+			path: file.path,
+			content: file.content,
+		});
+	});
+
+	return app;
+}

package/src/routes/graph.ts

@@ -0,0 +1,111 @@
+import { Hono } from "hono";
+import type { EngineContext } from "../engine.js";
+import { SourcePressError } from "../middleware/error-handler.js";
+import { handleRouteError } from "../middleware/route-error-handler.js";
+
+export function graphRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	app.onError(handleRouteError);
+
+	// GET /graph — get full graph summary
+	app.get("/graph", async (c) => {
+		const graph = engine.knowledge.getGraph();
+
+		if (!graph) {
+			return c.json({
+				status: "empty",
+				message: "No graph built yet. POST /api/graph/rebuild to build.",
+				entities: 0,
+				relations: 0,
+				clusters: 0,
+			});
+		}
+
+		// Serialize Map to array for JSON
+		const entities = Array.from(graph.entities.values()).map((e) => ({
+			name: e.name,
+			type: e.type,
+			aliases: e.aliases,
+			confidence: e.confidence,
+			source_file: e.source_file,
+		}));
+
+		return c.json({
+			status: "built",
+			built_at: graph.built_at,
+			file_count: graph.file_count,
+			entity_count: entities.length,
+			relation_count: graph.relations.length,
+			cluster_count: graph.clusters.length,
+			entities,
+			relations: graph.relations,
+			clusters: graph.clusters,
+		});
+	});
+
+	// GET /graph/entity/:name — query a specific entity
+	app.get("/graph/entity/:name", async (c) => {
+		const name = decodeURIComponent(c.req.param("name"));
+		const result = engine.knowledge.query(name);
+
+		if (!result) {
+			throw new SourcePressError(
+				404,
+				"ENTITY_NOT_FOUND",
+				`Entity "${name}" not found in graph. Graph may need rebuilding.`,
+			);
+		}
+
+		return c.json(result);
+	});
+
+	// GET /graph/stale — find stale content
+	app.get("/graph/stale", async (c) => {
+		const collections = engine.listCollections();
+		const allContent = [];
+		for (const coll of collections) {
+			const files = await engine.listContent(coll);
+			allContent.push(...files);
+		}
+
+		// Build timestamps from knowledge store
+		const knowledgeFiles = await engine.knowledgeStore.list();
+		const timestamps: Record<string, string> = {};
+		for (const f of knowledgeFiles) {
+			timestamps[f.path] = f.ingested_at;
+		}
+
+		const stale = engine.knowledge.findStale(allContent, timestamps);
+		return c.json({ items: stale, total: stale.length });
+	});
+
+	// GET /graph/gaps — find knowledge gaps
+	app.get("/graph/gaps", async (c) => {
+		const collections = engine.listCollections();
+		const allContent = [];
+		for (const coll of collections) {
+			const files = await engine.listContent(coll);
+			allContent.push(...files);
+		}
+
+		const gaps = engine.knowledge.findGaps(allContent);
+		return c.json({ items: gaps, total: gaps.length });
+	});
+
+	// POST /graph/rebuild — rebuild the knowledge graph
+	app.post("/graph/rebuild", async (c) => {
+		const graph = await engine.knowledge.buildGraph();
+
+		return c.json({
+			rebuilt: true,
+			built_at: graph.built_at,
+			entity_count: graph.entities.size,
+			relation_count: graph.relations.length,
+			cluster_count: graph.clusters.length,
+			file_count: graph.file_count,
+		});
+	});
+
+	return app;
+}

package/src/routes/health.ts

@@ -0,0 +1,33 @@
+import { Hono } from "hono";
+
+export interface HealthStatus {
+	status: "ok" | "degraded" | "error";
+	version: string;
+	timestamp: string;
+	services: {
+		github: "connected" | "disconnected" | "unknown";
+		knowledge: "ready" | "empty" | "unknown";
+		cache: "ready" | "unknown";
+	};
+}
+
+export function healthRoutes() {
+	const app = new Hono();
+
+	app.get("/health", (c) => {
+		const health: HealthStatus = {
+			status: "ok",
+			version: "0.1.0",
+			timestamp: new Date().toISOString(),
+			services: {
+				github: "unknown",
+				knowledge: "unknown",
+				cache: "unknown",
+			},
+		};
+
+		return c.json(health);
+	});
+
+	return app;
+}

package/src/routes/import.ts

@@ -0,0 +1,122 @@
+import { Hono } from "hono";
+import type { EngineContext } from "../engine.js";
+import { SourcePressError } from "../middleware/error-handler.js";
+import { handleRouteError } from "../middleware/route-error-handler.js";
+
+const MAX_BATCH_SIZE = 50;
+
+export function importRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	app.onError(handleRouteError);
+
+	// POST /knowledge/import — scrape a single URL (synchronous)
+	app.post("/knowledge/import", async (c) => {
+		const body = await c.req.json<{ url: string }>();
+		if (!body.url) {
+			throw new SourcePressError(400, "INVALID_INPUT", "url is required");
+		}
+
+		try {
+			const result = await engine.knowledge.importUrl(body.url);
+			return c.json(
+				{
+					imported: true,
+					path: result.path,
+					type: result.type,
+					quality: result.quality,
+					quality_score: result.quality_score,
+					entities: result.entities,
+					source_url: result.source_url,
+				},
+				201,
+			);
+		} catch (error) {
+			throw new SourcePressError(
+				422,
+				"IMPORT_FAILED",
+				error instanceof Error ? error.message : "Failed to import URL",
+			);
+		}
+	});
+
+	// POST /knowledge/import/batch — import multiple URLs (async job)
+	app.post("/knowledge/import/batch", async (c) => {
+		if (!engine.jobs) {
+			throw new SourcePressError(501, "JOBS_NOT_CONFIGURED", "Job system not configured");
+		}
+
+		const body = await c.req.json<{ urls: string[] }>();
+		if (!body.urls || !Array.isArray(body.urls) || body.urls.length === 0) {
+			throw new SourcePressError(
+				400,
+				"INVALID_INPUT",
+				"urls array is required and must not be empty",
+			);
+		}
+		if (body.urls.length > MAX_BATCH_SIZE) {
+			throw new SourcePressError(
+				400,
+				"BATCH_TOO_LARGE",
+				`Batch size ${body.urls.length} exceeds maximum of ${MAX_BATCH_SIZE}`,
+			);
+		}
+
+		const jobId = await engine.jobs.enqueue({
+			type: "import-batch",
+			params: { urls: body.urls },
+		});
+		const jobStatus = await engine.jobs.status(jobId);
+
+		return c.json(jobStatus, 202);
+	});
+
+	// POST /knowledge/import/sitemap — parse sitemap for interactive selection
+	app.post("/knowledge/import/sitemap", async (c) => {
+		const body = await c.req.json<{ url: string }>();
+		if (!body.url) {
+			throw new SourcePressError(400, "INVALID_INPUT", "url is required");
+		}
+
+		try {
+			const result = await engine.knowledge.parseSitemap(body.url);
+			return c.json(result);
+		} catch (error) {
+			throw new SourcePressError(
+				422,
+				"SITEMAP_PARSE_FAILED",
+				error instanceof Error ? error.message : "Failed to parse sitemap",
+			);
+		}
+	});
+
+	// POST /knowledge/import/sitemap/run — run sitemap import with filters (async job)
+	app.post("/knowledge/import/sitemap/run", async (c) => {
+		if (!engine.jobs) {
+			throw new SourcePressError(501, "JOBS_NOT_CONFIGURED", "Job system not configured");
+		}
+
+		const body = await c.req.json<{
+			sitemap_url: string;
+			include?: string[];
+			exclude?: string[];
+		}>();
+		if (!body.sitemap_url) {
+			throw new SourcePressError(400, "INVALID_INPUT", "sitemap_url is required");
+		}
+
+		const jobId = await engine.jobs.enqueue({
+			type: "import-sitemap",
+			params: {
+				sitemap_url: body.sitemap_url,
+				include: body.include,
+				exclude: body.exclude,
+			},
+		});
+		const jobStatus = await engine.jobs.status(jobId);
+
+		return c.json(jobStatus, 202);
+	});
+
+	return app;
+}

package/src/routes/index.ts

@@ -0,0 +1,11 @@
+export { approvalRoutes } from "./approval.js";
+export { healthRoutes } from "./health.js";
+export { contentRoutes } from "./content.js";
+export { knowledgeRoutes } from "./knowledge.js";
+export { graphRoutes } from "./graph.js";
+export { schemaRoutes } from "./schema.js";
+export { intentRoutes } from "./intent.js";
+export { evalRoutes } from "./eval.js";
+export { mediaRoutes } from "./media.js";
+export { jobRoutes } from "./jobs.js";
+export { importRoutes } from "./import.js";

package/src/routes/intent.ts

@@ -0,0 +1,105 @@
+import { Hono } from "hono";
+import type { EngineContext } from "../engine.js";
+import { SourcePressError } from "../middleware/error-handler.js";
+import { handleRouteError } from "../middleware/route-error-handler.js";
+
+export function intentRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	// GET /intent — list intent files
+	app.get("/intent", async (c) => {
+		const intentPath = engine.config.intent.path;
+		const tree = await engine.github.getTree();
+		const intentFiles = tree
+			.filter((entry) => entry.path.startsWith(intentPath) && entry.type === "blob")
+			.map((entry) => ({
+				path: entry.path,
+				name: entry.path.replace(intentPath, "").replace(/\.(md|yaml|json)$/, ""),
+			}));
+
+		return c.json({ items: intentFiles, total: intentFiles.length });
+	});
+
+	// GET /intent/:name — get a single intent file
+	app.get("/intent/:name", async (c) => {
+		const name = c.req.param("name");
+		const intentPath = engine.config.intent.path;
+		const filePath = `${intentPath}${name}.md`;
+		const file = await engine.github.getFile(filePath);
+
+		if (!file) {
+			throw new SourcePressError(404, "INTENT_NOT_FOUND", `Intent "${name}" not found`);
+		}
+
+		return c.json({
+			name,
+			path: file.path,
+			content: file.content,
+		});
+	});
+
+	// PUT /intent/:name — update an intent file (direct commit, intent is human-owned)
+	app.put("/intent/:name", async (c) => {
+		const name = c.req.param("name");
+		const intentPath = engine.config.intent.path;
+		const filePath = `${intentPath}${name}.md`;
+
+		const body = await c.req.json<{ content: string }>();
+
+		if (!body.content) {
+			throw new SourcePressError(400, "INVALID_INPUT", "content is required");
+		}
+
+		// Check if file exists to get SHA
+		const existing = await engine.github.getFile(filePath);
+		const existingSha = existing?.sha;
+
+		const result = await engine.github.createOrUpdateFile(
+			filePath,
+			body.content,
+			`update(intent): update ${name}`,
+			undefined,
+			existingSha,
+		);
+
+		return c.json({
+			updated: true,
+			path: filePath,
+			commit_sha: result.commit_sha,
+		});
+	});
+
+	// GET /intent/:name/impact — analyze which content is affected by this intent
+	app.get("/intent/:name/impact", async (c) => {
+		const name = c.req.param("name");
+		const intentPath = engine.config.intent.path;
+		const filePath = `${intentPath}${name}.md`;
+		const file = await engine.github.getFile(filePath);
+
+		if (!file) {
+			throw new SourcePressError(404, "INTENT_NOT_FOUND", `Intent "${name}" not found`);
+		}
+
+		// Collect all content
+		const collections = engine.listCollections();
+		const allContent = [];
+		for (const coll of collections) {
+			const files = await engine.listContent(coll);
+			allContent.push(...files);
+		}
+
+		// Return content count — full AI-based impact analysis requires
+		// the previous version of intent, which we defer to a future enhancement
+		return c.json({
+			intent: name,
+			content_count: allContent.length,
+			message:
+				"Full AI-based intent impact analysis requires previous intent version. Use POST /api/intent/:name/impact with previous_content field for detailed analysis.",
+			content_paths: allContent.map((f) => f.path),
+		});
+	});
+
+	app.onError(handleRouteError);
+
+	return app;
+}