project-context-ai 2.2.5 → 2.3.0

package/dist/scanner/business.js

@@ -1,6 +1,10 @@
+// ─── Business Context Scanner — Orchestrator ────────────
 import { join } from "node:path";
-import { readTextFile, readFilesMatching } from "../utils/files.js";
+import { readTextFile } from "../utils/files.js";
 import { getScanConfig } from "./config.js";
+import { humanizeName, findFile } from "./description.js";
+import { detectSkills, scanHandlers, scanFrontend } from "./skills.js";
+import { scanValidation, detectAuthPatterns, extractDomainEntities, extractEntityGroups, extractKeyModules, extractDirectoryMap, detectEntryPointDescriptions, inferDataFlow, } from "./domain.js";
 // Doc files to look for (in priority order)
 const DOC_FILES = [
     "README.md",
@@ -46,14 +50,12 @@ export async function scanBusiness(rootPath, allFiles, deps, frameworks, routes,
 }
 // ─── Description ──────────────────────────────────────────
 async function extractDescription(rootPath, allFiles) {
-    // Try README.md first
     const readmeFile = findFile(allFiles, "readme.md");
     if (readmeFile) {
         const desc = await extractFirstParagraph(rootPath, readmeFile);
         if (desc && desc.length > 20)
             return desc;
     }
-    // Try PRODUCT_VISION.md or similar
     for (const docName of ["PRODUCT_VISION.md", "ABOUT.md", "OVERVIEW.md"]) {
         const docFile = findFile(allFiles, docName.toLowerCase());
         if (docFile) {
@@ -62,7 +64,6 @@ async function extractDescription(rootPath, allFiles) {
                 return desc;
         }
     }
-    // Fallback: package.json description
     const pkgFile = allFiles.find((f) => f === "package.json");
     if (pkgFile) {
         const content = await readTextFile(join(rootPath, pkgFile));
@@ -160,9 +161,14 @@ async function extractFeatures(rootPath, allFiles) {
         [/\bbranch|conversation.?tree|dev.?area/i, "Conversation branching"],
         [/code.?review|pr.?review/i, "Code review"],
     ];
+    let addedCapabilityHeading = false;
     for (const [pattern, label] of capabilityPatterns) {
         const matchCount = allFiles.filter((f) => pattern.test(f)).length;
         if (matchCount >= 2 && !features.includes(label)) {
+            if (!addedCapabilityHeading) {
+                features.push("[Product Capabilities]");
+                addedCapabilityHeading = true;
+            }
             features.push(label);
         }
     }
@@ -196,7 +202,6 @@ function extractAllBullets(content, max) {
     let pendingHeading = null;
     for (const line of lines) {
         const trimmed = line.trim();
-        // Capture ## headings — but only add if followed by actual content
         if (trimmed.startsWith("## ")) {
             const heading = trimmed.replace(/^##\s+/, "").replace(/\*\*/g, "").trim();
             if (heading && !heading.match(/^(Table of Contents|TOC|Index|Sumário)/i)) {
@@ -204,12 +209,10 @@ function extractAllBullets(content, max) {
             }
             continue;
         }
-        // Capture bullet points
         const bulletMatch = trimmed.match(/^[-*+]\s+(.+)/);
         if (bulletMatch) {
             const text = bulletMatch[1].replace(/\*\*/g, "").replace(/`/g, "").trim();
             if (text.length > 3 && text.length < 200) {
-                // Emit pending heading only if there's content after it
                 if (pendingHeading) {
                     bullets.push(`[${pendingHeading}]`);
                     pendingHeading = null;
@@ -222,171 +225,12 @@ function extractAllBullets(content, max) {
     }
     return bullets;
 }
-// ─── Skills / Plugins Detection ───────────────────────────
-async function detectSkills(rootPath, allFiles) {
-    const skills = [];
-    // Only files named *-skill.ts or in skills/plugins directories (NOT handlers — those are separate)
-    const skillFiles = allFiles.filter((f) => (f.match(/[-_](skill|plugin)\.(ts|js)$/i) ||
-        f.match(/(Skill|Plugin)\.(ts|js)$/i) ||
-        f.match(/(skills|plugins)\//)) &&
-        f.match(/\.(ts|js)$/) &&
-        !f.includes("index.") && !f.includes(".test.") && !f.includes(".spec.") &&
-        !f.includes("handlers/"));
-    if (skillFiles.length === 0)
-        return [];
-    const cfg = getScanConfig();
-    const files = await readFilesMatching(rootPath, skillFiles, { maxFiles: cfg.maxFiles, maxFileSize: cfg.maxFileSize });
-    // Build content map for companion file lookups
-    const contentMap = new Map();
-    for (const { file, content } of files)
-        contentMap.set(file, content);
-    for (const { file, content } of files) {
-        const skill = extractSkillInfo(file, content);
-        if (!skill)
-            continue;
-        // If no tools found, look for companion tools file (e.g. browser-skill.ts → browser-tools.ts)
-        if (!skill.tools || skill.tools.length === 0) {
-            const dir = file.split("/").slice(0, -1).join("/");
-            const baseName = file.split("/").pop()?.replace(/[-_]skill\.(ts|js)$/i, "") || "";
-            const companionPatterns = [
-                `${dir}/${baseName}-tools.ts`,
-                `${dir}/${baseName}Tools.ts`,
-                `${dir}/${baseName}-tool.ts`,
-                `${dir}/${baseName}.tools.ts`,
-                `${dir}/tools.ts`,
-                `${dir}/${baseName}-actions.ts`,
-            ];
-            for (const companion of companionPatterns) {
-                const companionContent = contentMap.get(companion);
-                if (companionContent) {
-                    const companionTools = [];
-                    // Broad tool name extraction from companion files
-                    const patterns = [
-                        /name\s*:\s*['"`]([a-z][a-z0-9_-]+)['"`]/g,
-                        /registerTool\s*\(\s*['"`]([^'"`]+)['"`]/g,
-                        /\.tool\s*\(\s*['"`]([a-z][a-z0-9_-]+)['"`]/g,
-                        /(?:create|define|add)Tool\s*\(\s*['"`]([^'"`]+)['"`]/g,
-                    ];
-                    for (const pattern of patterns) {
-                        let m;
-                        while ((m = pattern.exec(companionContent)) !== null) {
-                            if (!companionTools.includes(m[1])) {
-                                companionTools.push(m[1]);
-                            }
-                        }
-                    }
-                    if (companionTools.length > 0) {
-                        skill.tools = companionTools.slice(0, 20);
-                        skill.toolCount = companionTools.length;
-                    }
-                    break;
-                }
-            }
-        }
-        skills.push(skill);
-    }
-    return skills.slice(0, 50);
-}
-function extractSkillInfo(file, content) {
-    // ONLY extract classes that implement an interface (actual skills, not random exports)
-    const classMatch = content.match(/export\s+class\s+(\w+)\s+(?:extends\s+\w+\s+)?implements\s+(\w+)/);
-    if (!classMatch) {
-        // Fallback: only accept classes with "Skill" or "Plugin" in the name
-        const namedMatch = content.match(/export\s+class\s+(\w+(?:Skill|Plugin))\b/);
-        if (!namedMatch)
-            return null;
-        const name = namedMatch[1];
-        return extractSkillData(name, undefined, file, content);
-    }
-    return extractSkillData(classMatch[1], classMatch[2], file, content);
-}
-function extractSkillData(name, iface, file, content) {
-    // Extract JSDoc description (first comment block before class)
-    let description;
-    const jsdocMatch = content.match(/\/\*\*\s*([\s\S]*?)\*\/\s*(?:export\s+)?class/);
-    if (jsdocMatch) {
-        description = jsdocMatch[1].replace(/\s*\*\s*/g, " ").replace(/@\w+.*/g, "").trim();
-    }
-    // Fallback: infer description from class name (fix spacing for acronyms like SEO, API)
-    if (!description || description.length < 5) {
-        const cleanName = name.replace(/Skill$|Plugin$|Handler$|Command$/, "");
-        description = humanizeName(cleanName);
-    }
-    // Truncate JSDoc descriptions cleanly (don't cut mid-word)
-    if (description && description.length > 350) {
-        const cut = description.lastIndexOf(" ", 350);
-        description = description.slice(0, cut > 150 ? cut : 350);
-    }
-    // Extract tool names — multiple strategies combined
-    const tools = [];
-    const seenTools = new Set();
-    function addTool(t) {
-        if (t.length > 2 && !seenTools.has(t) && tools.length < 20) {
-            seenTools.add(t);
-            tools.push(t);
-        }
-    }
-    // Strategy 1: registerTool("name", ...)
-    const toolRegex = /registerTool\s*\(\s*['"`]([^'"`]+)['"`]/g;
-    let toolMatch;
-    while ((toolMatch = toolRegex.exec(content)) !== null)
-        addTool(toolMatch[1]);
-    // Strategy 2: name: "tool_name" inside any object (tool definitions)
-    const nameRegex = /name\s*:\s*['"`]([a-z][a-z0-9_]+)['"`]/g;
-    let nameMatch;
-    while ((nameMatch = nameRegex.exec(content)) !== null) {
-        const tn = nameMatch[1];
-        if (tn.includes("_"))
-            addTool(tn);
-    }
-    // Strategy 3: .tool("name", ...) — MCP/SDK-style chaining
-    const chainToolRegex = /\.tool\s*\(\s*['"`]([a-z][a-z0-9_-]+)['"`]/g;
-    let chainMatch;
-    while ((chainMatch = chainToolRegex.exec(content)) !== null)
-        addTool(chainMatch[1]);
-    // Strategy 4: createTool/defineTool/addTool("name", ...)
-    const factoryRegex = /(?:create|define|add|register)(?:Tool|Action)\s*\(\s*['"`]([^'"`]+)['"`]/g;
-    let factoryMatch;
-    while ((factoryMatch = factoryRegex.exec(content)) !== null)
-        addTool(factoryMatch[1]);
-    // Strategy 5: @Tool("name") or @tool("name") — decorator pattern
-    const decoratorRegex = /@(?:Tool|tool|Action|action)\s*\(\s*['"`]([^'"`]+)['"`]/g;
-    let decoratorMatch;
-    while ((decoratorMatch = decoratorRegex.exec(content)) !== null)
-        addTool(decoratorMatch[1]);
-    // Strategy 6: name: "tool-name" with hyphens (relaxed) — only if near description/inputSchema
-    const relaxedNameRegex = /name\s*:\s*['"`]([a-z][a-z0-9_-]+)['"`]/g;
-    let relaxedMatch;
-    const contentLines = content.split("\n");
-    while ((relaxedMatch = relaxedNameRegex.exec(content)) !== null) {
-        const tn = relaxedMatch[1];
-        if (seenTools.has(tn))
-            continue;
-        // Check surrounding context (5 lines) for tool-definition keywords
-        const lineIdx = content.slice(0, relaxedMatch.index).split("\n").length - 1;
-        const nearby = contentLines.slice(Math.max(0, lineIdx - 3), lineIdx + 5).join("\n");
-        if (/description\s*:|inputSchema|handler\s*:|execute\s*\(|parameters\s*:/.test(nearby)) {
-            addTool(tn);
-        }
-    }
-    return {
-        name,
-        file,
-        interface: iface,
-        description: description || undefined,
-        tools: tools.length > 0 ? tools : undefined,
-        toolCount: tools.length > 0 ? tools.length : undefined,
-    };
-}
 // ─── Documentation Summaries ──────────────────────────────
 async function extractDocumentation(rootPath, allFiles) {
     const docs = [];
-    const allFilesLower = allFiles.map((f) => f.toLowerCase());
-    // Find all .md files at root level and in docs/ folder
     const mdFiles = allFiles.filter((f) => f.match(/\.md$/i) &&
-        (!f.includes("/") || // root level
-            f.startsWith("docs/") // docs folder
-        ) &&
+        (!f.includes("/") ||
+            f.startsWith("docs/")) &&
         !f.match(/^(CLAUDE|AGENTS|LICENSE|CHANGELOG|HISTORY)\.md$/i) &&
         !f.includes("node_modules") &&
         !f.includes(".context-ai"));
@@ -395,10 +239,8 @@ async function extractDocumentation(rootPath, allFiles) {
         const content = await readTextFile(join(rootPath, file));
         if (!content || content.length < 50)
             continue;
-        // Extract title (first # heading)
         const titleMatch = content.match(/^#\s+(.+)$/m);
         const title = titleMatch ? titleMatch[1].trim() : file;
-        // Extract summary: headings list gives a good overview
         const headings = [];
         for (const line of content.split("\n")) {
             if (line.startsWith("## ")) {
@@ -439,560 +281,4 @@ async function extractDocumentation(rootPath, allFiles) {
     }
     return docs;
 }
-// ─── Validation Rules ─────────────────────────────────────
-async function scanValidation(rootPath, allFiles, deps) {
-    const depNames = deps.map((d) => d.name);
-    const rules = [];
-    const hasZod = depNames.includes("zod");
-    const hasYup = depNames.includes("yup");
-    const hasJoi = depNames.includes("joi") || depNames.includes("@hapi/joi");
-    if (!hasZod && !hasYup && !hasJoi)
-        return [];
-    const cfg = getScanConfig();
-    const codeFiles = await readFilesMatching(rootPath, allFiles, {
-        extensions: [".ts", ".tsx", ".js", ".jsx"],
-        maxFiles: cfg.maxFiles,
-        maxFileSize: cfg.maxFileSize,
-        pathPatterns: [/(schema|validation|validator|types|dto|input|form)/i],
-    });
-    for (const { file, content } of codeFiles) {
-        if (hasZod) {
-            const zodRegex = /(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*z\.object\s*\(\s*\{([^}]*)\}/g;
-            let match;
-            while ((match = zodRegex.exec(content)) !== null) {
-                const fields = extractObjectKeys(match[2]);
-                rules.push({ schema: match[1], file, library: "zod", fields: fields.slice(0, 10) });
-            }
-        }
-        if (hasYup) {
-            const yupRegex = /(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:yup|Yup)\.object\s*\(\s*\{([^}]*)\}/g;
-            let match;
-            while ((match = yupRegex.exec(content)) !== null) {
-                const fields = extractObjectKeys(match[2]);
-                rules.push({ schema: match[1], file, library: "yup", fields: fields.slice(0, 10) });
-            }
-        }
-        if (hasJoi) {
-            const joiRegex = /(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*Joi\.object\s*\(\s*\{([^}]*)\}/g;
-            let match;
-            while ((match = joiRegex.exec(content)) !== null) {
-                const fields = extractObjectKeys(match[2]);
-                rules.push({ schema: match[1], file, library: "joi", fields: fields.slice(0, 10) });
-            }
-        }
-        if (rules.length >= 30)
-            break;
-    }
-    return rules;
-}
-function extractObjectKeys(objectBody) {
-    const keys = [];
-    const keyRegex = /(\w+)\s*:/g;
-    let match;
-    while ((match = keyRegex.exec(objectBody)) !== null) {
-        keys.push(match[1]);
-    }
-    return keys;
-}
-// ─── Auth Patterns ────────────────────────────────────────
-function detectAuthPatterns(allFiles, deps, frameworks, routes) {
-    const patterns = [];
-    const depNames = deps.map((d) => d.name);
-    if (depNames.includes("next-auth") || depNames.includes("@auth/core")) {
-        patterns.push("NextAuth.js / Auth.js session-based authentication");
-    }
-    if (depNames.some((d) => d.startsWith("@clerk/"))) {
-        patterns.push("Clerk authentication and user management");
-    }
-    if (depNames.some((d) => d.startsWith("@auth0/"))) {
-        patterns.push("Auth0 authentication");
-    }
-    if (depNames.includes("passport")) {
-        patterns.push("Passport.js authentication strategies");
-    }
-    if (depNames.includes("jsonwebtoken") || depNames.includes("jose")) {
-        patterns.push("JWT token-based authentication");
-    }
-    if (depNames.includes("bcrypt") || depNames.includes("bcryptjs") || depNames.includes("argon2")) {
-        patterns.push("Password hashing (bcrypt/argon2)");
-    }
-    const hasAuthMiddleware = allFiles.some((f) => f.match(/(middleware|guard|auth)\.(ts|js)$/) && f.includes("auth"));
-    if (hasAuthMiddleware)
-        patterns.push("Custom auth middleware");
-    const hasRBAC = allFiles.some((f) => f.match(/(role|permission|rbac|authorize)\.(ts|js)$/));
-    if (hasRBAC)
-        patterns.push("Role-based access control (RBAC)");
-    if (routes && routes.some((r) => r.auth)) {
-        const authRouteCount = routes.filter((r) => r.auth).length;
-        patterns.push(`${authRouteCount}/${routes.length} routes require authentication`);
-    }
-    return patterns;
-}
-// ─── Domain Entities ──────────────────────────────────────
-async function extractDomainEntities(rootPath, allFiles, database) {
-    const entities = new Set();
-    if (database) {
-        for (const model of database)
-            entities.add(model.name);
-    }
-    const domainFiles = allFiles.filter((f) => f.match(/(domain|entities|models)\//i) &&
-        f.match(/\.(ts|js)$/) &&
-        !f.includes("index.") &&
-        !f.includes(".test.") &&
-        !f.includes(".spec."));
-    const cfg = getScanConfig();
-    const files = await readFilesMatching(rootPath, domainFiles, { maxFiles: cfg.maxFiles, maxFileSize: cfg.maxFileSize });
-    for (const { content } of files) {
-        const classRegex = /(?:export\s+)?(?:class|interface|type)\s+(\w+)/g;
-        let match;
-        while ((match = classRegex.exec(content)) !== null) {
-            const name = match[1];
-            if (!name.match(/^(I[A-Z]|Props|State|Config|Options|Params|Args|Result|Response|Request|Error|Exception|Helper|Util|Service|Repository|Controller|Module|Guard|Pipe|Filter|Interceptor|Decorator|Interface|Type|Enum|Dto|Input|Output)/)) {
-                entities.add(name);
-            }
-        }
-    }
-    // Limit to 15 most important cross-boundary types
-    return Array.from(entities).slice(0, 15);
-}
-// ─── Entity Groups (by file) ──────────────────────────────
-async function extractEntityGroups(rootPath, allFiles, database) {
-    const groups = [];
-    // From database models — group by file
-    if (database) {
-        const byFile = new Map();
-        for (const m of database) {
-            if (!byFile.has(m.file))
-                byFile.set(m.file, []);
-            byFile.get(m.file).push(m.name);
-        }
-        for (const [file, entities] of byFile) {
-            groups.push({ file, entities });
-        }
-    }
-    // From domain/entity/model dirs (NOT core — too noisy)
-    const domainFiles = allFiles.filter((f) => f.match(/(domain|entities|models)\//i) &&
-        f.match(/\.(ts|js)$/) &&
-        !f.includes("index.") && !f.includes(".test.") && !f.includes(".spec."));
-    const cfg = getScanConfig();
-    const files = await readFilesMatching(rootPath, domainFiles, { maxFiles: cfg.maxFiles, maxFileSize: cfg.maxFileSize });
-    for (const { file, content } of files) {
-        const entities = [];
-        const regex = /(?:export\s+)?(?:class|interface|type)\s+(\w+)/g;
-        let match;
-        while ((match = regex.exec(content)) !== null) {
-            const name = match[1];
-            if (!name.match(/^(I[A-Z]|Props|State|Config|Options|Params|Args|Result|Response|Request|Error|Helper|Util|Service|Repository|Controller|Module)/)) {
-                entities.push(name);
-            }
-        }
-        if (entities.length > 0) {
-            groups.push({ file, entities });
-        }
-    }
-    return groups.slice(0, 30);
-}
-// ─── Key Modules (important files with descriptions) ──────
-async function extractKeyModules(rootPath, allFiles) {
-    const modules = [];
-    // Find important files in core/key directories — exclude skill internals and handler files (already in Handlers section)
-    const EXCLUDE_FROM_KEY_MODULES = /[-_](tools|publishers|constants|types|helpers|utils)\.(ts|js)$|command[-_]handler/i;
-    const keyFiles = allFiles.filter((f) => f.match(/\.(ts|js)$/) &&
-        !f.includes(".test.") && !f.includes(".spec.") && !f.includes("index.") &&
-        !EXCLUDE_FROM_KEY_MODULES.test(f) &&
-        !f.includes("handlers/") && // already covered by Handlers section
-        (f.match(/(core|domain)\//i) ||
-            f.match(/^(src|backend|lib)\/(server|app|main|agent|run)/i) ||
-            f.match(/(infra\/(?!skills))/i) // infra but not skill internals
-        ));
-    const cfg = getScanConfig();
-    const files = await readFilesMatching(rootPath, keyFiles, {
-        maxFiles: Math.min(cfg.maxFiles, 200),
-        maxFileSize: cfg.maxFileSize, // use full config limit to not skip large critical files
-    });
-    for (const { file, content } of files) {
-        const description = extractModuleDescription(content, file);
-        if (description && description.length > 5) {
-            const name = file.split("/").pop()?.replace(/\.(ts|js)$/, "") || file;
-            modules.push({ file, name, description });
-        }
-    }
-    // Prioritize critical files (agent, run-loop, pipeline, etc.) at the top
-    const CRITICAL = /\b(agent|run[-_]?loop|pipeline|prompt[-_]?router|system[-_]?prompt|session|conversation|handler)\b/i;
-    modules.sort((a, b) => {
-        const aScore = CRITICAL.test(a.name) ? 0 : 1;
-        const bScore = CRITICAL.test(b.name) ? 0 : 1;
-        return aScore - bScore;
-    });
-    return modules.slice(0, 25);
-}
-// ─── Directory Map ────────────────────────────────────────
-async function extractDirectoryMap(rootPath, allFiles) {
-    const dirs = new Map();
-    // Count files per 2nd-level directory
-    for (const file of allFiles) {
-        const parts = file.split("/");
-        if (parts.length >= 2) {
-            const dir = parts.slice(0, 2).join("/");
-            dirs.set(dir, (dirs.get(dir) || 0) + 1);
-        }
-        if (parts.length >= 3 && (parts[0] === "src" || parts[0] === "backend" || parts[0] === "frontend" || parts[0] === "lib")) {
-            const dir = parts.slice(0, 3).join("/");
-            dirs.set(dir, (dirs.get(dir) || 0) + 1);
-        }
-    }
-    // Known descriptions for common directories
-    const KNOWN = {
-        core: "Engine/motor (agent, run-loop, pipeline, tools, prompts)",
-        domain: "Pure types, interfaces, and ports",
-        infra: "Implementations (providers, stores, skills, adapters)",
-        server: "HTTP + WebSocket + request handlers",
-        services: "Service layer / registry",
-        handlers: "Request/event handlers",
-        controllers: "Request controllers",
-        middleware: "Middleware pipeline",
-        middlewares: "Middleware pipeline",
-        components: "UI components",
-        hooks: "Custom React/Vue hooks",
-        stores: "State management stores",
-        utils: "Utility functions",
-        helpers: "Helper functions",
-        lib: "Shared library code",
-        shared: "Shared code across modules",
-        api: "API routes / endpoints",
-        apis: "Multiple API definitions",
-        routes: "Route definitions",
-        models: "Data models / schemas",
-        entities: "Database entities",
-        repositories: "Data access layer",
-        config: "Configuration",
-        scripts: "Build/automation scripts",
-        skills: "Agent skills / plugins",
-        plugins: "Plugin modules",
-        tools: "Tool definitions",
-        providers: "Service providers (LLM, auth, etc.)",
-        electron: "Electron main process + desktop shell",
-        migrations: "Database migrations",
-        tests: "Test files",
-        __tests__: "Test files",
-    };
-    const results = [];
-    const SKIP_DIRS = /^(dist|build|out|\.next|\.nuxt|\.output|coverage|dist-\w+|__pycache__|node_modules)/;
-    for (const [dir, fileCount] of [...dirs.entries()].sort((a, b) => b[1] - a[1])) {
-        if (fileCount < 1)
-            continue;
-        // Skip build artifacts
-        if (dir.split("/").some((p) => SKIP_DIRS.test(p)))
-            continue;
-        const lastPart = dir.split("/").pop() || "";
-        const description = KNOWN[lastPart] || `${lastPart} directory`;
-        if (KNOWN[lastPart] || fileCount >= 3) {
-            results.push({ path: dir, description: `${description} (${fileCount} files)` });
-        }
-    }
-    return results.slice(0, 20);
-}
-// ─── Handlers (Fix #4) ────────────────────────────────────
-async function scanHandlers(rootPath, allFiles) {
-    const handlerFiles = allFiles.filter((f) => (f.match(/[-_]handler\.(ts|js)$/i) ||
-        (f.includes("handlers/") && f.match(/\.(ts|js)$/) && !f.includes("index."))) &&
-        !f.match(/types?\.(ts|js)$/) // exclude type definition files
-    );
-    const cfg = getScanConfig();
-    const files = await readFilesMatching(rootPath, handlerFiles, { maxFiles: cfg.maxFiles, maxFileSize: cfg.maxFileSize });
-    const handlers = [];
-    for (const { file, content } of files) {
-        const baseName = file.split("/").pop()?.replace(/\.(ts|js)$/, "").replace(/-handler$/, "") || "";
-        // Use shared description extractor (avoids decorative headers)
-        let description = extractModuleDescription(content, file);
-        // If generic, enhance with export names
-        if (description.startsWith("Exports:") || description.length < 10) {
-            const exportNames = [];
-            const exportRegex = /export\s+(?:const|function|async\s+function)\s+(\w+)/g;
-            let m;
-            while ((m = exportRegex.exec(content)) !== null) {
-                exportNames.push(m[1]);
-                if (exportNames.length >= 4)
-                    break;
-            }
-            if (exportNames.length > 0) {
-                description = `Handles ${baseName} — exports: ${exportNames.join(", ")}`;
-            }
-            else {
-                description = `Handles ${baseName} requests`;
-            }
-        }
-        handlers.push({ name: baseName, file, description });
-    }
-    return handlers;
-}
-// ─── Frontend (Fix #6) ────────────────────────────────────
-async function scanFrontend(rootPath, allFiles) {
-    // Detect stores (Zustand, Redux, Pinia, etc.)
-    const storeFiles = allFiles.filter((f) => f.match(/(stores?|state)\//i) && f.match(/\.(ts|tsx|js|jsx)$/) && !f.includes(".test."));
-    const stores = storeFiles.map((f) => {
-        const name = f.split("/").pop()?.replace(/\.(ts|tsx|js|jsx)$/, "") || "";
-        return name;
-    }).filter((n) => n && n !== "index");
-    // Detect hooks
-    const hookFiles = allFiles.filter((f) => (f.match(/hooks?\//i) || f.match(/use[A-Z]\w+\.(ts|tsx)$/)) &&
-        f.match(/\.(ts|tsx)$/) && !f.includes(".test."));
-    const hooks = hookFiles.map((f) => {
-        const name = f.split("/").pop()?.replace(/\.(ts|tsx)$/, "") || "";
-        return name;
-    }).filter((n) => n && n !== "index");
-    // Detect component directories
-    const componentDirs = new Set();
-    for (const f of allFiles) {
-        if (f.match(/components?\//i) && f.match(/\.(tsx|jsx)$/)) {
-            const parts = f.split("/");
-            const compIdx = parts.findIndex((p) => p.match(/components?/i));
-            if (compIdx >= 0 && parts[compIdx + 1]) {
-                componentDirs.add(parts[compIdx + 1]);
-            }
-        }
-    }
-    // Detect UI features
-    const features = [];
-    const featurePatterns = [
-        [/voice|speech|whisper/i, "Voice input"],
-        [/vim[/-]?mode|vim\./i, "Vim mode"],
-        [/keybind|shortcut/i, "Keyboard shortcuts"],
-        [/theme|dark-?mode/i, "Theming / dark mode"],
-        [/i18n|locale|translate/i, "Internationalization"],
-        [/extension/i, "Extensions system"],
-        [/buddy|assistant/i, "AI buddy/assistant UI"],
-    ];
-    for (const [pattern, label] of featurePatterns) {
-        if (allFiles.some((f) => pattern.test(f)))
-            features.push(label);
-    }
-    if (stores.length === 0 && hooks.length === 0 && componentDirs.size === 0)
-        return null;
-    return {
-        stores: stores.slice(0, 15),
-        hooks: hooks.slice(0, 15),
-        componentDirs: Array.from(componentDirs).slice(0, 15),
-        features,
-    };
-}
-// ─── Entry Points (Fix #2) ───────────────────────────────
-async function detectEntryPointDescriptions(rootPath, allFiles) {
-    const entries = [];
-    const entryPatterns = [
-        { pattern: /^(src\/)?index\.(ts|js)$/, defaultDesc: "Main entry point" },
-        { pattern: /^(backend\/)?src\/index\.(ts|js)$/, defaultDesc: "Backend entry (CLI/REPL)" },
-        { pattern: /^(backend\/)?src\/server\.(ts|js)$/, defaultDesc: "HTTP/WS server" },
-        { pattern: /web-?server\.(ts|js)$/, defaultDesc: "Web server" },
-        { pattern: /electron\/main\.(cjs|js|ts)$/, defaultDesc: "Electron desktop main process" },
-        { pattern: /^src\/main\.(ts|tsx|js)$/, defaultDesc: "App main entry" },
-        { pattern: /^src\/app\.(ts|tsx|js)$/, defaultDesc: "App root" },
-        { pattern: /^app\/layout\.(tsx|ts)$/, defaultDesc: "Next.js App Router layout" },
-        { pattern: /^pages\/_app\.(tsx|ts)$/, defaultDesc: "Next.js Pages Router entry" },
-        { pattern: /^main\.(py|go)$/, defaultDesc: "Main entry" },
-        { pattern: /manage\.py$/, defaultDesc: "Django management" },
-    ];
-    for (const { pattern, defaultDesc } of entryPatterns) {
-        const match = allFiles.find((f) => pattern.test(f));
-        if (!match)
-            continue;
-        // Use defaultDesc as base, enhance with port detection only
-        let description = defaultDesc;
-        const content = await readTextFile(join(rootPath, match));
-        if (content) {
-            // Only extract REAL JSDoc descriptions (not decorative headers)
-            const jsdocMatch = content.match(/\/\*\*\s*([\s\S]*?)\*\//);
-            if (jsdocMatch) {
-                const desc = jsdocMatch[1].replace(/\s*\*\s*/g, " ").replace(/@\w+.*/g, "").trim();
-                // Only use if it's a real sentence, not a header like "--- X ---"
-                if (desc.length > 15 && !desc.match(/^-{2,}/) && !desc.match(/imports/) && desc.includes(" ")) {
-                    description = desc.slice(0, 100);
-                }
-            }
-            // Detect port
-            const portMatch = content.match(/(?:port|PORT)\s*[=:]\s*(\d{2,5})/);
-            if (portMatch && !description.includes("port"))
-                description += ` (port ${portMatch[1]})`;
-        }
-        entries.push({ file: match, description });
-    }
-    return entries;
-}
-// ─── Data Flow (Fix #1) ──────────────────────────────────
-function inferDataFlow(allFiles, entryPoints, frameworks) {
-    const flow = [];
-    const fwNames = frameworks.map((f) => f.name);
-    // Detect if there's a WebSocket layer
-    const hasWS = allFiles.some((f) => f.match(/ws[-_]?handler|websocket|socket/i));
-    const hasElectron = allFiles.some((f) => f.startsWith("electron/"));
-    const hasFrontend = allFiles.some((f) => f.match(/(frontend|ui)\//i) && f.match(/\.(tsx|jsx)$/));
-    const hasAgent = allFiles.some((f) => f.match(/agent\.(ts|js)$/));
-    const hasRunLoop = allFiles.some((f) => f.match(/run[-_]?loop/i));
-    const hasHandlers = allFiles.some((f) => f.includes("handlers/"));
-    // Build flow based on what exists (entry points already shown in their own section)
-    if (hasFrontend && hasWS) {
-        flow.push("Frontend → WebSocket → Handler → Agent/Service → Response → Stream → Frontend");
-    }
-    else if (hasFrontend && hasHandlers) {
-        flow.push("Frontend → HTTP API → Handler → Service → Response → Frontend");
-    }
-    else if (fwNames.includes("Next.js")) {
-        flow.push("Browser → Next.js Route → API Handler → Service → Response");
-    }
-    else if (fwNames.includes("Express") || fwNames.includes("Fastify")) {
-        flow.push("Client → HTTP → Middleware → Controller → Service → Repository → Response");
-    }
-    if (hasAgent && hasRunLoop) {
-        flow.push("Agent.run() → RunLoop → LLM Provider → Tool Execution → Stream Events");
-    }
-    if (hasElectron && hasFrontend) {
-        flow.push("Electron main → spawns Backend → opens BrowserWindow → Frontend connects via WebSocket");
-    }
-    return flow;
-}
-// ─── Module Description ───────────────────────────────────
-function extractModuleDescription(content, file) {
-    const fileName = file.split("/").pop()?.replace(/\.(ts|js)$/, "") || "";
-    // 1a. BEST: JSDoc on exported class (the main abstraction — prioritized over functions)
-    const classJSDoc = content.match(/\/\*\*\s*([\s\S]*?)\*\/\s*\n\s*export\s+(?:class|abstract\s+class)\s+(\w+)/);
-    if (classJSDoc) {
-        const desc = cleanJSDoc(classJSDoc[1]);
-        if (desc && isGoodDescription(desc))
-            return sanitizeDescription(desc);
-    }
-    // 1b. Fallback: JSDoc on exported function (for pure-function modules without classes)
-    const funcJSDoc = content.match(/\/\*\*\s*([\s\S]*?)\*\/\s*\n\s*export\s+(?:function|async\s+function)\s+(\w+)/);
-    if (funcJSDoc) {
-        const desc = cleanJSDoc(funcJSDoc[1]);
-        if (desc && isGoodDescription(desc))
-            return sanitizeDescription(desc);
-    }
-    // 2. File-level JSDoc at the very top (before any import/code)
-    const topJSDoc = content.match(/^\s*\/\*\*\s*([\s\S]*?)\*\//);
-    if (topJSDoc) {
-        const desc = cleanJSDoc(topJSDoc[1]);
-        if (desc && isGoodDescription(desc))
-            return sanitizeDescription(desc);
-    }
-    // 3. Meaningful comment block at the top of file (before first export)
-    const lines = content.split("\n");
-    for (const line of lines.slice(0, 50)) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        if (trimmed.startsWith("import ") || trimmed.startsWith("import{"))
-            continue;
-        // Stop at first export — comments between functions are NOT module-level
-        if (trimmed.startsWith("export ") || trimmed.startsWith("export{"))
-            break;
-        // Only look at pure comment lines (not inline code comments)
-        const commentMatch = trimmed.match(/^\/\/\s*(.+)/);
-        if (commentMatch) {
-            const text = commentMatch[1].trim();
-            if (isGoodDescription(text))
-                return sanitizeDescription(text);
-            continue;
-        }
-        // If we hit actual code, stop looking for comments
-        if (!trimmed.startsWith("//") && !trimmed.startsWith("/*") && !trimmed.startsWith("*")) {
-            break;
-        }
-    }
-    // 4. Infer from filename + exports (filename is always semantic, more reliable than first export name)
-    const exports = [];
-    const exportRegex = /export\s+(?:class|function|const|interface|type|async\s+function)\s+(\w+)/g;
-    let match;
-    while ((match = exportRegex.exec(content)) !== null) {
-        exports.push(match[1]);
-        if (exports.length >= 5)
-            break;
-    }
-    if (exports.length > 0) {
-        return sanitizeDescription(`${humanizeName(fileName)} — exports: ${exports.join(", ")}`);
-    }
-    // 5. Filename-based fallback
-    return humanizeName(fileName);
-}
-function cleanJSDoc(raw) {
-    let text = raw
-        .replace(/\s*\*\s*/g, " ")
-        .replace(/@\w+.*/g, "")
-        .replace(/\{[^}]*\}/g, "") // remove type annotations
-        .trim();
-    // Stop at first code-like boundary (semicolon, opening brace, pipe type, typed field)
-    const codeBoundary = text.search(/[;{|}]|:\s*[A-Z]\w*[<\[]/);
-    if (codeBoundary > 10)
-        text = text.slice(0, codeBoundary).trim();
-    return text;
-}
-function sanitizeDescription(desc) {
-    return desc
-        .replace(/\n/g, " ")
-        .replace(/\s{2,}/g, " ")
-        .replace(/[;{}]/g, "")
-        .trim()
-        .slice(0, 200);
-}
-function isGoodDescription(text) {
-    if (text.length < 10)
-        return false;
-    // Skip decorative box-drawing lines (─, ═, ━, ──── patterns)
-    if (text.includes("────") || text.includes("════") || text.includes("━━━━"))
-        return false;
-    if (/^[─═━\s]/.test(text))
-        return false;
-    // Skip decorative headers (--- X ---, === X ===, ### X)
-    if (text.match(/^[-=]{2,}/) || text.match(/^#{1,3}\s/))
-        return false;
-    // Skip implementation details / TODO comments
-    if (/^(Allow|Ensure|Make sure|TODO|FIXME|HACK|XXX)\b/i.test(text))
-        return false;
-    // Skip just a name/title (single word or ALL_CAPS)
-    if (text.match(/^[A-Z_]+$/) || !text.includes(" "))
-        return false;
-    // Skip lines that are just file references
-    if (text.match(/^\w+\.(ts|js|tsx|jsx)$/))
-        return false;
-    // Skip code fragments that leaked into descriptions
-    if (text.includes("export const") || text.includes("export function"))
-        return false;
-    if (text.includes(" = {") || text.includes(" = [") || text.match(/;\s*$/))
-        return false;
-    // Skip lines with TypeScript type syntax
-    if (/:\s*(Map|Set|Array|Record|Promise|string|number|boolean)</.test(text))
-        return false;
-    // Skip lines that are mostly special characters
-    if (text.replace(/[^a-zA-Z\s]/g, "").length < text.length * 0.4)
-        return false;
-    return true;
-}
-// ─── Helpers ──────────────────────────────────────────────
-function humanizeName(name) {
-    // Handle kebab-case and snake_case
-    let clean = name.replace(/[-_]/g, " ");
-    // Handle PascalCase/camelCase — but NOT UPPER_CASE (keep ANALYSIS_PROMPT as-is)
-    if (!name.match(/^[A-Z_0-9]+$/)) {
-        // Preserve known compound words before splitting
-        clean = clean
-            .replace(/YouTube/g, "Youtube")
-            .replace(/GitHub/g, "Github")
-            .replace(/TypeScript/g, "Typescript")
-            .replace(/JavaScript/g, "Javascript")
-            .replace(/WebSocket/g, "Websocket");
-        clean = clean
-            .replace(/([a-z])([A-Z])/g, "$1 $2") // camelCase
-            .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2"); // ACRONYMWord
-        // Restore proper names
-        clean = clean
-            .replace(/Youtube/g, "YouTube")
-            .replace(/Github/g, "GitHub")
-            .replace(/Typescript/g, "TypeScript")
-            .replace(/Javascript/g, "JavaScript")
-            .replace(/Websocket/g, "WebSocket");
-    }
-    return clean.trim().charAt(0).toUpperCase() + clean.trim().slice(1);
-}
-function findFile(allFiles, nameLower) {
-    return allFiles.find((f) => f.toLowerCase() === nameLower || f.toLowerCase().endsWith(`/${nameLower}`));
-}
 //# sourceMappingURL=business.js.map