@payconductor/houndsman 0.2.0 → 0.4.0

package/src/tests/markdown.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Markdown mínimo do `action` — blocos, inline e sanitização de links.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { parseInline, parseMarkdown, safeUrl } from "../server/client/markdown";
+
+describe("parseMarkdown", () => {
+	test("separa parágrafos, listas, quote e bloco de código", () => {
+		const blocks = parseMarkdown(
+			"Primeira linha\nsegunda linha.\n\n- um\n- dois\n\n1. passo\n2. outro\n\n> nota\n\n```ts\nconst x = 1;\n```",
+		);
+		expect(blocks.map((block) => block.type)).toEqual([
+			"paragraph",
+			"list",
+			"list",
+			"quote",
+			"code",
+		]);
+		expect(blocks[0]).toEqual({
+			type: "paragraph",
+			text: "Primeira linha\nsegunda linha.",
+		});
+		expect(blocks[1]).toEqual({
+			type: "list",
+			ordered: false,
+			items: ["um", "dois"],
+		});
+		expect(blocks[2]).toEqual({
+			type: "list",
+			ordered: true,
+			items: ["passo", "outro"],
+		});
+		expect(blocks[3]).toEqual({ type: "quote", text: "nota" });
+		expect(blocks[4]).toEqual({
+			type: "code",
+			language: "ts",
+			code: "const x = 1;",
+		});
+	});
+
+	test("texto vazio não gera blocos", () => {
+		expect(parseMarkdown("  \n\n ")).toEqual([]);
+	});
+});
+
+describe("parseInline", () => {
+	test("reconhece code, bold, itálico e link na ordem", () => {
+		const tokens = parseInline(
+			"Use `npm run ci` e **sempre** valide _tudo_ em [docs](https://x.dev).",
+		);
+		expect(tokens).toEqual([
+			{ type: "text", text: "Use " },
+			{ type: "code", text: "npm run ci" },
+			{ type: "text", text: " e " },
+			{ type: "strong", text: "sempre" },
+			{ type: "text", text: " valide " },
+			{ type: "em", text: "tudo" },
+			{ type: "text", text: " em " },
+			{ type: "link", text: "docs", url: "https://x.dev" },
+			{ type: "text", text: "." },
+		]);
+	});
+
+	test("não confunde underscore de identificador com itálico", () => {
+		expect(parseInline("foo_bar_baz")).toEqual([
+			{ type: "text", text: "foo_bar_baz" },
+		]);
+	});
+
+	test("asterisco simples também vira itálico", () => {
+		expect(parseInline("seja *rápido*")).toEqual([
+			{ type: "text", text: "seja " },
+			{ type: "em", text: "rápido" },
+		]);
+	});
+});
+
+describe("safeUrl", () => {
+	test("aceita http(s)/mailto e caminho relativo; barra o resto", () => {
+		expect(safeUrl("https://x.dev")).toBe("https://x.dev");
+		expect(safeUrl("http://x.dev")).toBe("http://x.dev");
+		expect(safeUrl("mailto:a@b.c")).toBe("mailto:a@b.c");
+		expect(safeUrl("/docs")).toBe("/docs");
+		expect(safeUrl("javascript:alert(1)")).toBeNull();
+		expect(safeUrl("//evil.dev")).toBeNull();
+		expect(safeUrl("data:text/html,x")).toBeNull();
+	});
+});

package/src/tests/review-scripts.test.ts

@@ -1150,13 +1150,16 @@ describe("jev-candidates", () => {
 
 describe("parseReviewArgs", () => {
 	test("lê flags de valor e booleanas", () => {
-		const opts = parseReviewArgs(
-			["--base", "develop", "--branch", "feature/x", "--finalize", "--clean"],
-			"tmp/artifacts",
-		);
+		const opts = parseReviewArgs([
+			"--base",
+			"develop",
+			"--branch",
+			"feature/x",
+			"--finalize",
+			"--clean",
+		]);
 		expect(opts.base).toBe("develop");
 		expect(opts.branch).toBe("feature/x");
-		expect(opts.dir).toBe("tmp/artifacts");
 		expect(opts.finalize).toBe(true);
 		expect(opts.clean).toBe(true);
 		expect(opts.failOnBlocking).toBe(false);

package/src/tests/run-status.test.ts

@@ -9,6 +9,8 @@ import {
 	statusAfterFindingsChange,
 	writeRunStatus,
 } from "../core/run-status";
+import { buildRepoIdentity } from "../core/storage/repo-identity";
+import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
 
 function findingState(partial: Partial<FindingState>): FindingState {
 	return {
@@ -45,53 +47,61 @@ function stateOf(findings: FindingState[]): FindingsStateFile {
 	};
 }
 
-/** Diretório temporário isolado. */
-function withTempDir(fn: (dir: string) => void): void {
+/** Banco temporário isolado + review da branch padrão. */
+function withStorage(
+	fn: (storage: SQLiteStorageProvider, reviewId: string) => void,
+): void {
 	const dir = mkdtempSync(join(tmpdir(), "houndsman-run-status-"));
+	const storage = new SQLiteStorageProvider(join(dir, "houndsman.db"));
 	try {
-		fn(dir);
+		const review = storage.getOrCreateReview({
+			repo: buildRepoIdentity(null, dir),
+			branch: "feature/x",
+			slug: "feature-x",
+		});
+		fn(storage, review.id);
 	} finally {
+		storage.close();
 		rmSync(dir, { recursive: true, force: true });
 	}
 }
 
-describe("run-status — arquivo", () => {
+describe("run-status — storage", () => {
 	test("grava, lê e preserva/restaura o startedAt", () => {
-		withTempDir((dir) => {
-			writeRunStatus(dir, {
-				branch: "feature/x",
+		withStorage((storage, reviewId) => {
+			writeRunStatus(storage, reviewId, {
 				status: "reviewing",
 				resetStartedAt: true,
 				now: "2026-01-01T00:00:00.000Z",
 			});
-			const first = readRunStatus(dir);
+			const first = readRunStatus(storage, reviewId);
 			expect(first?.status).toBe("reviewing");
 			expect(first?.slug).toBe("feature-x");
 			expect(first?.startedAt).toBe("2026-01-01T00:00:00.000Z");
 
-			writeRunStatus(dir, {
-				branch: "feature/x",
+			writeRunStatus(storage, reviewId, {
 				status: "review_done",
 				now: "2026-01-01T00:10:00.000Z",
 			});
-			const second = readRunStatus(dir);
+			const second = readRunStatus(storage, reviewId);
 			expect(second?.status).toBe("review_done");
 			expect(second?.startedAt).toBe("2026-01-01T00:00:00.000Z");
 			expect(second?.updatedAt).toBe("2026-01-01T00:10:00.000Z");
 
-			writeRunStatus(dir, {
-				branch: "feature/x",
+			writeRunStatus(storage, reviewId, {
 				status: "reviewing",
 				resetStartedAt: true,
 				now: "2026-01-01T00:20:00.000Z",
 			});
-			expect(readRunStatus(dir)?.startedAt).toBe("2026-01-01T00:20:00.000Z");
+			expect(readRunStatus(storage, reviewId)?.startedAt).toBe(
+				"2026-01-01T00:20:00.000Z",
+			);
 		});
 	});
 
-	test("readRunStatus devolve null sem arquivo", () => {
-		withTempDir((dir) => {
-			expect(readRunStatus(dir)).toBeNull();
+	test("readRunStatus devolve null para review inexistente", () => {
+		withStorage((storage) => {
+			expect(readRunStatus(storage, "missing")).toBeNull();
 		});
 	});
 });
@@ -127,7 +137,7 @@ describe("statusAfterFindingsChange", () => {
 		expect(statusAfterFindingsChange("review_done", state)).toBe("fix_done");
 	});
 
-	test("sem run.json e sem fix → fallback review_done", () => {
+	test("sem review e sem fix → fallback review_done", () => {
 		const state = stateOf([
 			findingState({ decision: "pending", execState: "pending" }),
 		]);
@@ -136,12 +146,12 @@ describe("statusAfterFindingsChange", () => {
 });
 
 describe("pingFindingsStatus", () => {
-	test("deriva do estado e grava o run.json", () => {
-		withTempDir((dir) => {
+	test("deriva do estado e grava o status na review", () => {
+		withStorage((storage, reviewId) => {
 			const state = stateOf([findingState({ execState: "in_progress" })]);
-			const file = pingFindingsStatus(dir, state);
-			expect(file.status).toBe("fixing");
-			expect(readRunStatus(dir)?.status).toBe("fixing");
+			const review = pingFindingsStatus(storage, reviewId, state);
+			expect(review.status).toBe("fixing");
+			expect(readRunStatus(storage, reviewId)?.status).toBe("fixing");
 		});
 	});
 });

package/src/tests/server.test.ts

@@ -1,30 +1,31 @@
 import { describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { HoundsmanConfig } from "../core/config";
+import { buildStateFromFindings, fileReader } from "../core/findings-state";
+import { dedupeFindings, parseWatchdogReport } from "../core/report-builder";
+import { buildRepoIdentity } from "../core/storage/repo-identity";
+import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
+import type { RepoIdentity } from "../core/storage/types";
 import { createRequestHandler, startServer } from "../server";
-import { readRunFile, runDirForSlug } from "../server/artifacts";
+import { isSlug } from "../server/artifacts";
 import { fakeHoundsmanConfig } from "./fixtures/fake-project";
 
-/** Run fake em disco + config apontando para ela. */
+/** Ambiente fake: banco temporário + review `main` com um finding. */
 function makeEnv(): {
-	artifactDir: string;
+	storage: SQLiteStorageProvider;
+	repo: RepoIdentity;
+	reviewId: string;
 	config: HoundsmanConfig;
 	cleanup: () => void;
 } {
-	const artifactDir = mkdtempSync(join(tmpdir(), "houndsman-server-"));
-	const outDir = join(artifactDir, "main");
-	mkdirSync(join(outDir, "findings"), { recursive: true });
-	writeFileSync(join(outDir, "manifest.json"), JSON.stringify({ branch: "main" }));
-	writeFileSync(
-		join(outDir, "classification.json"),
-		JSON.stringify({ watchdogs: { alpha: ["src/alpha/f.ts"] } }),
-	);
-	writeFileSync(join(outDir, "review.md"), "# Review\n");
-	writeFileSync(
-		join(outDir, "findings", "alpha.json"),
-		JSON.stringify({
+	const dir = mkdtempSync(join(tmpdir(), "houndsman-server-"));
+	const storage = new SQLiteStorageProvider(join(dir, "houndsman.db"));
+	const repo = buildRepoIdentity(null, dir);
+	const review = storage.getOrCreateReview({ repo, branch: "main", slug: "main" });
+	const report = parseWatchdogReport(
+		{
 			watchdogId: "alpha",
 			reviewedFiles: ["src/alpha/f.ts"],
 			skipped: [],
@@ -38,50 +39,51 @@ function makeEnv(): {
 					action: "tipar",
 				},
 			],
-		}),
+		},
+		"alpha.json",
 	);
+	if (report) {
+		const state = buildStateFromFindings(dedupeFindings([report]), {
+			branch: "main",
+			readFile: fileReader(process.cwd()),
+		});
+		// O arquivo fake não existe no cwd → sem âncora. Fixa a linha para o
+		// cenário de comentário inline no teste de submit.
+		for (const finding of Object.values(state.findings)) finding.line = 2;
+		storage.writeFindings(review.id, state);
+	}
+	storage.writeArtifact(review.id, {
+		name: "manifest.json",
+		kind: "manifest",
+		content: JSON.stringify({ branch: "main" }),
+	});
+	storage.writeArtifact(review.id, {
+		name: "classification.json",
+		kind: "classification",
+		content: JSON.stringify({ watchdogs: { alpha: ["src/alpha/f.ts"] } }),
+	});
+	storage.writeArtifact(review.id, {
+		name: "review.md",
+		kind: "review",
+		content: "# Review\n",
+	});
+	storage.writeArtifact(review.id, {
+		name: "briefs/alpha.md",
+		kind: "brief",
+		content: "# Brief alpha\n",
+	});
 	return {
-		artifactDir,
-		config: { ...fakeHoundsmanConfig, artifactDir },
-		cleanup: () => rmSync(artifactDir, { recursive: true, force: true }),
+		storage,
+		repo,
+		reviewId: review.id,
+		config: fakeHoundsmanConfig,
+		cleanup: () => {
+			storage.close();
+			rmSync(dir, { recursive: true, force: true });
+		},
 	};
 }
 
-/** Semeia um `state.json` com um finding inline (tem linha) na run. */
-function seedState(artifactDir: string, branch: string): void {
-	writeFileSync(
-		join(artifactDir, branch, "state.json"),
-		JSON.stringify({
-			version: 2,
-			branch,
-			slug: branch,
-			updatedAt: "2026-01-01T00:00:00.000Z",
-			order: ["f1"],
-			findings: {
-				f1: {
-					id: "f1",
-					fingerprint: "fp1",
-					watchdogIds: ["alpha"],
-					rule: "Nunca usar any",
-					severity: "blocking",
-					file: "src/alpha/f.ts",
-					line: 2,
-					message: "any detectado",
-					action: "tipar",
-					anchor: null,
-					count: 1,
-					present: true,
-					decision: "pending",
-					execState: "pending",
-					createdAt: "2026-01-01T00:00:00.000Z",
-					updatedAt: "2026-01-01T00:00:00.000Z",
-					history: [],
-				},
-			},
-		}),
-	);
-}
-
 const get = (handler: (r: Request) => Promise<Response>, path: string) =>
 	handler(new Request(`http://localhost${path}`));
 
@@ -89,7 +91,7 @@ describe("server API", () => {
 	test("GET /api/runs lista as runs com resumo", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const res = await get(handler, "/api/runs");
 			expect(res.status).toBe(200);
 			const body = (await res.json()) as {
@@ -106,7 +108,7 @@ describe("server API", () => {
 	test("GET findings reconstrói do artefato e PATCH atualiza o estado", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const list = await get(handler, "/api/runs/main/findings?all=1");
 			const body = (await list.json()) as {
 				findings: { id: string; decision: string }[];
@@ -148,7 +150,7 @@ describe("server API", () => {
 	test("PATCH expõe o run status em /api/runs", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const before = (await (await get(handler, "/api/runs")).json()) as {
 				runs: { status: string | null }[];
 			};
@@ -178,7 +180,7 @@ describe("server API", () => {
 	test("POST sync devolve o resultado da reancoragem", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			await get(handler, "/api/runs/main/findings?all=1");
 			const res = await handler(
 				new Request("http://localhost/api/runs/main/sync", { method: "POST" }),
@@ -195,6 +197,8 @@ describe("server API", () => {
 		const env = makeEnv();
 		try {
 			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
 				ghRunner: () => ({
 					ok: true,
 					code: 0,
@@ -224,8 +228,9 @@ describe("server API", () => {
 	test("POST submit posta comentários e grava o vínculo no estado", async () => {
 		const env = makeEnv();
 		try {
-			seedState(env.artifactDir, "main");
 			const handler = createRequestHandler(env.config, {
+				storage: env.storage,
+				repo: env.repo,
 				ghRunner: (args) =>
 					args[0] === "pr"
 						? {
@@ -273,10 +278,35 @@ describe("server API", () => {
 		}
 	});
 
+	test("artifacts lista todos os artefatos da run (inclui briefs)", async () => {
+		const env = makeEnv();
+		try {
+			const handler = createRequestHandler(env.config, env);
+			const res = await get(handler, "/api/runs/main/artifacts");
+			expect(res.status).toBe(200);
+			const body = (await res.json()) as {
+				artifacts: { name: string; kind: string }[];
+			};
+			expect(body.artifacts.map((item) => item.name)).toEqual(
+				expect.arrayContaining([
+					"manifest.json",
+					"classification.json",
+					"review.md",
+					"briefs/alpha.md",
+				]),
+			);
+			expect(
+				body.artifacts.find((item) => item.name === "briefs/alpha.md")?.kind,
+			).toBe("brief");
+		} finally {
+			env.cleanup();
+		}
+	});
+
 	test("artifacts serve arquivos da run e barra o resto", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const ok = await get(handler, "/api/runs/main/artifacts/manifest.json");
 			expect(ok.status).toBe(200);
 			expect(await ok.json()).toEqual({ branch: "main" });
@@ -285,6 +315,10 @@ describe("server API", () => {
 			expect(review.status).toBe(200);
 			expect(await review.text()).toContain("# Review");
 
+			const brief = await get(handler, "/api/runs/main/artifacts/briefs/alpha.md");
+			expect(brief.status).toBe(200);
+			expect(await brief.text()).toContain("# Brief alpha");
+
 			const denied = await get(handler, "/api/runs/main/artifacts/evil.txt");
 			expect(denied.status).toBe(404);
 
@@ -295,23 +329,17 @@ describe("server API", () => {
 		}
 	});
 
-	test("readRunFile barra path traversal", () => {
-		const env = makeEnv();
-		try {
-			const dir = runDirForSlug(env.artifactDir, "main");
-			expect(dir).not.toBeNull();
-			expect(readRunFile(dir as string, "../../../etc/passwd")).toBeNull();
-			expect(readRunFile(dir as string, "manifest.json")).toContain("main");
-			expect(runDirForSlug(env.artifactDir, "../main")).toBeNull();
-		} finally {
-			env.cleanup();
-		}
+	test("valida o slug usado nas rotas", () => {
+		expect(isSlug("main")).toBe(true);
+		expect(isSlug("feature-x")).toBe(true);
+		expect(isSlug("../main")).toBe(false);
+		expect(isSlug("a/b")).toBe(false);
 	});
 
 	test("GET / serve o shell e /assets/app.js empacota o cliente", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const shell = await get(handler, "/");
 			expect(await shell.text()).toContain('id="app"');
 
@@ -328,7 +356,7 @@ describe("server API", () => {
 	test("serve sem cache (no-store) e busta o bundle com um build id", async () => {
 		const env = makeEnv();
 		try {
-			const handler = createRequestHandler(env.config);
+			const handler = createRequestHandler(env.config, env);
 			const shell = await get(handler, "/");
 			expect(shell.headers.get("cache-control")).toContain("no-store");
 			expect(await shell.text()).toContain("/assets/app.js?v=");
@@ -346,7 +374,12 @@ describe("startServer", () => {
 		const env = makeEnv();
 		let server: ReturnType<typeof startServer>["server"] | undefined;
 		try {
-			const started = startServer({ config: env.config, port: 0 });
+			const started = startServer({
+				config: env.config,
+				port: 0,
+				storage: env.storage,
+				repo: env.repo,
+			});
 			server = started.server;
 			const res = await fetch(`${started.url}/api/health`);
 			expect(res.status).toBe(200);