claude-crap 0.3.7 → 0.4.0

package/src/tests/exclusions.test.ts

@@ -0,0 +1,117 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  DEFAULT_SKIP_DIRS,
+  DEFAULT_SKIP_PATTERNS,
+  createExclusionFilter,
+} from "../shared/exclusions.js";
+
+describe("DEFAULT_SKIP_DIRS", () => {
+  it("includes core directories", () => {
+    for (const dir of ["node_modules", ".git", "dist", "build", "bundle", "out", "target", "coverage", "vendor"]) {
+      assert.ok(DEFAULT_SKIP_DIRS.has(dir), `missing: ${dir}`);
+    }
+  });
+
+  it("includes framework build outputs", () => {
+    for (const dir of [".next", ".nuxt", ".output", ".vercel", ".svelte-kit", ".astro", ".angular", ".turbo", ".parcel-cache", ".expo"]) {
+      assert.ok(DEFAULT_SKIP_DIRS.has(dir), `missing: ${dir}`);
+    }
+  });
+
+  it("includes language-specific caches", () => {
+    for (const dir of [".venv", "venv", "__pycache__", ".cache", ".dart_tool", ".gradle"]) {
+      assert.ok(DEFAULT_SKIP_DIRS.has(dir), `missing: ${dir}`);
+    }
+  });
+
+  it("includes plugin state dirs", () => {
+    for (const dir of [".claude-crap", ".codesight"]) {
+      assert.ok(DEFAULT_SKIP_DIRS.has(dir), `missing: ${dir}`);
+    }
+  });
+});
+
+describe("DEFAULT_SKIP_PATTERNS", () => {
+  it("includes minified and bundled file patterns", () => {
+    const patterns = new Set(DEFAULT_SKIP_PATTERNS);
+    assert.ok(patterns.has("*.min.js"));
+    assert.ok(patterns.has("*.min.css"));
+    assert.ok(patterns.has("*.bundle.js"));
+    assert.ok(patterns.has("*.chunk.js"));
+  });
+});
+
+describe("createExclusionFilter", () => {
+  describe("shouldSkipDir", () => {
+    it("skips default directories", () => {
+      const filter = createExclusionFilter();
+      assert.equal(filter.shouldSkipDir("node_modules"), true);
+      assert.equal(filter.shouldSkipDir("dist"), true);
+      assert.equal(filter.shouldSkipDir("bundle"), true);
+      assert.equal(filter.shouldSkipDir(".next"), true);
+      assert.equal(filter.shouldSkipDir(".dart_tool"), true);
+    });
+
+    it("allows normal directories", () => {
+      const filter = createExclusionFilter();
+      assert.equal(filter.shouldSkipDir("src"), false);
+      assert.equal(filter.shouldSkipDir("lib"), false);
+      assert.equal(filter.shouldSkipDir("apps"), false);
+    });
+
+    it("skips hidden directories except .claude-plugin", () => {
+      const filter = createExclusionFilter();
+      assert.equal(filter.shouldSkipDir(".hidden"), true);
+      assert.equal(filter.shouldSkipDir(".secret"), true);
+      assert.equal(filter.shouldSkipDir(".claude-plugin"), false);
+    });
+
+    it("respects user directory exclusions with trailing slash", () => {
+      const filter = createExclusionFilter(["legacy/", "generated/"]);
+      assert.equal(filter.shouldSkipDir("legacy"), true);
+      assert.equal(filter.shouldSkipDir("generated"), true);
+      assert.equal(filter.shouldSkipDir("src"), false);
+    });
+  });
+
+  describe("shouldSkipFile", () => {
+    it("skips default minified patterns", () => {
+      const filter = createExclusionFilter();
+      assert.equal(filter.shouldSkipFile("lib/app.min.js", "app.min.js"), true);
+      assert.equal(filter.shouldSkipFile("styles/main.min.css", "main.min.css"), true);
+      assert.equal(filter.shouldSkipFile("lib/vendor.bundle.js", "vendor.bundle.js"), true);
+      assert.equal(filter.shouldSkipFile("lib/0.chunk.js", "0.chunk.js"), true);
+    });
+
+    it("allows normal source files", () => {
+      const filter = createExclusionFilter();
+      assert.equal(filter.shouldSkipFile("src/index.ts", "index.ts"), false);
+      assert.equal(filter.shouldSkipFile("lib/utils.js", "utils.js"), false);
+    });
+
+    it("applies user glob patterns to filenames", () => {
+      const filter = createExclusionFilter(["*.proto.ts"]);
+      assert.equal(filter.shouldSkipFile("src/api/service.proto.ts", "service.proto.ts"), true);
+      assert.equal(filter.shouldSkipFile("src/api/service.ts", "service.ts"), false);
+    });
+
+    it("applies user glob patterns to relative paths", () => {
+      const filter = createExclusionFilter(["src/generated/**"]);
+      assert.equal(filter.shouldSkipFile("src/generated/types.ts", "types.ts"), true);
+      assert.equal(filter.shouldSkipFile("src/real/types.ts", "types.ts"), false);
+    });
+
+    it("works with empty user exclusions", () => {
+      const filter = createExclusionFilter([]);
+      assert.equal(filter.shouldSkipFile("src/index.ts", "index.ts"), false);
+      assert.equal(filter.shouldSkipFile("lib/app.min.js", "app.min.js"), true);
+    });
+
+    it("works with undefined user exclusions", () => {
+      const filter = createExclusionFilter();
+      assert.equal(filter.shouldSkipFile("src/index.ts", "index.ts"), false);
+    });
+  });
+});

package/src/tests/integration/mcp-server.integration.test.ts

@@ -232,7 +232,7 @@ describe("MCP server integration", { skip: !serverBuilt }, () => {
     assert.ok(child && !child.killed, "server child should be running");
   });
 
-  it("exposes all nine tools via tools/list", async () => {
+  it("exposes all eleven tools via tools/list", async () => {
     const response = await client!.request<{ result?: { tools?: Array<{ name: string }> } }>(
       "tools/list",
     );
@@ -245,6 +245,7 @@ describe("MCP server integration", { skip: !serverBuilt }, () => {
       "compute_tdr",
       "ingest_sarif",
       "ingest_scanner_output",
+      "list_projects",
       "require_test_harness",
       "score_project",
     ]);

package/src/tests/project-map.test.ts

@@ -0,0 +1,302 @@
+/**
+ * Unit tests for the project-map discovery module.
+ *
+ * Covers workspace classification (single-project vs monorepo),
+ * per-project language detection across all supported project types,
+ * deduplication when a workspace appears in both npm workspaces and
+ * directory scan results, and the persist/load round-trip.
+ *
+ * Each test creates a fresh temporary directory tree and removes it in
+ * a `finally` block so failures leave no artefacts on disk.
+ *
+ * @module tests/project-map.test
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  discoverProjectMap,
+  persistProjectMap,
+  loadProjectMap,
+  type ProjectMap,
+  type ProjectEntry,
+} from "../monorepo/project-map.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function makeTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "crap-projmap-"));
+}
+
+/**
+ * Write a file at `absPath`, creating all parent directories first.
+ */
+function touch(absPath: string, content = ""): void {
+  mkdirSync(join(absPath, ".."), { recursive: true });
+  writeFileSync(absPath, content, "utf8");
+}
+
+/**
+ * Return the ProjectEntry for the given relative path, or throw if absent.
+ */
+function findProject(map: ProjectMap, relPath: string): ProjectEntry {
+  const entry = map.projects.find((p) => p.path === relPath);
+  assert.ok(entry, `expected project at path "${relPath}" — found: ${map.projects.map((p) => p.path).join(", ")}`);
+  return entry;
+}
+
+// ── discoverProjectMap ────────────────────────────────────────────────
+
+describe("discoverProjectMap", () => {
+  it("single-project workspace is not a monorepo and has no sub-projects", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "my-app" }));
+      writeFileSync(join(dir, "tsconfig.json"), "{}");
+
+      const map = await discoverProjectMap(dir);
+
+      assert.equal(map.isMonorepo, false);
+      assert.deepEqual(map.projects, []);
+      assert.equal(map.workspaceRoot, dir);
+      assert.equal(typeof map.generatedAt, "string");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("npm workspaces monorepo detects both sub-projects with correct types", async () => {
+    const dir = makeTmpDir();
+    try {
+      // Root manifest declares workspaces
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({ name: "root", workspaces: ["apps/web", "apps/api"] }),
+      );
+
+      // apps/web — TypeScript project
+      mkdirSync(join(dir, "apps", "web"), { recursive: true });
+      writeFileSync(join(dir, "apps", "web", "package.json"), JSON.stringify({ name: "web" }));
+      writeFileSync(join(dir, "apps", "web", "tsconfig.json"), "{}");
+
+      // apps/api — plain JavaScript project (no tsconfig)
+      mkdirSync(join(dir, "apps", "api"), { recursive: true });
+      writeFileSync(join(dir, "apps", "api", "package.json"), JSON.stringify({ name: "api" }));
+
+      const map = await discoverProjectMap(dir);
+
+      assert.equal(map.isMonorepo, true);
+      assert.equal(map.projects.length, 2);
+
+      const web = findProject(map, "apps/web");
+      assert.equal(web.type, "typescript");
+      assert.equal(web.name, "web");
+
+      const api = findProject(map, "apps/api");
+      assert.equal(api.type, "javascript");
+      assert.equal(api.name, "api");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("mixed monorepo discovers both an npm workspace and a Dart project", async () => {
+    const dir = makeTmpDir();
+    try {
+      // Root declares only apps/web in workspaces; apps/mobile is found by scan
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({ name: "root", workspaces: ["apps/web"] }),
+      );
+
+      // apps/web — TypeScript
+      mkdirSync(join(dir, "apps", "web"), { recursive: true });
+      writeFileSync(join(dir, "apps", "web", "package.json"), JSON.stringify({ name: "web" }));
+      writeFileSync(join(dir, "apps", "web", "tsconfig.json"), "{}");
+
+      // apps/mobile — Dart / Flutter (discovered via directory scan, not workspaces)
+      mkdirSync(join(dir, "apps", "mobile"), { recursive: true });
+      writeFileSync(
+        join(dir, "apps", "mobile", "pubspec.yaml"),
+        "name: mobile\nenvironment:\n  sdk: '>=3.0.0 <4.0.0'\n",
+      );
+
+      const map = await discoverProjectMap(dir);
+
+      assert.equal(map.isMonorepo, true);
+
+      const web = findProject(map, "apps/web");
+      assert.equal(web.type, "typescript");
+
+      const mobile = findProject(map, "apps/mobile");
+      assert.equal(mobile.type, "dart");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("Python project is detected with type 'python' and scanner 'bandit'", async () => {
+    const dir = makeTmpDir();
+    try {
+      // Root with no workspaces — but has a sub-directory with Python signals
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({ name: "root", workspaces: ["apps/ml"] }),
+      );
+
+      mkdirSync(join(dir, "apps", "ml"), { recursive: true });
+      writeFileSync(
+        join(dir, "apps", "ml", "pyproject.toml"),
+        "[project]\nname = \"ml\"\n",
+      );
+
+      const map = await discoverProjectMap(dir);
+
+      const ml = findProject(map, "apps/ml");
+      assert.equal(ml.type, "python");
+      assert.equal(ml.scanner, "bandit");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("Java project is detected with type 'java' and scanner 'dotnet_format'", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({ name: "root", workspaces: ["apps/backend"] }),
+      );
+
+      mkdirSync(join(dir, "apps", "backend"), { recursive: true });
+      writeFileSync(
+        join(dir, "apps", "backend", "pom.xml"),
+        "<project><modelVersion>4.0.0</modelVersion></project>",
+      );
+
+      const map = await discoverProjectMap(dir);
+
+      const backend = findProject(map, "apps/backend");
+      assert.equal(backend.type, "java");
+      assert.equal(backend.scanner, "semgrep");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("C# project is detected with type 'csharp' and scanner 'dotnet_format'", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({ name: "root", workspaces: ["apps/api"] }),
+      );
+
+      mkdirSync(join(dir, "apps", "api"), { recursive: true });
+      writeFileSync(
+        join(dir, "apps", "api", "MyApp.csproj"),
+        "<Project Sdk=\"Microsoft.NET.Sdk\"></Project>",
+      );
+
+      const map = await discoverProjectMap(dir);
+
+      const api = findProject(map, "apps/api");
+      assert.equal(api.type, "csharp");
+      assert.equal(api.scanner, "dotnet_format");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("empty workspace returns isMonorepo false and an empty projects array", async () => {
+    const dir = makeTmpDir();
+    try {
+      const map = await discoverProjectMap(dir);
+
+      assert.equal(map.isMonorepo, false);
+      assert.deepEqual(map.projects, []);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("project listed in npm workspaces AND found by directory scan appears only once", async () => {
+    const dir = makeTmpDir();
+    try {
+      // apps/shared is declared in workspaces; it also lives inside apps/
+      // which the directory scanner would naturally traverse
+      writeFileSync(
+        join(dir, "package.json"),
+        JSON.stringify({ name: "root", workspaces: ["apps/shared"] }),
+      );
+
+      mkdirSync(join(dir, "apps", "shared"), { recursive: true });
+      writeFileSync(join(dir, "apps", "shared", "package.json"), JSON.stringify({ name: "shared" }));
+      writeFileSync(join(dir, "apps", "shared", "tsconfig.json"), "{}");
+
+      const map = await discoverProjectMap(dir);
+
+      const matches = map.projects.filter((p) => p.path === "apps/shared");
+      assert.equal(
+        matches.length,
+        1,
+        `expected exactly 1 entry for "apps/shared", got ${matches.length}`,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+// ── persistProjectMap / loadProjectMap ───────────────────────────────
+
+describe("persistProjectMap / loadProjectMap", () => {
+  it("persisted map round-trips through loadProjectMap with deep equality", async () => {
+    const dir = makeTmpDir();
+    try {
+      const original: ProjectMap = {
+        generatedAt: new Date().toISOString(),
+        workspaceRoot: dir,
+        isMonorepo: true,
+        projects: [
+          {
+            name: "web",
+            path: "apps/web",
+            type: "typescript",
+            scanner: "eslint",
+            scannerAvailable: true,
+          },
+          {
+            name: "ml",
+            path: "apps/ml",
+            type: "python",
+            scanner: "bandit",
+            scannerAvailable: false,
+          },
+        ],
+      };
+
+      await persistProjectMap(original, dir);
+      const loaded = loadProjectMap(dir);
+
+      assert.ok(loaded !== null, "loadProjectMap returned null after persist");
+      assert.deepEqual(loaded, original);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("loadProjectMap returns null when no persisted file exists", () => {
+    const dir = makeTmpDir();
+    try {
+      const result = loadProjectMap(dir);
+      assert.equal(result, null);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/tests/scanner-detector.test.ts

@@ -90,24 +90,34 @@ describe("detectScanners", () => {
     }
   });
 
-  it("detects eslint from package.json devDependencies", async () => {
+  it("detects eslint from package.json — not installed vs installed", async () => {
     const dir = makeTmpDir();
     try {
       writeFileSync(
         join(dir, "package.json"),
         JSON.stringify({ devDependencies: { eslint: "^9.0.0" } }),
       );
+      // Without node_modules/.bin/eslint — declared but not installed
       const results = await detectScanners(dir);
       const eslint = results.find((r) => r.scanner === "eslint");
       assert.ok(eslint);
-      assert.equal(eslint.available, true);
-      assert.ok(eslint.reason.includes("package.json"));
+      assert.equal(eslint.available, false);
+      assert.ok(eslint.reason.includes("not installed"));
+
+      // With binary present — installed
+      mkdirSync(join(dir, "node_modules", ".bin"), { recursive: true });
+      writeFileSync(join(dir, "node_modules", ".bin", "eslint"), "");
+      const results2 = await detectScanners(dir);
+      const eslint2 = results2.find((r) => r.scanner === "eslint");
+      assert.ok(eslint2);
+      assert.equal(eslint2.available, true);
+      assert.ok(eslint2.reason.includes("installed"));
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  it("detects stryker from package.json @stryker-mutator/core", async () => {
+  it("detects stryker from package.json — not installed vs installed", async () => {
     const dir = makeTmpDir();
     try {
       writeFileSync(
@@ -116,11 +126,21 @@ describe("detectScanners", () => {
           devDependencies: { "@stryker-mutator/core": "^7.0.0" },
         }),
       );
+      // Without binary — declared but not installed
       const results = await detectScanners(dir);
       const stryker = results.find((r) => r.scanner === "stryker");
       assert.ok(stryker);
-      assert.equal(stryker.available, true);
-      assert.ok(stryker.reason.includes("package.json"));
+      assert.equal(stryker.available, false);
+      assert.ok(stryker.reason.includes("not installed"));
+
+      // With binary present — installed
+      mkdirSync(join(dir, "node_modules", ".bin"), { recursive: true });
+      writeFileSync(join(dir, "node_modules", ".bin", "stryker"), "");
+      const results2 = await detectScanners(dir);
+      const stryker2 = results2.find((r) => r.scanner === "stryker");
+      assert.ok(stryker2);
+      assert.equal(stryker2.available, true);
+      assert.ok(stryker2.reason.includes("installed"));
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -133,9 +153,9 @@ describe("detectScanners", () => {
       // Config and package.json probes will all fail.
       // Binary probe results depend on the host — don't assert on those,
       // but do assert the structure is correct.
-      assert.equal(results.length, 4);
+      assert.equal(results.length, 6);
       for (const r of results) {
-        assert.ok(["eslint", "semgrep", "bandit", "stryker"].includes(r.scanner));
+        assert.ok(["eslint", "semgrep", "bandit", "stryker", "dart_analyze", "dotnet_format"].includes(r.scanner));
         assert.equal(typeof r.available, "boolean");
         assert.equal(typeof r.reason, "string");
       }
@@ -150,7 +170,7 @@ describe("detectScanners", () => {
       writeFileSync(join(dir, "package.json"), "not json at all");
       // Should not throw — just skip the package.json probe
       const results = await detectScanners(dir);
-      assert.equal(results.length, 4);
+      assert.equal(results.length, 6);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -172,10 +192,10 @@ describe("detectScanners", () => {
     }
   });
 
-  it("SCANNER_SIGNALS covers all four scanners", () => {
+  it("SCANNER_SIGNALS covers all supported scanners", () => {
     assert.deepEqual(
       Object.keys(SCANNER_SIGNALS).sort(),
-      ["bandit", "eslint", "semgrep", "stryker"],
+      ["bandit", "dart_analyze", "dotnet_format", "eslint", "semgrep", "stryker"],
     );
   });
 });