capy-mcp 1.0.6 → 1.0.8

package/dist/component-discovery.d.ts

@@ -3,7 +3,6 @@ interface DiscoveredComponent {
     path: string;
     basename: string;
     exports: string[];
-    contents: string;
 }
 export interface ComponentDiscoveryPlan {
     allDiscoveredComponents: DiscoveredComponent[];

package/dist/component-discovery.js

@@ -36,14 +36,12 @@ async function scanForComponents(projectRoot, projectFacts) {
         ...projectFacts.likelyComponentDirs,
         ...projectFacts.likelyUiDirs,
     ]);
-    let patterns;
-    if (searchDirs.size > 0) {
-        patterns = Array.from(searchDirs).map((dir) => `${dir}/**/*.{ts,tsx,js,jsx}`);
-    }
-    else {
-        // Fallback: scan everything if no dirs were discovered
-        patterns = ["**/*.{ts,tsx,js,jsx}"];
+    // If no component dirs were discovered, return empty instead of
+    // falling back to a repo-wide scan that reads every file's contents.
+    if (searchDirs.size === 0) {
+        return [];
     }
+    const patterns = Array.from(searchDirs).map((dir) => `${dir}/**/*.{ts,tsx,js,jsx}`);
     const sourceFiles = await glob(patterns, {
         cwd: projectRoot,
         nodir: true,
@@ -72,7 +70,6 @@ async function scanForComponents(projectRoot, projectFacts) {
                 path: file,
                 basename: basename(file).replace(/\.[^.]+$/, ""),
                 exports,
-                contents,
             });
         }
     }

package/dist/project.js

@@ -28,14 +28,15 @@ export async function buildProjectFacts(projectRoot, framework) {
         ],
     });
     const normalized = sourceFiles.map((f) => toPosixPath(f));
-    // Scan files for PascalCase exports to find component directories
-    const componentDirs = await findComponentDirs(projectRoot, normalized);
-    // Find page/route directories by looking for routing markers
+    // Find page/route directories FIRST — we need these to exclude from component dirs
     const pageDirs = findPageDirs(normalized);
+    // Scan files for PascalCase exports to find component directories
+    // Exclude page dirs so route files don't inflate the component list
+    const componentDirs = await findComponentDirs(projectRoot, normalized, pageDirs);
     // Find style files — already dynamic via glob
     const styleFiles = await findStyleFiles(projectRoot);
-    // UI dirs = union of component + page dirs
-    const likelyUiDirs = Array.from(new Set([...componentDirs, ...pageDirs.filter((dir) => !dir.endsWith("/preview"))]));
+    // UI dirs = component dirs only (page dirs are routes, not reusable UI)
+    const likelyUiDirs = Array.from(new Set([...componentDirs]));
     return {
         framework: framework.kind,
         routingStyle: framework.routingStyle,
@@ -49,42 +50,45 @@ export async function buildProjectFacts(projectRoot, framework) {
     };
 }
 /**
- * Find component directories by scanning source files for PascalCase exports.
- * A directory is a "component dir" if it contains ≥1 file with a PascalCase export.
- * We deduplicate to the shallowest ancestor that qualifies.
+ * Find component directories by scanning .tsx/.jsx source files for
+ * PascalCase exports that look like React components.
+ *
+ * Key rules:
+ * - Only .tsx/.jsx files qualify (plain .ts/.js are utilities, not components)
+ * - Files must contain JSX or React signals (not just any PascalCase export)
+ * - Page/route directories are excluded (those are routes, not reusable UI)
  */
-async function findComponentDirs(projectRoot, sourceFiles) {
+async function findComponentDirs(projectRoot, sourceFiles, pageDirs) {
     const dirComponentCount = new Map();
     for (const file of sourceFiles) {
         // Skip files at the root level (no directory)
         if (!file.includes("/"))
             continue;
+        // Skip files inside page/route dirs — those are routes, not components
+        const dir = dirname(file);
+        if (isInsidePageDir(dir, pageDirs))
+            continue;
         const ext = file.split(".").pop() ?? "";
-        // Only check .tsx and .jsx files — those are almost always components
-        // Also check .ts/.js but require a PascalCase filename as extra signal
-        const isTsxJsx = ext === "tsx" || ext === "jsx";
+        // ONLY check .tsx and .jsx files — plain .ts/.js are utilities/hooks/config
+        if (ext !== "tsx" && ext !== "jsx")
+            continue;
+        // Skip common non-component page/route files by name
         const fileName = basename(file).replace(/\.[^.]+$/, "");
-        const isPascalFileName = /^[A-Z][a-zA-Z0-9]*$/.test(fileName);
-        if (!isTsxJsx && !isPascalFileName)
+        if (isRouteFileName(fileName))
             continue;
         const contents = await readText(`${projectRoot}/${file}`);
         if (!contents)
             continue;
+        // For .tsx/.jsx files, a PascalCase export is sufficient signal —
+        // the file extension itself indicates component intent
         if (hasPascalCaseExport(contents)) {
-            const dir = dirname(file);
             dirComponentCount.set(dir, (dirComponentCount.get(dir) ?? 0) + 1);
         }
     }
     if (dirComponentCount.size === 0)
         return [];
-    // Collect all dirs that have components
     const allDirs = Array.from(dirComponentCount.keys()).sort();
-    // Deduplicate: if both "src/components" and "src/components/sections" exist,
-    // keep the parent "src/components" (the child is already covered by glob patterns).
-    // But also keep the child if the parent has 0 direct components (e.g. parent is
-    // just an organizer directory).
-    const roots = deduplicateToRoots(allDirs);
-    return roots;
+    return deduplicateToRoots(allDirs);
 }
 /**
  * Given a sorted list of directory paths, return the root-most directories.
@@ -135,6 +139,41 @@ function findPageDirs(sourceFiles) {
 function hasPascalCaseExport(contents) {
     return /export\s+(?:default\s+)?(?:function|const|class)\s+[A-Z][A-Za-z0-9_]*/.test(contents);
 }
+/**
+ * Check if a file looks like a React component (contains JSX or React imports).
+ * This prevents pure utility files with PascalCase class exports from being
+ * treated as components.
+ */
+function looksLikeComponent(contents) {
+    // Contains JSX-like syntax: <Component, <div, <>, etc.
+    if (/<[A-Za-z][A-Za-z0-9.]*[\s/>]/.test(contents))
+        return true;
+    if (/<>/.test(contents))
+        return true;
+    // Imports React or uses React APIs
+    if (/from\s+['"]react['"]/.test(contents))
+        return true;
+    if (/React\.createElement/.test(contents))
+        return true;
+    return false;
+}
+/**
+ * Check if a directory is inside (or equal to) any of the known page dirs.
+ */
+function isInsidePageDir(dir, pageDirs) {
+    return pageDirs.some((pageDir) => dir === pageDir || dir.startsWith(pageDir + "/"));
+}
+/**
+ * Common route/page filenames that should not be treated as components.
+ */
+function isRouteFileName(name) {
+    const routeNames = new Set([
+        "layout", "page", "loading", "error", "not-found",
+        "template", "default", "route", "middleware",
+        "_app", "_document", "_error",
+    ]);
+    return routeNames.has(name);
+}
 async function findStyleFiles(projectRoot) {
     const files = await glob(["**/*.{css,scss,sass,less}"], {
         cwd: projectRoot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capy-mcp",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "MCP server that inspects a repo, returns a structured /preview brief, and writes a design-system JSON artifact for AI coding agents",
   "type": "module",
   "main": "dist/index.js",