@sourcepress/server 0.1.0

package/src/__tests__/graph.test.ts

@@ -0,0 +1,182 @@
+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 { graphRoutes } from "../routes/graph.js";
+
+const mockGraph = {
+	entities: new Map([
+		[
+			"Acme Corp",
+			{
+				type: "client",
+				name: "Acme Corp",
+				aliases: ["Acme"],
+				confidence: 0.95,
+				source_file: "knowledge/clients/acme.md",
+			},
+		],
+		[
+			"Next.js",
+			{
+				type: "technology",
+				name: "Next.js",
+				aliases: ["nextjs"],
+				confidence: 0.9,
+				source_file: "knowledge/clients/acme.md",
+			},
+		],
+	]),
+	relations: [
+		{
+			from_entity: "Acme Corp",
+			to_entity: "Next.js",
+			relation_type: "uses",
+			confidence: 0.8,
+			evidence: "Migration to Next.js",
+			source_file: "knowledge/clients/acme.md",
+		},
+	],
+	clusters: [],
+	built_at: "2026-04-01T00:00:00Z",
+	file_count: 1,
+};
+
+function createMockEngine(): EngineContext {
+	return {
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		config: {} as any,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		github: {} as any,
+		knowledge: {
+			getGraph: vi.fn().mockReturnValue(mockGraph),
+			query: vi.fn().mockImplementation((name: string) => {
+				const entity = mockGraph.entities.get(name);
+				if (!entity) return null;
+				return {
+					entity,
+					relations: mockGraph.relations.filter(
+						(r) => r.from_entity === name || r.to_entity === name,
+					),
+					related_entities: [],
+					files: [entity.source_file],
+				};
+			}),
+			findStale: vi.fn().mockReturnValue([]),
+			findGaps: vi.fn().mockReturnValue([
+				{
+					entity_name: "Acme Corp",
+					entity_type: "client",
+					knowledge_file_count: 1,
+					content_file_count: 0,
+					reason: "No content for Acme Corp",
+				},
+			]),
+			buildGraph: vi.fn().mockResolvedValue(mockGraph),
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} as any,
+		knowledgeStore: {
+			list: vi.fn().mockResolvedValue([]),
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} 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().mockResolvedValue([]),
+		getContent: vi.fn().mockResolvedValue(null),
+		getCollectionDef: vi.fn().mockReturnValue(null),
+		listCollections: vi.fn().mockReturnValue(["posts"]),
+	};
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", graphRoutes(engine));
+	return app;
+}
+
+describe("Graph routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	describe("GET /api/graph", () => {
+		it("returns graph summary when graph exists", async () => {
+			const res = await app.request("/api/graph");
+			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.status).toBe("built");
+			expect(body.entity_count).toBe(2);
+			expect(body.relation_count).toBe(1);
+		});
+
+		it("returns empty status when no graph", async () => {
+			// biome-ignore lint/suspicious/noExplicitAny: accessing vi mock method on typed interface
+			(engine.knowledge.getGraph as any).mockReturnValue(null);
+			const res = await app.request("/api/graph");
+			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.status).toBe("empty");
+		});
+	});
+
+	describe("GET /api/graph/entity/:name", () => {
+		it("returns entity with relations", async () => {
+			const res = await app.request("/api/graph/entity/Acme%20Corp");
+			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.entity.name).toBe("Acme Corp");
+		});
+
+		it("returns 404 for unknown entity", async () => {
+			const res = await app.request("/api/graph/entity/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("ENTITY_NOT_FOUND");
+		});
+	});
+
+	describe("GET /api/graph/gaps", () => {
+		it("returns knowledge gaps", async () => {
+			const res = await app.request("/api/graph/gaps");
+			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(1);
+			expect(body.items[0].entity_name).toBe("Acme Corp");
+		});
+	});
+
+	describe("GET /api/graph/stale", () => {
+		it("returns stale content list", async () => {
+			const res = await app.request("/api/graph/stale");
+			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("POST /api/graph/rebuild", () => {
+		it("rebuilds graph and returns stats", async () => {
+			const res = await app.request("/api/graph/rebuild", { method: "POST" });
+			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.rebuilt).toBe(true);
+			expect(body.entity_count).toBe(2);
+		});
+	});
+});

package/src/__tests__/health.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import { createApp } from "../app.js";
+import type { HealthStatus } from "../routes/health.js";
+
+describe("Health endpoint", () => {
+	const app = createApp();
+
+	it("GET /api/health returns 200 with status ok", async () => {
+		const res = await app.request("/api/health");
+		expect(res.status).toBe(200);
+
+		const body = (await res.json()) as HealthStatus;
+		expect(body.status).toBe("ok");
+		expect(body.version).toBe("0.1.0");
+		expect(body.timestamp).toBeDefined();
+		expect(body.services).toBeDefined();
+	});
+
+	it("returns correct service status fields", async () => {
+		const res = await app.request("/api/health");
+		const body = (await res.json()) as HealthStatus;
+
+		expect(body.services.github).toBe("unknown");
+		expect(body.services.knowledge).toBe("unknown");
+		expect(body.services.cache).toBe("unknown");
+	});
+});
+
+describe("CORS middleware", () => {
+	const app = createApp();
+
+	it("responds to OPTIONS with CORS headers", async () => {
+		const res = await app.request("/api/health", {
+			method: "OPTIONS",
+			headers: {
+				Origin: "http://localhost:3000",
+				"Access-Control-Request-Method": "GET",
+			},
+		});
+		// CORS now denies by default and only reflects allowed origins, not wildcard
+		expect(res.headers.get("access-control-allow-origin")).toBe("http://localhost:3000");
+	});
+});
+
+describe("Error handler", () => {
+	const app = createApp();
+
+	it("returns 404 for unknown routes", async () => {
+		const res = await app.request("/api/nonexistent");
+		expect(res.status).toBe(404);
+	});
+});
+
+describe("Auth middleware", () => {
+	const app = createApp();
+
+	it("allows requests without auth header", async () => {
+		const res = await app.request("/api/health");
+		expect(res.status).toBe(200);
+	});
+
+	it("allows requests with Bearer token", async () => {
+		const res = await app.request("/api/health", {
+			headers: { Authorization: "Bearer test-token" },
+		});
+		expect(res.status).toBe(200);
+	});
+});

package/src/__tests__/import.test.ts

@@ -0,0 +1,148 @@
+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 { importRoutes } from "../routes/import.js";
+
+function createMockEngine(): EngineContext {
+	return {
+		knowledge: {
+			importUrl: vi.fn().mockResolvedValue({
+				path: "knowledge/example.com/page.md",
+				type: "article",
+				quality: "structured",
+				quality_score: 0.8,
+				entities: [{ type: "company", name: "Acme" }],
+				source: "url",
+				source_url: "https://example.com/page",
+				body: "content",
+				ingested_at: "2026-04-04T10:00:00Z",
+			}),
+			parseSitemap: vi.fn().mockResolvedValue({
+				sitemap_url: "https://example.com/sitemap.xml",
+				sections: [
+					{ name: "Blog", pattern: "/blog/*", urls: ["https://example.com/blog/1"], count: 1 },
+					{
+						name: "Services",
+						pattern: "/services/*",
+						urls: ["https://example.com/services/web"],
+						count: 1,
+					},
+				],
+				total_urls: 2,
+			}),
+			filterSitemapUrls: vi.fn().mockReturnValue(["https://example.com/services/web"]),
+			importBatch: vi.fn(),
+		},
+		jobs: {
+			enqueue: vi.fn().mockResolvedValue("job-1"),
+			status: vi.fn().mockResolvedValue({
+				job_id: "job-1",
+				type: "import-batch",
+				status: "queued",
+				progress: { completed: 0, total: 0, failed: 0 },
+				created_at: "2026-04-04T10:00:00Z",
+			}),
+			register: vi.fn(),
+			cancel: vi.fn(),
+			list: vi.fn(),
+		},
+	} as unknown as EngineContext;
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", importRoutes(engine));
+	return app;
+}
+
+describe("Import routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	describe("POST /knowledge/import", () => {
+		it("imports a single URL", async () => {
+			const res = await app.request("/api/knowledge/import", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ url: "https://example.com/page" }),
+			});
+			expect(res.status).toBe(201);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const data = (await res.json()) as any;
+			expect(data.imported).toBe(true);
+			expect(data.path).toBe("knowledge/example.com/page.md");
+		});
+
+		it("rejects missing url", async () => {
+			const res = await app.request("/api/knowledge/import", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({}),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+
+	describe("POST /knowledge/import/batch", () => {
+		it("enqueues a batch import job", async () => {
+			const res = await app.request("/api/knowledge/import/batch", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ urls: ["https://example.com/a", "https://example.com/b"] }),
+			});
+			expect(res.status).toBe(202);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const data = (await res.json()) as any;
+			expect(data.job_id).toBe("job-1");
+			expect(data.type).toBe("import-batch");
+		});
+
+		it("rejects empty urls array", async () => {
+			const res = await app.request("/api/knowledge/import/batch", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ urls: [] }),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+
+	describe("POST /knowledge/import/sitemap", () => {
+		it("parses a sitemap and returns sections", async () => {
+			const res = await app.request("/api/knowledge/import/sitemap", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ url: "https://example.com/sitemap.xml" }),
+			});
+			expect(res.status).toBe(200);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const data = (await res.json()) as any;
+			expect(data.total_urls).toBe(2);
+			expect(data.sections).toHaveLength(2);
+		});
+	});
+
+	describe("POST /knowledge/import/sitemap/run", () => {
+		it("enqueues a sitemap import job", async () => {
+			const res = await app.request("/api/knowledge/import/sitemap/run", {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					sitemap_url: "https://example.com/sitemap.xml",
+					include: ["/services/*"],
+				}),
+			});
+			expect(res.status).toBe(202);
+			// biome-ignore lint/suspicious/noExplicitAny: typed JSON response parsing in tests
+			const data = (await res.json()) as any;
+			expect(data.job_id).toBe("job-1");
+		});
+	});
+});

package/src/__tests__/intent.test.ts

@@ -0,0 +1,133 @@
+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 { intentRoutes } from "../routes/intent.js";
+
+function createMockEngine(): EngineContext {
+	return {
+		config: {
+			intent: { path: "intent/" },
+			// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		} as any,
+		github: {
+			getTree: vi.fn().mockResolvedValue([
+				{ path: "intent/tone-of-voice.md", sha: "abc", type: "blob" },
+				{ path: "intent/brand-rules.md", sha: "def", type: "blob" },
+			]),
+			getFile: vi.fn().mockImplementation(async (path: string) => {
+				if (path === "intent/tone-of-voice.md") {
+					return {
+						path: "intent/tone-of-voice.md",
+						sha: "abc123",
+						content: "# Tone of Voice\n\n- Vi-form\n- Konkreta resultat",
+						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,
+		// biome-ignore lint/suspicious/noExplicitAny: partial mock of EngineContext
+		provider: {} as any,
+		listContent: vi.fn().mockResolvedValue([]),
+		getContent: vi.fn().mockResolvedValue(null),
+		getCollectionDef: vi.fn().mockReturnValue(null),
+		listCollections: vi.fn().mockReturnValue(["posts"]),
+	};
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", intentRoutes(engine));
+	return app;
+}
+
+describe("Intent routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	describe("GET /api/intent", () => {
+		it("returns list of intent files", async () => {
+			const res = await app.request("/api/intent");
+			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("tone-of-voice");
+		});
+	});
+
+	describe("GET /api/intent/:name", () => {
+		it("returns intent file content", async () => {
+			const res = await app.request("/api/intent/tone-of-voice");
+			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("tone-of-voice");
+			expect(body.content).toContain("Vi-form");
+		});
+
+		it("returns 404 for unknown intent", async () => {
+			const res = await app.request("/api/intent/nonexistent");
+			expect(res.status).toBe(404);
+		});
+	});
+
+	describe("PUT /api/intent/:name", () => {
+		it("updates intent file", async () => {
+			const res = await app.request("/api/intent/tone-of-voice", {
+				method: "PUT",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ content: "# Updated tone\n\n- New rules" }),
+			});
+			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/intent/tone-of-voice", {
+				method: "PUT",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({}),
+			});
+			expect(res.status).toBe(400);
+		});
+	});
+
+	describe("GET /api/intent/:name/impact", () => {
+		it("returns impact analysis placeholder", async () => {
+			const res = await app.request("/api/intent/tone-of-voice/impact");
+			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.intent).toBe("tone-of-voice");
+			expect(body.content_count).toBeDefined();
+		});
+
+		it("returns 404 for unknown intent", async () => {
+			const res = await app.request("/api/intent/nonexistent/impact");
+			expect(res.status).toBe(404);
+		});
+	});
+});

package/src/__tests__/jobs.test.ts

@@ -0,0 +1,107 @@
+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 { jobRoutes } from "../routes/jobs.js";
+
+function createMockEngine(withJobs = true): EngineContext {
+	const jobs = withJobs
+		? {
+				enqueue: vi.fn().mockResolvedValue("job-1"),
+				status: vi.fn().mockResolvedValue({
+					job_id: "job-1",
+					type: "rebuild-graph",
+					status: "completed",
+					progress: { completed: 1, total: 1, failed: 0 },
+					created_at: "2026-04-04T10:00:00Z",
+					completed_at: "2026-04-04T10:01:00Z",
+				}),
+				cancel: vi.fn().mockResolvedValue(undefined),
+				list: vi.fn().mockResolvedValue([
+					{
+						job_id: "job-1",
+						type: "rebuild-graph",
+						status: "completed",
+						progress: { completed: 1, total: 1, failed: 0 },
+						created_at: "2026-04-04T10:00:00Z",
+					},
+					{
+						job_id: "job-2",
+						type: "sync",
+						status: "running",
+						progress: { completed: 5, total: 10, failed: 0 },
+						created_at: "2026-04-04T10:02:00Z",
+					},
+				]),
+				register: vi.fn(),
+			}
+		: undefined;
+
+	return { jobs } as unknown as EngineContext;
+}
+
+function createTestApp(engine: EngineContext) {
+	const app = new Hono().basePath("/api");
+	app.use("*", errorHandler());
+	app.route("/", jobRoutes(engine));
+	return app;
+}
+
+describe("Job routes", () => {
+	let engine: EngineContext;
+	let app: Hono;
+
+	beforeEach(() => {
+		engine = createMockEngine();
+		app = createTestApp(engine);
+	});
+
+	it("GET /api/jobs lists all jobs", async () => {
+		const res = await app.request("/api/jobs");
+		expect(res.status).toBe(200);
+		const body = (await res.json()) as Record<string, unknown>;
+		expect(body.total).toBe(2);
+	});
+
+	it("GET /api/jobs/:id returns job status", async () => {
+		const res = await app.request("/api/jobs/job-1");
+		expect(res.status).toBe(200);
+		const body = (await res.json()) as Record<string, unknown>;
+		expect(body.job_id).toBe("job-1");
+		expect(body.status).toBe("completed");
+	});
+
+	it("POST /api/jobs starts a new job", async () => {
+		const res = await app.request("/api/jobs", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ type: "rebuild-graph" }),
+		});
+		expect(res.status).toBe(201);
+		const body = (await res.json()) as Record<string, unknown>;
+		expect(body.job_id).toBe("job-1");
+	});
+
+	it("POST /api/jobs returns 400 without type", async () => {
+		const res = await app.request("/api/jobs", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({}),
+		});
+		expect(res.status).toBe(400);
+	});
+
+	it("DELETE /api/jobs/:id cancels a job", async () => {
+		const res = await app.request("/api/jobs/job-1", { method: "DELETE" });
+		expect(res.status).toBe(200);
+		const body = (await res.json()) as Record<string, unknown>;
+		expect(body.cancelled).toBe(true);
+	});
+
+	it("returns 501 when jobs not configured", async () => {
+		const noJobsEngine = createMockEngine(false);
+		const noJobsApp = createTestApp(noJobsEngine);
+		const res = await noJobsApp.request("/api/jobs");
+		expect(res.status).toBe(501);
+	});
+});