claude-crap 0.3.7 → 0.4.0

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,6 +95,23 @@ async function main(): Promise<void> {
     "claude-crap MCP server starting",
   );
 
+  // 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.
+  }
+
   // Long-lived engines. Created once at boot and reused for every call.
   const astEngine = new TreeSitterEngine();
   const sarifStore = new SarifStore({
@@ -105,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;
@@ -112,9 +164,10 @@ async function main(): Promise<void> {
     dashboard = await startDashboard({
       config,
       sarifStore,
-      workspaceStatsProvider: () => estimateWorkspaceLoc(config.pluginRoot),
+      workspaceStatsProvider: () => estimateWorkspaceLoc(config.pluginRoot, { exclude: userExclusions }),
       logger,
       astEngine,
+      exclude: userExclusions,
     });
   } catch (err) {
     logger.warn(
@@ -222,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,
+      },
     ],
   }));
 
@@ -231,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 {
@@ -330,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);
+          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 },
@@ -585,6 +662,7 @@ async function main(): Promise<void> {
           const result = await autoScan(config.pluginRoot, sarifStore, logger, {
             engine: astEngine,
             cyclomaticMax: config.cyclomaticMax,
+            exclude: userExclusions,
           });
           const markdown = renderAutoScanMarkdown(result);
           return {
@@ -611,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
@@ -676,6 +773,7 @@ async function main(): Promise<void> {
   autoScan(config.pluginRoot, sarifStore, logger, {
     engine: astEngine,
     cyclomaticMax: config.cyclomaticMax,
+    exclude: userExclusions,
   })
     .then((result) => {
       const scanners = result.results

package/src/metrics/workspace-walker.ts

@@ -15,7 +15,9 @@
  */
 
 import { promises as fs } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
+
+import { createExclusionFilter } from "../shared/exclusions.js";
 
 /**
  * Result returned by {@link estimateWorkspaceLoc}.
@@ -29,26 +31,9 @@ export interface WorkspaceWalkResult {
   readonly truncated: boolean;
 }
 
-/**
- * Directories that should never contribute to the LOC count. Dependency
- * caches, build artifacts, VCS metadata, claude-crap's own state.
- */
-const SKIP_DIRS: ReadonlySet<string> = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "out",
-  "target",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".cache",
-  ".next",
-  ".nuxt",
-  ".claude-crap",
-  ".codesight",
-]);
+// Directory exclusions are now centralized in src/shared/exclusions.ts.
+// The createExclusionFilter() factory is called once per walk with
+// optional user-defined patterns from .claude-crap.json.
 
 /**
  * Extensions the walker treats as "code". Anything else is ignored,
@@ -91,9 +76,14 @@ export const MAX_FILES_WALKED = 20_000;
  * (which is tiny and contains the manifest).
  *
  * @param workspaceRoot Absolute path to the workspace root.
+ * @param options       Optional settings including user-defined exclusion patterns.
  * @returns             A {@link WorkspaceWalkResult} snapshot.
  */
-export async function estimateWorkspaceLoc(workspaceRoot: string): Promise<WorkspaceWalkResult> {
+export async function estimateWorkspaceLoc(
+  workspaceRoot: string,
+  options?: { exclude?: ReadonlyArray<string> },
+): Promise<WorkspaceWalkResult> {
+  const filter = createExclusionFilter(options?.exclude);
   let physicalLoc = 0;
   let fileCount = 0;
   let truncated = false;
@@ -108,11 +98,9 @@ export async function estimateWorkspaceLoc(workspaceRoot: string): Promise<Works
     }
     for (const entry of entries) {
       if (truncated) return;
-      // Skip hidden files except the plugin manifest dir.
-      if (entry.name.startsWith(".") && entry.name !== ".claude-plugin") continue;
       const full = join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name)) continue;
+        if (filter.shouldSkipDir(entry.name)) continue;
         await walk(full);
         continue;
       }
@@ -122,6 +110,8 @@ export async function estimateWorkspaceLoc(workspaceRoot: string): Promise<Works
       if (dot < 0) continue;
       const ext = lower.substring(dot);
       if (!CODE_EXTENSIONS.has(ext)) continue;
+      const relPath = relative(workspaceRoot, full);
+      if (filter.shouldSkipFile(relPath, entry.name)) continue;
       fileCount += 1;
       if (fileCount > MAX_FILES_WALKED) {
         truncated = true;
@@ -130,8 +120,6 @@ export async function estimateWorkspaceLoc(workspaceRoot: string): Promise<Works
       try {
         const content = await fs.readFile(full, "utf8");
         if (content.length > 0) {
-          // Subtract 1 for trailing newline, matching what most editors
-          // report as the file's line count.
           const lines = content.split(/\r?\n/).length;
           physicalLoc += content.endsWith("\n") ? lines - 1 : lines;
         }