@payconductor/houndsman 0.7.0 → 0.10.0

package/src/tests/server.test.ts

@@ -111,6 +111,44 @@ describe("server API", () => {
 		}
 	});
 
+	test("DELETE /api/runs/:slug apaga review, findings, artefatos e staging", async () => {
+		const env = makeEnv();
+		try {
+			const handler = createRequestHandler(env.config, env);
+			const res = await handler(
+				new Request("http://localhost/api/runs/main", { method: "DELETE" }),
+			);
+			expect(res.status).toBe(200);
+			const body = (await res.json()) as { deleted: boolean };
+			expect(body.deleted).toBe(true);
+
+			expect(env.storage.getReview(env.reviewId)).toBeNull();
+			expect(env.storage.readFindings(env.reviewId)).toBeNull();
+			expect(env.storage.listArtifacts(env.reviewId)).toHaveLength(0);
+
+			const list = await get(handler, "/api/runs");
+			const after = (await list.json()) as { runs: unknown[] };
+			expect(after.runs).toHaveLength(0);
+		} finally {
+			env.cleanup();
+		}
+	});
+
+	test("DELETE /api/runs/:slug inexistente devolve 404", async () => {
+		const env = makeEnv();
+		try {
+			const handler = createRequestHandler(env.config, env);
+			const res = await handler(
+				new Request("http://localhost/api/runs/nao-existe", {
+					method: "DELETE",
+				}),
+			);
+			expect(res.status).toBe(404);
+		} finally {
+			env.cleanup();
+		}
+	});
+
 	test("GET findings reconstrói do artefato e PATCH atualiza o estado", async () => {
 		const env = makeEnv();
 		try {
@@ -398,7 +436,19 @@ describe("server API", () => {
 		try {
 			const handler = createRequestHandler(env.config, env);
 			const shell = await get(handler, "/");
-			expect(await shell.text()).toContain('id="app"');
+			const html = await shell.text();
+			expect(html).toContain('id="app"');
+			expect(html).toContain("/assets/styles.css?v=");
+
+			// O CSS vive em `styles.css`, servido como arquivo real.
+			const css = await get(handler, "/assets/styles.css");
+			expect(css.status).toBe(200);
+			expect(css.headers.get("content-type")).toContain("text/css");
+			const styles = await css.text();
+			// Sidebar: rail vertical de seções + painel redimensionável.
+			expect(styles).toContain(".side-rail");
+			expect(styles).toContain("--side-width");
+			expect(styles).not.toContain(".side-tabs");
 
 			const bundle = await get(handler, "/assets/app.js");
 			expect(bundle.status).toBe(200);
@@ -420,6 +470,9 @@ describe("server API", () => {
 
 			const bundle = await get(handler, "/assets/app.js");
 			expect(bundle.headers.get("cache-control")).toContain("no-store");
+
+			const css = await get(handler, "/assets/styles.css");
+			expect(css.headers.get("cache-control")).toContain("no-store");
 		} finally {
 			env.cleanup();
 		}

package/src/tests/sidebar-sections.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Navegação da sidebar: registry de seções e preferências de layout.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	DEFAULT_SIDEBAR_SECTION,
+	getSidebarSection,
+	resolveSidebarSectionId,
+	SIDEBAR_SECTIONS,
+	type SidebarSectionContext,
+} from "../server/client/sidebar-sections";
+import {
+	clampSidebarWidth,
+	readSidebarPrefs,
+	SIDEBAR_DEFAULT_WIDTH,
+	SIDEBAR_MAX_WIDTH,
+	SIDEBAR_MIN_WIDTH,
+} from "../server/client/utils/sidebar-prefs";
+import type { RunSummary } from "../server/client/utils/types";
+
+function makeRun(slug: string): RunSummary {
+	return {
+		slug,
+		branch: slug,
+		summary: {
+			total: 0,
+			present: 0,
+			byDecision: { pending: 0, execute: 0, ignore: 0 },
+			byExecState: { pending: 0, in_progress: 0, done: 0, stale: 0 },
+			bySeverity: { blocking: 0, attention: 0, suggestion: 0, nit: 0 },
+		},
+	};
+}
+
+function makeContext(runs: RunSummary[]): SidebarSectionContext {
+	return {
+		runs,
+		slug: null,
+		onSelect: () => undefined,
+		onRefreshRuns: () => undefined,
+		active: true,
+	};
+}
+
+describe("SIDEBAR_SECTIONS", () => {
+	test("expõe Execuções e PRs na ordem canônica", () => {
+		expect(SIDEBAR_SECTIONS.map((section) => section.id)).toEqual(["runs", "prs"]);
+		expect(DEFAULT_SIDEBAR_SECTION).toBe("runs");
+	});
+
+	test("cada seção tem identificação e conteúdo", () => {
+		const ids = new Set<string>();
+		for (const section of SIDEBAR_SECTIONS) {
+			expect(section.id).not.toBe("");
+			expect(ids.has(section.id)).toBe(false);
+			ids.add(section.id);
+			expect(section.label.length).toBeGreaterThan(0);
+			expect(section.title.length).toBeGreaterThan(0);
+			expect(typeof section.icon).toBe("function");
+			expect(typeof section.Content).toBe("function");
+		}
+	});
+
+	test("o badge de Execuções reflete a contagem de runs", () => {
+		const runs = SIDEBAR_SECTIONS.find((section) => section.id === "runs");
+		expect(runs?.badge?.(makeContext([]))).toBeNull();
+		expect(runs?.badge?.(makeContext([makeRun("a"), makeRun("b")]))).toBe(2);
+	});
+
+	test("resolve ids salvos e cai no default quando inválidos", () => {
+		expect(resolveSidebarSectionId("prs")).toBe("prs");
+		expect(resolveSidebarSectionId("desconhecida")).toBe(DEFAULT_SIDEBAR_SECTION);
+		expect(resolveSidebarSectionId(null)).toBe(DEFAULT_SIDEBAR_SECTION);
+		expect(getSidebarSection("desconhecida").id).toBe(DEFAULT_SIDEBAR_SECTION);
+	});
+});
+
+describe("preferências da sidebar", () => {
+	test("clampa a largura entre mínimo e máximo", () => {
+		expect(clampSidebarWidth(200)).toBe(SIDEBAR_MIN_WIDTH);
+		expect(clampSidebarWidth(900)).toBe(SIDEBAR_MAX_WIDTH);
+		expect(clampSidebarWidth(400)).toBe(400);
+		expect(clampSidebarWidth(Number.NaN)).toBe(SIDEBAR_DEFAULT_WIDTH);
+	});
+
+	test("lê defaults sem preferências salvas", () => {
+		const prefs = readSidebarPrefs();
+		expect(prefs.width).toBeGreaterThanOrEqual(SIDEBAR_MIN_WIDTH);
+		expect(prefs.width).toBeLessThanOrEqual(SIDEBAR_MAX_WIDTH);
+		expect(typeof prefs.collapsed).toBe("boolean");
+		if (prefs.section !== null) expect(typeof prefs.section).toBe("string");
+	});
+});

package/src/tests/technical-summary.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Pontos técnicos estruturais do resumo final — builder determinístico e
+ * validação do artefato `technical-summary.json`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { AstAnalysis, AstFacts, AstImpact } from "../core/ast/types";
+import { buildTechnicalSummary, parseTechnicalSummary } from "../core/technical-summary";
+
+const facts: AstFacts = {
+	language: "typescript",
+	symbols: [],
+	imports: [],
+	exports: [],
+	decorators: [],
+	hasSyntaxErrors: false,
+};
+
+function analysis(partial: Partial<AstAnalysis> = {}): AstAnalysis {
+	return {
+		facts,
+		delta: {
+			addedSymbols: [],
+			removedSymbols: [],
+			modifiedSymbols: [],
+			changedSignatures: [],
+			addedImports: [],
+			removedImports: [],
+			changedExports: [],
+		},
+		...partial,
+	};
+}
+
+const classification = {
+	files: {
+		"src/bin-lookup/service.ts": { status: "added" },
+		"src/bin-lookup/provider.ts": { status: "added" },
+	},
+	churn: {
+		"src/bin-lookup/service.ts": { additions: 10, deletions: 0 },
+		"src/bin-lookup/provider.ts": { additions: 5, deletions: 0 },
+	},
+} as const;
+
+describe("buildTechnicalSummary", () => {
+	test("extrai contratos, implementações, assinaturas e dependências do AST", () => {
+		const ast = new Map<string, AstAnalysis>([
+			[
+				"src/bin-lookup/service.ts",
+				analysis({
+					delta: {
+						addedSymbols: [
+							{
+								name: "BinLookupProvider",
+								kind: "interface",
+								exported: true,
+								startLine: 1,
+								endLine: 3,
+							},
+							{
+								name: "BinLookupService",
+								kind: "class",
+								exported: true,
+								startLine: 5,
+								endLine: 20,
+							},
+						],
+						removedSymbols: [],
+						modifiedSymbols: [],
+						changedSignatures: [
+							{
+								name: "lookup",
+								before: "(bin: string)",
+								after: "(bin: string, brand: string)",
+								exported: true,
+							},
+						],
+						addedImports: ["./provider", "axios"],
+						removedImports: [],
+						changedExports: [{ name: "legacy", change: "removed" }],
+					},
+				}),
+			],
+		]);
+
+		const summary = buildTechnicalSummary({
+			classification,
+			ast,
+			headSha: "abc",
+		});
+
+		expect(summary.source).toBe("deterministic");
+		expect(summary.headSha).toBe("abc");
+		const text = summary.highlights.map((item) => `${item.area}: ${item.detail}`);
+		expect(text.join("\n")).toContain("Contratos: `BinLookupProvider`");
+		expect(text.join("\n")).toContain("Implementações: `BinLookupService`");
+		expect(text.join("\n")).toContain("Assinaturas alteradas: `lookup`");
+		expect(text.join("\n")).toContain("Novas dependências: `axios`");
+		expect(text.join("\n")).not.toContain("./provider");
+		expect(text.join("\n")).toContain("Exports alterados: `legacy`");
+	});
+
+	test("sem AST, agrupa arquivos novos por diretório", () => {
+		const summary = buildTechnicalSummary({ classification });
+		expect(summary.highlights[0]).toEqual({
+			area: "Estrutura",
+			detail: "Novo diretório `src/bin-lookup` com 2 arquivo(s).",
+		});
+	});
+
+	test("registra remoções e impacto", () => {
+		const impact: AstImpact = {
+			importers: { "src/bin-lookup/service.ts": ["src/a.ts"] },
+			affectedFiles: ["src/a.ts"],
+			exportedChanges: [
+				{
+					file: "src/bin-lookup/service.ts",
+					symbol: "lookup",
+					change: "removed",
+				},
+			],
+		};
+		const summary = buildTechnicalSummary({
+			classification: {
+				files: {
+					"src/old.ts": { status: "deleted" },
+					"src/bin-lookup/service.ts": { status: "modified" },
+				},
+				churn: {},
+			},
+			impact,
+		});
+		const text = summary.highlights.map((item) => `${item.area}: ${item.detail}`);
+		expect(text.join("\n")).toContain("Remoções: `src/old.ts`");
+		expect(text.join("\n")).toContain("Impacto: 1 arquivo(s) importam os alterados");
+	});
+
+	test("não gera destaques quando não há mudança estrutural", () => {
+		const summary = buildTechnicalSummary({
+			classification: { files: {}, churn: {} },
+		});
+		expect(summary.highlights).toEqual([]);
+	});
+});
+
+describe("parseTechnicalSummary", () => {
+	test("aceita artefato válido e normaliza o source", () => {
+		const summary = parseTechnicalSummary({
+			source: "deterministic",
+			headSha: "abc",
+			overview: "Estrutura",
+			highlights: [{ area: "Contratos", detail: "`X`" }],
+		});
+		expect(summary?.source).toBe("deterministic");
+		expect(summary?.highlights[0].area).toBe("Contratos");
+	});
+
+	test("rejeita conteúdo vazio ou inválido", () => {
+		expect(parseTechnicalSummary(null)).toBeNull();
+		expect(parseTechnicalSummary({})).toBeNull();
+		expect(
+			parseTechnicalSummary({ highlights: [{ area: "", detail: "" }] }),
+		).toBeNull();
+	});
+
+	test("limita a seis destaques", () => {
+		const summary = parseTechnicalSummary({
+			highlights: Array.from({ length: 10 }, (_, index) => ({
+				area: `Área ${index}`,
+				detail: `Detalhe ${index}`,
+			})),
+		});
+		expect(summary?.highlights).toHaveLength(6);
+	});
+});