claude-crap 0.3.8 → 0.4.0

package/plugin/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-crap-plugin",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-crap-plugin",
-      "version": "0.3.8",
+      "version": "0.4.0",
       "dependencies": {
         "@fastify/static": "^8.0.3",
         "@modelcontextprotocol/sdk": "^1.0.4",

package/plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-crap-plugin",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "private": true,
   "description": "Runtime dependencies for the claude-crap plugin bundle",
   "type": "module",

package/src/adapters/common.ts

@@ -23,7 +23,7 @@ import type { SarifLevel } from "../sarif/sarif-builder.js";
  * `ingest_scanner_output` MCP tool uses this as its `enum` constraint,
  * so keeping it narrow prevents drift.
  */
-export const KNOWN_SCANNERS = ["semgrep", "eslint", "bandit", "stryker", "dart_analyze"] as const;
+export const KNOWN_SCANNERS = ["semgrep", "eslint", "bandit", "stryker", "dart_analyze", "dotnet_format"] as const;
 
 /**
  * Union of supported scanner identifiers.

package/src/adapters/dotnet-format.ts

@@ -0,0 +1,125 @@
+/**
+ * Adapter: `dotnet format --report <path>` JSON output → SARIF 2.1.0.
+ *
+ * The dotnet format tool emits a JSON array with this shape:
+ *
+ *   [
+ *     {
+ *       "DocumentId": { "ProjectId": { "Id": "..." }, "Id": "..." },
+ *       "FileName": "AuthController.cs",
+ *       "FilePath": "/absolute/path/to/AuthController.cs",
+ *       "FileChanges": [
+ *         {
+ *           "LineNumber": 84,
+ *           "CharNumber": 16,
+ *           "DiagnosticId": "WHITESPACE",
+ *           "FormatDescription": "Fix whitespace formatting. Delete 5 characters."
+ *         }
+ *       ]
+ *     }
+ *   ]
+ *
+ * All dotnet format findings are style/formatting issues, so they
+ * map uniformly to SARIF "warning" level with a 5-minute effort
+ * estimate (formatting fixes are quick, mechanical changes).
+ *
+ * @module adapters/dotnet-format
+ */
+
+import {
+  type AdapterResult,
+  wrapResultsInSarif,
+} from "./common.js";
+
+// ── Types ──────────────────────────────────────────────────────────
+
+interface DotnetFileChange {
+  LineNumber: number;
+  CharNumber: number;
+  DiagnosticId: string;
+  FormatDescription: string;
+}
+
+interface DotnetFormatDocument {
+  DocumentId: {
+    ProjectId: { Id: string };
+    Id: string;
+  };
+  FileName: string;
+  FilePath: string;
+  FileChanges: DotnetFileChange[];
+}
+
+// ── Public API ─────────────────────────────────────────────────────
+
+/**
+ * Convert `dotnet format --report <path>` JSON output to SARIF 2.1.0.
+ *
+ * @param rawOutput The JSON string or pre-parsed array from `dotnet format`.
+ */
+export function adaptDotnetFormat(rawOutput: unknown): AdapterResult {
+  let parsed: DotnetFormatDocument[];
+
+  if (typeof rawOutput === "string") {
+    try {
+      parsed = JSON.parse(rawOutput) as DotnetFormatDocument[];
+    } catch {
+      throw new Error("[dotnet-format adapter] rawOutput is not valid JSON");
+    }
+  } else if (Array.isArray(rawOutput)) {
+    parsed = rawOutput as DotnetFormatDocument[];
+  } else {
+    throw new Error(
+      "[dotnet-format adapter] rawOutput must be a JSON string or an array of document entries",
+    );
+  }
+
+  if (!Array.isArray(parsed)) {
+    throw new Error("[dotnet-format adapter] parsed output must be an array");
+  }
+
+  const EFFORT_MINUTES = 5;
+  const results: object[] = [];
+  let findingCount = 0;
+  let totalEffortMinutes = 0;
+
+  for (const doc of parsed) {
+    if (!Array.isArray(doc.FileChanges)) continue;
+
+    for (const change of doc.FileChanges) {
+      findingCount++;
+      totalEffortMinutes += EFFORT_MINUTES;
+
+      results.push({
+        ruleId: change.DiagnosticId,
+        level: "warning",
+        message: {
+          text: change.FormatDescription,
+        },
+        locations: [
+          {
+            physicalLocation: {
+              artifactLocation: {
+                uri: doc.FilePath,
+              },
+              region: {
+                startLine: change.LineNumber,
+                startColumn: change.CharNumber,
+              },
+            },
+          },
+        ],
+        properties: {
+          effortMinutes: EFFORT_MINUTES,
+        },
+      });
+    }
+  }
+
+  return {
+    document: wrapResultsInSarif("dotnet_format", "1.0.0", results),
+    sourceTool: "dotnet_format",
+    findingCount,
+    totalEffortMinutes,
+  };
+}

package/src/adapters/index.ts

@@ -31,6 +31,7 @@ export { adaptEslint } from "./eslint.js";
 export { adaptBandit } from "./bandit.js";
 export { adaptStryker } from "./stryker.js";
 export { adaptDartAnalyzer } from "./dart-analyzer.js";
+export { adaptDotnetFormat } from "./dotnet-format.js";
 
 export {
   DEFAULT_EFFORT_BY_SEVERITY,
@@ -46,6 +47,7 @@ import { adaptEslint } from "./eslint.js";
 import { adaptBandit } from "./bandit.js";
 import { adaptStryker } from "./stryker.js";
 import { adaptDartAnalyzer } from "./dart-analyzer.js";
+import { adaptDotnetFormat } from "./dotnet-format.js";
 import type { AdapterResult, KnownScanner } from "./common.js";
 
 /**
@@ -74,6 +76,8 @@ export function adaptScannerOutput(
       return adaptStryker(rawOutput);
     case "dart_analyze":
       return adaptDartAnalyzer(rawOutput);
+    case "dotnet_format":
+      return adaptDotnetFormat(rawOutput);
     default: {
       const exhaustive: never = scanner;
       throw new Error(`[adapters] Unknown scanner: ${String(exhaustive)}`);

package/src/crap-config.ts

@@ -83,6 +83,8 @@ export interface CrapConfig {
   readonly strictnessSource: "env" | "file" | "default";
   /** User-defined exclusion patterns (directories with trailing `/`, or file globs). */
   readonly exclude: ReadonlyArray<string>;
+  /** Relative paths to directories containing sub-projects (e.g. `["apps", "packages"]`). */
+  readonly projectDirs: ReadonlyArray<string>;
 }
 
 /**
@@ -113,6 +115,7 @@ export function loadCrapConfig(options: LoadCrapConfigOptions): CrapConfig {
   // comes from the environment variable.
   const fileResult = readFromFile(options.workspaceRoot);
   const exclude = fileResult?.exclude ?? [];
+  const projectDirs = fileResult?.projectDirs ?? [];
 
   const envRaw = process.env["CLAUDE_CRAP_STRICTNESS"];
   if (typeof envRaw === "string" && envRaw.trim() !== "") {
@@ -123,14 +126,14 @@ export function loadCrapConfig(options: LoadCrapConfigOptions): CrapConfig {
           `Expected one of: ${STRICTNESS_VALUES.join(", ")}.`,
       );
     }
-    return { strictness: normalized, strictnessSource: "env", exclude };
+    return { strictness: normalized, strictnessSource: "env", exclude, projectDirs };
   }
 
   if (fileResult?.strictness) {
-    return { strictness: fileResult.strictness, strictnessSource: "file", exclude };
+    return { strictness: fileResult.strictness, strictnessSource: "file", exclude, projectDirs };
   }
 
-  return { strictness: DEFAULT_STRICTNESS, strictnessSource: "default", exclude };
+  return { strictness: DEFAULT_STRICTNESS, strictnessSource: "default", exclude, projectDirs };
 }
 
 /**
@@ -149,6 +152,7 @@ export function loadCrapConfig(options: LoadCrapConfigOptions): CrapConfig {
 interface FileResult {
   strictness: Strictness | null;
   exclude: string[];
+  projectDirs: string[];
 }
 
 function readFromFile(workspaceRoot: string): FileResult | null {
@@ -218,7 +222,26 @@ function readFromFile(workspaceRoot: string): FileResult | null {
     exclude = raw as string[];
   }
 
-  return { strictness, exclude };
+  // Parse projectDirs
+  let projectDirs: string[] = [];
+  if ("projectDirs" in doc) {
+    const raw = doc["projectDirs"];
+    if (!Array.isArray(raw)) {
+      throw new CrapConfigError(
+        `[crap-config] ${filePath}: 'projectDirs' must be an array of strings`,
+      );
+    }
+    for (const item of raw) {
+      if (typeof item !== "string") {
+        throw new CrapConfigError(
+          `[crap-config] ${filePath}: every entry in 'projectDirs' must be a string, got ${typeof item}`,
+        );
+      }
+    }
+    projectDirs = raw as string[];
+  }
+
+  return { strictness, exclude, projectDirs };
 }
 
 /**

package/src/dashboard/server.ts

@@ -107,7 +107,7 @@ export async function startDashboard(options: StartDashboardOptions): Promise<Da
   // ------------------------------------------------------------------
   // /api/health — liveness probe
   // ------------------------------------------------------------------
-  fastify.get("/api/health", async () => ({ status: "ok", server: "claude-crap", version: "0.3.8" }));
+  fastify.get("/api/health", async () => ({ status: "ok", server: "claude-crap", version: "0.4.0" }));
 
   // ------------------------------------------------------------------
   // /api/score — live project score

package/src/index.ts

@@ -59,6 +59,7 @@ import { findTestFile } from "./tools/test-harness.js";
 import { resolveWithinWorkspace } from "./workspace-guard.js";
 import { autoScan } from "./scanner/auto-scan.js";
 import { bootstrapScanner } from "./scanner/bootstrap.js";
+import { discoverProjectMap, persistProjectMap, type ProjectMap } from "./monorepo/project-map.js";
 import {
   autoScanSchema,
   bootstrapScannerSchema,
@@ -67,6 +68,7 @@ import {
   analyzeFileAstSchema,
   ingestSarifSchema,
   ingestScannerOutputSchema,
+  listProjectsSchema,
   requireTestHarnessSchema,
   scoreProjectSchema,
 } from "./schemas/tool-schemas.js";
@@ -93,14 +95,19 @@ async function main(): Promise<void> {
     "claude-crap MCP server starting",
   );
 
-  // Load user-defined exclusions from .claude-crap.json (non-fatal).
+  // Load user-defined exclusions and projectDirs from .claude-crap.json (non-fatal).
   let userExclusions: ReadonlyArray<string> = [];
+  let userProjectDirs: ReadonlyArray<string> = [];
   try {
     const crapConfig = loadCrapConfig({ workspaceRoot: config.pluginRoot });
     userExclusions = crapConfig.exclude;
+    userProjectDirs = crapConfig.projectDirs;
     if (userExclusions.length > 0) {
       logger.info({ exclude: userExclusions }, "user exclusions loaded from .claude-crap.json");
     }
+    if (userProjectDirs.length > 0) {
+      logger.info({ projectDirs: userProjectDirs }, "user projectDirs loaded from .claude-crap.json");
+    }
   } catch {
     // Non-fatal — use empty exclusions.
   }
@@ -117,6 +124,39 @@ async function main(): Promise<void> {
     "SARIF store ready",
   );
 
+  // Discover monorepo project map (non-fatal).
+  let projectMap: ProjectMap | null = null;
+  try {
+    projectMap = await discoverProjectMap(config.pluginRoot, { projectDirs: userProjectDirs });
+    if (projectMap.isMonorepo) {
+      logger.info(
+        { projects: projectMap.projects.map((p) => `${p.name}(${p.type})`), count: projectMap.projects.length },
+        "monorepo project map discovered",
+      );
+      await persistProjectMap(projectMap, config.pluginRoot);
+
+      // If any JS/TS sub-projects need ESLint and it's not available,
+      // run bootstrap at the monorepo root to auto-install it. In
+      // monorepos, ESLint is hoisted to the root node_modules.
+      const needsEslint = projectMap.projects.some(
+        (p) => (p.type === "typescript" || p.type === "javascript") && !p.scannerAvailable,
+      );
+      if (needsEslint) {
+        logger.info("monorepo: JS/TS projects detected but ESLint not installed — bootstrapping");
+        try {
+          await bootstrapScanner(config.pluginRoot, sarifStore, logger);
+          // Re-discover after install so scannerAvailable reflects reality
+          projectMap = await discoverProjectMap(config.pluginRoot, { projectDirs: userProjectDirs });
+          await persistProjectMap(projectMap, config.pluginRoot);
+        } catch (err) {
+          logger.warn({ err: (err as Error).message }, "monorepo ESLint bootstrap failed");
+        }
+      }
+    }
+  } catch (err) {
+    logger.warn({ err: (err as Error).message }, "project map discovery failed");
+  }
+
   // Try to start the local Vue.js dashboard. Failures here are
   // intentionally non-fatal — the MCP server still works without it.
   let dashboard: DashboardHandle | null = null;
@@ -235,6 +275,11 @@ async function main(): Promise<void> {
           "Detect project type, install the right scanner (ESLint for JS/TS, Bandit for Python, Semgrep for Java/C#), create minimal config, and run auto_scan to verify.",
         inputSchema: bootstrapScannerSchema,
       },
+      {
+        name: "list_projects",
+        description: "List all discovered sub-projects in the workspace. In a monorepo, returns each sub-project with its type, path, and recommended scanner.",
+        inputSchema: listProjectsSchema,
+      },
     ],
   }));
 
@@ -244,10 +289,20 @@ async function main(): Promise<void> {
   // The MCP SDK has already validated `args` against the tool's JSON
   // Schema by the time this handler runs, so we cast to the expected
   // shape without re-validating. Each branch delegates to a pure engine.
+  // Tool dispatch is split across two functions to keep cyclomatic
+  // complexity within the configured threshold (15) as the tool count
+  // grows. Each function handles a subset of tools.
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     logger.info({ tool: name }, "Tool call received");
+    return handleToolCall(name, args);
+  });
 
+  /** Dispatch a tool call to the correct handler. */
+  async function handleToolCall(
+    name: string,
+    args: Record<string, unknown> | undefined,
+  ): Promise<{ content: Array<{ type: string; text: string }>; isError?: boolean }> {
     switch (name) {
       case "compute_crap": {
         const typed = args as {
@@ -343,12 +398,21 @@ async function main(): Promise<void> {
       }
 
       case "score_project": {
-        const typed = (args ?? {}) as { format?: "markdown" | "json" | "both" };
+        const typed = (args ?? {}) as { format?: "markdown" | "json" | "both"; scope?: string };
         const format = typed.format ?? "both";
+        // Resolve scope to a workspace subdirectory
+        let scoreRoot = config.pluginRoot;
+        if (typed.scope && projectMap) {
+          const project = projectMap.projects.find((p) => p.name === typed.scope);
+          if (project) {
+            const { join } = await import("node:path");
+            scoreRoot = join(config.pluginRoot, project.path);
+          }
+        }
         try {
-          const workspace = await estimateWorkspaceLoc(config.pluginRoot, { exclude: userExclusions });
+          const workspace = await estimateWorkspaceLoc(scoreRoot, { exclude: userExclusions });
           const score: ProjectScore = computeProjectScore({
-            workspaceRoot: config.pluginRoot,
+            workspaceRoot: scoreRoot,
             minutesPerLoc: config.minutesPerLoc,
             tdrMaxRating: config.tdrMaxRating,
             workspace: { physicalLoc: workspace.physicalLoc, fileCount: workspace.fileCount },
@@ -625,10 +689,29 @@ async function main(): Promise<void> {
         }
       }
 
+      case "list_projects": {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  tool: "list_projects",
+                  isMonorepo: projectMap?.isMonorepo ?? false,
+                  projects: projectMap?.projects ?? [],
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      }
+
       default:
         throw new Error(`[claude-crap] Unknown tool: ${name}`);
     }
-  });
+  }
 
   // ------------------------------------------------------------------
   // Resources — topology and reports