@payconductor/houndsman 0.11.0 → 0.13.0

package/src/tests/changed-scope.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Escopo do diff — âncoras, símbolos alterados e fallback nos hunks.
+ *
+ * Congela a regra que impede o watchdog de reportar código pré-existente: só as
+ * faixas tocadas pela revisão (símbolo folha do AST ou hunk) são revisáveis.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { changedAnchors } from "../core/ast/diff";
+import type { AstAnalysis, AstFacts, AstSymbol } from "../core/ast/types";
+import {
+	buildChangedScope,
+	formatRanges,
+	formatSymbols,
+	isLineInScope,
+	mergeRanges,
+	summarizeScope,
+} from "../core/changed-scope";
+import type { DiffSource } from "../core/diff-source";
+
+/** Cabecalho padrão de um patch de arquivo. */
+function patch(body: string): string {
+	return `diff --git a/src/a.ts b/src/a.ts\n--- a/src/a.ts\n+++ b/src/a.ts\n${body}`;
+}
+
+function diffOf(patchText: string): DiffSource {
+	return {
+		byFile: new Map([["src/a.ts", patchText]]),
+		churn: new Map(),
+	};
+}
+
+function symbol(
+	overrides: Partial<AstSymbol> & Pick<AstSymbol, "name" | "kind">,
+): AstSymbol {
+	return {
+		exported: false,
+		startLine: 1,
+		endLine: 1,
+		...overrides,
+	};
+}
+
+function analysis(facts: AstFacts): AstAnalysis {
+	return { facts };
+}
+
+const FACTS: AstFacts = {
+	language: "typescript",
+	imports: [],
+	exports: [],
+	decorators: [],
+	hasSyntaxErrors: false,
+	symbols: [
+		symbol({ name: "Outer", kind: "class", startLine: 1, endLine: 20 }),
+		symbol({ name: "Outer.inner", kind: "method", startLine: 5, endLine: 10 }),
+		symbol({ name: "top", kind: "function", startLine: 25, endLine: 30 }),
+	],
+};
+
+describe("changedAnchors", () => {
+	test("adições e remoções apontam para o lado novo", () => {
+		const anchors = changedAnchors(
+			patch(
+				"@@ -10,3 +10,4 @@\n const before = 1;\n-const old = 2;\n+const current = 2;\n+const extra = 3;\n const after = 4;\n",
+			),
+		);
+
+		expect([...anchors.added].sort((a, b) => a - b)).toEqual([11, 12]);
+		expect([...anchors.deletedAt]).toEqual([11]);
+	});
+
+	test("remoção pura ancora no ponto do arquivo (sem consumir linha nova)", () => {
+		const anchors = changedAnchors(patch("@@ -10,2 +10,0 @@\n-a\n-b\n"));
+
+		expect([...anchors.added]).toEqual([]);
+		expect([...anchors.deletedAt]).toEqual([10]);
+	});
+});
+
+describe("buildChangedScope", () => {
+	const entries = [{ path: "src/a.ts", status: "modified" }];
+
+	test("âncora dentro de símbolo folha vira o intervalo do símbolo", () => {
+		const text = patch(
+			[
+				"@@ -2,0 +3,1 @@",
+				"+export const header = 1;",
+				"@@ -7,0 +8,1 @@",
+				"+  const inside = 1;",
+				"@@ -26,0 +27,1 @@",
+				"+  return 1;",
+				"",
+			].join("\n"),
+		);
+		const scope = buildChangedScope({
+			entries,
+			diff: diffOf(text),
+			ast: new Map([["src/a.ts", analysis(FACTS)]]),
+		});
+
+		const file = scope["src/a.ts"];
+		expect(file?.source).toBe("ast");
+		// `inner` (5-10) e `top` (25-30); o container `Outer` não expande.
+		expect(file?.symbols.map((item) => item.name)).toEqual(["Outer.inner", "top"]);
+		// Cabeçalho da classe (linha 3) fica como faixa avulsa.
+		expect(file?.ranges).toEqual([
+			{ start: 3, end: 3 },
+			{ start: 5, end: 10 },
+			{ start: 25, end: 30 },
+		]);
+	});
+
+	test("sem AST cai para os hunks do diff", () => {
+		const text = patch("@@ -10,0 +11,2 @@\n+a\n+b\n");
+		const scope = buildChangedScope({ entries, diff: diffOf(text) });
+
+		const file = scope["src/a.ts"];
+		expect(file?.source).toBe("hunks");
+		expect(file?.symbols).toEqual([]);
+		expect(file?.ranges).toEqual([{ start: 11, end: 12 }]);
+	});
+
+	test("rename/binário sem hunks fica sem faixas", () => {
+		const scope = buildChangedScope({
+			entries: [{ path: "src/a.ts", status: "renamed" }],
+			diff: diffOf(patch("")),
+		});
+
+		expect(scope["src/a.ts"]).toEqual({ ranges: [], symbols: [], source: "hunks" });
+	});
+
+	test("arquivo deletado nem entra no escopo", () => {
+		const scope = buildChangedScope({
+			entries: [{ path: "src/a.ts", status: "deleted" }],
+			diff: diffOf(patch("@@ -1,1 +0,0 @@\n-x\n")),
+		});
+
+		expect(scope["src/a.ts"]).toBeUndefined();
+	});
+});
+
+describe("helpers de escopo", () => {
+	test("isLineInScope respeita as faixas", () => {
+		const scope = {
+			"src/a.ts": {
+				ranges: [{ start: 5, end: 10 }],
+				symbols: [],
+				source: "hunks" as const,
+			},
+		};
+
+		expect(isLineInScope(scope, "src/a.ts", 7)).toBe(true);
+		expect(isLineInScope(scope, "src/a.ts", 11)).toBe(false);
+		expect(isLineInScope(scope, "src/b.ts", 7)).toBe(false);
+	});
+
+	test("mergeRanges une sobrepostos e adjacentes", () => {
+		expect(
+			mergeRanges([
+				{ start: 10, end: 12 },
+				{ start: 11, end: 15 },
+				{ start: 16, end: 18 },
+				{ start: 30, end: 30 },
+			]),
+		).toEqual([
+			{ start: 10, end: 18 },
+			{ start: 30, end: 30 },
+		]);
+	});
+
+	test("formatadores compactos", () => {
+		expect(formatRanges([])).toBe("sem linhas alteradas");
+		expect(
+			formatRanges([
+				{ start: 10, end: 14 },
+				{ start: 22, end: 22 },
+			]),
+		).toBe("10-14, 22");
+		expect(
+			formatSymbols([
+				{ name: "foo", kind: "function", startLine: 10, endLine: 14 },
+			]),
+		).toBe("`foo` (10-14)");
+		expect(
+			summarizeScope({
+				"src/a.ts": {
+					ranges: [{ start: 1, end: 2 }],
+					symbols: [
+						{ name: "foo", kind: "function", startLine: 1, endLine: 2 },
+					],
+					source: "ast",
+				},
+			}),
+		).toEqual({ files: 1, ranges: 1, symbols: 1 });
+	});
+});

package/src/tests/cli.test.ts

@@ -192,6 +192,7 @@ describe("cli smoke — imports dinâmicos", () => {
 			const result = runCli(project.cwd, ["doctor", "--no-ping"]);
 			expect(result.code).toBe(0);
 			expect(result.stdout).toContain("Validando");
+			expect(result.stdout).toContain("maki (hunt local)");
 		} finally {
 			project.cleanup();
 		}

package/src/tests/fallback.test.ts

@@ -1,16 +1,10 @@
-/**
- * Fallback de classificação e findings emergentes (lógica/domínio).
- */
+/** Fallback de classificação (arquivos sem dono). */
 
 import { describe, expect, test } from "bun:test";
 import { defineHoundsmanConfig } from "../core/config";
 import { classifyEntries } from "../core/file-classifier";
 import { checkRegistry } from "../core/registry-check";
 import { defineWatchdog } from "../core/types";
-import { AgentState } from "../harness/investigation/agent-state";
-import { EvidenceVerifier } from "../harness/investigation/evidence-verifier";
-import { FindingCritic } from "../harness/investigation/finding-critic";
-import { FindingValidator } from "../harness/validation/finding-validator";
 
 const alpha = defineWatchdog({
 	id: "alpha",
@@ -28,7 +22,6 @@ const fallback = defineWatchdog({
 	description: "Fallback de lógica/domínio.",
 	scope: "arquivos sem dono",
 	fallback: true,
-	allowEmergentFindings: true,
 	rules: [
 		{
 			severity: "attention",
@@ -82,91 +75,3 @@ describe("classificação com fallback", () => {
 		).toBe(true);
 	});
 });
-
-describe("findings emergentes", () => {
-	const file = "a.ts";
-	const content = "const x = 1;\n";
-	const state = new AgentState();
-	const evidence = state.addEvidence({
-		file,
-		startLine: 1,
-		endLine: 1,
-		snippet: content.trim(),
-		kind: "definition",
-		sourceTool: "test",
-		confidence: 0.9,
-	});
-	const draft = {
-		rule: "Lógica: a função fazA na verdade fazB",
-		severity: "blocking" as const,
-		file,
-		line: 1,
-		message: "comportamento diverge do nome",
-		action: "renomear ou corrigir",
-		evidenceIds: [evidence.id],
-		confidence: 0.9,
-	};
-	const verifier = new EvidenceVerifier({
-		allowedFiles: [file],
-		readFile: (path) => (path === file ? content : null),
-	});
-
-	test("crítico aceita e limita a severidade quando habilitado", () => {
-		const critic = new FindingCritic({
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			verifier,
-			allowEmergentFindings: true,
-		});
-		const decision = critic.reviewOne(draft, state);
-		expect(decision.verdict).toBe("keep");
-		expect(decision.draft.severity).toBe("attention");
-	});
-
-	test("crítico descarta quando o opt-in está desligado", () => {
-		const critic = new FindingCritic({
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			verifier,
-		});
-		const decision = critic.reviewOne(draft, state);
-		expect(decision.verdict).toBe("drop");
-		expect(decision.reason).toContain("desabilitado");
-	});
-
-	test("validador espelha a mesma regra", () => {
-		const report = {
-			watchdogId: "default",
-			reviewedFiles: [file],
-			skipped: [],
-			findings: [draft],
-		};
-		const allowed = new FindingValidator({
-			watchdogId: "default",
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			allowedFiles: new Set([file]),
-			overflow: new Set(),
-			readFile: (path) => (path === file ? content : null),
-			allowEmergentFindings: true,
-		}).validate(report);
-		expect(allowed.report.findings[0]?.severity).toBe("attention");
-		expect(allowed.dropped).toHaveLength(0);
-
-		const denied = new FindingValidator({
-			watchdogId: "default",
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			allowedFiles: new Set([file]),
-			overflow: new Set(),
-			readFile: (path) => (path === file ? content : null),
-		}).validate(report);
-		expect(denied.report.findings).toHaveLength(0);
-	});
-
-	test("finding emergente sem descrição é descartado", () => {
-		const critic = new FindingCritic({
-			knownRules: new Set([fallback.rules[0]?.text ?? ""]),
-			verifier,
-			allowEmergentFindings: true,
-		});
-		const decision = critic.reviewOne({ ...draft, rule: "Lógica:" }, state);
-		expect(decision.verdict).toBe("drop");
-	});
-});

package/src/tests/fixtures/fake-model-provider.ts

@@ -41,7 +41,6 @@ export class FakeModelProvider implements ModelProvider {
 		return {
 			output: output as T,
 			usage: fakeUsage(),
-			steps: 1,
 			finishReason: "stop",
 		};
 	}

package/src/tests/hunt-cli.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Smoke test do comando `hunt` (harness local).
+ *
+ * Não executa o maki real: cobre help, doctor e os erros acionáveis antes do
+ * prepare. A skill `/houndsman hunt` continua coberta pelos testes da camada.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const CLI = join(import.meta.dir, "..", "cli", "index.ts");
+
+const CONFIG = (hunt = "") => `export default {
+	projectName: "Hunt Smoke",
+	storage: { provider: "sqlite", path: "./houndsman.db" },
+	watchdogs: {
+		alpha: {
+			id: "alpha",
+			name: "Alpha",
+			description: "Watchdog de smoke.",
+			scope: "src/**",
+			classify: [{ value: "^src/" }],
+			rules: [{ severity: "attention", text: "Evitar any." }],
+			contextFiles: [],
+		},
+	},
+	exclusions: [],
+	docMappings: [],
+	${hunt}
+};
+`;
+
+type Project = { cwd: string; home: string; cleanup: () => void };
+
+function makeProject(hunt = ""): Project {
+	const cwd = mkdtempSync(join(tmpdir(), "houndsman-hunt-cli-"));
+	const home = mkdtempSync(join(tmpdir(), "houndsman-hunt-home-"));
+	writeFileSync(join(cwd, "houndsman.config.ts"), CONFIG(hunt));
+	return {
+		cwd,
+		home,
+		cleanup: () => {
+			rmSync(cwd, { recursive: true, force: true });
+			rmSync(home, { recursive: true, force: true });
+		},
+	};
+}
+
+type CliResult = { code: number; stdout: string; stderr: string };
+
+function runCli(
+	cwd: string,
+	args: string[],
+	env: Record<string, string> = {},
+): CliResult {
+	const proc = Bun.spawnSync(["bun", CLI, ...args], {
+		cwd,
+		env: { ...process.env, NO_COLOR: "1", ...env },
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	return {
+		code: proc.exitCode ?? -1,
+		stdout: proc.stdout.toString(),
+		stderr: proc.stderr.toString(),
+	};
+}
+
+describe("hunt — help e diagnóstico", () => {
+	test("--help distingue a skill do comando CLI", () => {
+		const result = runCli(process.cwd(), ["hunt", "--help"]);
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain("/houndsman hunt");
+		expect(result.stdout).toContain("houndsman hunt install");
+		expect(result.stdout).toContain("--allow-partial");
+	});
+
+	test("doctor não falha sem maki e trata o harness como opcional", () => {
+		const project = makeProject();
+		try {
+			const result = runCli(project.cwd, ["hunt", "doctor"], {
+				HOUNDSMAN_HOME: project.home,
+				HOUNDSMAN_MAKI_PATH: join(project.cwd, "maki-inexistente"),
+			});
+			expect(result.code).toBe(0);
+			expect(result.stdout).toContain("Harness local");
+			expect(result.stdout).toContain("modelo:");
+			expect(result.stdout).toContain("harness:");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("doctor funciona sem projeto configurado (diagnóstico global)", () => {
+		const cwd = mkdtempSync(join(tmpdir(), "houndsman-hunt-nocfg-"));
+		const home = mkdtempSync(join(tmpdir(), "houndsman-hunt-home-"));
+		try {
+			const result = runCli(cwd, ["hunt", "doctor"], {
+				HOUNDSMAN_HOME: home,
+				HOUNDSMAN_MAKI_PATH: join(cwd, "maki-inexistente"),
+			});
+			expect(result.code).toBe(0);
+			expect(result.stdout).toContain("Harness local");
+		} finally {
+			rmSync(cwd, { recursive: true, force: true });
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("hunt — erros antes do prepare", () => {
+	test("sem binário, orienta a instalar (e não toca na review)", () => {
+		const project = makeProject();
+		try {
+			const result = runCli(project.cwd, ["hunt", "--branch", "main"], {
+				HOUNDSMAN_HOME: project.home,
+				HOUNDSMAN_MAKI_PATH: join(project.cwd, "maki-inexistente"),
+				HOUNDSMAN_DEEP_SEEK_API_KEY: "sk-test",
+			});
+			expect(result.code).toBe(1);
+			expect(result.stderr).toContain("hunt install");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("sem credencial, aponta a env correta", () => {
+		const project = makeProject();
+		try {
+			const env = { ...process.env };
+			delete env.HOUNDSMAN_DEEP_SEEK_API_KEY;
+			const proc = Bun.spawnSync(["bun", CLI, "hunt", "--branch", "main"], {
+				cwd: project.cwd,
+				env: {
+					...env,
+					NO_COLOR: "1",
+					HOUNDSMAN_HOME: project.home,
+					HOUNDSMAN_MAKI_PATH: join(project.cwd, "maki-inexistente"),
+				},
+				stdout: "pipe",
+				stderr: "pipe",
+			});
+			expect(proc.exitCode).toBe(1);
+			expect(proc.stderr.toString()).toContain("HOUNDSMAN_DEEP_SEEK_API_KEY");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("respeita hunt.enabled: false", () => {
+		const project = makeProject("hunt: { enabled: false },");
+		try {
+			const result = runCli(project.cwd, ["hunt"], {
+				HOUNDSMAN_HOME: project.home,
+				HOUNDSMAN_DEEP_SEEK_API_KEY: "sk-test",
+			});
+			expect(result.code).toBe(1);
+			expect(result.stderr).toContain("desligado");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("rejeita --finalize (o hunt já finaliza)", () => {
+		const project = makeProject();
+		try {
+			const result = runCli(project.cwd, ["hunt", "--finalize"], {
+				HOUNDSMAN_HOME: project.home,
+			});
+			expect(result.code).toBe(1);
+			expect(result.stderr).toContain("já finaliza");
+		} finally {
+			project.cleanup();
+		}
+	});
+
+	test("subcomando desconhecido mostra o help", () => {
+		const result = runCli(process.cwd(), ["hunt", "foo"]);
+		expect(result.code).toBe(1);
+		expect(result.stderr).toContain("desconhecido");
+		expect(result.stdout).toContain("houndsman hunt install");
+	});
+});

package/src/tests/hunt-install.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Instalação local do maki (sem rede).
+ *
+ * Valida a resolução de asset/versão/checksum e a instalação a partir de um
+ * arquivo local (`--from`), além do ponteiro gerenciado e do uninstall.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	installMaki,
+	makiCurrentFile,
+	makiInstallDir,
+	makiSourceLabel,
+	readMakiInstall,
+	resolveMakiBinary,
+	uninstallMaki,
+} from "../core/hunt/maki-install";
+import {
+	effectiveMakiVersion,
+	makiAssetFor,
+	makiBinaryName,
+	makiChecksumsUrl,
+	makiDownloadUrl,
+	parseChecksums,
+} from "../core/hunt/maki-release";
+
+const original = {
+	home: process.env.HOUNDSMAN_HOME,
+	makiPath: process.env.HOUNDSMAN_MAKI_PATH,
+	makiVersion: process.env.HOUNDSMAN_MAKI_VERSION,
+};
+const dirs: string[] = [];
+
+afterEach(() => {
+	restoreEnv("HOUNDSMAN_HOME", original.home);
+	restoreEnv("HOUNDSMAN_MAKI_PATH", original.makiPath);
+	restoreEnv("HOUNDSMAN_MAKI_VERSION", original.makiVersion);
+	for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+function restoreEnv(name: string, value: string | undefined): void {
+	if (value === undefined) delete process.env[name];
+	else process.env[name] = value;
+}
+
+function tempDir(prefix: string): string {
+	const dir = mkdtempSync(join(tmpdir(), prefix));
+	dirs.push(dir);
+	return dir;
+}
+
+describe("maki-release", () => {
+	test("resolve asset por plataforma/arquitetura", () => {
+		expect(makiAssetFor("win32", "x64", "0.6.5")?.name).toBe(
+			"maki-v0.6.5-x86_64-pc-windows-msvc.zip",
+		);
+		expect(makiAssetFor("darwin", "arm64", "v0.6.5")?.name).toBe(
+			"maki-v0.6.5-aarch64-apple-darwin.tar.gz",
+		);
+		expect(makiAssetFor("linux", "x64", "0.6.5")?.name).toBe(
+			"maki-v0.6.5-x86_64-unknown-linux-musl.tar.gz",
+		);
+		expect(makiAssetFor("solaris", "x64", "0.6.5")).toBeNull();
+	});
+
+	test("versão normaliza v e aceita override por env", () => {
+		expect(effectiveMakiVersion("v1.2.3")).toBe("1.2.3");
+		process.env.HOUNDSMAN_MAKI_VERSION = "v2.0.0";
+		expect(effectiveMakiVersion()).toBe("2.0.0");
+		expect(() => effectiveMakiVersion("../../x")).toThrow("Versão do maki inválida");
+	});
+
+	test("URLs e parse de sha256sums", () => {
+		expect(makiDownloadUrl("0.6.5", "maki.tar.gz")).toContain(
+			"/releases/download/v0.6.5/maki.tar.gz",
+		);
+		expect(makiChecksumsUrl("0.6.5").endsWith("/v0.6.5/sha256sums.txt")).toBe(true);
+		const checksums = parseChecksums(
+			[
+				`${"a".repeat(64)}  maki-a.tar.gz`,
+				`${"b".repeat(64)} *maki-b.zip`,
+				"linha inválida",
+			].join("\n"),
+		);
+		expect(checksums.get("maki-a.tar.gz")).toBe("a".repeat(64));
+		expect(checksums.get("maki-b.zip")).toBe("b".repeat(64));
+	});
+});
+
+describe("resolução do binário", () => {
+	test("HOUNDSMAN_MAKI_PATH tem precedência", () => {
+		const root = tempDir("houndsman-maki-resolve-");
+		const binary = join(root, "maki-custom");
+		writeFileSync(binary, "fake");
+		process.env.HOUNDSMAN_MAKI_PATH = binary;
+		const resolved = resolveMakiBinary();
+		expect(resolved?.path).toBe(binary);
+		expect(resolved?.source).toBe("env");
+		expect(makiSourceLabel("env")).toBe("HOUNDSMAN_MAKI_PATH");
+	});
+});
+
+describe("installMaki (arquivo local)", () => {
+	const hasTar = Boolean(Bun.which("tar"));
+
+	test.skipIf(!hasTar)("extrai, grava o ponteiro e remove", async () => {
+		const home = tempDir("houndsman-maki-home-");
+		process.env.HOUNDSMAN_HOME = home;
+
+		const src = tempDir("houndsman-maki-src-");
+		const name = makiBinaryName();
+		mkdirSync(join(src, "nested"), { recursive: true });
+		writeFileSync(join(src, "nested", name), "#!/bin/sh\necho fake\n");
+		const archive = join(tempDir("houndsman-maki-archive-"), "maki.tar.gz");
+		const tar = Bun.spawnSync(["tar", "-czf", archive, "-C", src, "."], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		expect(tar.exitCode).toBe(0);
+
+		const first = await installMaki({ version: "9.9.9", from: archive });
+		expect(first.skipped).toBe(false);
+		expect(existsSync(first.path)).toBe(true);
+		expect(first.path).toBe(join(makiInstallDir("9.9.9"), name));
+		expect(readFileSync(first.path, "utf8")).toContain("echo fake");
+
+		const manifest = readMakiInstall();
+		expect(manifest?.version).toBe("9.9.9");
+		expect(manifest?.path).toBe(first.path);
+		expect(existsSync(makiCurrentFile())).toBe(true);
+
+		const resolved = resolveMakiBinary();
+		expect(resolved?.source).toBe("managed");
+		expect(resolved?.version).toBe("9.9.9");
+
+		const second = await installMaki({ version: "9.9.9", from: archive });
+		expect(second.skipped).toBe(true);
+
+		const removed = uninstallMaki();
+		expect(removed).toBe(join(home, "tools", "maki"));
+		expect(existsSync(join(home, "tools", "maki"))).toBe(false);
+	});
+});