@sourcepress/server 0.1.0

package/src/routes/jobs.ts

@@ -0,0 +1,84 @@
+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 jobRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	// GET /jobs — list all jobs
+	app.get("/jobs", async (c) => {
+		if (!engine.jobs) {
+			throw new SourcePressError(501, "JOBS_NOT_CONFIGURED", "Job system not configured");
+		}
+		const status = c.req.query("status") as
+			| "queued"
+			| "running"
+			| "completed"
+			| "failed"
+			| "cancelled"
+			| undefined;
+		const type = c.req.query("type");
+		const limitStr = c.req.query("limit");
+		const limit = limitStr ? Number.parseInt(limitStr, 10) : undefined;
+
+		const jobs = await engine.jobs.list({ status, type, limit });
+		return c.json({ items: jobs, total: jobs.length });
+	});
+
+	// GET /jobs/:id — get job status
+	app.get("/jobs/:id", async (c) => {
+		if (!engine.jobs) {
+			throw new SourcePressError(501, "JOBS_NOT_CONFIGURED", "Job system not configured");
+		}
+		const id = c.req.param("id");
+		const job = await engine.jobs.status(id);
+		if (!job) {
+			throw new SourcePressError(404, "JOB_NOT_FOUND", `Job "${id}" not found`);
+		}
+		return c.json(job);
+	});
+
+	// POST /jobs — start a new job
+	app.post("/jobs", async (c) => {
+		if (!engine.jobs) {
+			throw new SourcePressError(501, "JOBS_NOT_CONFIGURED", "Job system not configured");
+		}
+		const body = await c.req.json<{ type: string; params?: Record<string, unknown> }>();
+		if (!body.type) {
+			throw new SourcePressError(400, "INVALID_INPUT", "type is required");
+		}
+		try {
+			const jobId = await engine.jobs.enqueue({ type: body.type, params: body.params ?? {} });
+			const jobStatus = await engine.jobs.status(jobId);
+			return c.json(jobStatus, 201);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("No handler registered")) {
+				throw new SourcePressError(400, "UNKNOWN_JOB_TYPE", error.message);
+			}
+			throw error;
+		}
+	});
+
+	// DELETE /jobs/:id — cancel a job
+	app.delete("/jobs/:id", async (c) => {
+		if (!engine.jobs) {
+			throw new SourcePressError(501, "JOBS_NOT_CONFIGURED", "Job system not configured");
+		}
+		const id = c.req.param("id");
+		const existing = await engine.jobs.status(id);
+		if (!existing) {
+			throw new SourcePressError(
+				404,
+				"JOB_NOT_FOUND",
+				`Job "${id}" not found or already completed`,
+			);
+		}
+		await engine.jobs.cancel(id);
+		return c.json({ cancelled: true, id });
+	});
+
+	app.onError(handleRouteError);
+
+	return app;
+}

package/src/routes/knowledge.ts

@@ -0,0 +1,73 @@
+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 knowledgeRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	app.onError(handleRouteError);
+
+	// GET /knowledge — list knowledge files
+	app.get("/knowledge", async (c) => {
+		const files = await engine.knowledgeStore.list();
+		const items = files.map((f) => ({
+			path: f.path,
+			type: f.type,
+			quality: f.quality,
+			quality_score: f.quality_score,
+			entities: f.entities,
+			ingested_at: f.ingested_at,
+			source: f.source,
+		}));
+
+		return c.json({ items, total: items.length });
+	});
+
+	// GET /knowledge/:path — get a single knowledge file (path is URL-encoded)
+	app.get("/knowledge/:path{.+}", async (c) => {
+		const path = c.req.param("path");
+		const file = await engine.knowledgeStore.retrieve(path);
+
+		if (!file) {
+			throw new SourcePressError(404, "KNOWLEDGE_NOT_FOUND", `Knowledge file "${path}" not found`);
+		}
+
+		return c.json(file);
+	});
+
+	// POST /knowledge — ingest new knowledge (classify + store)
+	app.post("/knowledge", async (c) => {
+		const body = await c.req.json<{
+			path: string;
+			body: string;
+			source?: "manual" | "url" | "document" | "transcript" | "scrape";
+			source_url?: string;
+		}>();
+
+		if (!body.path || !body.body) {
+			throw new SourcePressError(400, "INVALID_INPUT", "path and body are required");
+		}
+
+		const knowledgeFile = await engine.knowledge.ingest(
+			body.path,
+			body.body,
+			body.source ?? "manual",
+			body.source_url,
+		);
+
+		return c.json(
+			{
+				ingested: true,
+				path: knowledgeFile.path,
+				type: knowledgeFile.type,
+				quality: knowledgeFile.quality,
+				quality_score: knowledgeFile.quality_score,
+				entities: knowledgeFile.entities,
+			},
+			201,
+		);
+	});
+
+	return app;
+}

package/src/routes/media.ts

@@ -0,0 +1,117 @@
+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 mediaRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	app.onError(handleRouteError);
+
+	// GET /media — list all media with metadata
+	app.get("/media", async (c) => {
+		if (!engine.media) {
+			throw new SourcePressError(501, "MEDIA_NOT_CONFIGURED", "Media storage not configured");
+		}
+
+		const prefix = c.req.query("prefix");
+		const items = await engine.media.list(prefix ?? undefined);
+		return c.json({ items, total: items.length });
+	});
+
+	// POST /media/upload — upload a media file (multipart form)
+	app.post("/media/upload", async (c) => {
+		if (!engine.media) {
+			throw new SourcePressError(501, "MEDIA_NOT_CONFIGURED", "Media storage not configured");
+		}
+
+		const formData = await c.req.formData();
+		const file = formData.get("file");
+		const path = formData.get("path");
+		const source = formData.get("source");
+
+		if (!file || !(file instanceof File)) {
+			throw new SourcePressError(400, "INVALID_INPUT", "Missing file in form data");
+		}
+		if (!path || typeof path !== "string") {
+			throw new SourcePressError(400, "INVALID_INPUT", "Missing path in form data");
+		}
+		if (!source || typeof source !== "string") {
+			throw new SourcePressError(400, "INVALID_INPUT", "Missing source in form data");
+		}
+
+		const validSources = ["uploaded", "ai-generated", "scraped", "stock"] as const;
+		if (!validSources.includes(source as (typeof validSources)[number])) {
+			throw new SourcePressError(
+				400,
+				"INVALID_INPUT",
+				`Invalid source. Must be one of: ${validSources.join(", ")}`,
+			);
+		}
+
+		const buffer = Buffer.from(await file.arrayBuffer());
+		const alt = formData.get("alt");
+		const generatedBy = formData.get("generated_by");
+		const prompt = formData.get("prompt");
+
+		const ref = await engine.media.upload({
+			file: buffer,
+			path,
+			content_type: file.type,
+			source: source as "uploaded" | "ai-generated" | "scraped" | "stock",
+			alt: typeof alt === "string" ? alt : undefined,
+			generated_by: typeof generatedBy === "string" ? generatedBy : undefined,
+			prompt: typeof prompt === "string" ? prompt : undefined,
+			uploaded_by: "api", // TODO: use auth context when available
+		});
+
+		return c.json(ref, 201);
+	});
+
+	// GET /media/:path — get metadata for a specific file
+	app.get("/media/:path{.+}", async (c) => {
+		if (!engine.media) {
+			throw new SourcePressError(501, "MEDIA_NOT_CONFIGURED", "Media storage not configured");
+		}
+
+		const path = c.req.param("path");
+		const meta = await engine.media.getMeta(path);
+
+		if (!meta) {
+			throw new SourcePressError(404, "MEDIA_NOT_FOUND", `Media not found: ${path}`);
+		}
+
+		return c.json(meta);
+	});
+
+	// PUT /media/:path — update metadata for a media file
+	app.put("/media/:path{.+}", async (c) => {
+		if (!engine.media) {
+			throw new SourcePressError(501, "MEDIA_NOT_CONFIGURED", "Media storage not configured");
+		}
+
+		const path = c.req.param("path");
+		const body = await c.req.json<{
+			alt?: string;
+			source?: "uploaded" | "ai-generated" | "scraped" | "stock";
+			generated_by?: string;
+			prompt?: string;
+		}>();
+
+		const updated = await engine.media.updateMeta(path, body);
+		return c.json(updated);
+	});
+
+	// DELETE /media/:path — delete a media file
+	app.delete("/media/:path{.+}", async (c) => {
+		if (!engine.media) {
+			throw new SourcePressError(501, "MEDIA_NOT_CONFIGURED", "Media storage not configured");
+		}
+
+		const path = c.req.param("path");
+		await engine.media.delete(path);
+		return c.json({ deleted: true, path });
+	});
+
+	return app;
+}

package/src/routes/schema.ts

@@ -0,0 +1,75 @@
+import { collectionToZod } from "@sourcepress/core";
+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 schemaRoutes(engine: EngineContext) {
+	const app = new Hono();
+
+	// GET /schema — full schema (all collections)
+	app.get("/schema", (c) => {
+		const collections = engine.listCollections();
+		const schema: Record<
+			string,
+			{
+				name: string;
+				path: string;
+				format: string;
+				fields: Record<string, unknown>;
+			}
+		> = {};
+
+		for (const name of collections) {
+			const def = engine.getCollectionDef(name);
+			if (def) {
+				schema[name] = {
+					name: def.name,
+					path: def.path,
+					format: def.format,
+					fields: def.fields,
+				};
+			}
+		}
+
+		return c.json({
+			collections: schema,
+			total: collections.length,
+		});
+	});
+
+	// GET /schema/:collection — schema for a single collection
+	app.get("/schema/:collection", (c) => {
+		const collection = c.req.param("collection");
+		const def = engine.getCollectionDef(collection);
+
+		if (!def) {
+			throw new SourcePressError(
+				404,
+				"COLLECTION_NOT_FOUND",
+				`Collection "${collection}" not found`,
+			);
+		}
+
+		// Generate Zod schema description for reference
+		let zodDescription: string | null = null;
+		try {
+			const zodSchema = collectionToZod(def);
+			zodDescription = JSON.stringify(zodSchema.shape, null, 2);
+		} catch {
+			zodDescription = null;
+		}
+
+		return c.json({
+			name: def.name,
+			path: def.path,
+			format: def.format,
+			fields: def.fields,
+			zod_shape: zodDescription,
+		});
+	});
+
+	app.onError(handleRouteError);
+
+	return app;
+}

package/src/standalone.ts

@@ -0,0 +1,130 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { serve } from "@hono/node-server";
+import type { SourcePressConfig } from "@sourcepress/core";
+import { createApp } from "./app.js";
+import { createEngine } from "./engine.js";
+
+function loadEnv(dir: string): void {
+	const envPath = resolve(dir, ".env");
+	if (!existsSync(envPath)) return;
+	const content = readFileSync(envPath, "utf-8");
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = trimmed.slice(0, eqIndex).trim();
+		const value = trimmed.slice(eqIndex + 1).trim();
+		if (!process.env[key]) {
+			process.env[key] = value;
+		}
+	}
+}
+
+// TODO: loadConfig + loadEnv here duplicate the logic in packages/cli/src/config.ts — consolidate into a shared utility
+async function loadConfig(dir: string): Promise<SourcePressConfig> {
+	const tsPath = resolve(dir, "sourcepress.config.ts");
+	const jsPath = resolve(dir, "sourcepress.config.js");
+
+	// Prefer .js (works without compilation) over .ts
+	const configPath = existsSync(jsPath) ? jsPath : existsSync(tsPath) ? tsPath : null;
+
+	if (configPath) {
+		try {
+			// Try direct import first (works if running via tsx or if .js)
+			const mod = await import(configPath);
+			return mod.default ?? mod;
+		} catch {
+			// If .ts import fails, try compiling with esbuild
+			if (configPath.endsWith(".ts")) {
+				try {
+					const { execFileSync } = await import("node:child_process");
+					const tmpJs = resolve(dir, ".sourcepress.config.tmp.mjs");
+					execFileSync(
+						"npx",
+						[
+							"esbuild",
+							configPath,
+							"--bundle",
+							"--format=esm",
+							"--platform=node",
+							`--outfile=${tmpJs}`,
+							"--external:@sourcepress/*",
+						],
+						{ stdio: "pipe" },
+					);
+					const mod = await import(tmpJs);
+					const { unlinkSync } = await import("node:fs");
+					unlinkSync(tmpJs);
+					return mod.default ?? mod;
+				} catch (e) {
+					console.warn(`Could not compile ${configPath}:`, e instanceof Error ? e.message : e);
+				}
+			}
+			console.warn(`Could not load ${configPath}, using env-based config`);
+		}
+	}
+
+	// Fallback: build config from env vars
+	return {
+		repository: {
+			owner: process.env.GITHUB_OWNER ?? "sourcepress",
+			repo: process.env.GITHUB_REPO ?? "demo",
+			branch: process.env.GITHUB_BRANCH ?? "main",
+		},
+		ai: {
+			provider: (process.env.AI_PROVIDER as "anthropic" | "openai" | "local") ?? "anthropic",
+			model: process.env.AI_MODEL ?? "claude-sonnet-4-5-20250514",
+		},
+		collections: {},
+		knowledge: { path: "knowledge/", graph: { backend: "local" } },
+		intent: { path: "intent/" },
+	};
+}
+
+async function main() {
+	const projectDir = process.argv[2] || process.cwd();
+	const port = Number(process.env.PORT ?? 4321);
+
+	// Load .env from project directory
+	loadEnv(projectDir);
+
+	const githubToken = process.env.GITHUB_TOKEN;
+	if (!githubToken) {
+		console.error("GITHUB_TOKEN is required. Set it in .env or as environment variable.");
+		process.exit(1);
+	}
+
+	const config = await loadConfig(projectDir);
+
+	console.log(`Project: ${projectDir}`);
+	console.log(`Repository: ${config.repository.owner}/${config.repository.repo}`);
+	console.log(`Collections: ${Object.keys(config.collections).join(", ") || "(none)"}`);
+
+	const apiKeysRaw = process.env.SOURCEPRESS_API_KEYS ?? process.env.API_KEYS;
+	const apiKeys = apiKeysRaw
+		? apiKeysRaw
+				.split(",")
+				.map((k) => k.trim())
+				.filter(Boolean)
+		: undefined;
+
+	const engine = await createEngine({
+		config,
+		githubToken,
+		aiApiKey: process.env.ANTHROPIC_API_KEY ?? process.env.AI_API_KEY,
+		apiKeys,
+	});
+
+	const app = createApp(engine, apiKeys);
+
+	console.log(`\nSourcePress API running at http://localhost:${port}`);
+	console.log(`Health:  http://localhost:${port}/api/health`);
+	console.log(`Schema:  http://localhost:${port}/api/schema`);
+	console.log(`Content: http://localhost:${port}/api/content`);
+
+	serve({ fetch: app.fetch, port });
+}
+
+main();

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