@shrkcrft/framework-scanners 0.1.0-alpha.10

package/dist/extractor-api/extractor-registry.d.ts

@@ -0,0 +1,19 @@
+import type { IFrameworkExtractor } from './framework-extractor.js';
+/**
+ * Registry of framework extractors. The runner registers the built-in
+ * extractors at startup; pack-contributed extractors can register
+ * later via `register(...)`.
+ */
+export declare class FrameworkExtractorRegistry {
+    private readonly byName;
+    register(extractor: IFrameworkExtractor): void;
+    list(): readonly IFrameworkExtractor[];
+    applicable(file: {
+        path: string;
+        content: string;
+    }): readonly IFrameworkExtractor[];
+    has(framework: string): boolean;
+    get(framework: string): IFrameworkExtractor | undefined;
+    size(): number;
+}
+//# sourceMappingURL=extractor-registry.d.ts.map

package/dist/extractor-api/extractor-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor-registry.d.ts","sourceRoot":"","sources":["../../src/extractor-api/extractor-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE;;;;GAIG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0C;IAEjE,QAAQ,CAAC,SAAS,EAAE,mBAAmB,GAAG,IAAI;IAO9C,IAAI,IAAI,SAAS,mBAAmB,EAAE;IAItC,UAAU,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,mBAAmB,EAAE;IAUnF,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIvD,IAAI,IAAI,MAAM;CAGf"}

package/dist/extractor-api/extractor-registry.js

@@ -0,0 +1,36 @@
+/**
+ * Registry of framework extractors. The runner registers the built-in
+ * extractors at startup; pack-contributed extractors can register
+ * later via `register(...)`.
+ */
+export class FrameworkExtractorRegistry {
+    byName = new Map();
+    register(extractor) {
+        if (this.byName.has(extractor.framework)) {
+            throw new Error(`framework extractor already registered: ${extractor.framework}`);
+        }
+        this.byName.set(extractor.framework, extractor);
+    }
+    list() {
+        return [...this.byName.values()].sort((a, b) => a.framework.localeCompare(b.framework));
+    }
+    applicable(file) {
+        return this.list().filter((e) => {
+            try {
+                return e.fileMatches(file);
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    has(framework) {
+        return this.byName.has(framework);
+    }
+    get(framework) {
+        return this.byName.get(framework);
+    }
+    size() {
+        return this.byName.size;
+    }
+}

package/dist/extractor-api/framework-extractor.d.ts

@@ -0,0 +1,48 @@
+import type { IEdge, INode } from '@shrkcrft/graph';
+import type { FrameworkName } from '../schema/framework-schema.js';
+/**
+ * Plugin contract for a framework extractor.
+ *
+ * Each extractor inspects a single source file and returns the
+ * framework-specific nodes + edges it produces. The runner walks the
+ * project, applies every extractor whose `fileMatches` returns true,
+ * dedupes, and writes the result to the framework store.
+ *
+ * Extractors must be **side-effect free** and deterministic. They take
+ * file path + content and return data — no fs writes, no caching of
+ * their own.
+ */
+export interface IFrameworkExtractor {
+    /** Stable name (e.g. 'nestjs', 'react'). */
+    framework: FrameworkName;
+    /** Display label for diagnostics. */
+    label: string;
+    /**
+     * Fast pre-filter: should the AST extractor pass run for this file?
+     * Typically checks the path (e.g. `*.tsx`) and/or content fingerprint
+     * (e.g. presence of `'@nestjs/common'` import or JSX).
+     */
+    fileMatches(file: {
+        path: string;
+        content: string;
+    }): boolean;
+    /**
+     * Run the full extraction against the file. Called only when
+     * `fileMatches` returns true. Errors raised here are converted to
+     * diagnostics by the runner — never propagated out of an index build.
+     */
+    extract(input: IExtractInput): IExtractOutput;
+}
+export interface IExtractInput {
+    /** Project-relative POSIX path. */
+    filePath: string;
+    /** File contents. */
+    content: string;
+    /** Code-graph node id for the file (`file:<path>`). */
+    fileNodeId: string;
+}
+export interface IExtractOutput {
+    nodes: readonly INode[];
+    edges: readonly IEdge[];
+}
+//# sourceMappingURL=framework-extractor.d.ts.map

package/dist/extractor-api/framework-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-extractor.d.ts","sourceRoot":"","sources":["../../src/extractor-api/framework-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,4CAA4C;IAC5C,SAAS,EAAE,aAAa,CAAC;IACzB,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;IAC9D;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAAC;CAC/C;AAED,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,KAAK,EAAE,CAAC;IACxB,KAAK,EAAE,SAAS,KAAK,EAAE,CAAC;CACzB"}

package/dist/extractor-api/framework-extractor.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const ANGULAR_EXTRACTOR_SOURCE = "angular-extractor@v1";
+/**
+ * Angular extractor.
+ *
+ * Detects classes carrying any of the @Component / @Directive / @Pipe /
+ * @Injectable / @NgModule decorators. Emits one `FrameworkEntity` per
+ * decorated class, with the subtype derived from the decorator name.
+ *
+ * Component-specific metadata (selector, standalone, templateUrl) is
+ * lifted into `data` so the agent / dashboard can render it without a
+ * second AST walk.
+ *
+ * Out of scope (Wave 7 follow-up): template parsing, DI graph between
+ * services, route configurations. Each is its own pass.
+ */
+export declare const angularExtractor: IFrameworkExtractor;
+//# sourceMappingURL=angular-extractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"angular-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/angular-extractor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAoB/D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,EAAE,mBAqC9B,CAAC"}

package/dist/extractors/angular-extractor.js

@@ -0,0 +1,175 @@
+import { createHash } from 'node:crypto';
+import * as nodePath from 'node:path';
+import * as ts from 'typescript';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const ANGULAR_EXTRACTOR_SOURCE = 'angular-extractor@v1';
+const FAST_FILTER_NEEDLES = [
+    "from '@angular/core'",
+    'from "@angular/core"',
+    '@Component',
+    '@Directive',
+    '@NgModule',
+    '@Injectable',
+    '@Pipe',
+];
+const DECORATOR_TO_SUBTYPE = {
+    Component: 'component',
+    Directive: 'directive',
+    Pipe: 'pipe',
+    Injectable: 'service',
+    NgModule: 'module',
+};
+/**
+ * Angular extractor.
+ *
+ * Detects classes carrying any of the @Component / @Directive / @Pipe /
+ * @Injectable / @NgModule decorators. Emits one `FrameworkEntity` per
+ * decorated class, with the subtype derived from the decorator name.
+ *
+ * Component-specific metadata (selector, standalone, templateUrl) is
+ * lifted into `data` so the agent / dashboard can render it without a
+ * second AST walk.
+ *
+ * Out of scope (Wave 7 follow-up): template parsing, DI graph between
+ * services, route configurations. Each is its own pass.
+ */
+export const angularExtractor = {
+    framework: 'angular',
+    label: 'Angular',
+    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);
+                for (const d of decorators) {
+                    const subtype = DECORATOR_TO_SUBTYPE[d.name];
+                    if (!subtype)
+                        continue;
+                    const extra = extractDecoratorMetadata(d, subtype);
+                    const entity = makeEntity(input, node.name.text, subtype, extra);
+                    nodes.push(entity);
+                    edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype }));
+                    // A class can only carry one Angular role decorator in
+                    // practice; if a future class somehow has two we'd over-count
+                    // but the IDs are deterministic so duplicates collapse.
+                    break;
+                }
+            }
+            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 extractDecoratorMetadata(d, subtype) {
+    if (!d.callArguments || d.callArguments.length === 0)
+        return {};
+    const arg0 = d.callArguments[0];
+    if (!arg0 || !ts.isObjectLiteralExpression(arg0))
+        return {};
+    const out = {};
+    for (const prop of arg0.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        if (!ts.isIdentifier(prop.name))
+            continue;
+        const key = prop.name.text;
+        const value = prop.initializer;
+        // Lift the most useful string fields. Arrays of identifiers (e.g.
+        // `imports: [CommonModule, MyOtherModule]`) become arrays of names.
+        if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value)) {
+            if (subtype === 'component' && (key === 'selector' || key === 'templateUrl' || key === 'styleUrl')) {
+                out[key] = value.text;
+            }
+            else if (subtype === 'directive' && key === 'selector') {
+                out[key] = value.text;
+            }
+            else if (subtype === 'pipe' && key === 'name') {
+                out[key] = value.text;
+            }
+        }
+        else if (value.kind === ts.SyntaxKind.TrueKeyword || value.kind === ts.SyntaxKind.FalseKeyword) {
+            if (key === 'standalone')
+                out['standalone'] = value.kind === ts.SyntaxKind.TrueKeyword;
+        }
+        else if (ts.isArrayLiteralExpression(value)) {
+            if (subtype === 'module' && (key === 'imports' || key === 'declarations' || key === 'providers' || key === 'exports')) {
+                out[key] = arrayOfIdentifierNames(value);
+            }
+            else if (subtype === 'component' && key === 'imports') {
+                out[key] = arrayOfIdentifierNames(value);
+            }
+        }
+    }
+    return out;
+}
+function arrayOfIdentifierNames(arr) {
+    const out = [];
+    for (const el of arr.elements) {
+        if (ts.isIdentifier(el))
+            out.push(el.text);
+    }
+    return out;
+}
+function makeEntity(input, className, subtype, extra) {
+    return {
+        id: `framework:angular:${subtype}:${input.filePath}#${className}`,
+        kind: NodeKind.FrameworkEntity,
+        label: className,
+        path: input.filePath,
+        tags: ['angular', subtype],
+        data: { framework: 'angular', subtype, className, ...extra },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: ANGULAR_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/astro-extractor.d.ts

@@ -0,0 +1,15 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const ASTRO_EXTRACTOR_SOURCE = "astro-extractor@v1";
+/**
+ * Astro extractor.
+ *
+ * Astro uses file-based routing under `src/pages/`. Detection is
+ * entirely path-based; the content is not parsed (Astro has its own
+ * frontmatter / template DSL that's out of scope for the MVP).
+ *
+ *   - `src/pages/**\/*.astro` → page (with derived route path)
+ *   - `**\/*.astro` outside pages/ → component
+ *   - `src/pages/**\/*.{ts,js}` → API route (server-side endpoint)
+ */
+export declare const astroExtractor: IFrameworkExtractor;
+//# sourceMappingURL=astro-extractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"astro-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/astro-extractor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,sBAAsB,uBAAuB,CAAC;AAM3D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,mBAsD5B,CAAC"}

package/dist/extractors/astro-extractor.js

@@ -0,0 +1,128 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const ASTRO_EXTRACTOR_SOURCE = 'astro-extractor@v1';
+const PAGE_RE = /(?:^|\/)src\/pages\/(.+?)\.astro$/;
+const COMPONENT_RE = /\.astro$/;
+const API_ROUTE_RE = /(?:^|\/)src\/pages\/(.+?)\.(?:ts|js)$/;
+/**
+ * Astro extractor.
+ *
+ * Astro uses file-based routing under `src/pages/`. Detection is
+ * entirely path-based; the content is not parsed (Astro has its own
+ * frontmatter / template DSL that's out of scope for the MVP).
+ *
+ *   - `src/pages/**\/*.astro` → page (with derived route path)
+ *   - `**\/*.astro` outside pages/ → component
+ *   - `src/pages/**\/*.{ts,js}` → API route (server-side endpoint)
+ */
+export const astroExtractor = {
+    framework: 'astro',
+    label: 'Astro',
+    fileMatches({ path }) {
+        return path.endsWith('.astro') || API_ROUTE_RE.test(path);
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const pageMatch = PAGE_RE.exec(input.filePath);
+        if (pageMatch) {
+            const route = astroRoute(pageMatch[1]);
+            const e = makeEntity(input, 'page', `page ${route}`, { kind: 'page', routePath: route });
+            nodes.push(e);
+            edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'page' }));
+            return { nodes, edges };
+        }
+        const apiMatch = API_ROUTE_RE.exec(input.filePath);
+        if (apiMatch) {
+            const route = '/' + normalize(apiMatch[1]);
+            // Astro API routes export one binding per HTTP verb (`export const
+            // GET = ...`, `export async function POST(...) { ... }`, etc.).
+            // Detect each exported method and emit a per-method route entity.
+            // If no method exports are found, fall back to a single
+            // unspecified `api-route` entity so the file still surfaces.
+            const methods = detectAstroApiMethods(input.content);
+            if (methods.length === 0) {
+                const e = makeEntity(input, 'api-route', `API ${route}`, { kind: 'api-route', routePath: route });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'api-route' }));
+            }
+            else {
+                for (const method of methods) {
+                    const e = makeEntity(input, 'api-route', `${method} ${route}`, {
+                        kind: 'api-route',
+                        routePath: route,
+                        method,
+                    });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'api-route', method }));
+                }
+            }
+            return { nodes, edges };
+        }
+        if (COMPONENT_RE.test(input.filePath)) {
+            const filename = input.filePath.split('/').pop().replace(/\.astro$/, '');
+            const e = makeEntity(input, 'component', filename, { kind: 'component', name: filename });
+            nodes.push(e);
+            edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'component' }));
+        }
+        return { nodes, edges };
+    },
+};
+function astroRoute(p) {
+    return '/' + normalize(p);
+}
+function normalize(p) {
+    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;
+        // Astro dynamic segments: `[id].astro` → `:id`, `[...slug].astro` → `*`.
+        if (/^\[\.\.\..+\]$/.test(seg))
+            out.push('*');
+        else if (/^\[.+\]$/.test(seg))
+            out.push(':' + seg.slice(1, -1));
+        else
+            out.push(seg);
+    }
+    return out.join('/');
+}
+function makeEntity(input, subtype, label, data) {
+    return {
+        id: `framework:astro:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['astro', subtype],
+        data: { framework: 'astro', subtype, ...data },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: ASTRO_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}
+const ASTRO_API_METHOD_NAMES = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'ALL'];
+/**
+ * Detect which HTTP verbs an Astro API endpoint file exports. Matches:
+ *   - `export const GET = ...`
+ *   - `export let POST = ...`
+ *   - `export async function PUT(...) { ... }`
+ *   - `export function DELETE(...) { ... }`
+ * Returns the unique set of detected verb names, in canonical order.
+ */
+function detectAstroApiMethods(content) {
+    const found = new Set();
+    for (const m of ASTRO_API_METHOD_NAMES) {
+        const re = new RegExp(`^\\s*export\\s+(?:const|let|var|(?:async\\s+)?function)\\s+${m}\\b`, 'm');
+        if (re.test(content))
+            found.add(m);
+    }
+    return ASTRO_API_METHOD_NAMES.filter((m) => found.has(m));
+}

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

@@ -0,0 +1,24 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const DJANGO_EXTRACTOR_SOURCE = "django-extractor@v1";
+/**
+ * Django extractor.
+ *
+ * Regex-only (Python is not parsed via the TS AST). Detection:
+ *   - Class inheriting from `models.Model`, `models.AbstractUser`, or
+ *     another known Django base → **model** entity.
+ *   - Class inheriting from `View`, `TemplateView`, `ListView`, etc. →
+ *     **view** entity.
+ *   - Function with a leading parameter named `request` (heuristic for
+ *     function-based views) → **view** entity.
+ *   - `path('<route>', view, name='...')` / `re_path(...)` inside a
+ *     `urls.py`-like file → **url-pattern** entity. Detection is loose;
+ *     captures the route string + view name when expressible.
+ *
+ * Out of scope:
+ *   - Admin registrations.
+ *   - Middleware classes.
+ *   - Migration files (Django generates these; treating them as code
+ *     would be noisy).
+ */
+export declare const djangoExtractor: IFrameworkExtractor;
+//# sourceMappingURL=django-extractor.d.ts.map

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

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

package/dist/extractors/django-extractor.js

@@ -0,0 +1,124 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const DJANGO_EXTRACTOR_SOURCE = 'django-extractor@v1';
+const FAST_FILTER_NEEDLES = [
+    'from django',
+    'django.db',
+    'django.urls',
+    'django.views',
+    'django.http',
+    'models.Model',
+    'TemplateView',
+    'path(',
+    're_path(',
+];
+/**
+ * Django extractor.
+ *
+ * Regex-only (Python is not parsed via the TS AST). Detection:
+ *   - Class inheriting from `models.Model`, `models.AbstractUser`, or
+ *     another known Django base → **model** entity.
+ *   - Class inheriting from `View`, `TemplateView`, `ListView`, etc. →
+ *     **view** entity.
+ *   - Function with a leading parameter named `request` (heuristic for
+ *     function-based views) → **view** entity.
+ *   - `path('<route>', view, name='...')` / `re_path(...)` inside a
+ *     `urls.py`-like file → **url-pattern** entity. Detection is loose;
+ *     captures the route string + view name when expressible.
+ *
+ * Out of scope:
+ *   - Admin registrations.
+ *   - Middleware classes.
+ *   - Migration files (Django generates these; treating them as code
+ *     would be noisy).
+ */
+export const djangoExtractor = {
+    framework: 'django',
+    label: 'Django',
+    fileMatches({ path, content }) {
+        if (!path.endsWith('.py'))
+            return false;
+        for (const needle of FAST_FILTER_NEEDLES) {
+            if (content.includes(needle))
+                return true;
+        }
+        return false;
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const isUrlsFile = /(?:^|\/)urls\.py$/.test(input.filePath);
+        const lines = input.content.split('\n');
+        // Models: `class Foo(models.Model):` or `class Foo(AbstractBaseUser):`.
+        const modelRe = /^class\s+([A-Za-z_]\w*)\s*\((?:[\w.]*\.)?(?:Model|AbstractUser|AbstractBaseUser|AbstractModel|TimeStampedModel)\b/;
+        // CBVs: a class whose first base name ends in `View`.
+        const viewRe = /^class\s+([A-Za-z_]\w*)\s*\(([^)]+)\)/;
+        // FBVs: function whose first parameter is `request`.
+        const fbvRe = /^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(\s*request\b/;
+        // URL pattern: `path('<route>', view, ...)` or `re_path(...)`.
+        const urlRe = /(?:^|\s)(?:path|re_path|url)\s*\(\s*['"]([^'"]*)['"]\s*,\s*([A-Za-z_][\w.]*)(?:\.as_view\(\))?/;
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            const trimmed = raw.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const line = i + 1;
+            let m;
+            if ((m = modelRe.exec(raw))) {
+                const e = makeEntity(input, 'model', m[1], { className: m[1] });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'model', line }));
+                continue;
+            }
+            if ((m = viewRe.exec(raw))) {
+                const className = m[1];
+                const bases = m[2].split(',').map((s) => s.trim());
+                // Pick first base that looks like a view (ends in 'View') and isn't a model base.
+                if (bases.some((b) => /View$/.test(b)) && !bases.some((b) => /Model$|AbstractUser|AbstractBaseUser/.test(b))) {
+                    const e = makeEntity(input, 'view', className, { className, kind: 'cbv', bases });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'view', line }));
+                }
+                continue;
+            }
+            if ((m = fbvRe.exec(raw))) {
+                const name = m[1];
+                const e = makeEntity(input, 'view', name, { kind: 'fbv' });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'view', line }));
+                continue;
+            }
+            if (isUrlsFile && (m = urlRe.exec(raw))) {
+                const route = m[1];
+                const target = m[2];
+                const e = makeEntity(input, 'url-pattern', `${route} → ${target}`, {
+                    route,
+                    target,
+                });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'url-pattern', line }));
+            }
+        }
+        return { nodes, edges };
+    },
+};
+function makeEntity(input, subtype, label, extra) {
+    return {
+        id: `framework:django:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['django', subtype],
+        data: { framework: 'django', subtype, ...extra },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: DJANGO_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const EXPRESS_EXTRACTOR_SOURCE = "express-extractor@v1";
+/**
+ * Express extractor.
+ *
+ * Express has no decorators, so detection is signature-based:
+ *   - A variable initialized with a call to `express()` or
+ *     `express.Router()` (or to `Router(...)` when `Router` was
+ *     imported from `'express'`) becomes a **router** entity.
+ *   - Subsequent `<router>.get(path, …)` etc. calls become **route**
+ *     entities with method + path data.
+ *
+ * Middleware chains (extra handlers in the call args) are recorded on
+ * the route entity's `data.middlewareCount`. Detailed middleware-node
+ * extraction is out of scope for the MVP.
+ */
+export declare const expressExtractor: IFrameworkExtractor;
+//# sourceMappingURL=express-extractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"express-extractor.d.ts","sourceRoot":"","sources":["../../src/extractors/express-extractor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,mBAAmB,EACpB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAgB/D;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,EAAE,mBAwE9B,CAAC"}