claude-crap 0.3.8 → 0.4.0

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

@@ -153,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, 5);
+      assert.equal(results.length, 6);
       for (const r of results) {
-        assert.ok(["eslint", "semgrep", "bandit", "stryker", "dart_analyze"].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");
       }
@@ -170,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, 5);
+      assert.equal(results.length, 6);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -195,7 +195,7 @@ describe("detectScanners", () => {
   it("SCANNER_SIGNALS covers all supported scanners", () => {
     assert.deepEqual(
       Object.keys(SCANNER_SIGNALS).sort(),
-      ["bandit", "dart_analyze", "eslint", "semgrep", "stryker"],
+      ["bandit", "dart_analyze", "dotnet_format", "eslint", "semgrep", "stryker"],
     );
   });
 });