@shrkcrft/framework-scanners 0.1.0-alpha.10

package/dist/extractors/vue-extractor.js

@@ -0,0 +1,125 @@
+import { createHash } from 'node:crypto';
+import { EdgeKind, NodeKind } from '@shrkcrft/graph';
+export const VUE_EXTRACTOR_SOURCE = 'vue-extractor@v1';
+const SCRIPT_OPEN_RE = /<script\b[^>]*>/i;
+const SCRIPT_CLOSE_RE = /<\/script>/i;
+const SETUP_RE = /<script[^>]*\bsetup\b[^>]*>/i;
+const DEFINE_COMPONENT_RE = /\b(defineComponent|defineAsyncComponent)\s*\(/;
+const COMPOSITION_HOOK_RE = /\b(ref|reactive|computed|watch|onMounted|onUnmounted|onBeforeMount|onUpdated)\s*\(/g;
+const NAME_OPTION_RE = /\bname\s*:\s*['"`]([^'"`]+)['"`]/;
+/**
+ * Vue extractor.
+ *
+ * Detection sources (in order):
+ *   1. `.vue` SFC files — always a component, named after the filename.
+ *   2. `.ts` / `.tsx` / `.js` / `.jsx` files containing
+ *      `defineComponent(` or `defineAsyncComponent(` — emits a
+ *      component entity per call.
+ *
+ * For SFC files we also detect Composition API hook usages from the
+ * `<script>` block via regex (lightweight — no template parsing).
+ *
+ * Out of scope: template parsing, <style> block detection, scoped slots.
+ */
+export const vueExtractor = {
+    framework: 'vue',
+    label: 'Vue',
+    fileMatches({ path, content }) {
+        if (path.endsWith('.vue'))
+            return true;
+        if (!/\.(?:t|j)sx?$/.test(path))
+            return false;
+        return DEFINE_COMPONENT_RE.test(content) || content.includes("from 'vue'") || content.includes('from "vue"');
+    },
+    extract(input) {
+        const nodes = [];
+        const edges = [];
+        if (input.filePath.endsWith('.vue')) {
+            extractFromSfc(input, nodes, edges);
+        }
+        else {
+            extractFromTs(input, nodes, edges);
+        }
+        return { nodes, edges };
+    },
+};
+function extractFromSfc(input, nodes, edges) {
+    const script = extractScriptBlock(input.content);
+    const isSetup = SETUP_RE.test(input.content);
+    // Component name from filename (without ext); honor `name:` option if present in script.
+    const filename = input.filePath.split('/').pop().replace(/\.vue$/, '');
+    let name = filename;
+    if (!isSetup) {
+        const m = script.match(NAME_OPTION_RE);
+        if (m)
+            name = m[1];
+    }
+    const entity = makeEntity(input, 'component', name, {
+        sfc: true,
+        setup: isSetup,
+    });
+    nodes.push(entity);
+    edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype: 'component' }));
+    // Composition API hook usages.
+    const hooks = new Set();
+    let m;
+    COMPOSITION_HOOK_RE.lastIndex = 0;
+    while ((m = COMPOSITION_HOOK_RE.exec(script)) !== null) {
+        hooks.add(m[1]);
+    }
+    for (const hook of hooks) {
+        const hookEntity = makeEntity(input, 'hook-usage', hook, { hook });
+        nodes.push(hookEntity);
+        edges.push(edge(entity.id, hookEntity.id, EdgeKind.UsesHook, { hook }));
+        edges.push(edge(input.fileNodeId, hookEntity.id, EdgeKind.FrameworkDeclares, { subtype: 'hook-usage' }));
+    }
+}
+function extractFromTs(input, nodes, edges) {
+    // Walk every `defineComponent(...)` call. We don't need an AST —
+    // regex with a captured-string `name:` option is enough for the MVP.
+    const re = /\bdefineComponent\s*\(\s*\{([^}]*)\}/g;
+    let m;
+    let idx = 0;
+    while ((m = re.exec(input.content)) !== null) {
+        idx += 1;
+        const body = m[1] ?? '';
+        const nameMatch = body.match(NAME_OPTION_RE);
+        const name = nameMatch ? nameMatch[1] : `Component${idx}`;
+        const entity = makeEntity(input, 'component', name, { sfc: false });
+        nodes.push(entity);
+        edges.push(edge(input.fileNodeId, entity.id, EdgeKind.FrameworkDeclares, { subtype: 'component' }));
+    }
+}
+function extractScriptBlock(content) {
+    const open = content.search(SCRIPT_OPEN_RE);
+    if (open < 0)
+        return '';
+    const after = content.slice(open).indexOf('>');
+    if (after < 0)
+        return '';
+    const start = open + after + 1;
+    const closeIdx = content.slice(start).search(SCRIPT_CLOSE_RE);
+    if (closeIdx < 0)
+        return content.slice(start);
+    return content.slice(start, start + closeIdx);
+}
+function makeEntity(input, subtype, name, extra) {
+    return {
+        id: `framework:vue:${subtype}:${input.filePath}#${name}`,
+        kind: NodeKind.FrameworkEntity,
+        label: name,
+        path: input.filePath,
+        tags: ['vue', subtype],
+        data: { framework: 'vue', subtype, name, ...extra },
+    };
+}
+function edge(from, to, kind, data) {
+    return {
+        id: createHash('sha1').update(`${from}|${to}|${kind}`).digest('hex'),
+        from,
+        to,
+        kind,
+        source: VUE_EXTRACTOR_SOURCE,
+        ...(data ? { data } : {}),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export * from './schema/framework-schema.js';
+export * from './extractor-api/framework-extractor.js';
+export * from './extractor-api/extractor-registry.js';
+export * from './extractors/nestjs-extractor.js';
+export * from './extractors/react-extractor.js';
+export * from './extractors/express-extractor.js';
+export * from './extractors/nextjs-extractor.js';
+export * from './extractors/angular-extractor.js';
+export * from './extractors/vue-extractor.js';
+export * from './extractors/svelte-extractor.js';
+export * from './extractors/fastify-extractor.js';
+export * from './extractors/fastapi-extractor.js';
+export * from './extractors/solid-extractor.js';
+export * from './extractors/astro-extractor.js';
+export * from './extractors/django-extractor.js';
+export * from './extractors/flask-extractor.js';
+export * from './extractors/spring-extractor.js';
+export * from './extractors/rails-extractor.js';
+export * from './extractors/phoenix-extractor.js';
+export * from './extractors/graphql-extractor.js';
+export * from './extractors/laravel-extractor.js';
+export * from './extractors/flutter-extractor.js';
+export * from './store/framework-store.js';
+export * from './runner/run-extractors.js';
+export * from './runner/load-pack-extractors.js';
+export * from './query/framework-query-api.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wCAAwC,CAAC;AACvD,cAAc,uCAAuC,CAAC;AACtD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+export * from "./schema/framework-schema.js";
+export * from "./extractor-api/framework-extractor.js";
+export * from "./extractor-api/extractor-registry.js";
+export * from "./extractors/nestjs-extractor.js";
+export * from "./extractors/react-extractor.js";
+export * from "./extractors/express-extractor.js";
+export * from "./extractors/nextjs-extractor.js";
+export * from "./extractors/angular-extractor.js";
+export * from "./extractors/vue-extractor.js";
+export * from "./extractors/svelte-extractor.js";
+export * from "./extractors/fastify-extractor.js";
+export * from "./extractors/fastapi-extractor.js";
+export * from "./extractors/solid-extractor.js";
+export * from "./extractors/astro-extractor.js";
+export * from "./extractors/django-extractor.js";
+export * from "./extractors/flask-extractor.js";
+export * from "./extractors/spring-extractor.js";
+export * from "./extractors/rails-extractor.js";
+export * from "./extractors/phoenix-extractor.js";
+export * from "./extractors/graphql-extractor.js";
+export * from "./extractors/laravel-extractor.js";
+export * from "./extractors/flutter-extractor.js";
+export * from "./store/framework-store.js";
+export * from "./runner/run-extractors.js";
+export * from "./runner/load-pack-extractors.js";
+export * from "./query/framework-query-api.js";

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

@@ -0,0 +1,39 @@
+import type { IEdge, INode } from '@shrkcrft/graph';
+import type { IFrameworkSnapshot } from '../schema/framework-schema.js';
+export interface IFrameworkListOptions {
+    framework?: string;
+    subtype?: string;
+    /** Filter by project-relative file path. */
+    file?: string;
+    /** Cap on returned entities. Default 200. */
+    limit?: number;
+}
+/**
+ * Read-only query API for the framework snapshot. Merges in-memory
+ * with the code-graph snapshot when callers need cross-store joins
+ * (e.g. "entities declared in file F"). For the MVP the file
+ * relationship is read from the framework store's edges directly.
+ */
+export declare class FrameworkQueryApi {
+    private readonly snap;
+    private readonly entitiesByFile;
+    private readonly entitiesByKey;
+    constructor(snap: IFrameworkSnapshot);
+    static fromStore(projectRoot: string): FrameworkQueryApi;
+    static missingDescription(projectRoot: string): string | undefined;
+    manifest(): IFrameworkSnapshot['manifest'];
+    /** Entities declared in a specific file. */
+    forFile(filePath: string): readonly INode[];
+    /** List entities, optionally filtered by framework + subtype + file. */
+    list(opts?: IFrameworkListOptions): readonly INode[];
+    /** Returns all NestJS routes flattened to `{method, path, handler, file}`. */
+    routes(): readonly {
+        method: string;
+        path: string;
+        handler: string;
+        file: string;
+    }[];
+    /** All framework-scoped edges. */
+    edges(): readonly IEdge[];
+}
+//# sourceMappingURL=framework-query-api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"framework-query-api.d.ts","sourceRoot":"","sources":["../../src/query/framework-query-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAExE,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,qBAAa,iBAAiB;IAIhB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwC;IACvE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAwC;gBAEzC,IAAI,EAAE,kBAAkB;IAkBrD,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,iBAAiB;IAKxD,MAAM,CAAC,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKlE,QAAQ,IAAI,kBAAkB,CAAC,UAAU,CAAC;IAI1C,4CAA4C;IAC5C,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,KAAK,EAAE;IAI3C,wEAAwE;IACxE,IAAI,CAAC,IAAI,GAAE,qBAA0B,GAAG,SAAS,KAAK,EAAE;IAoBxD,8EAA8E;IAC9E,MAAM,IAAI,SAAS;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE;IAiBpF,kCAAkC;IAClC,KAAK,IAAI,SAAS,KAAK,EAAE;CAG1B"}

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

@@ -0,0 +1,99 @@
+import { FrameworkStore } from "../store/framework-store.js";
+/**
+ * Read-only query API for the framework snapshot. Merges in-memory
+ * with the code-graph snapshot when callers need cross-store joins
+ * (e.g. "entities declared in file F"). For the MVP the file
+ * relationship is read from the framework store's edges directly.
+ */
+export class FrameworkQueryApi {
+    snap;
+    entitiesByFile;
+    entitiesByKey;
+    constructor(snap) {
+        this.snap = snap;
+        const byFile = new Map();
+        const byKey = new Map();
+        for (const n of snap.nodes.values()) {
+            if (n.path) {
+                const list = byFile.get(n.path);
+                if (list)
+                    list.push(n);
+                else
+                    byFile.set(n.path, [n]);
+            }
+            const key = `${n.data?.['framework'] ?? '?'}:${n.data?.['subtype'] ?? '?'}`;
+            const klist = byKey.get(key);
+            if (klist)
+                klist.push(n);
+            else
+                byKey.set(key, [n]);
+        }
+        this.entitiesByFile = byFile;
+        this.entitiesByKey = byKey;
+    }
+    static fromStore(projectRoot) {
+        const s = new FrameworkStore(projectRoot).loadSnapshot();
+        return new FrameworkQueryApi(s);
+    }
+    static missingDescription(projectRoot) {
+        const exists = new FrameworkStore(projectRoot).exists();
+        return exists ? undefined : "Framework store missing. Run 'shrk framework index'.";
+    }
+    manifest() {
+        return this.snap.manifest;
+    }
+    /** Entities declared in a specific file. */
+    forFile(filePath) {
+        return this.entitiesByFile.get(filePath) ?? [];
+    }
+    /** List entities, optionally filtered by framework + subtype + file. */
+    list(opts = {}) {
+        const limit = opts.limit ?? 200;
+        if (opts.framework && opts.subtype) {
+            const key = `${opts.framework}:${opts.subtype}`;
+            const hits = this.entitiesByKey.get(key) ?? [];
+            return filterFile(hits, opts.file).slice(0, limit);
+        }
+        const out = [];
+        for (const list of this.entitiesByKey.values()) {
+            for (const n of list) {
+                if (opts.framework && n.data?.['framework'] !== opts.framework)
+                    continue;
+                if (opts.subtype && n.data?.['subtype'] !== opts.subtype)
+                    continue;
+                if (opts.file && n.path !== opts.file)
+                    continue;
+                out.push(n);
+                if (out.length >= limit)
+                    return out;
+            }
+        }
+        return out;
+    }
+    /** Returns all NestJS routes flattened to `{method, path, handler, file}`. */
+    routes() {
+        const out = [];
+        for (const n of this.snap.nodes.values()) {
+            if (n.data?.['framework'] !== 'nestjs')
+                continue;
+            if (n.data?.['subtype'] !== 'route')
+                continue;
+            out.push({
+                method: n.data['method'] ?? '?',
+                path: n.data['path'] ?? '/',
+                handler: `${n.data['className'] ?? '?'}.${n.data['handler'] ?? '?'}`,
+                file: n.path ?? '',
+            });
+        }
+        return out.sort((a, b) => a.method.localeCompare(b.method) || a.path.localeCompare(b.path) || a.handler.localeCompare(b.handler));
+    }
+    /** All framework-scoped edges. */
+    edges() {
+        return [...this.snap.edges.values()];
+    }
+}
+function filterFile(nodes, file) {
+    if (!file)
+        return nodes;
+    return nodes.filter((n) => n.path === file);
+}

package/dist/runner/load-pack-extractors.d.ts

@@ -0,0 +1,36 @@
+import type { IPackDiscoveryResult } from '@shrkcrft/packs';
+import type { IFrameworkExtractor } from '../extractor-api/framework-extractor.js';
+import { FrameworkExtractorRegistry } from '../extractor-api/extractor-registry.js';
+export interface ILoadPackExtractorsResult {
+    /** Extractors loaded successfully. */
+    extractors: readonly IFrameworkExtractor[];
+    /** Free-form messages per skipped / failed pack. */
+    diagnostics: readonly string[];
+    /** Packs that contributed at least one extractor. */
+    packs: readonly string[];
+}
+/**
+ * Walk the pack discovery result and load any
+ * `contributions.frameworkExtractorFiles` declared by valid packs.
+ *
+ * Errors per pack become diagnostics — never propagated. Framework
+ * name collisions with built-in extractors (or with each other) are
+ * also diagnostics; the colliding contribution is skipped. Built-in
+ * extractors always win — packs may not shadow them.
+ *
+ * Pure: this loader does NOT mutate any registry on its own. The
+ * caller decides what to do with the returned extractors (typically
+ * `registry.register(ex)` against a `defaultRegistry()`).
+ */
+export declare function loadPackExtractors(discovery: IPackDiscoveryResult, builtinFrameworkNames: ReadonlySet<string>): Promise<ILoadPackExtractorsResult>;
+/**
+ * Convenience: build a `FrameworkExtractorRegistry` pre-populated with
+ * the built-ins AND with pack-contributed extractors. Diagnostics are
+ * available for surfacing in CLI / MCP output via the returned tuple.
+ */
+export declare function buildRegistryWithPacks(defaultRegistry: FrameworkExtractorRegistry, discovery: IPackDiscoveryResult): Promise<{
+    registry: FrameworkExtractorRegistry;
+    diagnostics: readonly string[];
+    packs: readonly string[];
+}>;
+//# sourceMappingURL=load-pack-extractors.d.ts.map

package/dist/runner/load-pack-extractors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-pack-extractors.d.ts","sourceRoot":"","sources":["../../src/runner/load-pack-extractors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAC;AAEpF,MAAM,WAAW,yBAAyB;IACxC,sCAAsC;IACtC,UAAU,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC3C,oDAAoD;IACpD,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,qDAAqD;IACrD,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,oBAAoB,EAC/B,qBAAqB,EAAE,WAAW,CAAC,MAAM,CAAC,GACzC,OAAO,CAAC,yBAAyB,CAAC,CAqDpC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,eAAe,EAAE,0BAA0B,EAC3C,SAAS,EAAE,oBAAoB,GAC9B,OAAO,CAAC;IAAE,QAAQ,EAAE,0BAA0B,CAAC;IAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC,CAa7G"}

package/dist/runner/load-pack-extractors.js

@@ -0,0 +1,87 @@
+import * as nodePath from 'node:path';
+import { safeImport } from '@shrkcrft/core';
+/**
+ * Walk the pack discovery result and load any
+ * `contributions.frameworkExtractorFiles` declared by valid packs.
+ *
+ * Errors per pack become diagnostics — never propagated. Framework
+ * name collisions with built-in extractors (or with each other) are
+ * also diagnostics; the colliding contribution is skipped. Built-in
+ * extractors always win — packs may not shadow them.
+ *
+ * Pure: this loader does NOT mutate any registry on its own. The
+ * caller decides what to do with the returned extractors (typically
+ * `registry.register(ex)` against a `defaultRegistry()`).
+ */
+export async function loadPackExtractors(discovery, builtinFrameworkNames) {
+    const extractors = [];
+    const diagnostics = [];
+    const packs = [];
+    const seenNames = new Set(builtinFrameworkNames);
+    for (const pack of discovery.validPacks) {
+        const files = pack.manifest?.contributions.frameworkExtractorFiles ?? [];
+        if (files.length === 0)
+            continue;
+        let contributedCount = 0;
+        for (const rel of files) {
+            const abs = nodePath.resolve(pack.packageRoot, rel);
+            const result = await safeImport(abs);
+            if (!result.ok) {
+                diagnostics.push(`${pack.packageName}:${rel}: load failed (${result.error.message})`);
+                continue;
+            }
+            const fromDefault = result.module.default;
+            const candidates = [];
+            if (Array.isArray(fromDefault)) {
+                candidates.push(...fromDefault);
+            }
+            else if (fromDefault && typeof fromDefault === 'object') {
+                candidates.push(fromDefault);
+            }
+            if (result.module.extractor)
+                candidates.push(result.module.extractor);
+            if (Array.isArray(result.module.extractors))
+                candidates.push(...result.module.extractors);
+            if (candidates.length === 0) {
+                diagnostics.push(`${pack.packageName}:${rel}: no extractor exports found`);
+                continue;
+            }
+            for (const ex of candidates) {
+                if (!ex || typeof ex !== 'object' || typeof ex.framework !== 'string' || typeof ex.fileMatches !== 'function' || typeof ex.extract !== 'function') {
+                    diagnostics.push(`${pack.packageName}:${rel}: invalid extractor shape (missing framework / fileMatches / extract)`);
+                    continue;
+                }
+                if (seenNames.has(ex.framework)) {
+                    diagnostics.push(`${pack.packageName}:${rel}: framework "${ex.framework}" already registered — skipping`);
+                    continue;
+                }
+                seenNames.add(ex.framework);
+                extractors.push(ex);
+                contributedCount += 1;
+            }
+        }
+        if (contributedCount > 0)
+            packs.push(pack.packageName);
+    }
+    return { extractors, diagnostics, packs };
+}
+/**
+ * Convenience: build a `FrameworkExtractorRegistry` pre-populated with
+ * the built-ins AND with pack-contributed extractors. Diagnostics are
+ * available for surfacing in CLI / MCP output via the returned tuple.
+ */
+export async function buildRegistryWithPacks(defaultRegistry, discovery) {
+    const builtinNames = new Set(defaultRegistry.list().map((e) => e.framework));
+    const loaded = await loadPackExtractors(discovery, builtinNames);
+    for (const ex of loaded.extractors) {
+        // `registry.register` throws on collision — we've already filtered
+        // duplicates above. Use a try/catch just in case.
+        try {
+            defaultRegistry.register(ex);
+        }
+        catch (e) {
+            loaded.diagnostics.concat(`${ex.framework}: register failed (${e.message})`);
+        }
+    }
+    return { registry: defaultRegistry, diagnostics: loaded.diagnostics, packs: loaded.packs };
+}

package/dist/runner/run-extractors.d.ts

@@ -0,0 +1,29 @@
+import { FrameworkExtractorRegistry } from '../extractor-api/extractor-registry.js';
+import { type IFrameworkManifest } from '../schema/framework-schema.js';
+export interface IRunExtractorsOptions {
+    projectRoot: string;
+    /** Custom registry (e.g. with pack-contributed extractors). Default: built-ins. */
+    registry?: FrameworkExtractorRegistry;
+    /** Restrict to a subset of frameworks (by name). */
+    only?: readonly string[];
+    /** Cap on files scanned (for tests). 0 = no cap. */
+    maxFiles?: number;
+}
+export interface IRunExtractorsResult {
+    manifest: IFrameworkManifest;
+    durationMs: number;
+    filesScanned: number;
+    diagnostics: readonly string[];
+}
+/** Built-in registry pre-populated with the bundled extractors. */
+export declare function defaultRegistry(): FrameworkExtractorRegistry;
+/**
+ * Walk the project's source files (via the code graph snapshot) and
+ * run every applicable framework extractor. Writes results to the
+ * framework store.
+ *
+ * The code graph must already exist — frameworks are *enriched* views
+ * over the graph, not a from-scratch index.
+ */
+export declare function runExtractors(options: IRunExtractorsOptions): IRunExtractorsResult;
+//# sourceMappingURL=run-extractors.d.ts.map

package/dist/runner/run-extractors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-extractors.d.ts","sourceRoot":"","sources":["../../src/runner/run-extractors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAC;AAqBpF,OAAO,EACL,KAAK,kBAAkB,EACxB,MAAM,+BAA+B,CAAC;AAIvC,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,0BAA0B,CAAC;IACtC,oDAAoD;IACpD,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,mEAAmE;AACnE,wBAAgB,eAAe,IAAI,0BAA0B,CAsB5D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,qBAAqB,GAAG,oBAAoB,CAoElF"}

package/dist/runner/run-extractors.js

@@ -0,0 +1,144 @@
+import { readFileSync } from 'node:fs';
+import { GraphQueryApi, GraphStore } from '@shrkcrft/graph';
+import { FrameworkExtractorRegistry } from "../extractor-api/extractor-registry.js";
+import { angularExtractor } from "../extractors/angular-extractor.js";
+import { astroExtractor } from "../extractors/astro-extractor.js";
+import { djangoExtractor } from "../extractors/django-extractor.js";
+import { expressExtractor } from "../extractors/express-extractor.js";
+import { fastapiExtractor } from "../extractors/fastapi-extractor.js";
+import { fastifyExtractor } from "../extractors/fastify-extractor.js";
+import { flaskExtractor } from "../extractors/flask-extractor.js";
+import { graphqlExtractor } from "../extractors/graphql-extractor.js";
+import { flutterExtractor } from "../extractors/flutter-extractor.js";
+import { laravelExtractor } from "../extractors/laravel-extractor.js";
+import { nestjsExtractor } from "../extractors/nestjs-extractor.js";
+import { nextjsExtractor } from "../extractors/nextjs-extractor.js";
+import { reactExtractor } from "../extractors/react-extractor.js";
+import { phoenixExtractor } from "../extractors/phoenix-extractor.js";
+import { railsExtractor } from "../extractors/rails-extractor.js";
+import { solidExtractor } from "../extractors/solid-extractor.js";
+import { springExtractor } from "../extractors/spring-extractor.js";
+import { svelteExtractor } from "../extractors/svelte-extractor.js";
+import { vueExtractor } from "../extractors/vue-extractor.js";
+import { FrameworkStore } from "../store/framework-store.js";
+import * as nodePath from 'node:path';
+/** Built-in registry pre-populated with the bundled extractors. */
+export function defaultRegistry() {
+    const r = new FrameworkExtractorRegistry();
+    r.register(nestjsExtractor);
+    r.register(reactExtractor);
+    r.register(expressExtractor);
+    r.register(nextjsExtractor);
+    r.register(angularExtractor);
+    r.register(vueExtractor);
+    r.register(svelteExtractor);
+    r.register(fastifyExtractor);
+    r.register(fastapiExtractor);
+    r.register(solidExtractor);
+    r.register(astroExtractor);
+    r.register(djangoExtractor);
+    r.register(flaskExtractor);
+    r.register(springExtractor);
+    r.register(railsExtractor);
+    r.register(phoenixExtractor);
+    r.register(graphqlExtractor);
+    r.register(laravelExtractor);
+    r.register(flutterExtractor);
+    return r;
+}
+/**
+ * Walk the project's source files (via the code graph snapshot) and
+ * run every applicable framework extractor. Writes results to the
+ * framework store.
+ *
+ * The code graph must already exist — frameworks are *enriched* views
+ * over the graph, not a from-scratch index.
+ */
+export function runExtractors(options) {
+    const start = Date.now();
+    const diagnostics = [];
+    const graphStore = new GraphStore(options.projectRoot);
+    if (!graphStore.exists()) {
+        throw new Error("code-graph store missing. Run 'shrk graph index' before 'shrk framework index'.");
+    }
+    const api = GraphQueryApi.fromStore(options.projectRoot);
+    const registry = options.registry ?? defaultRegistry();
+    const enabled = filterEnabled(registry, options.only);
+    const aggregateNodes = [];
+    const aggregateEdges = [];
+    const seenNodeIds = new Set();
+    const seenEdgeIds = new Set();
+    let filesScanned = 0;
+    for (const file of api.allFiles()) {
+        if (options.maxFiles && options.maxFiles > 0 && filesScanned >= options.maxFiles)
+            break;
+        if (!file.path)
+            continue;
+        filesScanned += 1;
+        let content;
+        try {
+            content = readFileSync(nodePath.resolve(options.projectRoot, file.path), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const ex of enabled) {
+            if (!safeMatches(ex, file.path, content, diagnostics))
+                continue;
+            try {
+                const result = ex.extract({ filePath: file.path, content, fileNodeId: file.id });
+                for (const n of result.nodes) {
+                    if (seenNodeIds.has(n.id))
+                        continue;
+                    seenNodeIds.add(n.id);
+                    aggregateNodes.push(n);
+                }
+                for (const e of result.edges) {
+                    if (seenEdgeIds.has(e.id))
+                        continue;
+                    seenEdgeIds.add(e.id);
+                    aggregateEdges.push(e);
+                }
+            }
+            catch (err) {
+                diagnostics.push(`${ex.framework}: ${file.path}: ${err.message}`);
+            }
+        }
+    }
+    const countsByFramework = {};
+    const countsBySubtype = {};
+    for (const n of aggregateNodes) {
+        const framework = String(n.data?.['framework'] ?? 'unknown');
+        const subtype = String(n.data?.['subtype'] ?? 'unknown');
+        countsByFramework[framework] = (countsByFramework[framework] ?? 0) + 1;
+        const key = `${framework}:${subtype}`;
+        countsBySubtype[key] = (countsBySubtype[key] ?? 0) + 1;
+    }
+    const frameworks = [...new Set(enabled.map((e) => e.framework))].sort();
+    const store = new FrameworkStore(options.projectRoot);
+    const manifest = store.writeSnapshot(aggregateNodes, aggregateEdges, {
+        projectRoot: options.projectRoot,
+        lastBuiltAt: new Date().toISOString(),
+        lastBuildDurationMs: Date.now() - start,
+        countsByFramework,
+        countsBySubtype,
+        frameworks,
+    });
+    return { manifest, durationMs: Date.now() - start, filesScanned, diagnostics };
+}
+function filterEnabled(registry, only) {
+    const all = registry.list();
+    if (!only || only.length === 0)
+        return all;
+    const set = new Set(only);
+    return all.filter((e) => set.has(e.framework));
+}
+function safeMatches(ex, path, content, diagnostics) {
+    try {
+        return ex.fileMatches({ path, content });
+    }
+    catch (e) {
+        diagnostics.push(`${ex.framework}: fileMatches threw on ${path}: ${e.message}`);
+        return false;
+    }
+}