@shrkcrft/framework-scanners 0.1.0-alpha.10

package/dist/extractors/flask-extractor.js

@@ -0,0 +1,142 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const FLASK_EXTRACTOR_SOURCE = 'flask-extractor@v1';
+const FAST_FILTER_NEEDLES = [
+    'from flask',
+    'Flask(__name__)',
+    'Flask(name=',
+    'Blueprint(',
+    '@app.route',
+    '@blueprint.route',
+];
+/**
+ * Flask extractor.
+ *
+ * Regex-only. Detection model:
+ *   - `<name> = Flask(...)` → **app** entity.
+ *   - `<name> = Blueprint('<bp>', __name__, ...)` → **blueprint**
+ *     entity. The first string argument is captured as the blueprint
+ *     name.
+ *   - `@<name>.route('<path>', methods=[...])` immediately preceding a
+ *     `def <handler>` → **route** entity with method(s) + path +
+ *     handler. The default method is GET when `methods=` is absent.
+ */
+export const flaskExtractor = {
+    framework: 'flask',
+    label: 'Flask',
+    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 lines = input.content.split('\n');
+        const appNames = new Map();
+        const flaskRe = /^([A-Za-z_]\w*)\s*=\s*Flask\s*\(/;
+        const bpRe = /^([A-Za-z_]\w*)\s*=\s*Blueprint\s*\(\s*['"]([^'"]+)['"]/;
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            let m = flaskRe.exec(raw);
+            if (m) {
+                const name = m[1];
+                const e = makeEntity(input, 'app', name, { name });
+                appNames.set(name, e);
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'app', line: i + 1 }));
+                continue;
+            }
+            m = bpRe.exec(raw);
+            if (m) {
+                const localName = m[1];
+                const bpName = m[2];
+                const e = makeEntity(input, 'blueprint', bpName, { localName, name: bpName });
+                appNames.set(localName, e);
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'blueprint', line: i + 1 }));
+            }
+        }
+        if (appNames.size === 0)
+            return { nodes, edges };
+        // Routes: `@<appOrBlueprint>.route('<path>', methods=[...])` then a `def`.
+        const routeRe = /^@([A-Za-z_]\w*)\.route\s*\(\s*['"]([^'"]+)['"]\s*(?:,\s*methods\s*=\s*\[([^\]]+)\])?/;
+        const defRe = /^(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/;
+        for (let i = 0; i < lines.length; i += 1) {
+            const m = routeRe.exec(lines[i]);
+            if (!m)
+                continue;
+            const target = m[1];
+            const path = m[2];
+            const methodsRaw = m[3];
+            const methods = methodsRaw
+                ? methodsRaw.split(',').map((s) => s.trim().replace(/^['"]|['"]$/g, '').toUpperCase()).filter(Boolean)
+                : ['GET'];
+            if (!appNames.has(target))
+                continue;
+            // Find handler name on a subsequent non-decorator line.
+            let handler = 'handler';
+            for (let j = i + 1; j < lines.length; j += 1) {
+                const t = lines[j].trimStart();
+                if (!t)
+                    continue;
+                if (t.startsWith('@'))
+                    continue;
+                const def = defRe.exec(t);
+                if (def)
+                    handler = def[1];
+                break;
+            }
+            // Emit one route entity per HTTP method (matches FastAPI's per-method shape).
+            const app = appNames.get(target);
+            for (const method of methods) {
+                const e = makeRouteEntity(input, target, handler, method, path);
+                nodes.push(e);
+                edges.push(edge(app.id, e.id, EdgeKind.HandlesRoute, { method, path, handler }));
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'route', line: i + 1 }));
+            }
+        }
+        return { nodes, edges };
+    },
+};
+function makeEntity(input, subtype, label, extra) {
+    return {
+        id: `framework:flask:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['flask', subtype],
+        data: { framework: 'flask', subtype, ...extra },
+    };
+}
+function makeRouteEntity(input, appName, handler, method, path) {
+    return {
+        id: `framework:flask:route:${input.filePath}#${appName}.${handler}#${method}:${path}`,
+        kind: NodeKind.FrameworkEntity,
+        label: `${method} ${path}`,
+        path: input.filePath,
+        tags: ['flask', 'route'],
+        data: {
+            framework: 'flask',
+            subtype: 'route',
+            app: appName,
+            handler,
+            method,
+            path,
+        },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: FLASK_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const FLUTTER_EXTRACTOR_SOURCE = "flutter-extractor@v1";
+/**
+ * Flutter framework extractor.
+ *
+ * Regex-only — Dart source isn't AST-parsed. Detection:
+ *
+ *   - **Widget**: `class X extends StatelessWidget` / `StatefulWidget` /
+ *     `ConsumerWidget` / `HookWidget` / `HookConsumerWidget`. Emits
+ *     one entity per matched class.
+ *
+ *   - **State**: `class _XState extends State<X>` →
+ *     state entity, linked to its parent widget via `UsesHook` edges
+ *     (re-using the edge kind for "this state belongs to that widget").
+ *
+ *   - **Notifier**: `class X extends ChangeNotifier` /
+ *     `class X with ChangeNotifier` → notifier entity. Common for
+ *     Provider / Riverpod-style state.
+ *
+ * Out of scope:
+ *   - Widget tree inspection (the `build()` body).
+ *   - InheritedWidget chains.
+ *   - Riverpod provider declarations.
+ */
+export declare const flutterExtractor: IFrameworkExtractor;
+//# sourceMappingURL=flutter-extractor.d.ts.map

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

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

package/dist/extractors/flutter-extractor.js

@@ -0,0 +1,137 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const FLUTTER_EXTRACTOR_SOURCE = 'flutter-extractor@v1';
+const WIDGET_BASES = new Set([
+    'StatelessWidget',
+    'StatefulWidget',
+    'ConsumerWidget',
+    'HookWidget',
+    'HookConsumerWidget',
+]);
+const FAST_FILTER_NEEDLES = [
+    "package:flutter/",
+    'extends StatelessWidget',
+    'extends StatefulWidget',
+    'extends State<',
+    'ChangeNotifier',
+    'ConsumerWidget',
+];
+/**
+ * Flutter framework extractor.
+ *
+ * Regex-only — Dart source isn't AST-parsed. Detection:
+ *
+ *   - **Widget**: `class X extends StatelessWidget` / `StatefulWidget` /
+ *     `ConsumerWidget` / `HookWidget` / `HookConsumerWidget`. Emits
+ *     one entity per matched class.
+ *
+ *   - **State**: `class _XState extends State<X>` →
+ *     state entity, linked to its parent widget via `UsesHook` edges
+ *     (re-using the edge kind for "this state belongs to that widget").
+ *
+ *   - **Notifier**: `class X extends ChangeNotifier` /
+ *     `class X with ChangeNotifier` → notifier entity. Common for
+ *     Provider / Riverpod-style state.
+ *
+ * Out of scope:
+ *   - Widget tree inspection (the `build()` body).
+ *   - InheritedWidget chains.
+ *   - Riverpod provider declarations.
+ */
+export const flutterExtractor = {
+    framework: 'flutter',
+    label: 'Flutter',
+    fileMatches({ path, content }) {
+        if (!path.endsWith('.dart'))
+            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');
+        // Track widget classes so a follow-up `_XState extends State<X>`
+        // can link back via the X parameter.
+        const widgetEntities = new Map();
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            if (raw.startsWith(' ') || raw.startsWith('\t'))
+                continue;
+            const trimmed = raw.trimStart();
+            // Widget classes.
+            let m = /^class\s+([A-Za-z_]\w*)\s+extends\s+([A-Za-z_]\w*)/.exec(trimmed);
+            if (m) {
+                const className = m[1];
+                const baseClass = m[2];
+                if (WIDGET_BASES.has(baseClass)) {
+                    const e = makeEntity(input, 'widget', className, {
+                        className,
+                        baseClass,
+                        stateful: baseClass === 'StatefulWidget',
+                    });
+                    widgetEntities.set(className, e);
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'widget', line: i + 1 }));
+                    continue;
+                }
+                if (baseClass === 'ChangeNotifier') {
+                    const e = makeEntity(input, 'notifier', className, { className, baseClass });
+                    nodes.push(e);
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'notifier', line: i + 1 }));
+                    continue;
+                }
+            }
+            // State<Widget> classes.
+            m = /^class\s+([A-Za-z_]\w*)\s+extends\s+State\s*<\s*([A-Za-z_]\w*)\s*>/.exec(trimmed);
+            if (m) {
+                const stateName = m[1];
+                const widgetName = m[2];
+                const e = makeEntity(input, 'state', stateName, {
+                    stateName,
+                    widget: widgetName,
+                });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'state', line: i + 1 }));
+                // Wire state → widget if we've seen the widget already.
+                const widget = widgetEntities.get(widgetName);
+                if (widget) {
+                    edges.push(edge(widget.id, e.id, EdgeKind.UsesHook, { kind: 'state', widget: widgetName }));
+                }
+                continue;
+            }
+            // Mixin form: `class X extends Y with ChangeNotifier`
+            m = /^class\s+([A-Za-z_]\w*)\s+(?:extends\s+[A-Za-z_]\w*\s+)?with\s+([^{]+)/.exec(trimmed);
+            if (m && m[2].split(',').map((s) => s.trim()).includes('ChangeNotifier')) {
+                const className = m[1];
+                const e = makeEntity(input, 'notifier', className, { className, baseClass: 'with ChangeNotifier' });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'notifier', line: i + 1 }));
+            }
+        }
+        return { nodes, edges };
+    },
+};
+function makeEntity(input, subtype, label, extra) {
+    return {
+        id: `framework:flutter:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['flutter', subtype],
+        data: { framework: 'flutter', subtype, ...extra },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: FLUTTER_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

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

@@ -0,0 +1,27 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const GRAPHQL_EXTRACTOR_SOURCE = "graphql-extractor@v1";
+/**
+ * GraphQL schema extractor.
+ *
+ * Parses `.graphql` / `.gql` SDL files. Detected:
+ *   - `type Name { … }`             → type
+ *   - `interface Name { … }`         → interface
+ *   - `enum Name { … }`              → enum
+ *   - `input Name { … }`             → input
+ *   - `union Name = A | B`           → union
+ *   - `scalar Name`                  → scalar
+ *   - `directive @name on …`         → directive
+ *
+ * The three root types — `Query`, `Mutation`, `Subscription` — get one
+ * extra **field** entity per declared field. Each is wired back to the
+ * parent type via `HandlesRoute` so the dashboard's Routes panel can
+ * surface GraphQL operations alongside HTTP routes.
+ *
+ * Out of scope:
+ *   - `schema { query: ..., mutation: ... }` aliasing.
+ *   - `extend type X { … }` (the extender re-declares).
+ *   - Field arguments / nested complex types.
+ *   - GraphQL-in-strings (e.g. JS `gql\`type Foo { ... }\``).
+ */
+export declare const graphqlExtractor: IFrameworkExtractor;
+//# sourceMappingURL=graphql-extractor.d.ts.map

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

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

package/dist/extractors/graphql-extractor.js

@@ -0,0 +1,141 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const GRAPHQL_EXTRACTOR_SOURCE = 'graphql-extractor@v1';
+const ROOT_TYPE_NAMES = new Set(['Query', 'Mutation', 'Subscription']);
+/**
+ * GraphQL schema extractor.
+ *
+ * Parses `.graphql` / `.gql` SDL files. Detected:
+ *   - `type Name { … }`             → type
+ *   - `interface Name { … }`         → interface
+ *   - `enum Name { … }`              → enum
+ *   - `input Name { … }`             → input
+ *   - `union Name = A | B`           → union
+ *   - `scalar Name`                  → scalar
+ *   - `directive @name on …`         → directive
+ *
+ * The three root types — `Query`, `Mutation`, `Subscription` — get one
+ * extra **field** entity per declared field. Each is wired back to the
+ * parent type via `HandlesRoute` so the dashboard's Routes panel can
+ * surface GraphQL operations alongside HTTP routes.
+ *
+ * Out of scope:
+ *   - `schema { query: ..., mutation: ... }` aliasing.
+ *   - `extend type X { … }` (the extender re-declares).
+ *   - Field arguments / nested complex types.
+ *   - GraphQL-in-strings (e.g. JS `gql\`type Foo { ... }\``).
+ */
+export const graphqlExtractor = {
+    framework: 'graphql',
+    label: 'GraphQL',
+    fileMatches({ path }) {
+        return path.endsWith('.graphql') || path.endsWith('.gql');
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const lines = input.content.split('\n');
+        // Walk line by line, tracking the open root-type block (so each
+        // line inside it can be parsed as a field). Comments (`#`) are
+        // stripped.
+        let currentRootType;
+        let currentRootKind;
+        let braceDepth = 0;
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            const trimmed = raw.replace(/#.*$/, '').trim();
+            if (!trimmed)
+                continue;
+            // Track brace depth to know when we exit a block.
+            // (We open the block on the same line as the declaration and
+            // close it when '}' appears.)
+            if (currentRootType && trimmed.includes('}')) {
+                braceDepth -= (trimmed.match(/\}/g) ?? []).length;
+                if (braceDepth <= 0) {
+                    currentRootType = undefined;
+                    currentRootKind = undefined;
+                    braceDepth = 0;
+                }
+            }
+            // Type-shape declarations.
+            let m = /^(type|interface|enum|input|union|scalar|directive)\s+(@?[A-Za-z_][\w]*)/.exec(trimmed);
+            if (m) {
+                const kind = m[1];
+                const rawName = m[2];
+                const name = rawName.startsWith('@') ? rawName.slice(1) : rawName;
+                const entity = makeEntity(input, kind, name, { kind, name });
+                nodes.push(entity);
+                edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype: kind, line: i + 1 }));
+                // Open a root-type block when the declaration opens with `{`.
+                if ((kind === 'type' || kind === 'interface') && trimmed.includes('{')) {
+                    braceDepth += (trimmed.match(/\{/g) ?? []).length;
+                    braceDepth -= (trimmed.match(/\}/g) ?? []).length;
+                    if (ROOT_TYPE_NAMES.has(name)) {
+                        currentRootType = entity;
+                        currentRootKind = name;
+                    }
+                }
+                continue;
+            }
+            // Inside a Query / Mutation / Subscription block — capture fields.
+            if (currentRootType && currentRootKind) {
+                const fieldMatch = /^([A-Za-z_][\w]*)\s*(?:\(([^)]*)\))?\s*:\s*([\w\[\]!]+)/.exec(trimmed);
+                if (fieldMatch) {
+                    const fieldName = fieldMatch[1];
+                    const argString = fieldMatch[2] ?? '';
+                    const returnType = fieldMatch[3];
+                    const fieldEntity = makeFieldEntity(input, currentRootKind, fieldName, returnType, argString);
+                    nodes.push(fieldEntity);
+                    edges.push(edge(currentRootType.id, fieldEntity.id, EdgeKind.HandlesRoute, {
+                        operation: currentRootKind.toLowerCase(),
+                        field: fieldName,
+                    }));
+                    edges.push(edge(input.fileNodeId, fieldEntity.id, EdgeKind.FrameworkDeclares, {
+                        subtype: 'operation',
+                        line: i + 1,
+                    }));
+                }
+                // Continue tracking brace depth for nested blocks.
+                braceDepth += (trimmed.match(/\{/g) ?? []).length;
+            }
+        }
+        return { nodes, edges };
+    },
+};
+function makeEntity(input, subtype, label, extra) {
+    return {
+        id: `framework:graphql:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['graphql', subtype],
+        data: { framework: 'graphql', subtype, ...extra },
+    };
+}
+function makeFieldEntity(input, rootKind, fieldName, returnType, args) {
+    return {
+        id: `framework:graphql:operation:${input.filePath}#${rootKind}.${fieldName}`,
+        kind: NodeKind.FrameworkEntity,
+        label: `${rootKind.toLowerCase()} ${fieldName}`,
+        path: input.filePath,
+        tags: ['graphql', 'operation', rootKind.toLowerCase()],
+        data: {
+            framework: 'graphql',
+            subtype: 'operation',
+            operation: rootKind.toLowerCase(),
+            field: fieldName,
+            returnType,
+            ...(args ? { args } : {}),
+        },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: GRAPHQL_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const LARAVEL_EXTRACTOR_SOURCE = "laravel-extractor@v1";
+/**
+ * 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 declare const laravelExtractor: IFrameworkExtractor;
+//# sourceMappingURL=laravel-extractor.d.ts.map

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

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