@saluzi/codegraph 0.1.0

package/dist/resolution/frameworks/laravel.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * Laravel Framework Resolver
+ *
+ * Handles Laravel-specific patterns for reference resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.laravelResolver = exports.FACADE_MAPPINGS = void 0;
+const strip_comments_1 = require("../strip-comments");
+/**
+ * Laravel facade mappings to underlying classes
+ * Exported for potential use in facade resolution
+ */
+exports.FACADE_MAPPINGS = {
+    Auth: 'Illuminate\\Auth\\AuthManager',
+    Cache: 'Illuminate\\Cache\\CacheManager',
+    Config: 'Illuminate\\Config\\Repository',
+    DB: 'Illuminate\\Database\\DatabaseManager',
+    Event: 'Illuminate\\Events\\Dispatcher',
+    File: 'Illuminate\\Filesystem\\Filesystem',
+    Gate: 'Illuminate\\Auth\\Access\\Gate',
+    Hash: 'Illuminate\\Hashing\\HashManager',
+    Log: 'Illuminate\\Log\\LogManager',
+    Mail: 'Illuminate\\Mail\\Mailer',
+    Queue: 'Illuminate\\Queue\\QueueManager',
+    Redis: 'Illuminate\\Redis\\RedisManager',
+    Request: 'Illuminate\\Http\\Request',
+    Response: 'Illuminate\\Http\\Response',
+    Route: 'Illuminate\\Routing\\Router',
+    Session: 'Illuminate\\Session\\SessionManager',
+    Storage: 'Illuminate\\Filesystem\\FilesystemManager',
+    URL: 'Illuminate\\Routing\\UrlGenerator',
+    Validator: 'Illuminate\\Validation\\Factory',
+    View: 'Illuminate\\View\\Factory',
+};
+exports.laravelResolver = {
+    name: 'laravel',
+    languages: ['php'],
+    detect(context) {
+        // Check for artisan file (Laravel signature)
+        return context.fileExists('artisan') || context.fileExists('app/Http/Kernel.php');
+    },
+    resolve(ref, context) {
+        // Pattern 1: Model::method() - Eloquent static calls
+        const modelMatch = ref.referenceName.match(/^([A-Z][a-zA-Z]+)::(\w+)$/);
+        if (modelMatch) {
+            const [, className, methodName] = modelMatch;
+            const result = resolveModelCall(className, methodName, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.85,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        // Pattern 2: Facade calls - Auth::user(), Cache::get()
+        const facadeMatch = ref.referenceName.match(/^(Auth|Cache|DB|Log|Mail|Queue|Session|Storage|Validator|Route|Request|Response)::(\w+)$/);
+        if (facadeMatch) {
+            // Facades typically resolve to external Laravel code
+            // Mark as external but note the facade
+            return null; // External, can't resolve to local node
+        }
+        // Pattern 3: Helper function calls - route(), view(), config()
+        if (['route', 'view', 'config', 'env', 'app', 'abort', 'redirect', 'response', 'request', 'session', 'url', 'asset', 'mix'].includes(ref.referenceName)) {
+            // These are Laravel helpers - external
+            return null;
+        }
+        // Pattern 4: Controller method references
+        const controllerMatch = ref.referenceName.match(/^([A-Z][a-zA-Z]+Controller)@(\w+)$/);
+        if (controllerMatch) {
+            const [, controller, method] = controllerMatch;
+            const result = resolveControllerMethod(controller, method, context);
+            if (result) {
+                return {
+                    original: ref,
+                    targetNodeId: result,
+                    confidence: 0.9,
+                    resolvedBy: 'framework',
+                };
+            }
+        }
+        return null;
+    },
+    extract(filePath, content) {
+        if (!filePath.endsWith('.php'))
+            return { nodes: [], references: [] };
+        const nodes = [];
+        const references = [];
+        const now = Date.now();
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, 'php');
+        // Route::METHOD('/path', handler-expr)
+        // handler-expr can be: [Class::class, 'method'] | 'Controller@method' | Closure | Class::class
+        const routeRegex = /Route::(get|post|put|patch|delete|options|any)\s*\(\s*['"]([^'"]+)['"]\s*,\s*([^)]+)\)/g;
+        let match;
+        while ((match = routeRegex.exec(safe)) !== null) {
+            const [, method, routePath, handlerExpr] = match;
+            const line = safe.slice(0, match.index).split('\n').length;
+            const upper = method.toUpperCase();
+            const routeNode = {
+                id: `route:${filePath}:${line}:${upper}:${routePath}`,
+                kind: 'route',
+                name: `${upper} ${routePath}`,
+                qualifiedName: `${filePath}::route:${routePath}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: match[0].length,
+                language: 'php',
+                updatedAt: now,
+            };
+            nodes.push(routeNode);
+            const handlerName = extractLaravelHandler(handlerExpr);
+            if (handlerName) {
+                references.push({
+                    fromNodeId: routeNode.id,
+                    referenceName: handlerName,
+                    referenceKind: 'references',
+                    line,
+                    column: 0,
+                    filePath,
+                    language: 'php',
+                });
+            }
+        }
+        // Route::resource('name', Controller::class) / Route::apiResource('name', Controller::class)
+        const resourceRegex = /Route::(resource|apiResource)\s*\(\s*['"]([^'"]+)['"]\s*(?:,\s*([^)]+))?\)/g;
+        while ((match = resourceRegex.exec(safe)) !== null) {
+            const [, _fn, resourceName, handlerExpr] = match;
+            const line = safe.slice(0, match.index).split('\n').length;
+            const routeNode = {
+                id: `route:${filePath}:${line}:RESOURCE:${resourceName}`,
+                kind: 'route',
+                name: `resource:${resourceName}`,
+                qualifiedName: `${filePath}::route:${resourceName}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: match[0].length,
+                language: 'php',
+                updatedAt: now,
+            };
+            nodes.push(routeNode);
+            if (handlerExpr) {
+                const controllerName = extractLaravelHandler(handlerExpr);
+                if (controllerName) {
+                    references.push({
+                        fromNodeId: routeNode.id,
+                        referenceName: controllerName,
+                        referenceKind: 'imports',
+                        line,
+                        column: 0,
+                        filePath,
+                        language: 'php',
+                    });
+                }
+            }
+        }
+        return { nodes, references };
+    },
+};
+/**
+ * Parse a Laravel route handler expression and return the symbol to link.
+ *  - `[Class::class, 'method']`  -> `method`
+ *  - `'Controller@method'`       -> `method`
+ *  - `Class::class`              -> `Class`
+ *  - anything else (closure etc) -> null
+ */
+function extractLaravelHandler(expr) {
+    const trimmed = expr.trim();
+    // [Class::class, 'method'] — grab the string literal
+    const tupleMatch = trimmed.match(/^\[\s*[^,]+,\s*['"]([^'"]+)['"]\s*\]/);
+    if (tupleMatch)
+        return tupleMatch[1];
+    // 'Controller@method'
+    const atMatch = trimmed.match(/^['"]([^'"@]+)@([^'"]+)['"]$/);
+    if (atMatch)
+        return atMatch[2];
+    // Controller::class
+    const classMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)::class/);
+    if (classMatch)
+        return classMatch[1];
+    return null;
+}
+/**
+ * Resolve a Model::method() call
+ */
+function resolveModelCall(className, methodName, context) {
+    // Try app/Models/ first (Laravel 8+)
+    let modelPath = `app/Models/${className}.php`;
+    if (context.fileExists(modelPath)) {
+        const nodes = context.getNodesInFile(modelPath);
+        // Look for the method in this class
+        const methodNode = nodes.find((n) => n.kind === 'method' && n.name === methodName);
+        if (methodNode) {
+            return methodNode.id;
+        }
+        // Return the class itself if method not found
+        const classNode = nodes.find((n) => n.kind === 'class' && n.name === className);
+        if (classNode) {
+            return classNode.id;
+        }
+    }
+    // Try app/ (Laravel 7 and below)
+    modelPath = `app/${className}.php`;
+    if (context.fileExists(modelPath)) {
+        const nodes = context.getNodesInFile(modelPath);
+        const methodNode = nodes.find((n) => n.kind === 'method' && n.name === methodName);
+        if (methodNode) {
+            return methodNode.id;
+        }
+        const classNode = nodes.find((n) => n.kind === 'class' && n.name === className);
+        if (classNode) {
+            return classNode.id;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve a Controller@method reference
+ */
+function resolveControllerMethod(controller, method, context) {
+    // Try app/Http/Controllers/
+    const controllerPath = `app/Http/Controllers/${controller}.php`;
+    if (context.fileExists(controllerPath)) {
+        const nodes = context.getNodesInFile(controllerPath);
+        const methodNode = nodes.find((n) => n.kind === 'method' && n.name === method);
+        if (methodNode) {
+            return methodNode.id;
+        }
+    }
+    // Try name-based lookup for namespaced controllers
+    const controllerCandidates = context.getNodesByName(controller);
+    for (const ctrl of controllerCandidates) {
+        if (ctrl.kind === 'class' && ctrl.filePath.includes('Controllers')) {
+            const nodesInFile = context.getNodesInFile(ctrl.filePath);
+            const methodNode = nodesInFile.find((n) => n.kind === 'method' && n.name === method);
+            if (methodNode) {
+                return methodNode.id;
+            }
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=laravel.js.map

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

@@ -0,0 +1,26 @@
+/**
+ * NestJS Framework Resolver
+ *
+ * Handles NestJS decorator-based routing across its transport layers:
+ *   - HTTP:          @Controller(prefix) + @Get/@Post/@Put/@Patch/@Delete/@Head/@Options/@All
+ *   - GraphQL:       @Resolver + @Query/@Mutation/@Subscription
+ *   - Microservices: @MessagePattern / @EventPattern
+ *   - WebSockets:    @WebSocketGateway(namespace) + @SubscribeMessage(event)
+ *
+ * Like the other framework extractors this is regex-over-source (comment-
+ * stripped), not AST traversal. NestJS differs from Spring/ASP.NET in two ways
+ * that this resolver has to account for:
+ *
+ *   1. An HTTP route's path is split across TWO decorators — the class-level
+ *      `@Controller` prefix and the method-level `@Get`/`@Post` path — and both
+ *      are frequently empty (`@Controller()`, `@Get()`). We pair each method
+ *      decorator with its enclosing class and join the two paths.
+ *
+ *   2. `@Query()` is overloaded: it's a GraphQL *method* decorator (from
+ *      `@nestjs/graphql`) AND a REST *parameter* decorator (from
+ *      `@nestjs/common`). We only treat it as GraphQL when it sits inside an
+ *      `@Resolver` class, which is what disambiguates the two.
+ */
+import { FrameworkResolver } from '../types'
+export declare const nestjsResolver: FrameworkResolver
+//# sourceMappingURL=nestjs.d.ts.map

package/dist/resolution/frameworks/nestjs.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * NestJS Framework Resolver
+ *
+ * Handles NestJS decorator-based routing across its transport layers:
+ *   - HTTP:          @Controller(prefix) + @Get/@Post/@Put/@Patch/@Delete/@Head/@Options/@All
+ *   - GraphQL:       @Resolver + @Query/@Mutation/@Subscription
+ *   - Microservices: @MessagePattern / @EventPattern
+ *   - WebSockets:    @WebSocketGateway(namespace) + @SubscribeMessage(event)
+ *
+ * Like the other framework extractors this is regex-over-source (comment-
+ * stripped), not AST traversal. NestJS differs from Spring/ASP.NET in two ways
+ * that this resolver has to account for:
+ *
+ *   1. An HTTP route's path is split across TWO decorators — the class-level
+ *      `@Controller` prefix and the method-level `@Get`/`@Post` path — and both
+ *      are frequently empty (`@Controller()`, `@Get()`). We pair each method
+ *      decorator with its enclosing class and join the two paths.
+ *
+ *   2. `@Query()` is overloaded: it's a GraphQL *method* decorator (from
+ *      `@nestjs/graphql`) AND a REST *parameter* decorator (from
+ *      `@nestjs/common`). We only treat it as GraphQL when it sits inside an
+ *      `@Resolver` class, which is what disambiguates the two.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nestjsResolver = void 0;
+const strip_comments_1 = require("../strip-comments");
+const HTTP_METHODS = ['Get', 'Post', 'Put', 'Patch', 'Delete', 'Head', 'Options', 'All'];
+const GQL_OPS = ['Query', 'Mutation', 'Subscription'];
+exports.nestjsResolver = {
+    name: 'nestjs',
+    languages: ['typescript', 'javascript'],
+    detect(context) {
+        // Primary, fast path: any @nestjs/* dependency in package.json.
+        const packageJson = context.readFile('package.json');
+        if (packageJson) {
+            try {
+                const pkg = JSON.parse(packageJson);
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (Object.keys(deps).some((k) => k.startsWith('@nestjs/'))) {
+                    return true;
+                }
+            }
+            catch {
+                // Invalid JSON — fall through to the source scan.
+            }
+        }
+        // Fallback: NestJS-specific decorators in conventionally named files.
+        const allFiles = context.getAllFiles();
+        for (const file of allFiles) {
+            if (file.endsWith('.controller.ts') ||
+                file.endsWith('.controller.js') ||
+                file.endsWith('.module.ts') ||
+                file.endsWith('.resolver.ts') ||
+                file.endsWith('.gateway.ts')) {
+                const content = context.readFile(file);
+                if (content &&
+                    (content.includes('@nestjs/') ||
+                        content.includes('@Controller') ||
+                        content.includes('@Module(') ||
+                        content.includes('@Resolver(') ||
+                        content.includes('@WebSocketGateway('))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    },
+    resolve(ref, context) {
+        // Resolve provider/controller references (e.g. constructor-injected
+        // `UsersService`) to their class, preferring the Nest file-name
+        // convention (`*.service.ts`, `*.controller.ts`, …).
+        for (const [suffix, convention] of PROVIDER_CONVENTIONS) {
+            if (!suffix.test(ref.referenceName))
+                continue;
+            const candidates = context
+                .getNodesByName(ref.referenceName)
+                .filter((n) => n.kind === 'class');
+            if (candidates.length === 0)
+                return null;
+            const preferred = candidates.find((n) => n.filePath.includes(convention));
+            const target = preferred ?? candidates[0];
+            return {
+                original: ref,
+                targetNodeId: target.id,
+                confidence: preferred ? 0.85 : 0.7,
+                resolvedBy: 'framework',
+            };
+        }
+        return null;
+    },
+    extract(filePath, content) {
+        if (!/\.(m?js|tsx?|cjs)$/.test(filePath))
+            return { nodes: [], references: [] };
+        const nodes = [];
+        const references = [];
+        const now = Date.now();
+        const lang = detectLanguage(filePath);
+        const safe = (0, strip_comments_1.stripCommentsForRegex)(content, lang);
+        const addRoute = (index, method, path, length, handler) => {
+            const line = lineAt(safe, index);
+            const node = {
+                id: `route:${filePath}:${line}:${method}:${path}`,
+                kind: 'route',
+                name: `${method} ${path}`,
+                qualifiedName: `${filePath}::${method}:${path}`,
+                filePath,
+                startLine: line,
+                endLine: line,
+                startColumn: 0,
+                endColumn: length,
+                language: lang,
+                updatedAt: now,
+            };
+            nodes.push(node);
+            if (handler) {
+                references.push({
+                    fromNodeId: node.id,
+                    referenceName: handler,
+                    referenceKind: 'references',
+                    line,
+                    column: 0,
+                    filePath,
+                    language: lang,
+                });
+            }
+        };
+        const scopes = buildClassScopes(safe);
+        // HTTP routes: method decorator path joined onto the enclosing controller's prefix.
+        for (const hit of findDecorators(safe, HTTP_METHODS)) {
+            const scope = scopeFor(scopes, hit.index);
+            const prefix = scope && scope.kind === 'controller' ? scope.prefix : '';
+            const path = joinHttpPath(prefix, parseStringArg(hit.args));
+            addRoute(hit.index, hit.name.toUpperCase(), path, hit.length, methodNameAfter(safe, hit.end));
+        }
+        // GraphQL operations: only inside an @Resolver class (disambiguates the
+        // REST `@Query()` parameter decorator, which lives inside @Controller classes).
+        for (const hit of findDecorators(safe, GQL_OPS)) {
+            const scope = scopeFor(scopes, hit.index);
+            if (!scope || scope.kind !== 'resolver')
+                continue;
+            const handler = methodNameAfter(safe, hit.end);
+            const name = parseGraphqlName(hit.args, handler);
+            addRoute(hit.index, hit.name.toUpperCase(), name, hit.length, handler);
+        }
+        // Microservice message/event handlers.
+        for (const hit of findDecorators(safe, ['MessagePattern', 'EventPattern'])) {
+            const verb = hit.name === 'EventPattern' ? 'EVENT' : 'MESSAGE';
+            const handler = methodNameAfter(safe, hit.end);
+            addRoute(hit.index, verb, parseStringArg(hit.args) || handler || '', hit.length, handler);
+        }
+        // WebSocket message handlers, prefixed with the gateway namespace when present.
+        for (const hit of findDecorators(safe, ['SubscribeMessage'])) {
+            const scope = scopeFor(scopes, hit.index);
+            const namespace = scope && scope.kind === 'gateway' ? scope.prefix : '';
+            const handler = methodNameAfter(safe, hit.end);
+            const event = parseStringArg(hit.args) || handler || '';
+            addRoute(hit.index, 'WS', namespace ? `${namespace}:${event}` : event, hit.length, handler);
+        }
+        return { nodes, references };
+    },
+};
+// ---------------------------------------------------------------------------
+// Provider resolution conventions
+// ---------------------------------------------------------------------------
+const PROVIDER_CONVENTIONS = [
+    [/Service$/, '.service.'],
+    [/Controller$/, '.controller.'],
+    [/Resolver$/, '.resolver.'],
+    [/Gateway$/, '.gateway.'],
+    [/Repository$/, '.repository.'],
+    [/Guard$/, '.guard.'],
+    [/Interceptor$/, '.interceptor.'],
+    [/Pipe$/, '.pipe.'],
+    [/Module$/, '.module.'],
+];
+/**
+ * Find every `@Name(...)` decorator whose name is in `names`. Uses a
+ * string-aware balanced-paren reader for the argument list so type thunks
+ * like `@Query(() => [User])` are captured whole rather than truncated at the
+ * inner `()`.
+ */
+function findDecorators(safe, names) {
+    const hits = [];
+    const re = new RegExp(`@(${names.join('|')})\\s*\\(`, 'g');
+    let m;
+    while ((m = re.exec(safe)) !== null) {
+        const openIndex = m.index + m[0].length - 1; // position of '('
+        const parsed = readArgs(safe, openIndex);
+        if (!parsed)
+            continue;
+        hits.push({
+            name: m[1],
+            args: parsed.args,
+            index: m.index,
+            end: parsed.end,
+            length: parsed.end - m.index,
+        });
+        re.lastIndex = parsed.end; // resume past the args so nested text isn't re-scanned
+    }
+    return hits;
+}
+/**
+ * Read a balanced `(...)` starting at `openIndex` (which must point at `(`).
+ * String-aware, so parens inside string literals don't unbalance the count.
+ * Returns the inner text and the index just past the closing `)`.
+ */
+function readArgs(s, openIndex) {
+    if (s[openIndex] !== '(')
+        return null;
+    let depth = 0;
+    let inStr = null;
+    for (let i = openIndex; i < s.length; i++) {
+        const ch = s[i];
+        if (inStr) {
+            if (ch === '\\') {
+                i++;
+                continue;
+            }
+            if (ch === inStr)
+                inStr = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            inStr = ch;
+            continue;
+        }
+        if (ch === '(')
+            depth++;
+        else if (ch === ')') {
+            depth--;
+            if (depth === 0)
+                return { args: s.slice(openIndex + 1, i), end: i + 1 };
+        }
+    }
+    return null;
+}
+/**
+ * Starting just after a method decorator's `)`, return the name of the method
+ * it decorates. Skips any further stacked decorators (`@UseGuards(...)`,
+ * `@HttpCode(204)`, …) and access/async modifiers in between.
+ */
+function methodNameAfter(safe, start) {
+    let i = start;
+    const ws = /\s*/y;
+    const decoName = /@[\w.]+/y;
+    const modifier = /(?:public|private|protected|async|static)\b/y;
+    const ident = /([A-Za-z_$][\w$]*)\s*\(/y;
+    const eatWs = () => {
+        ws.lastIndex = i;
+        if (ws.exec(safe))
+            i = ws.lastIndex;
+    };
+    // Skip stacked decorators.
+    for (;;) {
+        eatWs();
+        if (safe[i] !== '@')
+            break;
+        decoName.lastIndex = i;
+        if (!decoName.exec(safe))
+            break;
+        i = decoName.lastIndex;
+        eatWs();
+        if (safe[i] === '(') {
+            const parsed = readArgs(safe, i);
+            if (!parsed)
+                return null;
+            i = parsed.end;
+        }
+    }
+    // Skip access/async/static modifiers.
+    for (;;) {
+        eatWs();
+        modifier.lastIndex = i;
+        if (modifier.exec(safe) && modifier.lastIndex > i) {
+            i = modifier.lastIndex;
+            continue;
+        }
+        break;
+    }
+    eatWs();
+    ident.lastIndex = i;
+    const m = ident.exec(safe);
+    return m ? m[1] : null;
+}
+/**
+ * Build the list of class-level decorator scopes, sorted by position. Each
+ * scope runs from its decorator up to the next class decorator (of any kind),
+ * which lets a method decorator find its enclosing class regardless of how
+ * many classes share a file.
+ */
+function buildClassScopes(safe) {
+    const defs = [
+        { kind: 'controller', name: 'Controller', prefixOf: parseControllerPrefix },
+        { kind: 'resolver', name: 'Resolver', prefixOf: () => '' },
+        { kind: 'gateway', name: 'WebSocketGateway', prefixOf: parseGatewayNamespace },
+        { kind: 'other', name: 'Injectable', prefixOf: () => '' },
+        { kind: 'other', name: 'Module', prefixOf: () => '' },
+        { kind: 'other', name: 'Catch', prefixOf: () => '' },
+    ];
+    const raw = [];
+    for (const def of defs) {
+        for (const hit of findDecorators(safe, [def.name])) {
+            raw.push({ kind: def.kind, prefix: def.prefixOf(hit.args), index: hit.index });
+        }
+    }
+    raw.sort((a, b) => a.index - b.index);
+    return raw.map((r, i) => ({
+        kind: r.kind,
+        prefix: r.prefix,
+        start: r.index,
+        end: i + 1 < raw.length ? raw[i + 1].index : safe.length,
+    }));
+}
+function scopeFor(scopes, index) {
+    for (const s of scopes) {
+        if (index >= s.start && index < s.end)
+            return s;
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+/** First string literal anywhere in the args, or '' (covers `'x'`, `{ k: 'x' }`). */
+function parseStringArg(args) {
+    const m = args.match(/['"`]([^'"`]*)['"`]/);
+    return m ? m[1] : '';
+}
+/** `@Controller('users')` | `@Controller({ path: 'users', host })` | `@Controller(['a','b'])` | `@Controller()`. */
+function parseControllerPrefix(args) {
+    const obj = args.match(/path\s*:\s*['"`]([^'"`]*)['"`]/);
+    if (obj)
+        return obj[1];
+    return parseStringArg(args);
+}
+/** `@WebSocketGateway({ namespace: 'chat' })` | `@WebSocketGateway(81, { namespace: '/chat' })` | `@WebSocketGateway()`. */
+function parseGatewayNamespace(args) {
+    const m = args.match(/namespace\s*:\s*['"`]([^'"`]*)['"`]/);
+    return m ? m[1] : '';
+}
+/**
+ * GraphQL operation name. Prefers an explicit `{ name: 'x' }` or a leading
+ * string literal (`@Query('users')`); otherwise the field name defaults to the
+ * handler method name. Avoids mistaking a `description` string for the name.
+ */
+function parseGraphqlName(args, handler) {
+    const named = args.match(/name\s*:\s*['"`]([^'"`]*)['"`]/);
+    if (named)
+        return named[1];
+    const lead = args.match(/^\s*['"`]([^'"`]*)['"`]/);
+    if (lead)
+        return lead[1];
+    return handler ?? '';
+}
+// ---------------------------------------------------------------------------
+// Path helpers
+// ---------------------------------------------------------------------------
+/** Join a controller prefix and method path into a single normalised `/path`. */
+function joinHttpPath(prefix, sub) {
+    const parts = [prefix, sub]
+        .map((p) => p.trim().replace(/^\/+|\/+$/g, ''))
+        .filter((p) => p.length > 0);
+    return '/' + parts.join('/');
+}
+function lineAt(safe, index) {
+    return safe.slice(0, index).split('\n').length;
+}
+function detectLanguage(filePath) {
+    if (filePath.endsWith('.ts') || filePath.endsWith('.tsx'))
+        return 'typescript';
+    return 'javascript';
+}
+//# sourceMappingURL=nestjs.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Python Framework Resolver
+ *
+ * Handles Django, Flask, and FastAPI patterns.
+ */
+import { FrameworkResolver } from '../types'
+export declare const djangoResolver: FrameworkResolver
+export declare const flaskResolver: FrameworkResolver
+export declare const fastapiResolver: FrameworkResolver
+//# sourceMappingURL=python.d.ts.map