@agentllm/codegraph-arkts 0.7.12 → 0.9.4-arkts.0

package/dist/resolution/frameworks/drupal.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Drupal Framework Resolver
+ *
+ * Supports Drupal 8/9/10/11 (Composer-based projects). Drupal 7 is not supported.
+ *
+ * ## What this resolver does
+ *
+ * 1. **Detection** — reads composer.json and checks for any `drupal/*` dependency in
+ *    `require` or `require-dev`.
+ *
+ * 2. **Route extraction** — parses `*.routing.yml` files and emits `route` nodes for each
+ *    Drupal route, with `references` edges to the `_controller`, `_form`, or entity handler
+ *    class/method.
+ *
+ * 3. **Hook detection** — scans `.module`, `.install`, `.theme`, and `.inc` files for Drupal
+ *    hook implementations. Two strategies are used:
+ *      a. Docblock: `@Implements hook_X()` → precise, no false positives.
+ *      b. Name pattern: function `{moduleName}_{hookSuffix}()` → catches hooks without
+ *         docblocks but may produce false positives on helper functions.
+ *    Detected hooks emit an `UnresolvedRef` from the implementing function node to the
+ *    canonical `hook_X` name, linking implementations to the hook when `codegraph_callers`
+ *    is invoked.
+ *
+ * ## Design decisions (review in future iterations)
+ *
+ * - Hook graph resolution (v1): hook references are stored as UnresolvedRef pointing to the
+ *   canonical `hook_X` name. If Drupal core is indexed, these will resolve to core hook
+ *   definitions. Without core, they remain unresolved but are still searchable via
+ *   `codegraph_search("form_alter")`. Full hook-node creation (virtual nodes for every hook)
+ *   is deferred to a future iteration.
+ *
+ * - Services / plugins (out of scope for v1): `*.services.yml` service definitions and plugin
+ *   annotations (`@Block`, `@FormElement`, etc.) are not extracted. Add a TODO below when
+ *   ready to implement.
+ *
+ * - Twig templates (out of scope for v1): `.twig` files are tracked as file nodes but no
+ *   symbol extraction is performed (no tree-sitter Twig grammar). Implement when a Twig
+ *   grammar WASM is available.
+ *
+ * ## TODOs for future iterations
+ *
+ * - TODO: Extract service definitions from `*.services.yml` files (class → service-id edges).
+ * - TODO: Extract plugin annotations (`@Block`, `@FormElement`, `@Field`, etc.) from PHP
+ *   docblocks and emit plugin nodes with references to the annotated class.
+ * - TODO: Add Twig symbol extraction when a tree-sitter Twig grammar becomes available.
+ * - TODO: Improve hook resolution: create virtual `hook_*` nodes so `codegraph_callers`
+ *   returns all implementations even when Drupal core is not indexed.
+ */
+import { FrameworkResolver } from '../types';
+export declare const drupalResolver: FrameworkResolver;
+//# sourceMappingURL=drupal.d.ts.map

package/dist/resolution/frameworks/drupal.js

@@ -0,0 +1,367 @@
+"use strict";
+/**
+ * Drupal Framework Resolver
+ *
+ * Supports Drupal 8/9/10/11 (Composer-based projects). Drupal 7 is not supported.
+ *
+ * ## What this resolver does
+ *
+ * 1. **Detection** — reads composer.json and checks for any `drupal/*` dependency in
+ *    `require` or `require-dev`.
+ *
+ * 2. **Route extraction** — parses `*.routing.yml` files and emits `route` nodes for each
+ *    Drupal route, with `references` edges to the `_controller`, `_form`, or entity handler
+ *    class/method.
+ *
+ * 3. **Hook detection** — scans `.module`, `.install`, `.theme`, and `.inc` files for Drupal
+ *    hook implementations. Two strategies are used:
+ *      a. Docblock: `@Implements hook_X()` → precise, no false positives.
+ *      b. Name pattern: function `{moduleName}_{hookSuffix}()` → catches hooks without
+ *         docblocks but may produce false positives on helper functions.
+ *    Detected hooks emit an `UnresolvedRef` from the implementing function node to the
+ *    canonical `hook_X` name, linking implementations to the hook when `codegraph_callers`
+ *    is invoked.
+ *
+ * ## Design decisions (review in future iterations)
+ *
+ * - Hook graph resolution (v1): hook references are stored as UnresolvedRef pointing to the
+ *   canonical `hook_X` name. If Drupal core is indexed, these will resolve to core hook
+ *   definitions. Without core, they remain unresolved but are still searchable via
+ *   `codegraph_search("form_alter")`. Full hook-node creation (virtual nodes for every hook)
+ *   is deferred to a future iteration.
+ *
+ * - Services / plugins (out of scope for v1): `*.services.yml` service definitions and plugin
+ *   annotations (`@Block`, `@FormElement`, etc.) are not extracted. Add a TODO below when
+ *   ready to implement.
+ *
+ * - Twig templates (out of scope for v1): `.twig` files are tracked as file nodes but no
+ *   symbol extraction is performed (no tree-sitter Twig grammar). Implement when a Twig
+ *   grammar WASM is available.
+ *
+ * ## TODOs for future iterations
+ *
+ * - TODO: Extract service definitions from `*.services.yml` files (class → service-id edges).
+ * - TODO: Extract plugin annotations (`@Block`, `@FormElement`, `@Field`, etc.) from PHP
+ *   docblocks and emit plugin nodes with references to the annotated class.
+ * - TODO: Add Twig symbol extraction when a tree-sitter Twig grammar becomes available.
+ * - TODO: Improve hook resolution: create virtual `hook_*` nodes so `codegraph_callers`
+ *   returns all implementations even when Drupal core is not indexed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drupalResolver = void 0;
+const tree_sitter_helpers_1 = require("../../extraction/tree-sitter-helpers");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse the last PHP namespace segment from a FQCN like `\Drupal\mymodule\Controller\Foo`.
+ * Returns `null` for strings that don't look like a FQCN.
+ */
+function lastSegment(fqcn) {
+    const clean = fqcn.replace(/^\\+/, '').trim();
+    if (!clean.includes('\\'))
+        return null;
+    const parts = clean.split('\\');
+    return parts[parts.length - 1] ?? null;
+}
+/**
+ * Derive the Drupal module name from a file path.
+ * e.g. `web/modules/custom/my_module/my_module.module` → `my_module`
+ */
+function moduleNameFromPath(filePath) {
+    const match = filePath.match(/\/([^/]+)\.[^./]+$/);
+    return match ? match[1] : null;
+}
+// ---------------------------------------------------------------------------
+// Route extraction helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract route nodes and handler references from a Drupal `*.routing.yml` file.
+ *
+ * Drupal routing YAML format:
+ *
+ *   route.name:
+ *     path: '/some/path'
+ *     defaults:
+ *       _controller: '\Drupal\module\Controller\MyController::method'
+ *       _form: '\Drupal\module\Form\MyForm'
+ *       _title: 'Page title'
+ *     requirements:
+ *       _permission: 'access content'
+ *     methods: [GET, POST]   # optional
+ */
+function extractDrupalRoutes(filePath, content) {
+    const nodes = [];
+    const references = [];
+    const now = Date.now();
+    const lines = content.split('\n');
+    let pending = null;
+    let currentPath = null;
+    let handlerRefs = [];
+    let methods = [];
+    const flushRoute = () => {
+        if (!pending || !currentPath)
+            return;
+        const methodTag = methods.length > 0 ? ` [${methods.join(',')}]` : '';
+        const routeNode = {
+            id: `route:${filePath}:${pending.lineNum}:${currentPath}`,
+            kind: 'route',
+            name: `${currentPath}${methodTag}`,
+            qualifiedName: `${filePath}::${pending.name}`,
+            filePath,
+            startLine: pending.lineNum,
+            endLine: pending.lineNum,
+            startColumn: 0,
+            endColumn: 0,
+            language: 'yaml',
+            updatedAt: now,
+        };
+        nodes.push(routeNode);
+        for (const handler of handlerRefs) {
+            references.push({
+                fromNodeId: routeNode.id,
+                referenceName: handler,
+                referenceKind: 'references',
+                line: pending.lineNum,
+                column: 0,
+                filePath,
+                language: 'yaml',
+            });
+        }
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        // Top-level route name: no leading whitespace, ends with a colon (no value after)
+        if (/^\S.*:\s*$/.test(line) && !/^\s/.test(line)) {
+            flushRoute();
+            pending = { name: trimmed.slice(0, -1).trim(), lineNum: i + 1 };
+            currentPath = null;
+            handlerRefs = [];
+            methods = [];
+            continue;
+        }
+        // path: '/some/path'
+        const pathMatch = trimmed.match(/^path:\s*['"]?([^'"#\n]+?)['"]?\s*(?:#.*)?$/);
+        if (pathMatch) {
+            currentPath = pathMatch[1].trim();
+            continue;
+        }
+        // _controller: '\Drupal\...\Class::method'
+        const controllerMatch = trimmed.match(/^_controller:\s*['"]?([^'"#\n]+?)['"]?\s*(?:#.*)?$/);
+        if (controllerMatch) {
+            handlerRefs.push(controllerMatch[1].trim());
+            continue;
+        }
+        // _form: '\Drupal\...\Form\MyForm'
+        const formMatch = trimmed.match(/^_form:\s*['"]?([^'"#\n]+?)['"]?\s*(?:#.*)?$/);
+        if (formMatch) {
+            handlerRefs.push(formMatch[1].trim());
+            continue;
+        }
+        // _entity_form / _entity_list / _entity_view: entity.type
+        const entityMatch = trimmed.match(/^_(entity_form|entity_list|entity_view):\s*['"]?([^'"#\n]+?)['"]?\s*(?:#.*)?$/);
+        if (entityMatch) {
+            handlerRefs.push(entityMatch[2].trim());
+            continue;
+        }
+        // methods: [GET, POST]  or  methods: [GET]
+        const methodsMatch = trimmed.match(/^methods:\s*\[([^\]]+)\]/);
+        if (methodsMatch) {
+            methods = methodsMatch[1].split(',').map((m) => m.trim().toUpperCase()).filter(Boolean);
+            continue;
+        }
+    }
+    flushRoute();
+    return { nodes, references };
+}
+// ---------------------------------------------------------------------------
+// Hook detection helpers
+// ---------------------------------------------------------------------------
+const HOOK_FILE_EXTENSIONS = ['.module', '.install', '.theme', '.inc'];
+function isDrupalHookFile(filePath) {
+    return HOOK_FILE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+}
+/**
+ * Extract hook implementation references from a Drupal PHP file.
+ *
+ * Strategy A (primary): look for docblocks containing `Implements hook_X().`
+ * followed immediately by the function definition. This is the Drupal coding
+ * standard and is precise.
+ *
+ * Strategy B (fallback): for functions whose name starts with `{moduleName}_`,
+ * treat the suffix as the hook name. Catches hooks without docblocks but may
+ * produce false positives on non-hook helper functions.
+ *
+ * Each detected hook emits an UnresolvedRef from the implementing function node
+ * (identified by computing the same ID tree-sitter would generate) to the
+ * canonical hook name, e.g. `hook_form_alter`.
+ */
+function extractDrupalHooks(filePath, content) {
+    const references = [];
+    // Build a map of function name → 1-indexed line number for all top-level functions.
+    // This mirrors tree-sitter's line numbering so we can reconstruct node IDs.
+    const funcLineMap = new Map();
+    const funcDef = /^function\s+(\w+)\s*\(/gm;
+    let fm;
+    while ((fm = funcDef.exec(content)) !== null) {
+        const name = fm[1];
+        if (!funcLineMap.has(name)) {
+            // line = number of newlines before match start + 1
+            funcLineMap.set(name, content.slice(0, fm.index).split('\n').length);
+        }
+    }
+    const emitHookRef = (hookName, funcName) => {
+        const lineNum = funcLineMap.get(funcName);
+        if (lineNum === undefined)
+            return;
+        const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(filePath, 'function', funcName, lineNum);
+        references.push({
+            fromNodeId: nodeId,
+            referenceName: hookName,
+            referenceKind: 'references',
+            line: lineNum,
+            column: 0,
+            filePath,
+            language: 'php',
+        });
+    };
+    // Strategy A: docblock `Implements hook_X().` followed by function definition.
+    // The docblock and function may be separated by blank lines.
+    const docblockPattern = /\/\*\*[\s\S]*?(?:@|\*\s+)Implements\s+(hook_\w+)\s*\(\)[\s\S]*?\*\/\s*\n(?:\s*\n)*function\s+(\w+)\s*\(/g;
+    const docblockMatched = new Set();
+    let match;
+    while ((match = docblockPattern.exec(content)) !== null) {
+        const [, hookName, funcName] = match;
+        emitHookRef(hookName, funcName);
+        docblockMatched.add(funcName);
+    }
+    // Strategy B: fallback name-pattern matching for functions without docblocks.
+    // Only applies to functions whose name starts with {moduleName}_ and that were
+    // not already matched by Strategy A.
+    const moduleName = moduleNameFromPath(filePath);
+    if (moduleName) {
+        const prefix = moduleName + '_';
+        for (const [funcName] of funcLineMap) {
+            if (docblockMatched.has(funcName))
+                continue;
+            if (!funcName.startsWith(prefix))
+                continue;
+            const hookSuffix = funcName.slice(prefix.length);
+            if (!hookSuffix)
+                continue;
+            // Emit a reference to hook_{suffix} — the resolver will link it if the
+            // hook is defined somewhere in the indexed graph (e.g. Drupal core).
+            emitHookRef(`hook_${hookSuffix}`, funcName);
+        }
+    }
+    return { nodes: [], references };
+}
+// ---------------------------------------------------------------------------
+// Resolver
+// ---------------------------------------------------------------------------
+exports.drupalResolver = {
+    name: 'drupal',
+    languages: ['php', 'yaml'],
+    // Drupal route handlers are FQCNs (`\Drupal\…\Class::method`, the single-colon
+    // controller-service form `\Drupal\…\Class:method`, or a bare `\…\FormClass`)
+    // and hook refs are canonical `hook_*` names — none match a declared symbol, so
+    // resolveOne's pre-filter would drop them before resolve() runs. Claim the
+    // shapes resolve() handles (mirrors the Rails `controller#action` claim).
+    claimsReference(name) {
+        return (name.startsWith('hook_') ||
+            name.includes('\\') ||
+            /^[A-Za-z_]\w*::?\w+$/.test(name));
+    },
+    detect(context) {
+        // Primary: composer.json identifies a Drupal project/module/theme/profile.
+        // A contrib module often has an EMPTY `require` (no `drupal/*` dep) but still
+        // declares `"name": "drupal/<module>"` and `"type": "drupal-module"`, so check
+        // those too — checking deps alone misses every standalone contrib module.
+        const composer = context.readFile('composer.json');
+        if (composer) {
+            try {
+                const json = JSON.parse(composer);
+                if (typeof json.name === 'string' && json.name.startsWith('drupal/'))
+                    return true;
+                if (typeof json.type === 'string' && json.type.startsWith('drupal-'))
+                    return true;
+                const deps = { ...json.require, ...(json['require-dev'] ?? {}) };
+                if (Object.keys(deps).some((k) => k.startsWith('drupal/')))
+                    return true;
+            }
+            catch {
+                // malformed composer.json — fall through to file-based detection
+            }
+        }
+        // Fallback (composer-less module, or a non-Drupal composer.json): the
+        // unmistakable Drupal signature is a `*.info.yml` manifest alongside a
+        // Drupal PHP/route file. Require both so a stray `.info.yml` elsewhere
+        // doesn't trigger a false positive.
+        const files = context.getAllFiles();
+        const hasInfoYml = files.some((f) => f.endsWith('.info.yml'));
+        if (!hasInfoYml)
+            return false;
+        return files.some((f) => f.endsWith('.routing.yml') ||
+            f.endsWith('.module') ||
+            f.endsWith('.install') ||
+            f.endsWith('.theme'));
+    },
+    resolve(ref, context) {
+        const name = ref.referenceName;
+        // _controller: '\Drupal\module\...\ClassName::methodName' (double colon) or the
+        // single-colon controller-service form '\Drupal\...\ClassName:methodName'.
+        const controllerMatch = name.match(/^\\?(?:Drupal\\[^:]+\\)?([^\\:]+):{1,2}(\w+)$/);
+        if (controllerMatch) {
+            const [, className, methodName] = controllerMatch;
+            const classNodes = context.getNodesByName(className);
+            for (const cls of classNodes) {
+                if (cls.kind !== 'class')
+                    continue;
+                const fileNodes = context.getNodesInFile(cls.filePath);
+                const method = fileNodes.find((n) => n.kind === 'method' && n.name === methodName);
+                if (method) {
+                    return { original: ref, targetNodeId: method.id, confidence: 0.9, resolvedBy: 'framework' };
+                }
+                return { original: ref, targetNodeId: cls.id, confidence: 0.7, resolvedBy: 'framework' };
+            }
+        }
+        // _form / _entity_form: '\Drupal\module\...\ClassName'  (bare FQCN, no method)
+        if (name.includes('\\') && !name.includes(':')) {
+            const className = lastSegment(name);
+            if (className) {
+                const classNodes = context.getNodesByName(className);
+                const cls = classNodes.find((n) => n.kind === 'class');
+                if (cls) {
+                    return { original: ref, targetNodeId: cls.id, confidence: 0.85, resolvedBy: 'framework' };
+                }
+            }
+        }
+        // hook_X — find any function whose name ends in _{hookSuffix} in a hook file
+        if (name.startsWith('hook_')) {
+            const hookSuffix = name.slice(5); // strip 'hook_'
+            const candidates = context.getNodesByKind('function').filter((n) => n.name.endsWith(`_${hookSuffix}`) && isDrupalHookFile(n.filePath));
+            if (candidates.length > 0) {
+                return {
+                    original: ref,
+                    targetNodeId: candidates[0].id,
+                    confidence: 0.75,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        return null;
+    },
+    extract(filePath, content) {
+        if (filePath.endsWith('.routing.yml')) {
+            return extractDrupalRoutes(filePath, content);
+        }
+        if (isDrupalHookFile(filePath) || filePath.endsWith('.php')) {
+            return extractDrupalHooks(filePath, content);
+        }
+        return { nodes: [], references: [] };
+    },
+};
+//# sourceMappingURL=drupal.js.map

package/dist/resolution/frameworks/express.js

@@ -12,6 +12,46 @@ function extractTailIdent(expr) {
     const m = cleaned.match(/(?:\.|^)([A-Za-z_][A-Za-z0-9_]*)$/);
     return m ? m[1] : null;
 }
+/**
+ * Index of the delimiter matching the one at `open`, skipping string/template
+ * literals so a `)` or `}` inside a string doesn't throw off the balance.
+ */
+function matchDelim(s, open, oc, cc) {
+    let depth = 0;
+    for (let i = open; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '"' || ch === "'" || ch === '`') {
+            const q = ch;
+            i++;
+            while (i < s.length && s[i] !== q) {
+                if (s[i] === '\\')
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        if (ch === oc)
+            depth++;
+        else if (ch === cc) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+// Express res/req methods + common JS builtins — calls to these inside a handler
+// body are framework/noise, not the business flow we want to surface as route edges.
+const RESERVED_CALLS = new Set([
+    'json', 'jsonp', 'send', 'sendStatus', 'sendFile', 'status', 'end', 'redirect',
+    'render', 'set', 'get', 'header', 'type', 'format', 'attachment', 'download',
+    'cookie', 'clearCookie', 'append', 'location', 'vary', 'links', 'accepts', 'is',
+    'next', 'then', 'catch', 'finally', 'resolve', 'reject', 'all', 'race',
+    'map', 'filter', 'forEach', 'reduce', 'find', 'push', 'pop', 'slice', 'splice',
+    'includes', 'keys', 'values', 'entries', 'assign', 'parse', 'stringify',
+    'log', 'error', 'warn', 'info', 'String', 'Number', 'Boolean', 'Array', 'Object',
+    'Date', 'Math', 'JSON', 'Promise', 'require', 'fail', 'redirect',
+]);
 exports.expressResolver = {
     name: 'express',
     languages: ['javascript', 'typescript'],
@@ -95,11 +135,14 @@ exports.expressResolver = {
         const now = Date.now();
         const lang = detectLanguage(filePath);
         const safe = (0, strip_comments_1.stripCommentsForRegex)(content, lang);
-        // (app|router).METHOD('/path', handler-expr)
-        const regex = /\b(app|router)\.(get|post|put|patch|delete|all|use)\s*\(\s*['"]([^'"]+)['"]\s*,\s*([^)]+)\)/g;
+        // Match the route head up to the first arg: (app|router).METHOD('/path',
+        // (NOT the whole call — handlers are often inline arrows whose `)`/`{}` the
+        // old single-regex couldn't span, so inline-handler routes connected to nothing.)
+        const head = /\b(app|router)\.(get|post|put|patch|delete|all|use)\s*\(\s*['"]([^'"]+)['"]\s*,/g;
         let match;
-        while ((match = regex.exec(safe)) !== null) {
-            const [, _obj, method, routePath, handlers] = match;
+        while ((match = head.exec(safe)) !== null) {
+            const method = match[2];
+            const routePath = match[3];
             if (method === 'use' && !routePath.startsWith('/'))
                 continue;
             const line = safe.slice(0, match.index).split('\n').length;
@@ -113,24 +156,64 @@ exports.expressResolver = {
                 endLine: line,
                 startColumn: 0,
                 endColumn: match[0].length,
-                language: detectLanguage(filePath),
+                language: lang,
                 updatedAt: now,
             };
             nodes.push(routeNode);
-            // Handler is the LAST comma-separated argument; earlier ones are middleware.
-            const parts = handlers.split(',').map((s) => s.trim()).filter(Boolean);
-            const last = parts[parts.length - 1];
-            const handlerName = last ? extractTailIdent(last) : null;
-            if (handlerName) {
-                references.push({
-                    fromNodeId: routeNode.id,
-                    referenceName: handlerName,
-                    referenceKind: 'references',
-                    line,
-                    column: 0,
-                    filePath,
-                    language: detectLanguage(filePath),
-                });
+            // The full argument list = balanced parens from the route call's open paren.
+            const openParen = safe.indexOf('(', match.index);
+            const closeParen = openParen >= 0 ? matchDelim(safe, openParen, '(', ')') : -1;
+            const args = closeParen > openParen ? safe.slice(openParen + 1, closeParen) : '';
+            const arrowAt = args.indexOf('=>');
+            if (arrowAt >= 0) {
+                // Inline arrow handler (`router.post('/x', async (req,res) => {…})`). The
+                // arrow is anonymous, so its body — the actual request→service flow — would
+                // be lost. Attribute the body's calls to the route node as `calls` edges so
+                // `trace(route, service)` connects. Body = balanced `{…}` after `=>`, or the
+                // single-expression tail for `=> expr` arrows.
+                const afterArrow = args.slice(arrowAt + 2);
+                const braceAt = afterArrow.indexOf('{');
+                let body = afterArrow;
+                if (braceAt >= 0 && afterArrow.slice(0, braceAt).trim() === '') {
+                    const end = matchDelim(afterArrow, braceAt, '{', '}');
+                    if (end > braceAt)
+                        body = afterArrow.slice(braceAt + 1, end);
+                }
+                const callRe = /\b([A-Za-z_$][\w$]*)\s*\(/g;
+                const seen = new Set();
+                let cm;
+                while ((cm = callRe.exec(body)) !== null) {
+                    const name = cm[1];
+                    if (seen.has(name) || RESERVED_CALLS.has(name))
+                        continue;
+                    seen.add(name);
+                    references.push({
+                        fromNodeId: routeNode.id,
+                        referenceName: name,
+                        referenceKind: 'calls',
+                        line,
+                        column: 0,
+                        filePath,
+                        language: lang,
+                    });
+                }
+            }
+            else {
+                // Named handler: the LAST comma-separated arg (earlier ones are middleware).
+                const parts = args.split(',').map((s) => s.trim()).filter(Boolean);
+                const last = parts[parts.length - 1];
+                const handlerName = last ? extractTailIdent(last) : null;
+                if (handlerName) {
+                    references.push({
+                        fromNodeId: routeNode.id,
+                        referenceName: handlerName,
+                        referenceKind: 'references',
+                        line,
+                        column: 0,
+                        filePath,
+                        language: lang,
+                    });
+                }
             }
         }
         return { nodes, references };

package/dist/resolution/frameworks/go.js

@@ -78,9 +78,12 @@ exports.goResolver = {
         const references = [];
         const now = Date.now();
         const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'go');
-        // (router|r|mux|app).METHOD("/path", handler)
-        // Handles Gin (GET/POST/...), Chi (Get/Post/...), net/http (HandleFunc/Handle).
-        const routeRegex = /\b(?:router|r|mux|app|e)\.(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|Get|Post|Put|Patch|Delete|Handle|HandleFunc)\s*\(\s*"([^"]+)"\s*,\s*([^)]+)\)/g;
+        // <anyVar>.METHOD("/path", handler) — Gin (GET/POST/...), Chi (Get/Post/...),
+        // net/http (HandleFunc/Handle). The receiver is ANY identifier, not just
+        // router|r|mux|app|e: real apps route on GROUP vars (`v1.GET`, `PublicGroup.GET`,
+        // `userRouter.POST`), which the fixed name list missed (gin-vue-admin: 4 routes
+        // for 625 files). The verb + string-path + handler-arg gates keep it route-specific.
+        const routeRegex = /\b\w+\.(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|Get|Post|Put|Patch|Delete|Handle|HandleFunc)\s*\(\s*"([^"]+)"\s*,\s*([^)]+)\)/g;
         let match;
         while ((match = routeRegex.exec(safe)) !== null) {
             const [, rawMethod, routePath, handlerExpr] = match;

package/dist/resolution/frameworks/index.d.ts

@@ -26,14 +26,17 @@ export declare function getApplicableFrameworks(detected: FrameworkResolver[], l
  * Register a custom framework resolver
  */
 export declare function registerFrameworkResolver(resolver: FrameworkResolver): void;
+export { drupalResolver } from './drupal';
 export { laravelResolver, FACADE_MAPPINGS } from './laravel';
 export { expressResolver } from './express';
+export { nestjsResolver } from './nestjs';
 export { reactResolver } from './react';
 export { svelteResolver } from './svelte';
 export { vueResolver } from './vue';
 export { djangoResolver, flaskResolver, fastapiResolver } from './python';
 export { railsResolver } from './ruby';
 export { springResolver } from './java';
+export { playResolver } from './play';
 export { goResolver } from './go';
 export { rustResolver } from './rust';
 export { aspnetResolver } from './csharp';

package/dist/resolution/frameworks/index.js

@@ -5,20 +5,23 @@
  * Manages framework-specific resolvers.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.vaporResolver = exports.uikitResolver = exports.swiftUIResolver = exports.aspnetResolver = exports.rustResolver = exports.goResolver = exports.springResolver = exports.railsResolver = exports.fastapiResolver = exports.flaskResolver = exports.djangoResolver = exports.vueResolver = exports.svelteResolver = exports.reactResolver = exports.expressResolver = exports.FACADE_MAPPINGS = exports.laravelResolver = void 0;
+exports.vaporResolver = exports.uikitResolver = exports.swiftUIResolver = exports.aspnetResolver = exports.rustResolver = exports.goResolver = exports.playResolver = exports.springResolver = exports.railsResolver = exports.fastapiResolver = exports.flaskResolver = exports.djangoResolver = exports.vueResolver = exports.svelteResolver = exports.reactResolver = exports.nestjsResolver = exports.expressResolver = exports.FACADE_MAPPINGS = exports.laravelResolver = exports.drupalResolver = void 0;
 exports.getAllFrameworkResolvers = getAllFrameworkResolvers;
 exports.getFrameworkResolver = getFrameworkResolver;
 exports.detectFrameworks = detectFrameworks;
 exports.getApplicableFrameworks = getApplicableFrameworks;
 exports.registerFrameworkResolver = registerFrameworkResolver;
+const drupal_1 = require("./drupal");
 const laravel_1 = require("./laravel");
 const express_1 = require("./express");
+const nestjs_1 = require("./nestjs");
 const react_1 = require("./react");
 const svelte_1 = require("./svelte");
 const vue_1 = require("./vue");
 const python_1 = require("./python");
 const ruby_1 = require("./ruby");
 const java_1 = require("./java");
+const play_1 = require("./play");
 const go_1 = require("./go");
 const rust_1 = require("./rust");
 const csharp_1 = require("./csharp");
@@ -29,8 +32,10 @@ const swift_1 = require("./swift");
 const FRAMEWORK_RESOLVERS = [
     // PHP
     laravel_1.laravelResolver,
+    drupal_1.drupalResolver,
     // JavaScript/TypeScript
     express_1.expressResolver,
+    nestjs_1.nestjsResolver,
     react_1.reactResolver,
     svelte_1.svelteResolver,
     vue_1.vueResolver,
@@ -42,6 +47,7 @@ const FRAMEWORK_RESOLVERS = [
     ruby_1.railsResolver,
     // Java
     java_1.springResolver,
+    play_1.playResolver,
     // Go
     go_1.goResolver,
     // Rust
@@ -97,11 +103,15 @@ function registerFrameworkResolver(resolver) {
     FRAMEWORK_RESOLVERS.push(resolver);
 }
 // Re-export framework resolvers
+var drupal_2 = require("./drupal");
+Object.defineProperty(exports, "drupalResolver", { enumerable: true, get: function () { return drupal_2.drupalResolver; } });
 var laravel_2 = require("./laravel");
 Object.defineProperty(exports, "laravelResolver", { enumerable: true, get: function () { return laravel_2.laravelResolver; } });
 Object.defineProperty(exports, "FACADE_MAPPINGS", { enumerable: true, get: function () { return laravel_2.FACADE_MAPPINGS; } });
 var express_2 = require("./express");
 Object.defineProperty(exports, "expressResolver", { enumerable: true, get: function () { return express_2.expressResolver; } });
+var nestjs_2 = require("./nestjs");
+Object.defineProperty(exports, "nestjsResolver", { enumerable: true, get: function () { return nestjs_2.nestjsResolver; } });
 var react_2 = require("./react");
 Object.defineProperty(exports, "reactResolver", { enumerable: true, get: function () { return react_2.reactResolver; } });
 var svelte_2 = require("./svelte");
@@ -116,6 +126,8 @@ var ruby_2 = require("./ruby");
 Object.defineProperty(exports, "railsResolver", { enumerable: true, get: function () { return ruby_2.railsResolver; } });
 var java_2 = require("./java");
 Object.defineProperty(exports, "springResolver", { enumerable: true, get: function () { return java_2.springResolver; } });
+var play_2 = require("./play");
+Object.defineProperty(exports, "playResolver", { enumerable: true, get: function () { return play_2.playResolver; } });
 var go_2 = require("./go");
 Object.defineProperty(exports, "goResolver", { enumerable: true, get: function () { return go_2.goResolver; } });
 var rust_2 = require("./rust");