codesift-mcp 0.3.0 → 0.4.0

package/dist/tools/project-tools.js

@@ -6,22 +6,26 @@
  * the zuvo project-profile schema v1.0.
  */
 import { readFile, writeFile, access, readdir, mkdir } from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { execFileSync } from "node:child_process";
 import { getCodeIndex } from "./index-tools.js";
+import { extractAstroConventions } from "./astro-config.js";
 // ---------------------------------------------------------------------------
 // Versioning — used by get_extractor_versions
 // ---------------------------------------------------------------------------
 export const EXTRACTOR_VERSIONS = {
     stack_detector: "1.0.0",
     file_classifier: "1.0.0",
-    hono: "1.0.0",
+    hono: "2.0.0",
     nestjs: "1.0.0",
     nextjs: "1.0.0",
     express: "1.0.0",
     react: "1.0.0",
     python: "1.0.0",
     php: "1.0.0",
+    astro: "1.0.0",
+    kotlin: "1.0.0",
 };
 // ---------------------------------------------------------------------------
 // Stack Detector
@@ -108,6 +112,11 @@ export async function detectStack(projectRoot) {
                 framework_version = phpDeps["laravel/framework"]?.replace(/^[\^~>=<]/, "") ?? null;
                 detected_from.push("composer.json:require.laravel/framework");
             }
+            else if (phpDeps?.["yiisoft/yii2"]) {
+                framework = "yii2";
+                framework_version = phpDeps["yiisoft/yii2"]?.replace(/^[\^~>=<]/, "") ?? null;
+                detected_from.push("composer.json:require.yiisoft/yii2");
+            }
             else if (phpDeps?.["symfony/framework-bundle"]) {
                 framework = "symfony";
                 detected_from.push("composer.json:require.symfony/framework-bundle");
@@ -127,7 +136,7 @@ export async function detectStack(projectRoot) {
         detected_from.push("pyproject.toml or requirements.txt");
     }
     // Check for PHP
-    if (["laravel", "symfony"].includes(framework ?? "")) {
+    if (["laravel", "symfony", "yii2"].includes(framework ?? "")) {
         language = "php";
         detected_from.push("framework implies php");
     }
@@ -287,6 +296,66 @@ export async function detectStack(projectRoot) {
             detected_from.push("tsconfig.base.json");
         }
     }
+    // Build tool detection (Vite, CRA, webpack, Parcel, esbuild, Rspack, Turbopack)
+    // Order matters: check more specific/modern tools first.
+    let build_tool = null;
+    if (pkg) {
+        const devDeps = pkg.devDependencies ?? {};
+        const deps = pkg.dependencies ?? {};
+        const allDeps = { ...deps, ...devDeps };
+        if (allDeps["vite"]) {
+            build_tool = "vite";
+            detected_from.push("package.json:vite");
+        }
+        else if (allDeps["react-scripts"]) {
+            build_tool = "cra";
+            detected_from.push("package.json:react-scripts");
+        }
+        else if (allDeps["@rsbuild/core"]) {
+            build_tool = "rsbuild";
+            detected_from.push("package.json:@rsbuild/core");
+        }
+        else if (allDeps["@rspack/cli"] || allDeps["@rspack/core"]) {
+            build_tool = "rspack";
+            detected_from.push("package.json:@rspack/*");
+        }
+        else if (allDeps["parcel"] || allDeps["parcel-bundler"]) {
+            build_tool = "parcel";
+            detected_from.push("package.json:parcel");
+        }
+        else if (allDeps["webpack"] || allDeps["webpack-cli"]) {
+            build_tool = "webpack";
+            detected_from.push("package.json:webpack");
+        }
+        else if (allDeps["esbuild"]) {
+            build_tool = "esbuild";
+            detected_from.push("package.json:esbuild");
+        }
+        else if (allDeps["turbopack"]) {
+            build_tool = "turbopack";
+            detected_from.push("package.json:turbopack");
+        }
+    }
+    // Fallback: look for config files if no dep match
+    if (!build_tool) {
+        const configChecks = [
+            ["vite.config.ts", "vite"],
+            ["vite.config.js", "vite"],
+            ["vite.config.mjs", "vite"],
+            ["webpack.config.js", "webpack"],
+            ["webpack.config.ts", "webpack"],
+            ["rspack.config.js", "rspack"],
+            ["rsbuild.config.ts", "rsbuild"],
+            [".parcelrc", "parcel"],
+        ];
+        for (const [file, tool] of configChecks) {
+            if (await fileExists(join(projectRoot, file))) {
+                build_tool = tool;
+                detected_from.push(file);
+                break;
+            }
+        }
+    }
     return {
         framework,
         framework_version,
@@ -294,6 +363,7 @@ export async function detectStack(projectRoot) {
         language_version,
         test_runner,
         package_manager,
+        build_tool,
         monorepo,
         detected_from,
     };
@@ -439,188 +509,102 @@ export function classifyFiles(index) {
         routine: { count: routineCount, by_type: routineCounts },
     };
 }
-function parseHonoCalls(source) {
-    const calls = [];
-    const lines = source.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const lineNum = i + 1;
-        // Match app.use("path", handler) or app.route("path", router)
-        const useMatch = line.match(/app\.(use|route|get|post|put|delete|all)\s*\(\s*["']([^"']+)["']\s*,\s*(.+)/);
-        if (useMatch) {
-            // Clean trailing ); but preserve function call parens like rateLimit(3, 3600)
-            const args = useMatch[3].trim().replace(/\);?\s*$/, "").trim();
-            calls.push({
-                type: useMatch[1],
-                path: useMatch[2],
-                args,
-                line: lineNum,
-            });
-            continue;
-        }
-        // Match app.use("*", handler) — global middleware
-        const globalUseMatch = line.match(/app\.use\s*\(\s*["']\*["']\s*,\s*(.+)/);
-        if (globalUseMatch) {
-            const args = globalUseMatch[1].trim().replace(/\);?\s*$/, "").trim();
-            calls.push({
-                type: "use",
-                path: "*",
-                args,
-                line: lineNum,
-            });
-            continue;
-        }
-        // Match app.get("/path", (c) => ...) — inline handler
-        const inlineMatch = line.match(/app\.(get|post|put|delete)\s*\(\s*["']([^"']+)["']\s*,/);
-        if (inlineMatch) {
-            calls.push({
-                type: inlineMatch[1],
-                path: inlineMatch[2],
-                args: "(inline handler)",
-                line: lineNum,
-            });
-        }
+// ---------------------------------------------------------------------------
+// Hono Extractor
+// ---------------------------------------------------------------------------
+let _honoFallbackCount = 0;
+export function getHonoFallbackCount() { return _honoFallbackCount; }
+/**
+ * Extract Hono conventions from an orchestrator file.
+ *
+ * Uses the tree-sitter AST extractor (HonoExtractor) and adapts the result
+ * to the legacy Conventions shape. Falls back to the regex-based legacy
+ * implementation on failure (with counter tracking for observability).
+ *
+ * Kill switch: set CODESIFT_LEGACY_HONO=1 to force legacy extractor.
+ */
+export async function extractHonoConventions(source, filePath) {
+    if (process.env.CODESIFT_LEGACY_HONO === "1") {
+        const { legacyExtractHonoConventions } = await import("./legacy-hono-conventions.js");
+        return legacyExtractHonoConventions(source, filePath);
     }
-    return calls;
-}
-function extractMiddlewareName(args) {
-    // Handle rateLimit(3, 3600) → "rateLimit"
-    const funcCall = args.match(/^(\w+)\s*\(/);
-    if (funcCall)
-        return funcCall[1];
-    // Handle simple identifier: clerkAuth
-    const simple = args.match(/^(\w+)$/);
-    if (simple)
-        return simple[1];
-    return null;
-}
-function extractRateLimit(args) {
-    const match = args.match(/rateLimit\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)/);
-    if (match)
-        return { max: parseInt(match[1]), window: parseInt(match[2]) };
-    return null;
-}
-export function extractHonoConventions(source, filePath) {
-    const calls = parseHonoCalls(source);
-    // Build import map: variable name → import path
-    const importMap = new Map();
-    for (const line of source.split("\n")) {
-        // import adminContests from "./routes/admin/contests/index.js";
-        const defaultImport = line.match(/import\s+(\w+)\s+from\s+["']([^"']+)["']/);
-        if (defaultImport) {
-            importMap.set(defaultImport[1], defaultImport[2]);
-        }
-        // import { clerkAuth } from "./middleware/auth.js";
-        const namedImport = line.match(/import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/);
-        if (namedImport) {
-            const names = namedImport[1].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim());
-            for (const name of names) {
-                importMap.set(name, namedImport[2]);
-            }
-        }
+    // If called with a source string and a file path that doesn't exist on disk,
+    // this is the legacy string-fixture API — use legacy extractor directly.
+    // The AST extractor needs a real file to parse.
+    const { existsSync } = await import("node:fs");
+    const { isAbsolute, resolve: pathResolve } = await import("node:path");
+    const resolved = isAbsolute(filePath) ? filePath : pathResolve(filePath);
+    if (!existsSync(resolved)) {
+        const { legacyExtractHonoConventions } = await import("./legacy-hono-conventions.js");
+        return legacyExtractHonoConventions(source, filePath);
+    }
+    try {
+        return await honoConventionsAdapter(resolved);
     }
-    const middleware_chains = [];
-    const rate_limits = [];
-    const route_mounts = [];
+    catch (err) {
+        _honoFallbackCount++;
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[codesift] Hono AST extractor failed (fallback #${_honoFallbackCount}): ${msg}`);
+        if (process.env.NODE_ENV !== "production" && process.env.CODESIFT_SILENT_FALLBACK !== "1") {
+            throw err;
+        }
+        const { legacyExtractHonoConventions } = await import("./legacy-hono-conventions.js");
+        return legacyExtractHonoConventions(source, filePath);
+    }
+}
+/**
+ * Adapter: run HonoExtractor.parse() and map HonoAppModel → Conventions.
+ */
+async function honoConventionsAdapter(filePath) {
+    const { HonoExtractor } = await import("../parser/extractors/hono.js");
+    const extractor = new HonoExtractor();
+    const model = await extractor.parse(filePath);
+    // Map middleware_chains
+    const middleware_chains = model.middleware_chains.map((mc) => ({
+        scope: mc.scope === "*" ? "global" : mc.scope.replace(/\/\*$/, "").split("/").filter(Boolean)[1] ?? mc.scope,
+        file: mc.entries[0]?.file ?? filePath,
+        chain: mc.entries.map((e) => ({
+            name: e.name,
+            line: e.line,
+            order: e.order,
+        })),
+    }));
+    // Map route_mounts
+    const route_mounts = model.mounts
+        .filter((m) => m.mount_type === "hono_route")
+        .map((m) => ({
+        file: filePath,
+        line: 0, // line not tracked in new model at mount level
+        mount_path: m.mount_path,
+        imported_from: m.child_file || null,
+        exported_as: m.child_var,
+    }));
+    // Map auth_patterns from middleware names
     const authGroups = {};
     let auth_middleware = null;
-    // Group middleware by scope — deduplicate same middleware on different paths
-    const scopeChains = new Map();
-    const scopeMwSeen = new Map(); // scope → set of middleware names already in chain
-    let globalOrder = 0;
-    const scopeOrders = new Map();
-    for (const call of calls) {
-        if (call.type === "use") {
-            const mwName = extractMiddlewareName(call.args);
-            const rl = extractRateLimit(call.args);
-            if (rl) {
-                rate_limits.push({
-                    file: filePath,
-                    line: call.line,
-                    max: rl.max,
-                    window: rl.window,
-                    applied_to_path: call.path !== "*" ? call.path : null,
-                    method: null,
-                });
-            }
-            else if (mwName) {
-                const scope = call.path === "*" ? "global" : inferScope(call.path ?? "");
-                // Deduplicate: same middleware applied to different paths in same scope
-                // e.g. publicTenantResolver on /api/contests/*, /api/translations/*, /api/r/*
-                if (!scopeMwSeen.has(scope))
-                    scopeMwSeen.set(scope, new Set());
-                const seen = scopeMwSeen.get(scope);
-                if (!seen.has(mwName)) {
-                    seen.add(mwName);
-                    const currentOrder = scope === "global"
-                        ? ++globalOrder
-                        : (scopeOrders.set(scope, (scopeOrders.get(scope) ?? 0) + 1), scopeOrders.get(scope));
-                    if (!scopeChains.has(scope))
-                        scopeChains.set(scope, []);
-                    scopeChains.get(scope).push({ name: mwName, line: call.line, order: currentOrder });
-                }
-                // Detect auth middleware
-                if (/auth|clerk|jwt|session|passport/i.test(mwName)) {
-                    auth_middleware = mwName;
-                    const group = inferScope(call.path ?? "");
-                    if (!authGroups[group])
-                        authGroups[group] = { requires_auth: false, middleware: [] };
-                    authGroups[group].requires_auth = true;
-                    if (!authGroups[group].middleware.includes(mwName)) {
-                        authGroups[group].middleware.push(mwName);
-                    }
-                }
-                else if (scope !== "global") {
-                    const group = scope;
-                    if (!authGroups[group])
-                        authGroups[group] = { requires_auth: false, middleware: [] };
-                    if (!authGroups[group].middleware.includes(mwName)) {
-                        authGroups[group].middleware.push(mwName);
-                    }
+    for (const mc of model.middleware_chains) {
+        const scope = mc.scope === "*" ? "global" : mc.scope.replace(/\/\*$/, "").split("/").filter(Boolean)[1] ?? mc.scope;
+        for (const entry of mc.entries) {
+            if (/auth|clerk|jwt|session|passport/i.test(entry.name)) {
+                auth_middleware = entry.name;
+                if (!authGroups[scope])
+                    authGroups[scope] = { requires_auth: false, middleware: [] };
+                authGroups[scope].requires_auth = true;
+                if (!authGroups[scope].middleware.includes(entry.name)) {
+                    authGroups[scope].middleware.push(entry.name);
                 }
             }
         }
-        else if (call.type === "route") {
-            const varName = call.args.trim();
-            route_mounts.push({
-                file: filePath,
-                line: call.line,
-                mount_path: call.path ?? "",
-                imported_from: importMap.get(varName) ?? null,
-                exported_as: varName,
-            });
-            // Infer route group for auth detection
-            const group = inferScope(call.path ?? "");
-            if (!authGroups[group])
-                authGroups[group] = { requires_auth: false, middleware: [] };
-        }
-        else if (call.type === "get" || call.type === "post" || call.type === "put" || call.type === "delete") {
-            // Inline route — nothing to extract for conventions, but note for route groups
-        }
     }
-    // Build middleware chain array
-    for (const [scope, chain] of scopeChains) {
-        middleware_chains.push({ scope, file: filePath, chain });
-    }
-    // Build auth pattern groups — ensure all route groups are represented
-    const routeGroups = new Set();
-    for (const mount of route_mounts) {
-        routeGroups.add(inferScope(mount.mount_path));
-    }
-    // Add health and other direct routes
-    for (const call of calls) {
-        if (call.type !== "use" && call.type !== "route" && call.path) {
-            routeGroups.add(inferScope(call.path));
-        }
-    }
-    for (const group of routeGroups) {
-        if (!authGroups[group]) {
+    // Ensure all route groups represented
+    for (const mount of model.mounts) {
+        const group = mount.mount_path.split("/").filter(Boolean)[1] ?? "root";
+        if (!authGroups[group])
             authGroups[group] = { requires_auth: false, middleware: [] };
-        }
     }
     return {
         middleware_chains,
-        rate_limits,
+        rate_limits: [], // rate limits extracted from AST in future; empty for now
         route_mounts,
         auth_patterns: { auth_middleware, groups: authGroups },
     };
@@ -628,6 +612,17 @@ export function extractHonoConventions(source, filePath) {
 // ---------------------------------------------------------------------------
 // NestJS Extractor
 // ---------------------------------------------------------------------------
+/** Count net `[` vs `]` on a line — positive means more open brackets. */
+function countBracketBalance(text) {
+    let depth = 0;
+    for (const ch of text) {
+        if (ch === "[")
+            depth++;
+        else if (ch === "]")
+            depth--;
+    }
+    return depth;
+}
 export function extractNestConventions(source, filePath) {
     const lines = source.split("\n");
     // Build import map
@@ -645,41 +640,164 @@ export function extractNestConventions(source, filePath) {
     const global_guards = [];
     const global_filters = [];
     const global_pipes = [];
+    const global_interceptors = [];
     const controllers = [];
     let throttler = null;
     let inImports = false;
+    let importsBracketDepth = 0;
     let inProviders = false;
+    let providersBracketDepth = 0;
     let inControllers = false;
+    let controllersBracketDepth = 0;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const lineNum = i + 1;
-        // Track @Module sections
-        if (/imports:\s*\[/.test(line))
+        // Track @Module sections via bracket depth — handles both multi-line arrays
+        // (imports: [\n  A,\n  B,\n]) and single-line arrays (imports: [A, B]).
+        // Critical: mark inImports BEFORE scanning the current line so the scan
+        // block runs on single-line `imports: [...]` arrays.
+        let closeInImportsAfterLine = false;
+        if (/imports:\s*\[/.test(line)) {
             inImports = true;
-        if (/providers:\s*\[/.test(line))
+            importsBracketDepth += countBracketBalance(line.slice(line.indexOf("[")));
+            if (importsBracketDepth <= 0) {
+                closeInImportsAfterLine = true;
+                importsBracketDepth = 0;
+            }
+        }
+        else if (inImports) {
+            importsBracketDepth += countBracketBalance(line);
+            if (importsBracketDepth <= 0) {
+                closeInImportsAfterLine = true;
+                importsBracketDepth = 0;
+            }
+        }
+        // R-1 fix: use bracket-depth tracking for providers/controllers too
+        // (same approach as imports) so single-line arrays close correctly.
+        let closeProvidersAfterLine = false;
+        if (/providers:\s*\[/.test(line)) {
             inProviders = true;
-        if (/controllers:\s*\[/.test(line))
+            providersBracketDepth += countBracketBalance(line.slice(line.indexOf("[", line.indexOf("providers"))));
+            if (providersBracketDepth <= 0) {
+                closeProvidersAfterLine = true;
+                providersBracketDepth = 0;
+            }
+        }
+        else if (inProviders) {
+            providersBracketDepth += countBracketBalance(line);
+            if (providersBracketDepth <= 0) {
+                closeProvidersAfterLine = true;
+                providersBracketDepth = 0;
+            }
+        }
+        let closeControllersAfterLine = false;
+        if (/controllers:\s*\[/.test(line)) {
             inControllers = true;
-        if (inImports && /^\s*\]/.test(line))
-            inImports = false;
-        if (inProviders && /^\s*\]/.test(line))
-            inProviders = false;
-        if (inControllers && /^\s*\]/.test(line))
-            inControllers = false;
-        // Extract module imports
+            controllersBracketDepth += countBracketBalance(line.slice(line.indexOf("[", line.indexOf("controllers"))));
+            if (controllersBracketDepth <= 0) {
+                closeControllersAfterLine = true;
+                controllersBracketDepth = 0;
+            }
+        }
+        else if (inControllers) {
+            controllersBracketDepth += countBracketBalance(line);
+            if (controllersBracketDepth <= 0) {
+                closeControllersAfterLine = true;
+                controllersBracketDepth = 0;
+            }
+        }
+        // Extract module imports — scan for all module names on the line (not just
+        // the first indented one). Handles single-line `imports: [A, B.forFeature([...]), C]`
+        // where multiple modules share one line.
         if (inImports) {
-            // Match: ModuleName, or ModuleName.forRoot(), or ModuleName.forRootAsync({...})
-            const moduleMatch = line.match(/^\s+(\w+Module)(?:\.for(?:Root|Feature)(?:Async)?\s*\()?/);
-            if (moduleMatch) {
+            const moduleRe = /(\w+Module)(?:\.for(Root|Feature)(?:Async)?\s*\()?/g;
+            let moduleMatch;
+            const matchedThisLine = new Set();
+            while ((moduleMatch = moduleRe.exec(line)) !== null) {
+                // Avoid duplicates within the same line
+                const key = `${moduleMatch[1]}:${moduleMatch.index}`;
+                if (matchedThisLine.has(key))
+                    continue;
+                matchedThisLine.add(key);
                 const name = moduleMatch[1];
+                const dynamicKind = moduleMatch[2]; // "Root" | "Feature" | undefined
                 const isGlobal = /isGlobal:\s*true/.test(line) || /ConfigModule|SentryModule/.test(name);
-                modules.push({
+                const entry = {
                     name,
                     file: filePath,
                     line: lineNum,
                     imported_from: importMap.get(name) ?? null,
                     is_global: isGlobal,
-                });
+                };
+                // G2: forFeature([...]) — extract entity class names (scan ahead up to 15 lines)
+                if (dynamicKind === "Feature") {
+                    const entities = [];
+                    let bracketDepth = 0;
+                    let started = false;
+                    for (let j = i; j < Math.min(i + 15, lines.length); j++) {
+                        for (const ch of lines[j]) {
+                            if (ch === "[") {
+                                bracketDepth++;
+                                started = true;
+                            }
+                            else if (ch === "]") {
+                                bracketDepth--;
+                                if (started && bracketDepth === 0)
+                                    break;
+                            }
+                        }
+                        // Capture entity names after the opening [
+                        const featureMatch = lines[j].match(/forFeature\s*\(\s*\[([^\]]*)\]?/);
+                        if (featureMatch) {
+                            const inner = featureMatch[1];
+                            for (const m of inner.matchAll(/\b([A-Z]\w*)\b/g))
+                                entities.push(m[1]);
+                            // Continue to next lines if the array spans multiple
+                            for (let k = j + 1; k < Math.min(j + 10, lines.length) && !/\]/.test(lines[k - 1]); k++) {
+                                for (const m of lines[k].matchAll(/\b([A-Z]\w*)\b/g))
+                                    entities.push(m[1]);
+                            }
+                            break;
+                        }
+                        // Multi-line case: forFeature([ on one line, entities on next
+                        if (/forFeature\s*\(\s*\[\s*$/.test(lines[j])) {
+                            for (let k = j + 1; k < Math.min(j + 10, lines.length); k++) {
+                                if (/^\s*\]/.test(lines[k]))
+                                    break;
+                                for (const m of lines[k].matchAll(/\b([A-Z]\w*)\b/g))
+                                    entities.push(m[1]);
+                            }
+                            break;
+                        }
+                    }
+                    if (entities.length > 0)
+                        entry.entities = entities;
+                }
+                // G2: forRoot({...}) — extract top-level config keys
+                if (dynamicKind === "Root") {
+                    const keys = [];
+                    let braceDepth = 0;
+                    for (let j = i; j < Math.min(i + 15, lines.length); j++) {
+                        for (const ch of lines[j]) {
+                            if (ch === "{")
+                                braceDepth++;
+                            else if (ch === "}")
+                                braceDepth--;
+                        }
+                        // Only capture keys at the top-level of the forRoot config object
+                        if (braceDepth >= 1) {
+                            // Match indented key: value pattern at top-level (heuristic: 1-level indent)
+                            const keyMatch = lines[j].match(/^\s{6,10}(\w+):\s*/);
+                            if (keyMatch && !keys.includes(keyMatch[1]))
+                                keys.push(keyMatch[1]);
+                        }
+                        if (braceDepth === 0 && j > i)
+                            break;
+                    }
+                    if (keys.length > 0)
+                        entry.dynamic_config_keys = keys;
+                }
+                modules.push(entry);
             }
             // Extract ThrottlerModule config
             if (/ThrottlerModule/.test(line)) {
@@ -754,9 +872,97 @@ export function extractNestConventions(source, filePath) {
                     }
                 }
             }
+            if (/provide:\s*APP_INTERCEPTOR/.test(line)) {
+                for (let j = i; j < Math.min(i + 5, lines.length); j++) {
+                    const useClassMatch = lines[j].match(/useClass:\s*(\w+)/);
+                    if (useClassMatch) {
+                        global_interceptors.push({
+                            name: useClassMatch[1],
+                            token: "APP_INTERCEPTOR",
+                            file: filePath,
+                            line: j + 1,
+                            imported_from: importMap.get(useClassMatch[1]) ?? null,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        // Close inImports at end of line iteration if brackets balanced
+        if (closeInImportsAfterLine)
+            inImports = false;
+        if (closeProvidersAfterLine)
+            inProviders = false;
+        if (closeControllersAfterLine)
+            inControllers = false;
+    }
+    // G1: parse middleware.configure(consumer) chains
+    const middleware_chains = parseMiddlewareChains(source, filePath);
+    return { modules, global_guards, global_filters, global_pipes, global_interceptors, controllers, throttler, middleware_chains };
+}
+/**
+ * G1: Parse `configure(consumer: MiddlewareConsumer) { ... }` blocks.
+ * Extracts consumer.apply(Middleware).forRoutes(...) chains.
+ */
+export function parseMiddlewareChains(source, filePath) {
+    const results = [];
+    // Find configure( method — can be `configure(consumer` or `configure(consumer: MiddlewareConsumer)`
+    const configureStart = source.search(/\bconfigure\s*\(\s*\w+\s*(?::\s*\w+)?\s*\)\s*\{/);
+    if (configureStart === -1)
+        return results;
+    // Extract body of configure method via brace counting
+    const bodyStart = source.indexOf("{", configureStart);
+    if (bodyStart === -1)
+        return results;
+    let depth = 1;
+    let i = bodyStart + 1;
+    while (i < source.length && depth > 0) {
+        if (source[i] === "{")
+            depth++;
+        else if (source[i] === "}")
+            depth--;
+        i++;
+    }
+    const body = source.slice(bodyStart + 1, i - 1);
+    // Match: consumer.apply(Middleware).forRoutes(<args>) — may chain multiple middlewares
+    // Use a tolerant pattern that captures the apply(...) arg and forRoutes(...) arg separately.
+    const applyRe = /\.apply\s*\(\s*([\w,\s]+)\s*\)\s*\.forRoutes\s*\(([\s\S]*?)\)\s*[;}]/g;
+    let m;
+    while ((m = applyRe.exec(body)) !== null) {
+        const middlewareNames = m[1].split(",").map((s) => s.trim()).filter(Boolean);
+        const routesArg = m[2];
+        const routes = [];
+        // Parse routesArg — supports:
+        //   '*'
+        //   'users/*'
+        //   { path: 'users', method: RequestMethod.GET }
+        //   ControllerClass
+        const stringPathRe = /['"`]([^'"`]+)['"`]/g;
+        let sm;
+        while ((sm = stringPathRe.exec(routesArg)) !== null) {
+            // Check if this string is part of a { path: '...', method: ... } object literal
+            const before = routesArg.slice(Math.max(0, sm.index - 30), sm.index);
+            if (/path:\s*$/.test(before)) {
+                // Object form — capture path AND method
+                const objRe = /path:\s*['"`]([^'"`]+)['"`]\s*,\s*method:\s*(?:RequestMethod\.)?(\w+)/;
+                const afterContext = routesArg.slice(Math.max(0, sm.index - 20), sm.index + 200);
+                const objMatch = objRe.exec(afterContext);
+                if (objMatch) {
+                    routes.push({ path: objMatch[1], method: objMatch[2] });
+                    continue;
+                }
+            }
+            routes.push({ path: sm[1] });
+        }
+        // Also capture bare ControllerClass (PascalCase identifier) if present
+        for (const name of middlewareNames) {
+            // R-3 fix: guard indexOf returning -1 (would produce wrong line via slice(0,-1))
+            const namePos = source.indexOf(name, configureStart);
+            const line = namePos >= 0 ? source.slice(0, namePos).split("\n").length : 0;
+            results.push({ middleware: name, routes, file: filePath, line });
         }
     }
-    return { modules, global_guards, global_filters, global_pipes, controllers, throttler };
+    return results;
 }
 export function extractNextConventions(_projectRoot, files) {
     const pages = [];
@@ -764,6 +970,8 @@ export function extractNextConventions(_projectRoot, files) {
     const inngest_functions = [];
     const webhooks = [];
     let services_count = 0;
+    let client_component_count = 0;
+    let server_action_count = 0;
     let middleware = null;
     const hasAppDir = files.some((f) => f.path.includes("app/"));
     const hasSrcDir = files.some((f) => f.path.startsWith("src/"));
@@ -787,6 +995,18 @@ export function extractNextConventions(_projectRoot, files) {
         if (/app\/.*\/error\.(tsx|jsx|ts|js)$/.test(p)) {
             pages.push({ path: p, type: "error" });
         }
+        if (/app\/.*\/not-found\.(tsx|jsx|ts|js)$/.test(p)) {
+            pages.push({ path: p, type: "not-found" });
+        }
+        if (/app\/.*\/global-error\.(tsx|jsx|ts|js)$/.test(p)) {
+            pages.push({ path: p, type: "global-error" });
+        }
+        if (/app\/.*\/default\.(tsx|jsx|ts|js)$/.test(p)) {
+            pages.push({ path: p, type: "default" });
+        }
+        if (/app\/.*\/template\.(tsx|jsx|ts|js)$/.test(p)) {
+            pages.push({ path: p, type: "template" });
+        }
         // API routes (App Router — route.ts files under app/api/)
         if (/app\/api\/.*route\.(ts|js)$/.test(p)) {
             api_routes.push({ path: p, methods: [], file: p });
@@ -807,12 +1027,27 @@ export function extractNextConventions(_projectRoot, files) {
         if (/webhook/.test(p) && /route\.(ts|js)$/.test(p)) {
             webhooks.push(p);
         }
+        // Directive scanning — check first line for "use client" / "use server"
+        if (/\.(tsx|ts|jsx|js)$/.test(p) && /app\//.test(p)) {
+            try {
+                const head = readFileSync(join(_projectRoot, p), { encoding: "utf8", flag: "r" }).slice(0, 80);
+                if (/['"]use client['"]/.test(head))
+                    client_component_count++;
+                if (/['"]use server['"]/.test(head))
+                    server_action_count++;
+            }
+            catch {
+                // file may have been deleted since indexing
+            }
+        }
     }
     return {
         pages,
         middleware,
         api_routes,
         services_count,
+        client_component_count,
+        server_action_count,
         inngest_functions,
         webhooks,
         config: { app_router: hasAppDir, src_dir: hasSrcDir, i18n: hasI18n },
@@ -863,7 +1098,7 @@ export function extractExpressConventions(source, filePath) {
     }
     return { middleware, routers, error_handlers };
 }
-export function extractReactConventions(files, deps) {
+export function extractReactConventions(files, deps, symbols) {
     // State management
     let state_management = null;
     if (deps["@reduxjs/toolkit"] || deps["redux"])
@@ -885,8 +1120,13 @@ export function extractReactConventions(files, deps) {
     else if (deps["wouter"])
         routing = "wouter";
     // UI library
+    // shadcn/ui detection: canonical path pattern is components/ui/*.tsx — checked
+    // FIRST so it takes precedence over generic radix dep (shadcn re-exports radix).
+    const hasShadcnFiles = files.some((f) => /(^|\/)components\/ui\/[a-z-]+\.(tsx|jsx)$/.test(f.path));
     let ui_library = null;
-    if (deps["@mui/material"])
+    if (hasShadcnFiles)
+        ui_library = "shadcn";
+    else if (deps["@mui/material"])
         ui_library = "mui";
     else if (deps["@chakra-ui/react"])
         ui_library = "chakra";
@@ -896,7 +1136,15 @@ export function extractReactConventions(files, deps) {
         ui_library = "radix";
     else if (deps["tailwindcss"])
         ui_library = "tailwind";
-    // Component counts
+    // Form library detection (Item 7)
+    let form_library = null;
+    if (deps["react-hook-form"])
+        form_library = "react-hook-form";
+    else if (deps["formik"])
+        form_library = "formik";
+    else if (deps["final-form"] || deps["react-final-form"])
+        form_library = "final-form";
+    // File-path-based component counts (legacy, coarse)
     let pages = 0, components = 0, hooks = 0;
     for (const f of files) {
         if (/\/pages?\//.test(f.path) && /\.(tsx|jsx)$/.test(f.path))
@@ -906,11 +1154,53 @@ export function extractReactConventions(files, deps) {
         if (/\/hooks?\//.test(f.path) || /\.hook\.(ts|js)$/.test(f.path))
             hooks++;
     }
+    // Symbol-based semantic counts (requires Wave 1 extractor)
+    let actual_component_count = 0;
+    let actual_hook_count = 0;
+    const hookUsageMap = new Map();
+    const component_patterns = { memo: 0, forwardRef: 0, lazy: 0 };
+    if (symbols) {
+        // Set of stdlib hooks to exclude from "hook usage" tracking — we want
+        // to highlight which library/custom hooks components consume.
+        for (const sym of symbols) {
+            if (sym.kind === "component") {
+                actual_component_count++;
+                if (sym.source) {
+                    // Detect wrapper patterns in component source
+                    // Generic-aware patterns: memo<Props>(...), forwardRef<T, P>(...), lazy<T>(...) — Item 9
+                    if (/\b(?:React\.)?memo\s*(?:<[^>]+>)?\s*\(/.test(sym.source))
+                        component_patterns.memo++;
+                    if (/\b(?:React\.)?forwardRef\s*(?:<[^>]+>)?\s*\(/.test(sym.source))
+                        component_patterns.forwardRef++;
+                    if (/\b(?:React\.)?lazy\s*(?:<[^>]+>)?\s*\(/.test(sym.source))
+                        component_patterns.lazy++;
+                    // Count hook calls inside this component
+                    const hookCalls = sym.source.matchAll(/\b(use[A-Z]\w*)\s*\(/g);
+                    for (const m of hookCalls) {
+                        const hookName = m[1];
+                        hookUsageMap.set(hookName, (hookUsageMap.get(hookName) ?? 0) + 1);
+                    }
+                }
+            }
+            else if (sym.kind === "hook") {
+                actual_hook_count++;
+            }
+        }
+    }
+    const hook_usage = [...hookUsageMap.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([name, count]) => ({ name, count }));
     return {
         state_management,
         routing,
         ui_library,
+        form_library,
         component_count: { pages, components, hooks },
+        actual_component_count,
+        actual_hook_count,
+        hook_usage,
+        component_patterns,
     };
 }
 export function extractPythonConventions(files) {
@@ -974,21 +1264,67 @@ export function extractPhpConventions(files) {
         if (/Controller\.php$/.test(f.path)) {
             controllers.push({ name, path: f.path });
         }
-        if (/\/[Mm]iddleware\//.test(f.path) && f.path.endsWith(".php")) {
+        if (/(^|\/)[Mm]iddleware\//.test(f.path) && f.path.endsWith(".php")) {
             middleware.push({ name, path: f.path });
         }
-        if (/\/[Mm]odels?\//.test(f.path) && f.path.endsWith(".php")) {
+        if (/(^|\/)[Mm]odels?\//.test(f.path) && f.path.endsWith(".php")) {
             models.push({ name, path: f.path });
         }
-        if (/routes\//.test(f.path) && f.path.endsWith(".php")) {
+        if (/(^|\/)routes\//.test(f.path) && f.path.endsWith(".php")) {
             routes_files.push(f.path);
         }
-        if (/migrations?\//.test(f.path)) {
+        if (/(^|\/)migrations?\//.test(f.path)) {
             migrations_count++;
         }
     }
     return { controllers, middleware, models, routes_files, migrations_count };
 }
+export function extractYii2Conventions(files) {
+    const base = extractPhpConventions(files);
+    const modules = [];
+    const widgets = [];
+    const behaviors = [];
+    const components = [];
+    const assets = [];
+    const config_files = [];
+    for (const f of files) {
+        const name = f.path.split("/").pop()?.replace(/\.php$/, "") ?? "";
+        // Modules: Module.php in modules/*/ directories
+        if (/(^|\/)modules\/[^/]+\/Module\.php$/.test(f.path)) {
+            modules.push({ name, path: f.path });
+        }
+        // Widgets: files in widgets/ directories or named *Widget.php
+        if ((/(^|\/)widgets\//.test(f.path) || /Widget\.php$/.test(f.path)) && f.path.endsWith(".php")) {
+            widgets.push({ name, path: f.path });
+        }
+        // Behaviors: files in behaviors/ directories or named *Behavior.php
+        if ((/(^|\/)behaviors\//.test(f.path) || /Behavior\.php$/.test(f.path)) && f.path.endsWith(".php")) {
+            behaviors.push({ name, path: f.path });
+        }
+        // Components: files in components/ directory
+        if (/(^|\/)components\//.test(f.path) && f.path.endsWith(".php")) {
+            components.push({ name, path: f.path });
+        }
+        // Assets: files named *Asset.php in assets/ directory
+        if (/(^|\/)assets\//.test(f.path) && /Asset\.php$/.test(f.path)) {
+            assets.push({ name, path: f.path });
+        }
+        // Config files
+        if (/config\/(web|console|db|params|main|test)\.php$/.test(f.path)) {
+            config_files.push(f.path);
+        }
+    }
+    return {
+        ...base,
+        framework_type: "yii2",
+        modules,
+        widgets,
+        behaviors,
+        components,
+        assets,
+        config_files,
+    };
+}
 // ---------------------------------------------------------------------------
 // Identity Extractor
 // ---------------------------------------------------------------------------
@@ -1269,23 +1605,6 @@ function extractGitHealth(projectRoot) {
         return null;
     }
 }
-function inferScope(path) {
-    if (path === "*")
-        return "global";
-    if (path.includes("/admin"))
-        return "admin";
-    if (path.includes("/webhook"))
-        return "webhook";
-    if (path.includes("/health"))
-        return "health";
-    if (path.includes("/public") || path.includes("/contests") || path.includes("/translations") || path.includes("/r/"))
-        return "public";
-    // Default: extract first meaningful segment
-    const segments = path.split("/").filter(Boolean);
-    if (segments.length >= 2)
-        return segments[1];
-    return "root";
-}
 // ---------------------------------------------------------------------------
 // Main orchestrator: analyze_project
 // ---------------------------------------------------------------------------
@@ -1343,6 +1662,7 @@ export async function analyzeProject(repoName, _options = {}) {
     let reactConventions;
     let pythonConventions;
     let phpConventions;
+    let astroConventions;
     let status = "complete";
     const fw = stack.framework;
     try {
@@ -1350,7 +1670,7 @@ export async function analyzeProject(repoName, _options = {}) {
             const orchestratorFile = file_classifications.critical.find((f) => f.code_type === "ORCHESTRATOR");
             if (orchestratorFile) {
                 const appSource = await readFile(join(projectRoot, orchestratorFile.path), "utf-8");
-                conventions = extractHonoConventions(appSource, orchestratorFile.path);
+                conventions = await extractHonoConventions(appSource, orchestratorFile.path);
             }
             else {
                 status = "partial";
@@ -1386,14 +1706,22 @@ export async function analyzeProject(repoName, _options = {}) {
         else if (fw === "react") {
             const pkg = await readJson(join(projectRoot, "package.json"));
             const allDeps = { ...pkg?.dependencies, ...pkg?.devDependencies };
-            reactConventions = extractReactConventions(index.files, allDeps);
+            reactConventions = extractReactConventions(index.files, allDeps, index.symbols);
         }
         else if (fw === "fastapi" || fw === "django" || fw === "flask") {
             pythonConventions = extractPythonConventions(index.files);
         }
+        else if (fw === "yii2") {
+            phpConventions = extractYii2Conventions(index.files);
+        }
         else if (fw === "laravel" || fw === "symfony") {
             phpConventions = extractPhpConventions(index.files);
         }
+        else if (fw === "astro") {
+            const astroResult = await extractAstroConventions(index.files.map((f) => f.path), projectRoot);
+            astroConventions = astroResult.conventions;
+            status = "complete";
+        }
         else {
             status = "partial";
         }
@@ -1425,6 +1753,7 @@ export async function analyzeProject(repoName, _options = {}) {
         ...(reactConventions ? { react_conventions: reactConventions } : {}),
         ...(pythonConventions ? { python_conventions: pythonConventions } : {}),
         ...(phpConventions ? { php_conventions: phpConventions } : {}),
+        ...(astroConventions ? { astro_conventions: astroConventions } : {}),
         dependency_health: await extractDependencyHealth(projectRoot) ?? undefined,
         git_health: extractGitHealth(projectRoot) ?? undefined,
         generation_metadata: {
@@ -1448,7 +1777,7 @@ async function writeProfileToDisk(projectRoot, profile) {
     await writeFile(profilePath, JSON.stringify(profile, null, 2), "utf-8");
     return profilePath;
 }
-function buildConventionsSummary(profile) {
+export function buildConventionsSummary(profile) {
     const p = profile;
     if (p.conventions)
         return {
@@ -1463,6 +1792,7 @@ function buildConventionsSummary(profile) {
             modules: p.nest_conventions.modules.length,
             global_guards: p.nest_conventions.global_guards.length,
             global_filters: p.nest_conventions.global_filters.length,
+            global_interceptors: p.nest_conventions.global_interceptors.length,
             controllers: p.nest_conventions.controllers.length,
             has_throttler: !!p.nest_conventions.throttler,
         };
@@ -1507,6 +1837,15 @@ function buildConventionsSummary(profile) {
             models: p.php_conventions.models.length,
             migrations: p.php_conventions.migrations_count,
         };
+    if (p.astro_conventions)
+        return {
+            type: "astro",
+            output_mode: p.astro_conventions.output_mode,
+            adapter: p.astro_conventions.adapter,
+            integrations: p.astro_conventions.integrations.length,
+            has_i18n: !!p.astro_conventions.i18n,
+            config_resolution: p.astro_conventions.config_resolution,
+        };
     return null;
 }
 function buildSummary(profile, profilePath) {
@@ -1540,7 +1879,45 @@ function buildSummary(profile, profilePath) {
 // ---------------------------------------------------------------------------
 // get_extractor_versions — fast metadata call
 // ---------------------------------------------------------------------------
+/**
+ * Languages with a tree-sitter parser extractor — these get symbol-level
+ * indexing (search_symbols, get_file_outline, get_symbol, find_references, etc.).
+ */
+export const PARSER_LANGUAGES = [
+    "typescript",
+    "javascript",
+    "python",
+    "go",
+    "rust",
+    "php",
+    "kotlin",
+    "prisma",
+    "markdown",
+    "astro",
+    "sql",
+    "sql-jinja",
+];
+/**
+ * Languages indexed as FileEntry (so get_file_tree and search_text with
+ * file_pattern work) but WITHOUT symbol extraction. Ripgrep-backed search_text
+ * and scan_secrets work on these via filesystem. Upgrade path: add a
+ * tree-sitter grammar .wasm and extractor to move a language to PARSER_LANGUAGES.
+ */
+export const TEXT_STUB_LANGUAGES = [
+    "swift", "dart", "scala", "clojure",
+    "elixir", "lua", "zig", "nim", "gradle", "sbt",
+];
 export function getExtractorVersions() {
-    return { ...EXTRACTOR_VERSIONS };
+    return {
+        parser_languages: PARSER_LANGUAGES,
+        text_stub_languages: TEXT_STUB_LANGUAGES,
+        profile_frameworks: { ...EXTRACTOR_VERSIONS },
+        note: "search_text, get_file_tree, search_conversations, and scan_secrets work on ALL indexed files " +
+            "(both parser_languages AND text_stub_languages). Only symbol-based tools (search_symbols, " +
+            "get_file_outline, get_symbol, find_references, trace_call_chain) require a full parser " +
+            "extractor, so they return nothing for text_stub_languages. profile_frameworks is the list " +
+            "of framework detectors used by analyze_project — NOT a list of supported languages.",
+        versions: { ...EXTRACTOR_VERSIONS },
+    };
 }
 //# sourceMappingURL=project-tools.js.map