capy-mcp 1.0.4 → 1.0.6

package/dist/brief.js

@@ -1,5 +1,6 @@
 import { detectFramework } from "./framework.js";
 import { buildProjectFacts } from "./project.js";
+import { buildComponentDiscoveryPlan } from "./component-discovery.js";
 const SECTION_ORDER = [
     "Foundations",
     "Colors",
@@ -17,10 +18,11 @@ const SECTION_ORDER = [
 export async function buildPreviewBrief(projectRoot, input) {
     const framework = await detectFramework(projectRoot);
     const projectFacts = await buildProjectFacts(projectRoot, framework);
-    const warnings = buildWarnings(framework, input.changedFiles);
+    const discoveryPlan = await buildComponentDiscoveryPlan(projectRoot, projectFacts);
+    const warnings = buildWarnings(framework, input.changedFiles, discoveryPlan.missingFamilyGaps);
     return {
         projectFacts,
-        inspectionPlan: buildInspectionPlan(projectFacts),
+        inspectionPlan: buildInspectionPlan(projectFacts, discoveryPlan),
         constraints: buildConstraints(framework),
         deliverableSpec: {
             goal: input.task === "update_preview"
@@ -41,27 +43,35 @@ export async function buildPreviewBrief(projectRoot, input) {
         },
         updateStrategy: buildUpdateStrategy(input.changedFiles),
         warnings,
-        instructions: buildInstructions(projectFacts, input),
+        instructions: buildInstructions(projectFacts, input, discoveryPlan.instruction),
     };
 }
-function buildInspectionPlan(projectFacts) {
-    const appShellTargets = uniqueCompact([
-        firstMatching(projectFacts.likelyPageDirs, "src/app")
-            ? "src/app/layout.tsx"
-            : undefined,
-        firstMatching(projectFacts.likelyPageDirs, "src/app")
-            ? "src/app/page.tsx"
-            : undefined,
-        firstMatching(projectFacts.likelyPageDirs, "app") ? "app/layout.tsx" : undefined,
-        firstMatching(projectFacts.likelyPageDirs, "app") ? "app/page.tsx" : undefined,
-        firstMatching(projectFacts.likelyPageDirs, "src/pages") ? "src/pages/_app.tsx" : undefined,
-        firstMatching(projectFacts.likelyPageDirs, "pages") ? "pages/_app.tsx" : undefined,
-    ]);
+function buildInspectionPlan(projectFacts, discoveryPlan) {
+    // Build app shell targets dynamically from discovered page dirs
+    // Use routing style to suggest the right shell files
+    const appShellTargets = [];
+    for (const pageDir of projectFacts.likelyPageDirs) {
+        if (projectFacts.routingStyle === "app-router") {
+            appShellTargets.push(`${pageDir}/layout.tsx`);
+            appShellTargets.push(`${pageDir}/page.tsx`);
+        }
+        else if (projectFacts.routingStyle === "pages-router") {
+            appShellTargets.push(`${pageDir}/_app.tsx`);
+        }
+        else {
+            // Unknown or other routing — suggest both
+            appShellTargets.push(`${pageDir}/layout.tsx`);
+            appShellTargets.push(`${pageDir}/page.tsx`);
+            appShellTargets.push(`${pageDir}/_app.tsx`);
+        }
+    }
+    // Deduplicate
+    const uniqueShellTargets = Array.from(new Set(appShellTargets));
     return [
         {
             step: 1,
             action: "Read the app shell and routing entry points first",
-            targets: appShellTargets.length > 0 ? appShellTargets : projectFacts.likelyPageDirs,
+            targets: uniqueShellTargets.length > 0 ? uniqueShellTargets : projectFacts.likelyPageDirs,
             reason: "Understand the project structure, routing style, and baseline visual language.",
         },
         {
@@ -72,12 +82,20 @@ function buildInspectionPlan(projectFacts) {
         },
         {
             step: 3,
-            action: "Inspect UI/component directories",
-            targets: projectFacts.likelyComponentDirs.length > 0 ? projectFacts.likelyComponentDirs : projectFacts.likelyUiDirs,
-            reason: "Find existing primitives, composites, and sections before inventing new preview-only UI.",
+            action: "Traverse discovered component directories",
+            targets: discoveryPlan.prioritizedFiles.length > 0
+                ? discoveryPlan.prioritizedFiles
+                : projectFacts.likelyComponentDirs,
+            reason: "Read the actual components discovered by Capy's scan. These are real files with PascalCase exports, not guesses.",
         },
         {
             step: 4,
+            action: "Inspect UI/component directories for anything the scan missed",
+            targets: projectFacts.likelyComponentDirs.length > 0 ? projectFacts.likelyComponentDirs : projectFacts.likelyUiDirs,
+            reason: "The automatic scan catches most components, but manually inspect directories for any non-standard patterns that were missed.",
+        },
+        {
+            step: 5,
             action: "Implement or update the preview route",
             targets: [projectFacts.previewEntryFile],
             reason: "Build a neat, scrollable /preview page that reflects the real app structure.",
@@ -90,6 +108,9 @@ function buildConstraints(framework) {
         "Build a preview page that can support both vertical and horizontal scanning where useful.",
         "Use horizontal specimen rows only when they make scanning easier.",
         "Prefer existing components over creating preview-only components.",
+        "Traverse all component directories found by Capy. Every file with a PascalCase export is a component candidate. Read real usage examples before marking a preview section complete.",
+        "When you only find hooks, providers, or usage patterns, trace one real usage example and mirror that flow in /preview instead of inventing a fake component.",
+        "If a component family is not present in the repo, label it as absent rather than fabricating a preview-only substitute.",
         "Keep the page neat, easy to scan, and aligned with the app's current design language.",
         "Include an icon inventory when the repo exposes app icons clearly enough to catalogue them.",
         "Show colors in a uniform swatch format with normalized 6-character hex labels and click-to-copy affordance.",
@@ -113,7 +134,7 @@ function buildUpdateStrategy(changedFiles) {
     }
     return strategies;
 }
-function buildWarnings(framework, changedFiles) {
+function buildWarnings(framework, changedFiles, discoveryGaps = []) {
     const warnings = [];
     if (framework.confirmationMessage) {
         warnings.push(framework.confirmationMessage);
@@ -121,18 +142,13 @@ function buildWarnings(framework, changedFiles) {
     if (!changedFiles || changedFiles.length === 0) {
         warnings.push("No changedFiles were provided. The agent should inspect git diff or recent edits when performing update_preview.");
     }
+    warnings.push(...discoveryGaps);
     return warnings;
 }
-function buildInstructions(projectFacts, input) {
+function buildInstructions(projectFacts, input, discoveryInstruction) {
     const lead = input.task === "update_preview"
         ? "Update the existing /preview route incrementally."
         : "Create the /preview route from scratch.";
     const userGoal = input.userGoal ? ` User goal: ${input.userGoal}.` : "";
-    return `${lead}${userGoal} Read the app shell first, then global styles, then component directories. After that, implement ${projectFacts.previewEntryFile} as a clean preview surface that supports both vertical and horizontal scanning when useful, includes a dedicated icon section when icons can be discovered, and renders colors as consistent swatches with 6-character hex labels plus click-to-copy behavior using a pointer cursor.`;
-}
-function uniqueCompact(values) {
-    return Array.from(new Set(values.filter(Boolean)));
-}
-function firstMatching(values, needle) {
-    return values.find((value) => value === needle);
+    return `${lead}${userGoal} Read the app shell first, then global styles, then traverse all discovered component directories. After that, implement ${projectFacts.previewEntryFile} as a clean preview surface that supports both vertical and horizontal scanning when useful, includes a dedicated icon section when icons can be discovered, and renders colors as consistent swatches with 6-character hex labels plus click-to-copy behavior using a pointer cursor. ${discoveryInstruction}`;
 }

package/dist/component-discovery.d.ts

@@ -0,0 +1,25 @@
+import type { ProjectFacts } from "./types.js";
+interface DiscoveredComponent {
+    path: string;
+    basename: string;
+    exports: string[];
+    contents: string;
+}
+export interface ComponentDiscoveryPlan {
+    allDiscoveredComponents: DiscoveredComponent[];
+    prioritizedFiles: string[];
+    discoveredFamilyFacts: string[];
+    missingFamilyGaps: string[];
+    instruction: string;
+}
+/**
+ * Discover components by scanning the filesystem — no hardcoded family lists.
+ *
+ * Strategy:
+ * 1. Glob for ALL source files within discovered component/UI dirs
+ * 2. Extract PascalCase exports from each file
+ * 3. Everything with a PascalCase export is a component
+ * 4. Classify what we found into loose categories for the agent
+ */
+export declare function buildComponentDiscoveryPlan(projectRoot: string, projectFacts: ProjectFacts): Promise<ComponentDiscoveryPlan>;
+export {};

package/dist/component-discovery.js

@@ -0,0 +1,144 @@
+import { basename, join } from "path";
+import { glob } from "glob";
+import { readText, toPosixPath } from "./files.js";
+/**
+ * Discover components by scanning the filesystem — no hardcoded family lists.
+ *
+ * Strategy:
+ * 1. Glob for ALL source files within discovered component/UI dirs
+ * 2. Extract PascalCase exports from each file
+ * 3. Everything with a PascalCase export is a component
+ * 4. Classify what we found into loose categories for the agent
+ */
+export async function buildComponentDiscoveryPlan(projectRoot, projectFacts) {
+    const components = await scanForComponents(projectRoot, projectFacts);
+    // Group components into loose categories for the agent's benefit
+    const prioritizedFiles = components.map((c) => c.path).slice(0, 12);
+    const discoveredFamilyFacts = buildDiscoveryFacts(components);
+    const missingFamilyGaps = buildGaps(components);
+    const instruction = buildInstruction(components, prioritizedFiles);
+    return {
+        allDiscoveredComponents: components,
+        prioritizedFiles,
+        discoveredFamilyFacts,
+        missingFamilyGaps,
+        instruction,
+    };
+}
+/**
+ * Scan the project for all files that export PascalCase identifiers.
+ * Uses the dynamically-discovered component dirs from project.ts,
+ * falls back to a broad scan if none were found.
+ */
+async function scanForComponents(projectRoot, projectFacts) {
+    // Build glob patterns from discovered dirs
+    const searchDirs = new Set([
+        ...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}"];
+    }
+    const sourceFiles = await glob(patterns, {
+        cwd: projectRoot,
+        nodir: true,
+        ignore: [
+            "**/*.test.*",
+            "**/*.spec.*",
+            "**/*.stories.*",
+            "**/*.story.*",
+            "**/node_modules/**",
+            "**/.next/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/coverage/**",
+            "**/.git/**",
+            "**/.capy/**",
+            "**/preview/**",
+        ],
+    });
+    const components = [];
+    for (const file of sourceFiles.map((f) => toPosixPath(f)).sort()) {
+        const contents = (await readText(join(projectRoot, file))) ?? "";
+        const exports = extractExportCandidates(contents);
+        // A file is a component if it has at least one PascalCase export
+        if (exports.length > 0) {
+            components.push({
+                path: file,
+                basename: basename(file).replace(/\.[^.]+$/, ""),
+                exports,
+                contents,
+            });
+        }
+    }
+    return components;
+}
+/**
+ * Build discovery facts — a short summary of what was found, organized
+ * by directory structure rather than hardcoded families.
+ */
+function buildDiscoveryFacts(components) {
+    if (components.length === 0)
+        return [];
+    // Group by directory
+    const byDir = new Map();
+    for (const comp of components) {
+        const slashIndex = comp.path.lastIndexOf("/");
+        const dir = slashIndex === -1 ? "." : comp.path.slice(0, slashIndex);
+        if (!byDir.has(dir))
+            byDir.set(dir, []);
+        byDir.get(dir).push(comp.exports[0] ?? comp.basename);
+    }
+    const facts = [];
+    for (const [dir, names] of byDir) {
+        const listed = names.slice(0, 5).join(", ");
+        const suffix = names.length > 5 ? ` and ${names.length - 5} more` : "";
+        facts.push(`${dir}/: ${listed}${suffix}.`);
+    }
+    return facts.slice(0, 8);
+}
+/**
+ * Build gap notes — only warn about genuinely concerning gaps,
+ * not prescriptive "you should have inputs" type warnings.
+ */
+function buildGaps(components) {
+    const gaps = [];
+    if (components.length === 0) {
+        gaps.push("No components were discovered. The scanner found no files with PascalCase exports in the project. You should manually search src/, components/, ui/, features/, lib/, or similar directories to find UI code.");
+    }
+    return gaps;
+}
+/**
+ * Build the instruction string for the agent — tell it how to traverse
+ * and find things rather than listing specific things to look for.
+ */
+function buildInstruction(components, prioritizedFiles) {
+    const traversalGuide = "Traverse the repo's component directories. Every file that exports a PascalCase identifier is a component. Read real usage of each component before building /preview sections. If a component looks like a page section, group it under 'Feature or Page Sections'. If it is a small reusable primitive, group it under the appropriate UI category.";
+    const usageGuide = "Use actual component files and real usage examples. If you only find hooks or providers, trace one real usage path and mirror that behavior in /preview instead of inventing a fake specimen.";
+    const placementGuide = "Place every component you find into the preview layout based on its actual role. If something does not fit a standard category, create a section for it. Do not invent components that don't exist in the repo, and do not omit components that do.";
+    if (prioritizedFiles.length === 0) {
+        return `${traversalGuide} ${usageGuide} ${placementGuide}`;
+    }
+    return `${traversalGuide} Start with ${prioritizedFiles.slice(0, 6).join(", ")}. ${usageGuide} ${placementGuide}`;
+}
+function extractExportCandidates(contents) {
+    const exportNames = new Set();
+    const patterns = [
+        /export\s+function\s+([A-Z][A-Za-z0-9_]*)/g,
+        /export\s+const\s+([A-Z][A-Za-z0-9_]*)/g,
+        /export\s+class\s+([A-Z][A-Za-z0-9_]*)/g,
+        /export\s+default\s+function\s+([A-Z][A-Za-z0-9_]*)/g,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(contents)) !== null) {
+            exportNames.add(match[1]);
+        }
+    }
+    return Array.from(exportNames);
+}

package/dist/design-system.js

@@ -1,6 +1,7 @@
 import { glob } from "glob";
 import { basename, join } from "path";
 import { buildPreviewBrief } from "./brief.js";
+import { buildComponentDiscoveryPlan } from "./component-discovery.js";
 import { readText, toPosixPath, writeText } from "./files.js";
 import { detectFramework } from "./framework.js";
 import { buildProjectFacts } from "./project.js";
@@ -8,6 +9,7 @@ const DEFAULT_ARTIFACT_PATH = ".capy/design-system.json";
 export async function buildDesignSystemArtifact(projectRoot, input = {}) {
     const framework = await detectFramework(projectRoot);
     const projectFacts = await buildProjectFacts(projectRoot, framework);
+    const discoveryPlan = await buildComponentDiscoveryPlan(projectRoot, projectFacts);
     const previewBrief = await buildPreviewBrief(projectRoot, {
         task: input.mode === "update" ? "update_preview" : "build_preview",
         changedFiles: input.changedFiles,
@@ -15,9 +17,9 @@ export async function buildDesignSystemArtifact(projectRoot, input = {}) {
     });
     const cssVariables = await collectCssVariables(projectRoot, projectFacts.likelyStyleFiles);
     const components = await collectComponents(projectRoot, projectFacts);
-    const readFirst = buildReadFirst(previewBrief, components);
+    const readFirst = buildReadFirst(previewBrief, components, discoveryPlan.prioritizedFiles);
     const bridges = await buildUsageBridges(projectRoot, projectFacts.likelyStyleFiles, components);
-    const gaps = buildGapNotes(projectFacts, components, cssVariables);
+    const gaps = buildGapNotes(projectFacts, components, cssVariables, discoveryPlan.missingFamilyGaps);
     const artifactPath = input.artifactPath ?? DEFAULT_ARTIFACT_PATH;
     return {
         forAgent: {
@@ -25,7 +27,7 @@ export async function buildDesignSystemArtifact(projectRoot, input = {}) {
                 ? "Update /preview incrementally. Read the files below first, then touch only the sections affected by the changed files unless shared foundations changed."
                 : "Build or refine /preview. Read the files below first, then mirror the repo's existing UI language instead of inventing a new one.",
             readFirst,
-            facts: buildAgentFacts(projectFacts, components, cssVariables),
+            facts: buildAgentFacts(projectFacts, components, cssVariables, discoveryPlan.discoveredFamilyFacts),
             bridges,
             gaps,
             updateHints: previewBrief.updateStrategy,
@@ -168,7 +170,7 @@ function classifyCssVariable(name) {
 function lineNumberAt(contents, index) {
     return contents.slice(0, index).split("\n").length;
 }
-function buildReadFirst(previewBrief, components) {
+function buildReadFirst(previewBrief, components, prioritizedFiles) {
     const seen = new Set();
     const readFirst = [];
     const firstComponentByDir = new Map();
@@ -181,8 +183,39 @@ function buildReadFirst(previewBrief, components) {
             firstComponentByDir.set(directory, component.path);
         }
     }
-    for (const step of previewBrief.inspectionPlan) {
+    for (const step of previewBrief.inspectionPlan.slice(0, 2)) {
         for (const target of step.targets) {
+            if (!looksLikeProjectPath(target))
+                continue;
+            const normalizedTarget = firstComponentByDir.get(target) ?? target;
+            if (seen.has(normalizedTarget))
+                continue;
+            seen.add(normalizedTarget);
+            readFirst.push({
+                path: normalizedTarget,
+                reason: step.reason,
+            });
+            if (readFirst.length >= 8) {
+                return readFirst;
+            }
+        }
+    }
+    for (const prioritizedFile of prioritizedFiles) {
+        if (seen.has(prioritizedFile))
+            continue;
+        seen.add(prioritizedFile);
+        readFirst.push({
+            path: prioritizedFile,
+            reason: "Likely reusable primitive or usage example. Read this before inventing preview-only specimens.",
+        });
+        if (readFirst.length >= 8) {
+            return readFirst;
+        }
+    }
+    for (const step of previewBrief.inspectionPlan.slice(2)) {
+        for (const target of step.targets) {
+            if (!looksLikeProjectPath(target))
+                continue;
             const normalizedTarget = firstComponentByDir.get(target) ?? target;
             if (seen.has(normalizedTarget))
                 continue;
@@ -198,16 +231,17 @@ function buildReadFirst(previewBrief, components) {
     }
     return readFirst;
 }
-function buildAgentFacts(projectFacts, components, cssVariables) {
+function buildAgentFacts(projectFacts, components, cssVariables, discoveredFamilyFacts) {
     return [
         `Use ${projectFacts.framework} conventions.`,
         `Implement /preview at ${projectFacts.previewEntryFile}.`,
         "Use repo-relative paths only.",
         `Found ${components.length} component candidates and ${cssVariables.length} CSS variables.`,
+        ...discoveredFamilyFacts,
     ];
 }
-function buildGapNotes(projectFacts, components, cssVariables) {
-    const gaps = [];
+function buildGapNotes(projectFacts, components, cssVariables, discoveryGaps) {
+    const gaps = [...discoveryGaps];
     if (components.length === 0) {
         gaps.push("No components were detected. Grep src/components, src/ui, src/features, components, ui, or features before assuming the app has no reusable UI.");
     }
@@ -261,3 +295,6 @@ function normalizeHex(hex) {
     }
     return `#${normalized}`;
 }
+function looksLikeProjectPath(target) {
+    return target.includes("/") || /^[A-Za-z0-9._-]+\.(?:tsx|ts|jsx|js|css|scss|sass|less)$/.test(target);
+}

package/dist/project.d.ts

@@ -1,2 +1,9 @@
 import type { FrameworkInfo, ProjectFacts } from "./types.js";
+/**
+ * Build project facts by actually scanning the filesystem instead of
+ * checking a hardcoded list of candidate directories.
+ *
+ * Strategy: glob for all source files, read their exports, then classify
+ * directories by what they contain rather than what they're named.
+ */
 export declare function buildProjectFacts(projectRoot: string, framework: FrameworkInfo): Promise<ProjectFacts>;

package/dist/project.js

@@ -1,24 +1,40 @@
+import { basename, dirname } from "path";
 import { glob } from "glob";
-import { join } from "path";
-import { fileExists, toPosixPath } from "./files.js";
+import { readText, toPosixPath } from "./files.js";
+/**
+ * Build project facts by actually scanning the filesystem instead of
+ * checking a hardcoded list of candidate directories.
+ *
+ * Strategy: glob for all source files, read their exports, then classify
+ * directories by what they contain rather than what they're named.
+ */
 export async function buildProjectFacts(projectRoot, framework) {
-    const componentDirs = await findExistingDirectories(projectRoot, [
-        "src/components",
-        "src/ui",
-        "src/features",
-        "components",
-        "ui",
-        "features",
-    ]);
-    const pageDirs = await findExistingDirectories(projectRoot, [
-        "src/app",
-        "app",
-        "src/pages",
-        "pages",
-        "src/routes",
-        "routes",
-    ]);
+    const sourceFiles = await glob(["**/*.{ts,tsx,js,jsx}"], {
+        cwd: projectRoot,
+        nodir: true,
+        ignore: [
+            "**/*.test.*",
+            "**/*.spec.*",
+            "**/*.stories.*",
+            "**/*.story.*",
+            "**/node_modules/**",
+            "**/.next/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/coverage/**",
+            "**/.git/**",
+            "**/.capy/**",
+            "**/preview/**",
+        ],
+    });
+    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
+    const pageDirs = findPageDirs(normalized);
+    // 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"))]));
     return {
         framework: framework.kind,
@@ -32,14 +48,92 @@ export async function buildProjectFacts(projectRoot, framework) {
         likelyUiDirs,
     };
 }
-async function findExistingDirectories(projectRoot, candidates) {
-    const results = [];
-    for (const candidate of candidates) {
-        if (await fileExists(join(projectRoot, candidate))) {
-            results.push(candidate);
+/**
+ * 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.
+ */
+async function findComponentDirs(projectRoot, sourceFiles) {
+    const dirComponentCount = new Map();
+    for (const file of sourceFiles) {
+        // Skip files at the root level (no directory)
+        if (!file.includes("/"))
+            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";
+        const fileName = basename(file).replace(/\.[^.]+$/, "");
+        const isPascalFileName = /^[A-Z][a-zA-Z0-9]*$/.test(fileName);
+        if (!isTsxJsx && !isPascalFileName)
+            continue;
+        const contents = await readText(`${projectRoot}/${file}`);
+        if (!contents)
+            continue;
+        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;
+}
+/**
+ * Given a sorted list of directory paths, return the root-most directories.
+ * "src/components/sections" is dropped if "src/components" is in the list.
+ */
+function deduplicateToRoots(sortedDirs) {
+    const roots = [];
+    for (const dir of sortedDirs) {
+        const isChildOfExisting = roots.some((root) => dir.startsWith(root + "/"));
+        if (!isChildOfExisting) {
+            roots.push(dir);
         }
     }
-    return results;
+    return roots;
+}
+/**
+ * Find page/route directories by looking for routing convention markers
+ * in the actual files instead of checking hardcoded paths.
+ */
+function findPageDirs(sourceFiles) {
+    const pageDirSet = new Set();
+    // Routing markers that indicate a directory is a page directory
+    const routingMarkers = [
+        "layout.tsx", "layout.ts", "layout.jsx", "layout.js",
+        "page.tsx", "page.ts", "page.jsx", "page.js",
+        "_app.tsx", "_app.ts", "_app.jsx", "_app.js",
+        "_document.tsx", "_document.ts",
+        "+page.svelte", "+layout.svelte",
+    ];
+    for (const file of sourceFiles) {
+        const fileName = basename(file);
+        if (routingMarkers.includes(fileName)) {
+            const dir = dirname(file);
+            // We want the top-level routing root, not every nested route
+            // e.g. for "src/app/blog/page.tsx" we want "src/app"
+            pageDirSet.add(dir);
+        }
+    }
+    if (pageDirSet.size === 0)
+        return [];
+    // Find the root-level page dirs (e.g. "src/app" covers "src/app/blog")
+    const sorted = Array.from(pageDirSet).sort();
+    return deduplicateToRoots(sorted);
+}
+/**
+ * Check if file contents contain a PascalCase export (function, const, or class).
+ */
+function hasPascalCaseExport(contents) {
+    return /export\s+(?:default\s+)?(?:function|const|class)\s+[A-Z][A-Za-z0-9_]*/.test(contents);
 }
 async function findStyleFiles(projectRoot) {
     const files = await glob(["**/*.{css,scss,sass,less}"], {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capy-mcp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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",