cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/vue/scope-resolver.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * Vue `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3, issue #940).
+ *
+ * ## Design rationale
+ *
+ * Vue SFCs compile down to TypeScript/JavaScript — the `<script>` /
+ * `<script setup>` block is pure TS/JS, parsed with the TypeScript
+ * grammar and captured by `emitVueScopeCaptures` (which delegates
+ * to `emitTsScopeCaptures`).  Because of this, nearly all hooks are
+ * identical to the TypeScript resolver:
+ *
+ *   - `mergeBindings` — TypeScript LEGB semantics apply in script blocks.
+ *   - `arityCompatibility` — same positional + rest rules.
+ *   - `buildMro` / `populateOwners` — shared with TypeScript.
+ *   - `isSuperReceiver` — `super(...)` / `super.foo` / `super[x]` pattern.
+ *   - `resolveImportTarget` — TypeScript resolver with `.vue` explicit-
+ *                             extension support; tsconfig paths loaded via
+ *                             `loadResolutionConfig`.
+ *
+ * ## Key differences from TypeScript
+ *
+ *   - `language: SupportedLanguages.Vue` — routes the resolver to Vue
+ *     files only; TypeScript files use the TypeScript resolver.
+ *   - `languageProvider: vueProvider` — the Vue-specific language
+ *     provider supplies the right built-ins and export checker for
+ *     `<script setup>` (all top-level bindings implicitly exported).
+ *   - `importEdgeReason: 'vue-scope: import'` — distinct tag for
+ *     debugging / edge provenance.
+ *   - `allowGlobalFreeCallFallback: false` — Vue uses explicit imports;
+ *     workspace-wide unique-name fallback is unnecessary and would
+ *     produce spurious edges for Vue built-ins (ref, reactive, …).
+ *
+ * ## Options API / this-binding
+ *
+ * Options API (`defineComponent({ methods: { … } })`) stores methods
+ * on the component instance, which tree-sitter sees as object property
+ * values.  `this.X()` inside a method resolves via the existing
+ * `tsReceiverBinding` hook (inherited from TypeScript), which walks to
+ * the enclosing Class scope.  For Options API the enclosing "class" is
+ * the `defineComponent({…})` object — not a true class — so `this`
+ * calls may not resolve through the type-binding layer.  `fieldFallbackOnMethodLookup`
+ * is therefore set to `true` so the field-name fallback catches common
+ * patterns even without an explicit type annotation.
+ *
+ * ## `<script setup>` macro calls
+ *
+ * `defineProps`, `defineEmits`, `defineExpose`, `withDefaults`, etc.
+ * are compiler macros available as globals inside `<script setup>`.
+ * They are listed in `vueProvider.builtInNames` and therefore treated
+ * as resolved without requiring an import edge.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vueScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const utils_js_1 = require("../../../../lib/utils.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const node_lookup_js_1 = require("../../scope-resolution/graph-bridge/node-lookup.js");
+const vue_js_1 = require("../vue.js");
+const language_config_js_1 = require("../../language-config.js");
+const index_js_2 = require("../typescript/index.js");
+const import_target_js_1 = require("./import-target.js");
+const vue_sfc_extractor_js_1 = require("../../vue-sfc-extractor.js");
+const scope_extractor_bridge_js_1 = require("../../scope-extractor-bridge.js");
+// Languages whose files may be pulled into the Vue scope-resolution pass
+// as import-closure context (`.vue` → `.ts` / `.js` cross-file resolution).
+const VUE_SCOPE_CONTEXT_LANGUAGES = new Set([
+    index_js_1.SupportedLanguages.Vue,
+    index_js_1.SupportedLanguages.TypeScript,
+    index_js_1.SupportedLanguages.JavaScript,
+]);
+function isVueScopeContextLanguage(lang) {
+    return lang !== null && VUE_SCOPE_CONTEXT_LANGUAGES.has(lang);
+}
+const vueScopeResolver = {
+    language: index_js_1.SupportedLanguages.Vue,
+    languageProvider: vue_js_1.vueProvider,
+    importEdgeReason: 'vue-scope: import',
+    resolveImportTarget: (0, import_target_js_1.makeVueResolveImportTarget)(),
+    // Vue projects universally use TypeScript — load tsconfig so path
+    // aliases (`@/`, `~/`, `#/`) resolve through the standard branch.
+    loadResolutionConfig: async (repoPath) => ({
+        tsconfigPaths: await (0, language_config_js_1.loadTsconfigPaths)(repoPath),
+    }),
+    // TypeScript LEGB semantics apply inside `<script>` / `<script setup>`.
+    mergeBindings: (existing, incoming) => [...(0, index_js_2.typescriptMergeBindings)([...existing, ...incoming])],
+    // Adapter: typescriptArityCompatibility uses (def, callsite); contract is (callsite, def).
+    arityCompatibility: (callsite, def) => (0, index_js_2.typescriptArityCompatibility)(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize),
+    populateOwners: (parsed) => (0, walkers_js_1.populateClassOwnedMembers)(parsed),
+    isSuperReceiver: (text) => /^super(\s*\(|\s*\.|\s*\[|\s*$)/.test(text.trim()),
+    // Options API `this.X()` calls may not resolve through the type-binding
+    // layer (no formal class declaration), so enable the field-fallback
+    // heuristic to catch them via declared field names.
+    fieldFallbackOnMethodLookup: true,
+    // Return-type propagation mirrors TypeScript.
+    propagatesReturnTypesAcrossImports: true,
+    hoistTypeBindingsToModule: true,
+    // Vue uses explicit imports for all external symbols; no global free-
+    // call fallback needed (would produce spurious edges for built-ins).
+    allowGlobalFreeCallFallback: false,
+    /**
+     * Expand the scope-resolution file universe for Vue by performing a
+     * transitive closure over imports starting from the primary `.vue` files.
+     *
+     * Vue SFCs import TypeScript/JavaScript modules (`import { fn } from './api'`),
+     * and those modules must be included in the Vue resolution pass for cross-file
+     * IMPORTS/CALLS edges to resolve correctly.  Without this expansion, only
+     * `.vue` files would be processed and all TS/JS imports would remain
+     * unresolved.
+     *
+     * Keeping this logic here (rather than hard-coding it in `phase.ts`) ensures
+     * that shared pipeline code remains language-agnostic.
+     */
+    collectScopeContextPaths({ primaryFilePaths, preExtractedByPath, entryFileContents, allScannedPaths, resolutionConfig, }) {
+        const resolveTargets = (targetRaw, fromFile) => {
+            const resolved = vueScopeResolver.resolveImportTarget(targetRaw, fromFile, allScannedPaths, resolutionConfig);
+            if (resolved === null)
+                return [];
+            if (typeof resolved === 'string')
+                return [resolved];
+            return resolved;
+        };
+        const visited = new Set(primaryFilePaths);
+        const queue = [...primaryFilePaths];
+        const fallbackParsed = new Map();
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === undefined)
+                break;
+            let parsed = preExtractedByPath.get(current) ?? fallbackParsed.get(current) ?? undefined;
+            if (parsed === undefined) {
+                const source = entryFileContents.get(current);
+                if (source !== undefined) {
+                    parsed = (0, scope_extractor_bridge_js_1.extractParsedFile)(vue_js_1.vueProvider, source, current);
+                    if (parsed !== undefined)
+                        fallbackParsed.set(current, parsed);
+                }
+            }
+            if (parsed === undefined)
+                continue;
+            for (const parsedImport of parsed.parsedImports) {
+                if (parsedImport.targetRaw.trim().length === 0)
+                    continue;
+                for (const targetPath of resolveTargets(parsedImport.targetRaw, current)) {
+                    if (!allScannedPaths.has(targetPath))
+                        continue;
+                    if (!isVueScopeContextLanguage((0, index_js_1.getLanguageFromFilename)(targetPath)))
+                        continue;
+                    if (visited.has(targetPath))
+                        continue;
+                    visited.add(targetPath);
+                    queue.push(targetPath);
+                }
+            }
+        }
+        return visited;
+    },
+    /**
+     * Emit template-derived edges after standard scope-resolution passes.
+     *
+     * Six edge categories (all scoped to `.vue` files only):
+     *
+     *   1. **CALLS** (`vue-template-component`)
+     *      PascalCase component elements → the imported component's File node.
+     *      Source = the parent file (File node).
+     *
+     *   2. **CALLS** (`vue-template-callback`) — reserved for future use
+     *      (see category 3 below).
+     *
+     *   3. **CALLS** (`vue-template-callback`)
+     *      `@event="handler"` on a **native** HTML element (`<button>`, `<input>`).
+     *      Source = the parent file (File node). Target = handler Function/Method.
+     *
+     *   4. **BINDS_EVENT_HANDLER** (`vue-event: @<eventName>`)
+     *      `@event="handler"` on a **component** element.
+     *      Source = the handler Function/Method node in the parent file.
+     *      Target = the child component's File node.
+     *
+     *   5. **EMITS_EVENT** (`vue-emit: <eventName>`)
+     *      `emit('eventName', …)` / `this.$emit('eventName', …)` in script block.
+     *      Source = the file's own File node (self-referential annotation).
+     *      Target = the same File node.
+     *      These "hanging" edges join with BINDS_EVENT_HANDLER via Cypher query
+     *      on the shared component File node to reveal handler/emitter pairs.
+     *
+     *   6. **ACCESSES** (`vue-template-attribute`)
+     *      `:prop="varName"` bound-attribute references.
+     *      Source = the file's File node. Target = resolved variable node.
+     */
+    emitPostResolutionEdges(graph, parsedFiles, nodeLookup, indexes, ctx) {
+        for (const parsedFile of parsedFiles) {
+            if (!parsedFile.filePath.endsWith('.vue'))
+                continue;
+            const content = ctx.fileContents.get(parsedFile.filePath);
+            if (!content)
+                continue;
+            const fileId = (0, utils_js_1.generateId)('File', parsedFile.filePath);
+            // Build localName → resolved targetFile from finalized import edges.
+            const importTargetByName = new Map();
+            for (const [scopeId, edges] of indexes.imports) {
+                const scope = indexes.scopeTree.getScope(scopeId);
+                if (scope?.filePath !== parsedFile.filePath)
+                    continue;
+                for (const edge of edges) {
+                    if (edge.targetFile !== null && edge.localName) {
+                        importTargetByName.set(edge.localName, edge.targetFile);
+                    }
+                }
+            }
+            // Extract all template/script edge data in a single pass — avoids
+            // re-running TEMPLATE_RE for each individual extractor call.
+            const { templateComponents, nativeEventHandlers, componentEventBindings, scriptEmitCalls, templateAttributeBindings, } = (0, vue_sfc_extractor_js_1.extractVueTemplateEdgeData)(content, { sourceKind: 'full-sfc' });
+            // 1 — Component-reference CALLS
+            for (const componentName of templateComponents) {
+                const targetFile = importTargetByName.get(componentName);
+                if (!targetFile)
+                    continue;
+                const targetFileId = (0, utils_js_1.generateId)('File', targetFile);
+                if (!graph.getNode(targetFileId))
+                    continue;
+                graph.addRelationship({
+                    id: (0, utils_js_1.generateId)('CALLS', `${fileId}:${componentName}->${targetFileId}`),
+                    sourceId: fileId,
+                    targetId: targetFileId,
+                    type: 'CALLS',
+                    confidence: 0.9,
+                    reason: 'vue-template-component',
+                });
+            }
+            // 3 — Native-element event-handler CALLS (@click="method" on <button> etc.)
+            for (const handlerName of nativeEventHandlers) {
+                const handlerNodeId = nodeLookup.get((0, node_lookup_js_1.simpleKey)(parsedFile.filePath, handlerName));
+                if (!handlerNodeId)
+                    continue;
+                graph.addRelationship({
+                    id: (0, utils_js_1.generateId)('CALLS', `${fileId}:@native:${handlerName}->${handlerNodeId}`),
+                    sourceId: fileId,
+                    targetId: handlerNodeId,
+                    type: 'CALLS',
+                    confidence: 0.9,
+                    reason: 'vue-template-callback',
+                });
+            }
+            // 4 — BINDS_EVENT_HANDLER: component event bindings (@event="handler" on component elements)
+            for (const { componentName, eventName, handlerName } of componentEventBindings) {
+                const targetFile = importTargetByName.get(componentName);
+                if (!targetFile)
+                    continue;
+                const targetFileId = (0, utils_js_1.generateId)('File', targetFile);
+                if (!graph.getNode(targetFileId))
+                    continue;
+                const handlerNodeId = nodeLookup.get((0, node_lookup_js_1.simpleKey)(parsedFile.filePath, handlerName));
+                if (!handlerNodeId)
+                    continue;
+                graph.addRelationship({
+                    id: (0, utils_js_1.generateId)('BINDS_EVENT_HANDLER', `${handlerNodeId}:@${eventName}->${targetFileId}`),
+                    sourceId: handlerNodeId,
+                    targetId: targetFileId,
+                    type: 'BINDS_EVENT_HANDLER',
+                    confidence: 0.9,
+                    reason: `vue-event: @${eventName}`,
+                });
+            }
+            // 5 — EMITS_EVENT: emit() / this.$emit() calls (self-referential annotation)
+            for (const { eventName } of scriptEmitCalls) {
+                graph.addRelationship({
+                    id: (0, utils_js_1.generateId)('EMITS_EVENT', `${fileId}:emit:${eventName}`),
+                    sourceId: fileId,
+                    targetId: fileId,
+                    type: 'EMITS_EVENT',
+                    confidence: 0.9,
+                    reason: `vue-emit: ${eventName}`,
+                });
+            }
+            // 6 — ACCESSES: bound-attribute references (:prop="varName")
+            for (const varName of templateAttributeBindings) {
+                const varNodeId = nodeLookup.get((0, node_lookup_js_1.simpleKey)(parsedFile.filePath, varName));
+                if (!varNodeId)
+                    continue;
+                graph.addRelationship({
+                    id: (0, utils_js_1.generateId)('ACCESSES', `${fileId}:bind:${varName}->${varNodeId}`),
+                    sourceId: fileId,
+                    targetId: varNodeId,
+                    type: 'ACCESSES',
+                    confidence: 0.8,
+                    reason: 'vue-template-attribute',
+                });
+            }
+        }
+    },
+};
+exports.vueScopeResolver = vueScopeResolver;

package/dist/core/code/engine/core/ingestion/languages/vue.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Vue language provider.
+ *
+ * Vue SFCs are preprocessed by extracting the <script> / <script setup>
+ * block content, which is then parsed as TypeScript. This provider reuses
+ * nearly all TypeScript infrastructure — queries, type config, field
+ * extraction, and named binding extraction.
+ *
+ * Export detection for <script setup> is handled directly in the parse
+ * worker (all top-level bindings are implicitly exported). The export
+ * checker here is used as fallback for non-setup <script> blocks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vueProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const typescript_javascript_js_1 = require("../class-extractors/configs/typescript-javascript.js");
+const language_provider_js_1 = require("../language-provider.js");
+const typescript_js_1 = require("../type-extractors/typescript.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const typescript_javascript_js_2 = require("../import-resolvers/configs/typescript-javascript.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const typescript_js_2 = require("../field-extractors/typescript.js");
+const typescript_js_3 = require("./typescript.js");
+const generic_js_2 = require("../variable-extractors/generic.js");
+const typescript_javascript_js_3 = require("../variable-extractors/configs/typescript-javascript.js");
+const generic_js_3 = require("../call-extractors/generic.js");
+const typescript_javascript_js_4 = require("../call-extractors/configs/typescript-javascript.js");
+const index_js_2 = require("./typescript/index.js");
+const captures_js_1 = require("./vue/captures.js");
+const typescript_js_4 = require("../cfg/visitors/typescript.js");
+const VUE_SPECIFIC_BUILT_INS = [
+    'ref',
+    'reactive',
+    'computed',
+    'watch',
+    'watchEffect',
+    'onMounted',
+    'onUnmounted',
+    'onBeforeMount',
+    'onBeforeUnmount',
+    'onUpdated',
+    'onBeforeUpdate',
+    'nextTick',
+    'defineProps',
+    'defineEmits',
+    'defineExpose',
+    'defineOptions',
+    'defineSlots',
+    'defineModel',
+    'withDefaults',
+    'toRef',
+    'toRefs',
+    'unref',
+    'isRef',
+    'shallowRef',
+    'triggerRef',
+    'provide',
+    'inject',
+    'useSlots',
+    'useAttrs',
+];
+const VUE_BUILT_INS = new Set([...typescript_js_3.BUILT_INS, ...VUE_SPECIFIC_BUILT_INS]);
+const vueClassExtractor = (0, generic_js_1.createClassExtractor)(typescript_javascript_js_1.vueClassConfig);
+exports.vueProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.Vue,
+    extensions: ['.vue'],
+    entryPointPatterns: [],
+    astFrameworkPatterns: [],
+    treeSitterQueries: tree_sitter_queries_js_1.TYPESCRIPT_QUERIES,
+    typeConfig: typescript_js_1.typeConfig,
+    exportChecker: export_detection_js_1.tsExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(typescript_javascript_js_2.vueImportConfig),
+    callExtractor: (0, generic_js_3.createCallExtractor)(typescript_javascript_js_4.typescriptCallConfig),
+    fieldExtractor: typescript_js_2.typescriptFieldExtractor,
+    variableExtractor: (0, generic_js_2.createVariableExtractor)(typescript_javascript_js_3.typescriptVariableConfig),
+    classExtractor: vueClassExtractor,
+    builtInNames: VUE_BUILT_INS,
+    // Vue SFC <script> blocks are extracted and parsed with the TypeScript
+    // grammar (parse-worker GRAMMAR_BY_LANGUAGE[Vue] = TypeScript.typescript),
+    // so the TS CFG visitor builds CFGs for the script's functions verbatim —
+    // no Vue-specific visitor needed (#2195).
+    cfgVisitor: (0, typescript_js_4.createTypeScriptCfgVisitor)(),
+    // Scope-resolution pipeline hooks (RFC #909 Ring 3)
+    emitScopeCaptures: captures_js_1.emitVueScopeCaptures,
+    interpretImport: index_js_2.interpretTsImport,
+    interpretTypeBinding: index_js_2.interpretTsTypeBinding,
+    bindingScopeFor: index_js_2.tsBindingScopeFor,
+    importOwningScope: index_js_2.tsImportOwningScope,
+    receiverBinding: index_js_2.tsReceiverBinding,
+    mergeBindings: (_scope, bindings) => (0, index_js_2.typescriptMergeBindings)(bindings),
+    arityCompatibility: index_js_2.typescriptArityCompatibility,
+    resolveImportTarget: index_js_2.resolveTsImportTarget,
+});

package/dist/core/code/engine/core/ingestion/local-symbol-pruner.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneLocalValueSymbols = exports.shouldKeepLocalValueSymbols = void 0;
+const env_js_1 = require("./utils/env.js");
+const LOCAL_VALUE_LABELS = new Set(['Const', 'Variable', 'Static']);
+const KEEP_LOCAL_VALUE_SYMBOLS_ENV = 'CGRAPH_KEEP_LOCAL_VALUE_SYMBOLS';
+const shouldKeepLocalValueSymbols = () => (0, env_js_1.parseTruthyEnv)(process.env[KEEP_LOCAL_VALUE_SYMBOLS_ENV]);
+exports.shouldKeepLocalValueSymbols = shouldKeepLocalValueSymbols;
+const emptyStats = (skippedByEnv) => ({
+    candidateNodes: 0,
+    prunedNodes: 0,
+    keptWithSemanticEdges: 0,
+    skippedByEnv,
+});
+const isLocalValueCandidate = (node) => {
+    if (!LOCAL_VALUE_LABELS.has(node.label))
+        return false;
+    return node.properties.scope === 'block';
+};
+// True when `rel` is the structural `File -> DEFINES -> candidate` edge. Callers
+// guard on the candidate already being the edge target, so only the source label
+// needs checking here.
+const isFileDefinesEdge = (graph, type, sourceId) => {
+    if (type !== 'DEFINES')
+        return false;
+    return graph.getNode(sourceId)?.label === 'File';
+};
+const pruneLocalValueSymbols = (graph, options = {}) => {
+    if (options.keepLocalValueSymbols ?? (0, exports.shouldKeepLocalValueSymbols)()) {
+        return emptyStats(true);
+    }
+    const candidateIds = new Set();
+    for (const node of graph.iterNodes()) {
+        if (isLocalValueCandidate(node))
+            candidateIds.add(node.id);
+    }
+    if (candidateIds.size === 0)
+        return emptyStats(false);
+    const candidatesWithSemanticEdges = new Set();
+    // Field-wise scan (#2680): a whole-graph walk that reads only these three, so
+    // materializing a relationship object per edge would be pure overhead.
+    graph.forEachRelationshipFields((sourceId, targetId, type) => {
+        // Any outgoing edge from a candidate is a semantic edge: the only structural
+        // edge a block-local value symbol carries is the incoming File -> DEFINES, on
+        // which the candidate is the target, never the source.
+        if (candidateIds.has(sourceId)) {
+            candidatesWithSemanticEdges.add(sourceId);
+        }
+        // An incoming edge is semantic unless it is the structural File -> DEFINES.
+        if (candidateIds.has(targetId) && !isFileDefinesEdge(graph, type, sourceId)) {
+            candidatesWithSemanticEdges.add(targetId);
+        }
+    });
+    let prunedNodes = 0;
+    for (const candidateId of candidateIds) {
+        if (candidatesWithSemanticEdges.has(candidateId))
+            continue;
+        if (graph.removeNode(candidateId))
+            prunedNodes++;
+    }
+    return {
+        candidateNodes: candidateIds.size,
+        prunedNodes,
+        keptWithSemanticEdges: candidatesWithSemanticEdges.size,
+        skippedByEnv: false,
+    };
+};
+exports.pruneLocalValueSymbols = pruneLocalValueSymbols;