@shrkcrft/framework-scanners 0.1.0-alpha.10

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

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

package/dist/extractors/phoenix-extractor.js

@@ -0,0 +1,212 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const PHOENIX_EXTRACTOR_SOURCE = 'phoenix-extractor@v1';
+const HTTP_VERBS = new Set(['get', 'post', 'put', 'patch', 'delete', 'options', 'head']);
+const FAST_FILTER_NEEDLES = [
+    'use Phoenix.Controller',
+    'use Phoenix.Router',
+    'use Phoenix.LiveView',
+    'use Phoenix.LiveComponent',
+    'use Ecto.Schema',
+    ':controller',
+    ':router',
+];
+/**
+ * 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 const phoenixExtractor = {
+    framework: 'phoenix',
+    label: 'Phoenix',
+    fileMatches({ path, content }) {
+        if (!path.endsWith('.ex') && !path.endsWith('.exs'))
+            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');
+        // Discover the current module + its kind (controller / router / live / schema).
+        let currentModuleName;
+        let currentEntity;
+        let currentKind;
+        // Stack of `scope "/prefix", AppWeb do … end` prefixes — only used
+        // inside a router module. Each `scope` line pushes; each `end`
+        // line at the matching depth pops.
+        const scopeStack = [];
+        // Parallel stack for the optional module argument
+        // (`scope "/api", AppWeb do`). When set, the captured controller
+        // name is prefixed with this module. Empty string when the scope
+        // had no module argument (i.e. only a path prefix).
+        const scopeModuleStack = [];
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            const trimmed = raw.trimStart();
+            const defm = /^defmodule\s+([A-Z][\w.]*)\s+do/.exec(trimmed);
+            if (defm) {
+                currentModuleName = defm[1];
+                currentEntity = undefined;
+                currentKind = undefined;
+                continue;
+            }
+            if (!currentModuleName)
+                continue;
+            // Bind the module to its Phoenix role via `use` calls.
+            if (!currentEntity) {
+                const useMatch = /^use\s+([A-Z][\w.]*)(?:,\s*(:?\w+))?/.exec(trimmed);
+                if (useMatch) {
+                    const mod = useMatch[1];
+                    const arg = useMatch[2] ?? '';
+                    if (mod === 'Phoenix.Controller' || arg === ':controller')
+                        currentKind = 'controller';
+                    else if (mod === 'Phoenix.Router' || arg === ':router')
+                        currentKind = 'router';
+                    else if (mod === 'Phoenix.LiveView')
+                        currentKind = 'live-view';
+                    else if (mod === 'Phoenix.LiveComponent')
+                        currentKind = 'live-component';
+                    else if (mod === 'Ecto.Schema')
+                        currentKind = 'schema';
+                    if (currentKind) {
+                        const e = makeEntity(input, currentKind, currentModuleName, { moduleName: currentModuleName });
+                        nodes.push(e);
+                        edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: currentKind, line: i + 1 }));
+                        currentEntity = e;
+                    }
+                    continue;
+                }
+            }
+            // Controller actions: `def action(conn, params)`.
+            if (currentKind === 'controller' && currentEntity) {
+                const actionMatch = /^def\s+([a-z_][\w?!]*)\s*\(\s*conn\b/.exec(trimmed);
+                if (actionMatch) {
+                    const action = actionMatch[1];
+                    const e = makeEntity(input, 'action', action, {
+                        controller: currentEntity.label,
+                        action,
+                    });
+                    nodes.push(e);
+                    edges.push(edge(currentEntity.id, e.id, EdgeKind.HandlesRoute, {
+                        controller: currentEntity.label,
+                        action,
+                    }));
+                    edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'action', line: i + 1 }));
+                }
+            }
+            // Router routes: `get "/path", Controller, :action`.
+            if (currentKind === 'router' && currentEntity) {
+                // `scope "/prefix", AppWeb do` — push prefix + module arg;
+                // matching `end` pops. We track scope opens/closes via the
+                // trailing `do` and the line-level `end`.
+                const scopeMatch = /^scope\s+"([^"]*)"(?:\s*,\s*([A-Z][\w.]*))?\s*do\b/.exec(trimmed);
+                if (scopeMatch) {
+                    scopeStack.push(scopeMatch[1]);
+                    scopeModuleStack.push(scopeMatch[2] ?? '');
+                    continue;
+                }
+                if (/^end\b/.test(trimmed) && scopeStack.length > 0) {
+                    scopeStack.pop();
+                    scopeModuleStack.pop();
+                    continue;
+                }
+                const routeMatch = /^(get|post|put|patch|delete|options|head)\s+"([^"]+)"\s*,\s*([A-Z][\w.]*)\s*,\s*:(\w+)/.exec(trimmed);
+                if (routeMatch) {
+                    const verb = routeMatch[1].toUpperCase();
+                    const localPath = routeMatch[2];
+                    const rawCtrl = routeMatch[3];
+                    const action = routeMatch[4];
+                    if (HTTP_VERBS.has(routeMatch[1])) {
+                        const path = combineScopes(scopeStack, localPath);
+                        // Qualify the controller with the innermost scope's module
+                        // argument if it was set and the captured name isn't
+                        // already a fully-qualified `Mod.Sub.Controller`.
+                        const innerModule = scopeModuleStack.length > 0 ? scopeModuleStack[scopeModuleStack.length - 1] : '';
+                        const ctrl = innerModule && !rawCtrl.includes('.') ? `${innerModule}.${rawCtrl}` : rawCtrl;
+                        const r = makeRouteEntity(input, currentEntity.label, verb, path, ctrl, action);
+                        nodes.push(r);
+                        edges.push(edge(currentEntity.id, r.id, EdgeKind.HandlesRoute, {
+                            method: verb,
+                            path,
+                            controller: ctrl,
+                            action,
+                        }));
+                        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:phoenix:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['phoenix', subtype],
+        data: { framework: 'phoenix', subtype, ...extra },
+    };
+}
+function makeRouteEntity(input, routerModule, method, path, controller, action) {
+    return {
+        id: `framework:phoenix:route:${input.filePath}#${routerModule}#${method}:${path}#${controller}.${action}`,
+        kind: NodeKind.FrameworkEntity,
+        label: `${method} ${path} → ${controller}.${action}`,
+        path: input.filePath,
+        tags: ['phoenix', 'route'],
+        data: { framework: 'phoenix', subtype: 'route', method, path, controller, action, router: routerModule },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: PHOENIX_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}
+/**
+ * Combine an outer scope prefix stack with a leaf path. Treats
+ * `/` as the no-op prefix. Returns `/` when both prefix and leaf are
+ * empty.
+ */
+function combineScopes(stack, leaf) {
+    const prefix = stack
+        .map((s) => s.replace(/^\//, '').replace(/\/$/, ''))
+        .filter((s) => s.length > 0)
+        .join('/');
+    const cleanLeaf = leaf.replace(/^\//, '');
+    if (!prefix)
+        return cleanLeaf ? '/' + cleanLeaf : '/';
+    if (!cleanLeaf)
+        return '/' + prefix;
+    return '/' + prefix + '/' + cleanLeaf;
+}

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

@@ -0,0 +1,25 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const RAILS_EXTRACTOR_SOURCE = "rails-extractor@v1";
+/**
+ * Rails extractor.
+ *
+ * Regex-only. Detection model:
+ *
+ *   - **Controllers**: `class Name < ApplicationController` (or
+ *     `ActionController::Base`). Action methods are public `def`s
+ *     declared inside; we capture the controller as a single entity
+ *     plus one `route`-style action entity per `def`.
+ *   - **Models**: `class Name < ApplicationRecord` (or
+ *     `ActiveRecord::Base`) → model entity.
+ *   - **Routes**: any file named `routes.rb` is parsed for top-level
+ *     `resources :name`, `resource :name`, `get '...' => '...'`, and
+ *     bare `get '...'`. Each emits a route entity.
+ *
+ * Out of scope:
+ *   - `namespace :foo do ... end` nesting (we don't merge the prefix
+ *     into nested route paths).
+ *   - Before-action filters / authorization DSLs.
+ *   - Concerns / mixins.
+ */
+export declare const railsExtractor: IFrameworkExtractor;
+//# sourceMappingURL=rails-extractor.d.ts.map

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

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

package/dist/extractors/rails-extractor.js

@@ -0,0 +1,180 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const RAILS_EXTRACTOR_SOURCE = 'rails-extractor@v1';
+const HTTP_VERBS = new Set(['get', 'post', 'put', 'patch', 'delete', 'match']);
+const FAST_FILTER_NEEDLES = [
+    'ApplicationController',
+    'ActionController::',
+    'ApplicationRecord',
+    'ActiveRecord::Base',
+    'Rails.application.routes.draw',
+    'resources :',
+    'resource :',
+];
+/**
+ * Rails extractor.
+ *
+ * Regex-only. Detection model:
+ *
+ *   - **Controllers**: `class Name < ApplicationController` (or
+ *     `ActionController::Base`). Action methods are public `def`s
+ *     declared inside; we capture the controller as a single entity
+ *     plus one `route`-style action entity per `def`.
+ *   - **Models**: `class Name < ApplicationRecord` (or
+ *     `ActiveRecord::Base`) → model entity.
+ *   - **Routes**: any file named `routes.rb` is parsed for top-level
+ *     `resources :name`, `resource :name`, `get '...' => '...'`, and
+ *     bare `get '...'`. Each emits a route entity.
+ *
+ * Out of scope:
+ *   - `namespace :foo do ... end` nesting (we don't merge the prefix
+ *     into nested route paths).
+ *   - Before-action filters / authorization DSLs.
+ *   - Concerns / mixins.
+ */
+export const railsExtractor = {
+    framework: 'rails',
+    label: 'Rails',
+    fileMatches({ path, content }) {
+        if (!path.endsWith('.rb'))
+            return false;
+        if (/(?:^|\/)routes\.rb$/.test(path))
+            return true;
+        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');
+        // Controllers + models walk class declarations.
+        let currentControllerEntity;
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i];
+            // Controller
+            let m = /^class\s+([A-Z][\w]*)\s*<\s*(?:ApplicationController|ActionController::[A-Za-z]+)/.exec(raw);
+            if (m) {
+                const e = makeEntity(input, 'controller', m[1], { className: m[1] });
+                nodes.push(e);
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'controller', line: i + 1 }));
+                currentControllerEntity = e;
+                continue;
+            }
+            // Model
+            m = /^class\s+([A-Z][\w]*)\s*<\s*(?:ApplicationRecord|ActiveRecord::Base)/.exec(raw);
+            if (m) {
+                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: i + 1 }));
+                continue;
+            }
+            // Controller actions (public def inside a controller body).
+            m = /^\s+def\s+([a-z_][\w?!]*)/.exec(raw);
+            if (m && currentControllerEntity) {
+                const action = m[1];
+                // Skip private rails internals.
+                if (action.startsWith('_'))
+                    continue;
+                const e = makeEntity(input, 'action', action, {
+                    controller: currentControllerEntity.label,
+                    action,
+                });
+                nodes.push(e);
+                edges.push(edge(currentControllerEntity.id, e.id, EdgeKind.HandlesRoute, {
+                    action,
+                    controller: currentControllerEntity.label,
+                }));
+                edges.push(edge(input.fileNodeId, e.id, EdgeKind.FrameworkDeclares, { subtype: 'action', line: i + 1 }));
+            }
+            // `end` at column 0 closes the controller. Heuristic; works for
+            // typical Rails one-class-per-file convention.
+            if (/^end\s*$/.test(raw.trimEnd())) {
+                currentControllerEntity = undefined;
+            }
+        }
+        // Routes (only in routes.rb).
+        if (/(?:^|\/)routes\.rb$/.test(input.filePath)) {
+            // Stack of `namespace :v1 do ... end` prefixes. Each entry is
+            // the symbol name (without leading colon), pushed on
+            // `namespace :foo do` and popped on the matching `end`.
+            const namespaceStack = [];
+            for (let i = 0; i < lines.length; i += 1) {
+                const raw = lines[i].trim();
+                if (!raw || raw.startsWith('#'))
+                    continue;
+                // namespace :foo do  → push
+                const nsMatch = /^namespace\s+:([a-z_]\w*)\s+do\b/.exec(raw);
+                if (nsMatch) {
+                    namespaceStack.push(nsMatch[1]);
+                    continue;
+                }
+                // `end` line closes the nearest namespace.
+                if (/^end\b/.test(raw) && namespaceStack.length > 0) {
+                    namespaceStack.pop();
+                    continue;
+                }
+                const prefix = namespaceStack.length > 0 ? '/' + namespaceStack.join('/') : '';
+                let m = /^resources\s+:([a-z_]\w*)/.exec(raw);
+                if (m) {
+                    const r = makeRouteEntity(input, m[1], 'RESOURCES', `${prefix}/${m[1]}`, 'index');
+                    nodes.push(r);
+                    edges.push(edge(input.fileNodeId, r.id, EdgeKind.FrameworkDeclares, { subtype: 'route', line: i + 1 }));
+                    continue;
+                }
+                m = /^resource\s+:([a-z_]\w*)/.exec(raw);
+                if (m) {
+                    const r = makeRouteEntity(input, m[1], 'RESOURCE', `${prefix}/${m[1]}`, 'show');
+                    nodes.push(r);
+                    edges.push(edge(input.fileNodeId, r.id, EdgeKind.FrameworkDeclares, { subtype: 'route', line: i + 1 }));
+                    continue;
+                }
+                // `get '/path' => 'controller#action'` OR `get '/path', to: 'controller#action'`
+                m = /^(get|post|put|patch|delete|match)\s+['"]([^'"]+)['"](?:\s*(?:=>|,\s*to:)\s*['"]([^'"]+)['"])?/.exec(raw);
+                if (m && HTTP_VERBS.has(m[1])) {
+                    const verb = m[1].toUpperCase();
+                    const leaf = m[2];
+                    const path = prefix ? `${prefix}${leaf.startsWith('/') ? '' : '/'}${leaf}` : leaf;
+                    const target = m[3] ?? '';
+                    const r = makeRouteEntity(input, 'routes', verb, 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:rails:${subtype}:${input.filePath}#${label}`,
+        kind: NodeKind.FrameworkEntity,
+        label,
+        path: input.filePath,
+        tags: ['rails', subtype],
+        data: { framework: 'rails', subtype, ...extra },
+    };
+}
+function makeRouteEntity(input, scope, method, path, target) {
+    const id = `framework:rails:route:${input.filePath}#${scope}#${method}:${path}#${target}`;
+    return {
+        id,
+        kind: NodeKind.FrameworkEntity,
+        label: `${method} ${path}${target ? ` → ${target}` : ''}`,
+        path: input.filePath,
+        tags: ['rails', 'route'],
+        data: { framework: 'rails', subtype: 'route', method, path, target, scope },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: RAILS_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

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

@@ -0,0 +1,19 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const REACT_EXTRACTOR_SOURCE = "react-extractor@v1";
+/**
+ * React extractor.
+ *
+ * Heuristic detection (no full type information):
+ *   - **Component**: top-level function / arrow function / class
+ *     declaration whose name starts with an uppercase letter AND whose
+ *     body contains a JSX element. False positives in TSX are filtered
+ *     by the JSX-presence check.
+ *   - **Hook usage**: any CallExpression whose callee identifier
+ *     matches `/^use[A-Z]/`. Recorded as a single hook-usage entity
+ *     per (file, hook name) pair.
+ *
+ * Emits FrameworkDeclares edges from file → entity, and UsesHook edges
+ * from component → hook-usage entity when both can be co-located.
+ */
+export declare const reactExtractor: IFrameworkExtractor;
+//# sourceMappingURL=react-extractor.d.ts.map

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

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

package/dist/extractors/react-extractor.js

@@ -0,0 +1,209 @@
+import { createHash } from 'node:crypto';
+import * as nodePath from 'node:path';
+import * as ts from 'typescript';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const REACT_EXTRACTOR_SOURCE = 'react-extractor@v1';
+const HOOK_NAME_RE = /^use[A-Z]/;
+const FAST_FILTER_NEEDLES = [
+    "from 'react'",
+    'from "react"',
+    "from 'react/jsx-runtime'",
+    'jsx',
+    'React.FC',
+    'createElement',
+];
+/**
+ * React extractor.
+ *
+ * Heuristic detection (no full type information):
+ *   - **Component**: top-level function / arrow function / class
+ *     declaration whose name starts with an uppercase letter AND whose
+ *     body contains a JSX element. False positives in TSX are filtered
+ *     by the JSX-presence check.
+ *   - **Hook usage**: any CallExpression whose callee identifier
+ *     matches `/^use[A-Z]/`. Recorded as a single hook-usage entity
+ *     per (file, hook name) pair.
+ *
+ * Emits FrameworkDeclares edges from file → entity, and UsesHook edges
+ * from component → hook-usage entity when both can be co-located.
+ */
+export const reactExtractor = {
+    framework: 'react',
+    label: 'React',
+    fileMatches({ path, content }) {
+        if (!/\.(?:t|j)sx?$/.test(path))
+            return false;
+        // Cheap pre-filter: skip files that show no sign of React.
+        const lower = content;
+        for (const needle of FAST_FILTER_NEEDLES) {
+            if (lower.includes(needle))
+                return true;
+        }
+        return false;
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        const sf = parse(input);
+        if (!sf)
+            return { nodes, edges };
+        const components = [];
+        const hookNames = new Set();
+        // First pass: identify components at the top level.
+        for (const stmt of sf.statements) {
+            visitTopLevel(stmt, input, components);
+        }
+        // Second pass: walk every node, collect hook usages, attribute them
+        // to enclosing components when possible.
+        const enclosingComponent = (n) => {
+            for (const c of components) {
+                if (isAncestor(c.node, n))
+                    return c.id;
+            }
+            return undefined;
+        };
+        const visit = (n) => {
+            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && HOOK_NAME_RE.test(n.expression.text)) {
+                const hookName = n.expression.text;
+                hookNames.add(hookName);
+                const compId = enclosingComponent(n);
+                if (compId) {
+                    const hookId = `framework:react:hook-usage:${input.filePath}#${hookName}`;
+                    edges.push(edge(compId, hookId, EdgeKind.UsesHook, { hook: hookName }));
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        ts.forEachChild(sf, visit);
+        for (const c of components) {
+            const node = {
+                id: c.id,
+                kind: NodeKind.FrameworkEntity,
+                label: c.name,
+                path: input.filePath,
+                tags: ['react', 'component'],
+                data: { framework: 'react', subtype: 'component', name: c.name },
+            };
+            nodes.push(node);
+            edges.push(edge(input.fileNodeId, c.id, EdgeKind.FrameworkDeclares, { subtype: 'component' }));
+        }
+        for (const hook of hookNames) {
+            const node = {
+                id: `framework:react:hook-usage:${input.filePath}#${hook}`,
+                kind: NodeKind.FrameworkEntity,
+                label: hook,
+                path: input.filePath,
+                tags: ['react', 'hook-usage'],
+                data: { framework: 'react', subtype: 'hook-usage', hook },
+            };
+            nodes.push(node);
+            edges.push(edge(input.fileNodeId, node.id, EdgeKind.FrameworkDeclares, { subtype: 'hook-usage' }));
+        }
+        return { nodes, edges };
+    },
+};
+function visitTopLevel(stmt, input, out) {
+    // export const Foo = () => <div />;
+    if (ts.isVariableStatement(stmt)) {
+        for (const decl of stmt.declarationList.declarations) {
+            if (!ts.isIdentifier(decl.name))
+                continue;
+            const name = decl.name.text;
+            if (!/^[A-Z]/.test(name))
+                continue;
+            const init = decl.initializer;
+            if (!init)
+                continue;
+            if (containsJsx(init)) {
+                out.push({ id: makeComponentId(input.filePath, name), name, node: init });
+            }
+        }
+        return;
+    }
+    // function Foo() { return <div />; }
+    if (ts.isFunctionDeclaration(stmt) && stmt.name && /^[A-Z]/.test(stmt.name.text)) {
+        if (containsJsx(stmt)) {
+            out.push({ id: makeComponentId(input.filePath, stmt.name.text), name: stmt.name.text, node: stmt });
+        }
+        return;
+    }
+    // export default function Foo() {}
+    if (ts.isExportAssignment(stmt) && ts.isFunctionExpression(stmt.expression)) {
+        const name = stmt.expression.name?.text ?? 'Default';
+        if (/^[A-Z]/.test(name) && containsJsx(stmt.expression)) {
+            out.push({ id: makeComponentId(input.filePath, name), name, node: stmt.expression });
+        }
+        return;
+    }
+    // class Foo extends React.Component { render() { return <div />; } }
+    if (ts.isClassDeclaration(stmt) && stmt.name && /^[A-Z]/.test(stmt.name.text)) {
+        if (extendsComponent(stmt) || containsJsx(stmt)) {
+            out.push({ id: makeComponentId(input.filePath, stmt.name.text), name: stmt.name.text, node: stmt });
+        }
+        return;
+    }
+}
+function containsJsx(node) {
+    let found = false;
+    const visit = (n) => {
+        if (found)
+            return;
+        if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(n, visit);
+    };
+    visit(node);
+    return found;
+}
+function extendsComponent(cls) {
+    if (!cls.heritageClauses)
+        return false;
+    for (const h of cls.heritageClauses) {
+        if (h.token !== ts.SyntaxKind.ExtendsKeyword)
+            continue;
+        for (const t of h.types) {
+            const text = t.expression.getText();
+            if (text === 'Component' || text === 'React.Component' || text === 'PureComponent' || text === 'React.PureComponent') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isAncestor(ancestor, descendant) {
+    let cur = descendant;
+    while (cur) {
+        if (cur === ancestor)
+            return true;
+        cur = cur.parent;
+    }
+    return false;
+}
+function makeComponentId(path, name) {
+    return `framework:react:component:${path}#${name}`;
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: REACT_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/solid-extractor.d.ts

@@ -0,0 +1,19 @@
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+export declare const SOLID_EXTRACTOR_SOURCE = "solid-extractor@v1";
+/**
+ * Solid extractor.
+ *
+ * Detection (heuristic — no type info):
+ *   - Top-level `function Component()` / `const Component = (...)` with a
+ *     name starting with an uppercase letter and a body that produces
+ *     JSX → component entity.
+ *   - Uses of `createSignal`, `createEffect`, `createMemo`,
+ *     `createStore`, etc. → primitive-usage entities, linked to the
+ *     enclosing component via UsesHook edges.
+ *
+ * Same shape as the React extractor; lives separately because the
+ * detection heuristics (Solid uses primitives instead of hooks) and
+ * fast-filter needles differ.
+ */
+export declare const solidExtractor: IFrameworkExtractor;
+//# sourceMappingURL=solid-extractor.d.ts.map

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

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