@shrkcrft/framework-scanners 0.1.0-alpha.10

package/dist/extractors/laravel-extractor.js

@@ -0,0 +1,208 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const LARAVEL_EXTRACTOR_SOURCE = 'laravel-extractor@v1';
+const ROUTE_VERBS = new Set(['get', 'post', 'put', 'patch', 'delete', 'options', 'any', 'match']);
+const FAST_FILTER_NEEDLES = [
+    'Illuminate\\',
+    'extends Controller',
+    'extends Model',
+    'extends Authenticatable',
+    'extends JsonResource',
+    'Route::',
+];
+/**
+ * Laravel framework extractor.
+ *
+ * Regex-only. Detection:
+ *   - Class extending `Controller` / `BaseController` / `RestController` → controller.
+ *   - Class extending `Model` / `Authenticatable` / `Pivot` → model.
+ *   - Class extending `JsonResource` / `ResourceCollection` → resource.
+ *   - `Route::get('/path', [Controller::class, 'action'])` (and other verbs) → route.
+ *   - `Route::resource('users', UserController::class)` → route (RESOURCE).
+ *
+ * Inside controllers, every `public function name(...)` becomes an
+ * action entity wired back to the controller via `HandlesRoute`.
+ *
+ * Out of scope:
+ *   - Route groups (`Route::middleware(...)->group(function () { … })`)
+ *   - Model relations (hasMany, belongsTo, …).
+ *   - Blade templates.
+ */
+export const laravelExtractor = {
+    framework: 'laravel',
+    label: 'Laravel',
+    fileMatches({ path, content }) {
+        if (!path.endsWith('.php'))
+            return false;
+        for (const needle of FAST_FILTER_NEEDLES) {
+            if (content.includes(needle))
+                return true;
+        }
+        return false;
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const lines = input.content.split('\n');
+        let currentControllerEntity;
+        // Stack of route-group prefixes from chained Route::prefix(...)->group
+        // and Route::middleware(...)->group(...) calls. A `->group(function`
+        // line pushes a captured prefix (empty when only middleware is
+        // applied), and the closing `});` pops.
+        const groupPrefixStack = [];
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            const trimmed = raw.trimStart();
+            // Detect group opens: e.g. `Route::prefix('/api')->group(function () {`
+            // or `Route::middleware(['auth'])->prefix('/v1')->group(function () {`.
+            // We pull the first `prefix('/x')` we see on the line if any; absent
+            // prefix → empty string.
+            const groupOpen = /->group\s*\(\s*function/.test(trimmed) && /Route::/.test(trimmed);
+            if (groupOpen) {
+                // `Route::prefix('/api')` (initial call) and chained
+                // `->prefix('/v1')` both need to be captured. We pick the
+                // first prefix on the line (outermost wins for nested
+                // chains).
+                const prefMatch = /(?:Route::|->)\s*prefix\s*\(\s*['"]([^'"]+)['"]/.exec(trimmed);
+                const prefix = prefMatch ? prefMatch[1] : '';
+                groupPrefixStack.push(prefix);
+                continue;
+            }
+            // Closing `});` (typical for the group callback). Pop the
+            // innermost prefix.
+            if (groupPrefixStack.length > 0 && /^\}\s*\)\s*;?\s*$/.test(trimmed)) {
+                groupPrefixStack.pop();
+                continue;
+            }
+            // class FooController extends Controller
+            let m = /^(?:abstract\s+|final\s+)*class\s+([A-Z]\w*)\s+extends\s+(\w+)/.exec(trimmed);
+            if (m) {
+                const className = m[1];
+                const baseClass = m[2];
+                if (/(?:^|[A-Za-z])Controller$/.test(baseClass) || /BaseController$/.test(baseClass)) {
+                    const e = makeEntity(input, 'controller', className, { className, baseClass });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'controller', line: i + 1 }));
+                    currentControllerEntity = e;
+                    continue;
+                }
+                if (baseClass === 'Model' || baseClass === 'Authenticatable' || baseClass === 'Pivot') {
+                    const e = makeEntity(input, 'model', className, { className, baseClass });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'model', line: i + 1 }));
+                    continue;
+                }
+                if (baseClass === 'JsonResource' || baseClass === 'ResourceCollection') {
+                    const e = makeEntity(input, 'resource', className, { className, baseClass });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'resource', line: i + 1 }));
+                    continue;
+                }
+                // Unrelated class — stop the controller-action capture.
+                currentControllerEntity = undefined;
+                continue;
+            }
+            // Closing `}` at column 0 ends the class body.
+            if (raw === '}' || raw.trimEnd() === '}') {
+                currentControllerEntity = undefined;
+            }
+            // Public action methods inside a controller body.
+            if (currentControllerEntity) {
+                m = /^\s+public\s+function\s+([a-zA-Z_]\w*)\s*\(/.exec(raw);
+                if (m && !m[1].startsWith('__')) {
+                    const action = m[1];
+                    const e = makeEntity(input, 'action', action, {
+                        controller: currentControllerEntity.label,
+                        action,
+                    });
+                    nodes.push(e);
+                    edges.push(edge(currentControllerEntity.id, e.id, EdgeKind.HandlesRoute, {
+                        controller: currentControllerEntity.label,
+                        action,
+                    }));
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'action', line: i + 1 }));
+                }
+            }
+            // Route registrations: Route::get('/path', [Ctrl::class, 'action'])
+            // or Route::get('/path', 'Ctrl@action') or Route::resource('x', Ctrl::class)
+            const verbMatch = /Route::(\w+)\s*\(\s*['"]([^'"]+)['"]\s*(?:,\s*(?:\[([^\]]+)\]|['"]([^'"]+)['"]|([A-Z]\w*)::class))?/.exec(trimmed);
+            if (verbMatch) {
+                const verb = verbMatch[1];
+                const localPath = verbMatch[2];
+                const groupPrefix = combinePrefixes(groupPrefixStack);
+                if (verb === 'resource' || verb === 'apiResource') {
+                    // Three possible target shapes: array, string, or bare `Foo::class`.
+                    const target = verbMatch[5] ?? verbMatch[4] ?? verbMatch[3] ?? '';
+                    const r = makeRouteEntity(input, verb.toUpperCase(), `${groupPrefix}/${localPath}`, target);
+                    nodes.push(r);
+                    edges.push(edge(input.fileNodeId, r.id, EdgeKind.FrameworkDeclares, { subtype: 'route', line: i + 1 }));
+                    continue;
+                }
+                if (!ROUTE_VERBS.has(verb))
+                    continue;
+                const verbUpper = verb.toUpperCase();
+                let target = verbMatch[4] ?? '';
+                if (verbMatch[3]) {
+                    // Array form `[Ctrl::class, 'method']`.
+                    const inside = verbMatch[3];
+                    const ctrlM = /([A-Z]\w*)::class\s*,\s*['"]([^'"]+)['"]/.exec(inside);
+                    if (ctrlM)
+                        target = `${ctrlM[1]}@${ctrlM[2]}`;
+                }
+                const path = combinePathWithGroup(groupPrefix, localPath);
+                const r = makeRouteEntity(input, verbUpper, path, target);
+                nodes.push(r);
+                edges.push(edge(input.fileNodeId, r.id, EdgeKind.FrameworkDeclares, { subtype: 'route', line: i + 1 }));
+            }
+        }
+        return { nodes, edges };
+    },
+};
+function makeEntity(input, subtype, label, extra) {
+    return {
+        id: `framework:laravel:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['laravel', subtype],
+        data: { framework: 'laravel', subtype, ...extra },
+    };
+}
+function makeRouteEntity(input, method, path, target) {
+    return {
+        id: `framework:laravel:route:${input.filePath}#${method}:${path}#${target}`,
+        kind: NodeKind.FrameworkEntity,
+        label: `${method} ${path}${target ? ` → ${target}` : ''}`,
+        path: input.filePath,
+        tags: ['laravel', 'route'],
+        data: { framework: 'laravel', subtype: 'route', method, path, target },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: LARAVEL_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}
+/**
+ * Combine the prefix stack (innermost first → joined left-to-right) into
+ * a single leading prefix. Returns '' when no group is active.
+ */
+function combinePrefixes(stack) {
+    const parts = stack
+        .map((s) => s.replace(/^\//, '').replace(/\/$/, ''))
+        .filter((s) => s.length > 0);
+    if (parts.length === 0)
+        return '';
+    return '/' + parts.join('/');
+}
+function combinePathWithGroup(prefix, leaf) {
+    if (!prefix)
+        return leaf;
+    const cleanLeaf = leaf.startsWith('/') ? leaf : '/' + leaf;
+    return prefix + cleanLeaf;
+}

package/dist/extractors/nestjs-extractor.d.ts

@@ -0,0 +1,18 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const NESTJS_EXTRACTOR_SOURCE = "nestjs-extractor@v1";
+/**
+ * NestJS extractor.
+ *
+ * Emits FrameworkEntity nodes (controller / module / provider / route)
+ * and connecting edges (FrameworkDeclares from file → entity;
+ * HandlesRoute from controller → route).
+ *
+ * Class-level entities are detected by their decorator names; route
+ * methods are detected by HTTP-method decorators on class members.
+ * Constructor-injection edges are out of scope for the MVP — they're
+ * encoded as a `data.injects` field on the consumer node instead, so
+ * later rounds can promote them to edges without changing the
+ * detection logic.
+ */
+export declare const nestjsExtractor: IFrameworkExtractor;
+//# sourceMappingURL=nestjs-extractor.d.ts.map

package/dist/extractors/nestjs-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestjs-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/nestjs-extractor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAe7D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,EAAE,mBAwE7B,CAAC"}

package/dist/extractors/nestjs-extractor.js

@@ -0,0 +1,222 @@
+import { createHash } from 'node:crypto';
+import * as nodePath from 'node:path';
+import * as ts from 'typescript';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const NESTJS_EXTRACTOR_SOURCE = 'nestjs-extractor@v1';
+const HTTP_METHOD_DECORATORS = new Set([
+    'Get',
+    'Post',
+    'Put',
+    'Delete',
+    'Patch',
+    'Options',
+    'Head',
+    'All',
+]);
+const FAST_FILTER_NEEDLES = ['@Controller', '@Module', '@Injectable', "from '@nestjs/"];
+/**
+ * NestJS extractor.
+ *
+ * Emits FrameworkEntity nodes (controller / module / provider / route)
+ * and connecting edges (FrameworkDeclares from file → entity;
+ * HandlesRoute from controller → route).
+ *
+ * Class-level entities are detected by their decorator names; route
+ * methods are detected by HTTP-method decorators on class members.
+ * Constructor-injection edges are out of scope for the MVP — they're
+ * encoded as a `data.injects` field on the consumer node instead, so
+ * later rounds can promote them to edges without changing the
+ * detection logic.
+ */
+export const nestjsExtractor = {
+    framework: 'nestjs',
+    label: 'NestJS',
+    fileMatches({ path, content }) {
+        if (!/\.(?:t|j)sx?$/.test(path))
+            return false;
+        for (const needle of FAST_FILTER_NEEDLES) {
+            if (content.includes(needle))
+                return true;
+        }
+        return false;
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const sf = parse(input);
+        if (!sf)
+            return { nodes, edges };
+        const visit = (node) => {
+            if (ts.isClassDeclaration(node) && node.name) {
+                const decorators = collectDecorators(node);
+                if (decorators.length === 0) {
+                    ts.forEachChild(node, visit);
+                    return;
+                }
+                const ctrl = decorators.find((d) => d.name === 'Controller');
+                const mod = decorators.find((d) => d.name === 'Module');
+                const inj = decorators.find((d) => d.name === 'Injectable');
+                if (ctrl) {
+                    const basePath = readFirstStringArg(ctrl.callArguments) ?? '';
+                    const entity = makeEntity(input, node, 'controller', { basePath });
+                    nodes.push(entity);
+                    edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype: 'controller' }));
+                    // Walk methods to find routes.
+                    for (const member of node.members) {
+                        if (!ts.isMethodDeclaration(member) || !member.name)
+                            continue;
+                        if (!ts.isIdentifier(member.name))
+                            continue;
+                        const methodDecorators = collectDecorators(member);
+                        for (const d of methodDecorators) {
+                            if (!HTTP_METHOD_DECORATORS.has(d.name))
+                                continue;
+                            const subPath = readFirstStringArg(d.callArguments) ?? '';
+                            const fullPath = joinRoute(basePath, subPath);
+                            const route = makeRouteEntity(input, node, member, {
+                                method: d.name.toUpperCase(),
+                                path: fullPath,
+                            });
+                            nodes.push(route);
+                            edges.push(edge(entity.id, route.id, EdgeKind.HandlesRoute, {
+                                method: d.name.toUpperCase(),
+                                path: fullPath,
+                            }));
+                            edges.push(edge(input.fileNodeId, route.id, EdgeKind.FrameworkDeclares, { subtype: 'route' }));
+                        }
+                    }
+                }
+                else if (mod) {
+                    const entity = makeEntity(input, node, 'module', {
+                        imports: readArrayProperty(mod.callArguments, 'imports'),
+                        providers: readArrayProperty(mod.callArguments, 'providers'),
+                        controllers: readArrayProperty(mod.callArguments, 'controllers'),
+                        exports: readArrayProperty(mod.callArguments, 'exports'),
+                    });
+                    nodes.push(entity);
+                    edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype: 'module' }));
+                }
+                else if (inj) {
+                    const entity = makeEntity(input, node, 'provider', {});
+                    nodes.push(entity);
+                    edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype: 'provider' }));
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(sf, visit);
+        return { nodes, edges };
+    },
+};
+function collectDecorators(node) {
+    if (!ts.canHaveDecorators(node))
+        return [];
+    const decorators = ts.getDecorators(node) ?? [];
+    const out = [];
+    for (const d of decorators) {
+        const expr = d.expression;
+        if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+            out.push({ name: expr.expression.text, callArguments: expr.arguments });
+        }
+        else if (ts.isIdentifier(expr)) {
+            out.push({ name: expr.text });
+        }
+    }
+    return out;
+}
+function readFirstStringArg(args) {
+    if (!args || args.length === 0)
+        return undefined;
+    const a = args[0];
+    if (a && ts.isStringLiteral(a))
+        return a.text;
+    return undefined;
+}
+function readArrayProperty(args, name) {
+    if (!args || args.length === 0)
+        return [];
+    const a = args[0];
+    if (!a || !ts.isObjectLiteralExpression(a))
+        return [];
+    for (const prop of a.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        if (!ts.isIdentifier(prop.name) || prop.name.text !== name)
+            continue;
+        if (!ts.isArrayLiteralExpression(prop.initializer))
+            continue;
+        const out = [];
+        for (const el of prop.initializer.elements) {
+            if (ts.isIdentifier(el))
+                out.push(el.text);
+        }
+        return out;
+    }
+    return [];
+}
+function joinRoute(base, sub) {
+    const b = base.replace(/\/+$/, '');
+    const s = sub.replace(/^\/+/, '');
+    if (!b && !s)
+        return '/';
+    if (!b)
+        return '/' + s;
+    if (!s)
+        return '/' + b.replace(/^\/+/, '');
+    return '/' + b.replace(/^\/+/, '') + '/' + s;
+}
+function makeEntity(input, cls, subtype, extra) {
+    const name = cls.name?.text ?? 'Anonymous';
+    const id = `framework:nestjs:${subtype}:${input.filePath}#${name}`;
+    return {
+        id,
+        kind: NodeKind.FrameworkEntity,
+        label: name,
+        path: input.filePath,
+        tags: ['nestjs', subtype],
+        data: { framework: 'nestjs', subtype, className: name, ...extra },
+    };
+}
+function makeRouteEntity(input, cls, member, data) {
+    const className = cls.name?.text ?? 'Anonymous';
+    const methodName = (member.name && ts.isIdentifier(member.name)) ? member.name.text : 'handler';
+    const id = `framework:nestjs:route:${input.filePath}#${className}.${methodName}#${data.method}:${data.path}`;
+    return {
+        id,
+        kind: NodeKind.FrameworkEntity,
+        label: `${data.method} ${data.path}`,
+        path: input.filePath,
+        tags: ['nestjs', 'route'],
+        data: {
+            framework: 'nestjs',
+            subtype: 'route',
+            className,
+            handler: methodName,
+            method: data.method,
+            path: data.path,
+        },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: NESTJS_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}
+function parse(input) {
+    const ext = nodePath.extname(input.filePath).toLowerCase();
+    const kind = ext === '.tsx' ? ts.ScriptKind.TSX
+        : ext === '.jsx' ? ts.ScriptKind.JSX
+            : ext === '.js' || ext === '.mjs' || ext === '.cjs' ? ts.ScriptKind.JS
+                : ts.ScriptKind.TS;
+    try {
+        return ts.createSourceFile(input.filePath, input.content, ts.ScriptTarget.Latest, true, kind);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/extractors/nextjs-extractor.d.ts

@@ -0,0 +1,19 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const NEXTJS_EXTRACTOR_SOURCE = "nextjs-extractor@v1";
+/**
+ * Next.js extractor.
+ *
+ * Detects:
+ *   - App-router files: `app/**\/page.tsx`, `layout.tsx`, `route.ts`,
+ *     etc. The route path is derived from the file location, ignoring
+ *     route groups `(...)` and parallel routes `@...`. `route.ts`
+ *     additionally inspects the content for exported HTTP method names
+ *     to emit per-method route entities.
+ *   - Pages-router files: `pages/foo.tsx` → `/foo`, `pages/[id].tsx` →
+ *     `/:id`. `pages/api/*.ts` becomes `api-route` entities.
+ *
+ * No content-shape detection — Next.js conventions are entirely
+ * filesystem-based for routing.
+ */
+export declare const nextjsExtractor: IFrameworkExtractor;
+//# sourceMappingURL=nextjs-extractor.d.ts.map

package/dist/extractors/nextjs-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/nextjs-extractor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAY7D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,EAAE,mBAwE7B,CAAC"}

package/dist/extractors/nextjs-extractor.js

@@ -0,0 +1,175 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const NEXTJS_EXTRACTOR_SOURCE = 'nextjs-extractor@v1';
+// Path-based detection only — Next.js entities are defined by file
+// LOCATION more than by file content. We still emit content-derived
+// metadata (e.g. exported HTTP method names for app-router route.ts).
+const APP_ROUTER_RE = /(?:^|\/)app\/(?:.*\/)?(page|layout|route|loading|error|not-found|template|head)\.(?:tsx?|jsx?)$/;
+const PAGES_ROUTER_RE = /(?:^|\/)pages\/(?!_app|_document|_error|api\/)(.+?)\.(?:tsx?|jsx?)$/;
+const PAGES_API_RE = /(?:^|\/)pages\/api\/(.+?)\.(?:tsx?|jsx?)$/;
+const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+/**
+ * Next.js extractor.
+ *
+ * Detects:
+ *   - App-router files: `app/**\/page.tsx`, `layout.tsx`, `route.ts`,
+ *     etc. The route path is derived from the file location, ignoring
+ *     route groups `(...)` and parallel routes `@...`. `route.ts`
+ *     additionally inspects the content for exported HTTP method names
+ *     to emit per-method route entities.
+ *   - Pages-router files: `pages/foo.tsx` → `/foo`, `pages/[id].tsx` →
+ *     `/:id`. `pages/api/*.ts` becomes `api-route` entities.
+ *
+ * No content-shape detection — Next.js conventions are entirely
+ * filesystem-based for routing.
+ */
+export const nextjsExtractor = {
+    framework: 'nextjs',
+    label: 'Next.js',
+    fileMatches({ path }) {
+        return APP_ROUTER_RE.test(path) || PAGES_ROUTER_RE.test(path) || PAGES_API_RE.test(path);
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const appMatch = APP_ROUTER_RE.exec(input.filePath);
+        if (appMatch) {
+            const role = appMatch[1];
+            const routePath = appRouteFromPath(input.filePath);
+            if (role === 'route') {
+                // route.ts — one entity per exported HTTP method.
+                const methods = detectExportedHttpMethods(input.content);
+                if (methods.length === 0) {
+                    // Still emit a placeholder route entity so the file is
+                    // surfaced; consumers see the empty method list.
+                    const e = makeEntity(input, 'route', `route ${routePath}`, { kind: 'app-route', routePath, methods: [] });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'route' }));
+                }
+                else {
+                    for (const method of methods) {
+                        const e = makeEntity(input, 'route', `${method} ${routePath}`, {
+                            kind: 'app-route',
+                            routePath,
+                            method,
+                        });
+                        nodes.push(e);
+                        edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'route' }));
+                    }
+                }
+            }
+            else {
+                const subtype = role; // 'page' | 'layout' | 'error' | …
+                const e = makeEntity(input, subtype, `${subtype} ${routePath}`, {
+                    kind: `app-${subtype}`,
+                    routePath,
+                });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype }));
+            }
+            return { nodes, edges };
+        }
+        const apiMatch = PAGES_API_RE.exec(input.filePath);
+        if (apiMatch) {
+            const routePath = '/api/' + normalizePagesPath(apiMatch[1]);
+            const e = makeEntity(input, 'api-route', `API ${routePath}`, {
+                kind: 'pages-api',
+                routePath,
+            });
+            nodes.push(e);
+            edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'api-route' }));
+            return { nodes, edges };
+        }
+        const pageMatch = PAGES_ROUTER_RE.exec(input.filePath);
+        if (pageMatch) {
+            const routePath = '/' + normalizePagesPath(pageMatch[1]);
+            const e = makeEntity(input, 'page', `page ${routePath}`, {
+                kind: 'pages-route',
+                routePath,
+            });
+            nodes.push(e);
+            edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'page' }));
+            return { nodes, edges };
+        }
+        return { nodes, edges };
+    },
+};
+function appRouteFromPath(filePath) {
+    // Slice from the first `app/` segment onward, strip the filename,
+    // and remove route groups + parallel route segments.
+    const idx = filePath.indexOf('/app/');
+    if (idx === -1)
+        return '/';
+    const tail = filePath.slice(idx + '/app'.length);
+    const dirOnly = tail.replace(/\/[^/]+$/, '');
+    const segments = dirOnly.split('/').filter((s) => s.length > 0);
+    const out = [];
+    for (const seg of segments) {
+        // Route groups `(marketing)` are ignored.
+        if (/^\(.+\)$/.test(seg))
+            continue;
+        // Parallel routes `@modal` are ignored.
+        if (seg.startsWith('@'))
+            continue;
+        // Dynamic segments `[id]` → `:id`, `[...slug]` → `*`, `[[...slug]]` → `*?`.
+        if (/^\[\[\.\.\..+\]\]$/.test(seg))
+            out.push('*?');
+        else if (/^\[\.\.\..+\]$/.test(seg))
+            out.push('*');
+        else if (/^\[.+\]$/.test(seg))
+            out.push(':' + seg.slice(1, -1));
+        else
+            out.push(seg);
+    }
+    return out.length === 0 ? '/' : '/' + out.join('/');
+}
+function normalizePagesPath(p) {
+    // Strip trailing 'index'; map [id] → :id, etc. Same convention as
+    // appRouteFromPath but for the pages-router filename pattern.
+    const parts = p.split('/').filter((s) => s.length > 0);
+    const out = [];
+    for (let i = 0; i < parts.length; i += 1) {
+        const seg = parts[i];
+        if (i === parts.length - 1 && seg === 'index')
+            continue;
+        if (/^\[\[\.\.\..+\]\]$/.test(seg))
+            out.push('*?');
+        else if (/^\[\.\.\..+\]$/.test(seg))
+            out.push('*');
+        else if (/^\[.+\]$/.test(seg))
+            out.push(':' + seg.slice(1, -1));
+        else
+            out.push(seg);
+    }
+    return out.join('/');
+}
+function detectExportedHttpMethods(content) {
+    const found = [];
+    for (const method of HTTP_METHODS) {
+        // `export async function GET(...)`, `export function POST(`, `export const PUT = …`.
+        const re = new RegExp(`export\\s+(?:async\\s+)?(?:function\\s+|const\\s+)${method}\\b`);
+        if (re.test(content))
+            found.push(method);
+    }
+    return found;
+}
+function makeEntity(input, subtype, label, data) {
+    return {
+        id: `framework:nextjs:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['nextjs', subtype],
+        data: { framework: 'nextjs', subtype, ...data },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: NEXTJS_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

package/dist/extractors/phoenix-extractor.d.ts

@@ -0,0 +1,28 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const PHOENIX_EXTRACTOR_SOURCE = "phoenix-extractor@v1";
+/**
+ * Phoenix extractor.
+ *
+ * Regex-only. Detection:
+ *
+ *   - **Controller**: `defmodule X do` followed by
+ *     `use AppWeb, :controller` OR `use Phoenix.Controller` →
+ *     controller entity. Public `def action(conn, params)` inside →
+ *     action entities.
+ *
+ *   - **Router**: any module with `use Phoenix.Router` (or
+ *     `use AppWeb, :router`). Parses top-level `get|post|...
+ *     "/path", Controller, :action` lines → route entities.
+ *
+ *   - **Schema**: `use Ecto.Schema` → schema entity (subtype: model).
+ *
+ *   - **LiveView / LiveComponent**: `use Phoenix.LiveView` /
+ *     `use Phoenix.LiveComponent` → component entity.
+ *
+ * Out of scope:
+ *   - `pipeline :foo do ... end` aggregations.
+ *   - `scope "/path", AppWeb do ... end` prefix nesting.
+ *   - Channel modules.
+ */
+export declare const phoenixExtractor: IFrameworkExtractor;
+//# sourceMappingURL=phoenix-extractor.d.ts.map