@payconductor/houndsman 0.3.0 → 0.5.0

package/src/tests/baseline.test.ts

@@ -26,13 +26,16 @@ import {
 	writeUserLayer,
 } from "../core/commands/scaffold";
 import { defineHoundsmanConfig } from "../core/config";
-import { defaultOptions, finalize, prepare } from "../core/orchestrator";
+import { defaultOptions, finalize, prepare, reviewContext } from "../core/orchestrator";
+import { displayPath } from "../core/paths";
 import {
 	type MergedFinding,
 	renderDomainReport,
 	renderReport,
 	type WatchdogReport,
 } from "../core/report-builder";
+import { resolveRepoIdentity } from "../core/storage/repo-identity";
+import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
 import { defineWatchdog } from "../core/types";
 import * as facade from "../index";
 
@@ -56,7 +59,6 @@ const baselineWatchdog = defineWatchdog({
 
 const baselineConfig = defineHoundsmanConfig({
 	projectName: "Baseline",
-	artifactDir: ".houndsman/.runs",
 	watchdogs: { alpha: baselineWatchdog },
 	exclusions: [/^dist\//],
 	docMappings: [[/^src\//, ["README.md"]]],
@@ -75,6 +77,10 @@ function normalizeArtifacts(text: string): string {
 			'"$1": "<timestamp>"',
 		)
 		.replace(/"\d{4}-\d{2}-\d{2}T[^"]*"/g, '"<timestamp>"')
+		.replace(
+			/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/g,
+			"<uuid>",
+		)
 		.replace(/\b[0-9a-f]{40}\b/g, "<sha>")
 		.replace(/\b[0-9a-f]{16}\b/g, "<fingerprint>")
 		.replace(/\b[0-9a-f]{10}\b/g, "<id>")
@@ -128,7 +134,7 @@ describe("baseline — brief", () => {
 			overflow: ["src/alpha/c.ts"],
 			deleted: ["src/alpha/old.ts"],
 			branch: "feature/x",
-			outputPath: ".houndsman/.runs/feature-x/findings/alpha.json",
+			outputPath: "/workspace/work/review-x/findings/alpha.json",
 			outputFormatPath: ".houndsman/core/skill/OUTPUT-FORMAT.md",
 			docs: ["AGENTS.md", "README.md"],
 			context: {
@@ -317,6 +323,8 @@ describe("baseline — artefatos de prepare/finalize", () => {
 	test("gera classification, brief, manifest, review e state", async () => {
 		const cwd = mkdtempSync(join(tmpdir(), "houndsman-baseline-run-"));
 		const originalCwd = process.cwd();
+		const originalHome = process.env.HOUNDSMAN_HOME;
+		let storage: SQLiteStorageProvider | null = null;
 
 		try {
 			git(cwd, ["init", "-b", "main"]);
@@ -343,30 +351,58 @@ describe("baseline — artefatos de prepare/finalize", () => {
 			git(cwd, ["commit", "-m", "change"]);
 
 			const opts = {
-				...defaultOptions(".houndsman/.runs"),
+				...defaultOptions(),
 				base,
 				head: "HEAD",
 				noJev: true,
 			};
 
+			process.env.HOUNDSMAN_HOME = join(cwd, ".home");
 			process.chdir(cwd);
 
-			const prepared = await prepare(opts, "main", baselineConfig);
-			expect(normalizeArtifacts(prepared.messages.join("\n"))).toMatchSnapshot();
-
-			const runDir = join(cwd, ".houndsman", ".runs", "main");
-			for (const file of [
-				"classification.json",
-				"manifest.json",
-				"briefs/alpha.md",
-			]) {
-				expect(
-					normalizeArtifacts(readFileSync(join(runDir, file), "utf8")),
-				).toMatchSnapshot(file);
+			const config = {
+				...baselineConfig,
+				storage: {
+					provider: "sqlite" as const,
+					path: join(cwd, "houndsman.db"),
+				},
+			};
+			storage = new SQLiteStorageProvider(join(cwd, "houndsman.db"));
+			const repo = resolveRepoIdentity();
+			const review = storage.getOrCreateReview({
+				repo,
+				branch: "main",
+				slug: "main",
+			});
+			const ctx = reviewContext(storage, review);
+			const homeDisplay = displayPath(cwd);
+			const escapedCwd = cwd.replace(/\\/g, "\\\\");
+			const normalize = (text: string): string =>
+				normalizeArtifacts(
+					text
+						.replaceAll(escapedCwd, "<cwd>")
+						.replaceAll(cwd, "<cwd>")
+						.replaceAll(cwd.replace(/\\/g, "/"), "<cwd>")
+						.replaceAll(cwd.replace(/\\/g, "/").toLowerCase(), "<cwd>")
+						.replaceAll(homeDisplay, "<cwd>"),
+				);
+
+			const prepared = await prepare(opts, "main", config, ctx);
+			expect(normalize(prepared.messages.join("\n"))).toMatchSnapshot();
+
+			for (const name of ["classification.json", "manifest.json"]) {
+				const artifact = storage.readArtifact(review.id, name);
+				expect(normalize(artifact?.content ?? "")).toMatchSnapshot(name);
 			}
+			const workBrief = readFileSync(ctx.work.briefFile("alpha"), "utf8");
+			const briefArtifact = storage.readArtifact(review.id, "briefs/alpha.md");
+			expect(briefArtifact?.content).toBe(workBrief);
+			expect(normalize(briefArtifact?.content ?? "")).toMatchSnapshot(
+				"briefs/alpha.md",
+			);
 
 			writeFileSync(
-				join(runDir, "findings", "alpha.json"),
+				ctx.work.findingFile("alpha"),
 				`${JSON.stringify(
 					{
 						watchdogId: "alpha",
@@ -389,21 +425,27 @@ describe("baseline — artefatos de prepare/finalize", () => {
 				)}\n`,
 			);
 
-			const finalized = finalize(opts, "main", baselineConfig);
-			expect(normalizeArtifacts(finalized.messages.join("\n"))).toMatchSnapshot();
-
-			for (const file of [
-				"review.md",
-				"review.alpha.md",
-				"state.json",
-				"run.json",
-			]) {
-				expect(
-					normalizeArtifacts(readFileSync(join(runDir, file), "utf8")),
-				).toMatchSnapshot(file);
+			const finalized = finalize(opts, "main", config, ctx);
+			expect(normalize(finalized.messages.join("\n"))).toMatchSnapshot();
+
+			for (const name of ["review.md", "review.alpha.md"]) {
+				const artifact = storage.readArtifact(review.id, name);
+				expect(normalize(artifact?.content ?? "")).toMatchSnapshot(name);
 			}
+			const resume = storage.readArtifact(review.id, "review-resume.md");
+			expect(resume?.kind).toBe("resume");
+			expect((resume?.content ?? "").length).toBeLessThanOrEqual(2500);
+			expect(
+				normalize(JSON.stringify(storage.readFindings(review.id), null, 2)),
+			).toMatchSnapshot("state.json");
+			expect(
+				normalize(JSON.stringify(storage.getReview(review.id), null, 2)),
+			).toMatchSnapshot("run.json");
 		} finally {
+			storage?.close();
 			process.chdir(originalCwd);
+			if (originalHome === undefined) delete process.env.HOUNDSMAN_HOME;
+			else process.env.HOUNDSMAN_HOME = originalHome;
 			rmSync(cwd, { recursive: true, force: true });
 		}
 	}, 30_000);
@@ -433,12 +475,19 @@ const REQUIRED_EXPORTS = [
 	"GitRepository",
 	"ProjectConfig",
 	"ProjectFiles",
-	"RunLayout",
 	"Watchdog",
 	"WatchdogRegistry",
 	"systemClock",
 	"HoundsmanServer",
 	"HoundsmanEngine",
+	"ReviewWorkArea",
+	"SQLiteStorageProvider",
+	"FileStorageProvider",
+	"createStorage",
+	"createMemoryStorage",
+	"resolveRepoIdentity",
+	"buildRepoIdentity",
+	"normalizeRemote",
 	"ReviewSession",
 	"ReviewScopeResolver",
 	"buildCarryover",
@@ -447,7 +496,6 @@ const REQUIRED_EXPORTS = [
 	"ArgParser",
 	"ProjectScaffolder",
 	"FixBatchBuilder",
-	"Verifier",
 	"BriefRenderer",
 	"ReportRenderer",
 	"ManifestWriter",
@@ -455,7 +503,6 @@ const REQUIRED_EXPORTS = [
 	"assetPath",
 	"buildAnchor",
 	"buildStateFromFindings",
-	"buildStateFromRunDir",
 	"checkRegistry",
 	"churnOf",
 	"classifyEntries",
@@ -492,14 +539,12 @@ const REQUIRED_EXPORTS = [
 	"resolveConfigPath",
 	"resolveJevConcurrency",
 	"resolveMaxFilesPerBrief",
-	"runDir",
 	"runFindingsCommand",
 	"runVerifyCommand",
 	"selectByBudget",
 	"severityRank",
 	"sortByRisk",
 	"startServer",
-	"stateFile",
 	"summarize",
 	"syncState",
 ] as const;

package/src/tests/cli.test.ts

@@ -7,9 +7,13 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+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";
 
 /** Caminho do executável do CLI (TS, rodado pelo Bun). */
 const CLI = join(import.meta.dir, "..", "cli", "index.ts");
@@ -17,6 +21,7 @@ const CLI = join(import.meta.dir, "..", "cli", "index.ts");
 /** Config mínima, como objeto literal (o `loadConfig` deriva `watchdogIds`). */
 const CONFIG = `export default {
 	projectName: "Smoke",
+	storage: { provider: "sqlite", path: "./houndsman.db" },
 	watchdogs: {
 		alpha: {
 			id: "alpha",
@@ -33,22 +38,18 @@ const CONFIG = `export default {
 };
 `;
 
-type Project = { cwd: string; artifacts: string; cleanup: () => void };
+type Project = { cwd: string; cleanup: () => void };
 
-/** Projeto temporário: config + uma run com um finding. */
+/** Projeto temporário: config + banco com uma run e um finding. */
 function makeProject(): Project {
 	const cwd = mkdtempSync(join(tmpdir(), "houndsman-cli-"));
-	const artifacts = join(cwd, ".houndsman", ".runs");
-	const runDir = join(artifacts, "main");
-	mkdirSync(join(runDir, "findings"), { recursive: true });
 	writeFileSync(join(cwd, "houndsman.config.ts"), CONFIG);
-	writeFileSync(
-		join(runDir, "classification.json"),
-		JSON.stringify({ watchdogs: { alpha: ["src/a.ts"] } }),
-	);
-	writeFileSync(
-		join(runDir, "findings", "alpha.json"),
-		JSON.stringify({
+
+	const storage = new SQLiteStorageProvider(join(cwd, "houndsman.db"));
+	const repo = buildRepoIdentity(null, cwd);
+	const review = storage.getOrCreateReview({ repo, branch: "main", slug: "main" });
+	const report = parseWatchdogReport(
+		{
 			watchdogId: "alpha",
 			reviewedFiles: ["src/a.ts"],
 			skipped: [],
@@ -62,11 +63,22 @@ function makeProject(): Project {
 					action: "tipar",
 				},
 			],
-		}),
+		},
+		"alpha.json",
 	);
+	if (report) {
+		storage.writeFindings(
+			review.id,
+			buildStateFromFindings(dedupeFindings([report]), {
+				branch: "main",
+				readFile: fileReader(cwd),
+			}),
+		);
+	}
+	storage.close();
+
 	return {
 		cwd,
-		artifacts,
 		cleanup: () => rmSync(cwd, { recursive: true, force: true }),
 	};
 }
@@ -112,8 +124,6 @@ describe("cli smoke — imports dinâmicos", () => {
 				"findings",
 				"summary",
 				"--json",
-				"--dir",
-				project.artifacts,
 				"--branch",
 				"main",
 			]);
@@ -132,8 +142,6 @@ describe("cli smoke — imports dinâmicos", () => {
 				"submit",
 				"--dry-run",
 				"--json",
-				"--dir",
-				project.artifacts,
 				"--branch",
 				"main",
 			]);
@@ -160,6 +168,19 @@ describe("cli smoke — imports dinâmicos", () => {
 		try {
 			const result = runCli(project.cwd, ["context", "--branch", "main"]);
 			expect(result.code).toBe(0);
+
+			// Auditoria: o brief do contexto fica persistido mesmo sem PR.
+			const storage = new SQLiteStorageProvider(join(project.cwd, "houndsman.db"));
+			try {
+				const repo = buildRepoIdentity(null, project.cwd);
+				const review = storage.findReview(repo.key, "main");
+				expect(review).not.toBeNull();
+				expect(
+					storage.readArtifact(review?.id ?? "", "context-brief.md")?.kind,
+				).toBe("context-brief");
+			} finally {
+				storage.close();
+			}
 		} finally {
 			project.cleanup();
 		}

package/src/tests/code-highlight.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Destaque de código do evidence — tokenizer próprio, sem dependência.
+ *
+ * Garante que a inferência por extensão funciona, que o texto original é
+ * preservado e que os tokens principais são classificados.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	highlightCode,
+	languageFromFile,
+	languageFromName,
+} from "../server/client/utils/code-highlight";
+
+/** O texto concatenado dos tokens deve ser idêntico ao input. */
+function joined(tokens: { text: string }[]): string {
+	return tokens.map((token) => token.text).join("");
+}
+
+describe("languageFromFile", () => {
+	test("infere pela extensão e ignora extensões desconhecidas", () => {
+		expect(languageFromFile("src/a.ts")).toBe("typescript");
+		expect(languageFromFile("src/a.tsx")).toBe("typescript");
+		expect(languageFromFile("scripts/a.py")).toBe("python");
+		expect(languageFromFile("db/a.sql")).toBe("sql");
+		expect(languageFromFile("charts/a.yaml")).toBe("yaml");
+		expect(languageFromFile("README.md")).toBeNull();
+		expect(languageFromFile("Makefile")).toBeNull();
+		expect(languageFromFile("a.unknown")).toBeNull();
+	});
+
+	test("aliases de fence markdown", () => {
+		expect(languageFromName("ts")).toBe("typescript");
+		expect(languageFromName("js")).toBe("javascript");
+		expect(languageFromName("py")).toBe("python");
+		expect(languageFromName("json")).toBe("json");
+		expect(languageFromName("yml")).toBe("yaml");
+		expect(languageFromName("cobol")).toBeNull();
+		expect(languageFromName(null)).toBeNull();
+	});
+});
+
+describe("highlightCode", () => {
+	test("TypeScript: keywords, tipos, números, strings e comentários", () => {
+		const input = 'const answer: number = 42; // resposta\nconst url = "https://x";';
+		const result = highlightCode(input, "typescript");
+		expect(result?.label).toBe("TypeScript");
+		expect(joined(result?.tokens ?? [])).toBe(input);
+		expect(result?.tokens.find((token) => token.text === "const")?.type).toBe(
+			"keyword",
+		);
+		expect(result?.tokens.find((token) => token.text === "number")?.type).toBe(
+			"type",
+		);
+		expect(result?.tokens.find((token) => token.text === "42")?.type).toBe("number");
+		expect(result?.tokens.find((token) => token.text === "// resposta")?.type).toBe(
+			"comment",
+		);
+		expect(result?.tokens.find((token) => token.text === '"https://x"')?.type).toBe(
+			"string",
+		);
+	});
+
+	test("Python: comentários com # e strings de três aspas", () => {
+		const input = 'def greet(name):\n    """doc"""\n    return "hi"  # ok';
+		const result = highlightCode(input, "python");
+		expect(joined(result?.tokens ?? [])).toBe(input);
+		expect(result?.tokens.find((token) => token.text === "def")?.type).toBe(
+			"keyword",
+		);
+		expect(result?.tokens.find((token) => token.text === "return")?.type).toBe(
+			"keyword",
+		);
+		expect(result?.tokens.find((token) => token.text === '"""doc"""')?.type).toBe(
+			"string",
+		);
+		expect(result?.tokens.find((token) => token.text === "# ok")?.type).toBe(
+			"comment",
+		);
+	});
+
+	test("JSON: chave vira propriedade e literal vira keyword", () => {
+		const input = '{"a": 1, "b": true}';
+		const result = highlightCode(input, "json");
+		expect(result?.label).toBe("JSON");
+		expect(joined(result?.tokens ?? [])).toBe(input);
+		expect(result?.tokens.find((token) => token.text === '"a"')?.type).toBe(
+			"property",
+		);
+		expect(result?.tokens.find((token) => token.text === "true")?.type).toBe(
+			"keyword",
+		);
+	});
+
+	test("HTML: tag e atributo", () => {
+		const input = '<div class="x">hi</div>';
+		const result = highlightCode(input, "html");
+		expect(joined(result?.tokens ?? [])).toBe(input);
+		expect(result?.tokens.find((token) => token.text === "div")?.type).toBe(
+			"keyword",
+		);
+		expect(result?.tokens.find((token) => token.text === "class")?.type).toBe(
+			"property",
+		);
+	});
+
+	test("YAML: chave no início da linha e comentário", () => {
+		const input = "name: value # note";
+		const result = highlightCode(input, "yaml");
+		expect(joined(result?.tokens ?? [])).toBe(input);
+		expect(result?.tokens.find((token) => token.text === "name")?.type).toBe(
+			"property",
+		);
+		expect(result?.tokens.find((token) => token.text === "# note")?.type).toBe(
+			"comment",
+		);
+	});
+
+	test("sem linguagem/desconhecida devolve null", () => {
+		expect(highlightCode("const x = 1", null)).toBeNull();
+		expect(highlightCode("const x = 1", "cobol")).toBeNull();
+	});
+});

package/src/tests/domain.test.ts

@@ -102,7 +102,7 @@ describe("ProjectConfig", () => {
 	test("resolve defaults e valores do projeto", () => {
 		const project = new ProjectConfig(fakeHoundsmanConfig);
 		expect(project.projectName).toBe("Fake Project");
-		expect(project.artifactDir).toBe("tmp/fake-review");
+		expect(project.storage).toEqual({});
 		expect(project.maxFilesPerBrief).toBe(40);
 		expect(project.jevConcurrency).toBe(5);
 		expect(project.alwaysIncludeDocs).toEqual(["README.md"]);