gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/variable-extractors/generic.js

@@ -1,4 +1,23 @@
 // gitnexus/src/core/ingestion/variable-extractors/generic.ts
+/**
+ * Type-declaration node types whose body can be a bare `block`. tree-sitter-python
+ * models a class body as a `block` node — the same node type used for function and
+ * control-flow bodies — so a class attribute would otherwise look block-scoped. Most
+ * other grammars give class bodies dedicated node types (`class_body`,
+ * `declaration_list`, `body_statement`), which are not in the block-scope list below,
+ * so this guard is a no-op for them but keeps the rule language-agnostic.
+ */
+const CLASS_LIKE_CONTAINERS = new Set([
+    'class_definition',
+    'class_declaration',
+    'class_specifier',
+    'struct_item',
+    'impl_item',
+    'trait_item',
+    'interface_declaration',
+    'enum_declaration',
+    'object_declaration',
+]);
 /**
  * Create a VariableExtractor from a declarative config.
  */
@@ -26,7 +45,7 @@ export function createVariableExtractor(config) {
                 t === 'compilation_unit') {
                 return 'module';
             }
-            // Function/method/block boundaries indicate block scope
+            // Function/method boundaries indicate block scope
             if (t === 'function_declaration' ||
                 t === 'function_definition' ||
                 t === 'function_item' ||
@@ -35,11 +54,17 @@ export function createVariableExtractor(config) {
                 t === 'arrow_function' ||
                 t === 'function_expression' ||
                 t === 'lambda' ||
-                t === 'block' ||
                 t === 'function_body' ||
                 t === 'compound_statement') {
                 return 'block';
             }
+            // A bare `block` is block scope UNLESS it is a class body. A class member
+            // (e.g. Python `class C: MAX = 100`) is not an inert function-local — keep
+            // walking so it resolves to its true enclosing scope ('module' for a
+            // top-level class) instead of being misclassified and pruned.
+            if (t === 'block' && !(current.parent && CLASS_LIKE_CONTAINERS.has(current.parent.type))) {
+                return 'block';
+            }
             current = current.parent;
         }
         return 'file';
@@ -50,13 +75,16 @@ export function createVariableExtractor(config) {
             return allNodeTypes.has(node.type);
         },
         extract(node, context) {
+            return this.extractAll(node, context)[0] ?? null;
+        },
+        extractAll(node, context) {
             if (!allNodeTypes.has(node.type))
-                return null;
-            const name = config.extractName(node);
-            if (!name)
-                return null;
-            const type = config.extractType(node) ?? null;
-            const visibility = config.extractVisibility(node);
+                return [];
+            const names = config.extractNames
+                ? config.extractNames(node)
+                : [config.extractName(node)].filter((name) => Boolean(name));
+            if (names.length === 0)
+                return [];
             // isConst/isStatic: node type membership is a hint, but config.isConst/isStatic
             // has final say. For languages where const and non-const share a node type
             // (e.g., TS lexical_declaration for both const and let), config.isConst disambiguates.
@@ -64,17 +92,17 @@ export function createVariableExtractor(config) {
             const isStatic = staticNodeSet.has(node.type) || config.isStatic(node);
             const isMutable = config.isMutable(node);
             const scope = determineScope(node);
-            return {
+            return names.map((name) => ({
                 name,
-                type,
-                visibility,
+                type: config.extractTypeForName?.(node, name) ?? config.extractType(node) ?? null,
+                visibility: config.extractVisibilityForName?.(node, name) ?? config.extractVisibility(node),
                 isConst,
                 isStatic,
                 isMutable,
                 scope,
                 sourceFile: context.filePath,
                 line: node.startPosition.row + 1,
-            };
+            }));
         },
     };
 }

package/dist/core/ingestion/variable-types.d.ts

@@ -51,6 +51,9 @@ export interface VariableExtractor {
     /** Extract variable metadata from a declaration node.
      *  Returns null if the node is not a recognized variable declaration. */
     extract(node: SyntaxNode, context: VariableExtractorContext): VariableInfo | null;
+    /** Extract every variable metadata entry from a declaration node.
+     *  Returns [] if the node is not a recognized variable declaration. */
+    extractAll(node: SyntaxNode, context: VariableExtractorContext): VariableInfo[];
     /** Check if a node is a recognized variable declaration type. */
     isVariableDeclaration(node: SyntaxNode): boolean;
 }
@@ -69,10 +72,16 @@ export interface VariableExtractionConfig {
     variableNodeTypes: string[];
     /** Extract the variable name from a declaration node */
     extractName: (node: SyntaxNode) => string | undefined;
+    /** Extract multiple variable names from a declaration node. */
+    extractNames?: (node: SyntaxNode) => string[];
     /** Extract type annotation from a declaration node */
     extractType: (node: SyntaxNode) => string | undefined;
+    /** Extract type annotation for one variable name from a multi-name declaration. */
+    extractTypeForName?: (node: SyntaxNode, name: string) => string | undefined;
     /** Extract visibility from a declaration node */
     extractVisibility: (node: SyntaxNode) => VariableVisibility;
+    /** Extract visibility for one variable name from a multi-name declaration. */
+    extractVisibilityForName?: (node: SyntaxNode, name: string) => VariableVisibility;
     /** Check if a declaration is const/immutable */
     isConst: (node: SyntaxNode) => boolean;
     /** Check if a declaration is static */

package/dist/core/ingestion/vue-sfc-extractor.d.ts

@@ -9,19 +9,20 @@
 export interface VueScriptExtraction {
     /** Extracted script content (TypeScript/JavaScript) */
     scriptContent: string;
-    /** 0-based line number in the .vue file where the script content starts */
+    /** 1-based line number in the .vue file where the script content starts
+     * (used as offset from tree-sitter's 0-based row). */
     lineOffset: number;
-    /** true if the primary block is <script setup> */
+    /** true if at least one block is <script setup> */
     isSetup: boolean;
+    /** Value of the `lang` attribute on the extracted script block (e.g. "ts", "js", "tsx", "jsx", or "" for default). */
+    lang: string;
 }
 /**
  * Extract script content from a Vue SFC.
  *
- * When both <script> and <script setup> are present, returns only the
- * <script setup> block (the dominant pattern — 94% of Vue files in real
- * projects use setup). The <script> (non-setup) block typically contains
- * only `defineOptions` or legacy option merges and is less important for
- * the knowledge graph.
+ * When both <script> and <script setup> are present, the content of all
+ * blocks is combined (non-setup first, then setup) so the full script
+ * surface is available to the knowledge graph.
  */
 export declare function extractVueScript(vueContent: string): VueScriptExtraction | null;
 /**
@@ -42,3 +43,92 @@ export declare const isVueSetupTopLevel: (node: {
  * Returns deduplicated component names (e.g., ["MyButton", "AppHeader"]).
  */
 export declare function extractTemplateComponents(vueContent: string): string[];
+export interface ComponentEventBinding {
+    /** PascalCase name of the child component element (e.g. `"PostList"`). */
+    componentName: string;
+    /** Vue event name without the `@` prefix (e.g. `"select"`, `"keyup.enter"`). */
+    eventName: string;
+    /** Bare identifier of the parent handler function (e.g. `"onPostSelected"`). */
+    handlerName: string;
+}
+/**
+ * Extract Vue component event bindings from a `<template>` block.
+ *
+ * Scans PascalCase component elements (e.g. `<PostList>`, `<UserCard>`) and
+ * returns each `@event="handler"` binding found in the element's attribute
+ * block. Native HTML element event handlers (`@click` on `<button>`, etc.)
+ * are intentionally excluded — only component-to-component event bindings
+ * that go through Vue's `emit()` / `defineEmits` system are included.
+ *
+ * **Limitation:** component tags whose attribute block spans multiple lines
+ * and contains a `>` inside an attribute value are not captured (the regex
+ * stops at the first `>`). Full template AST parsing would be required for
+ * those edge cases (tracked in #1647).
+ */
+export declare function extractComponentEventBindings(vueContent: string): ComponentEventBinding[];
+/**
+ * Extract event handler names bound to native HTML elements in the template.
+ *
+ * Only processes lowercase-named elements (`<button>`, `<input>`, `<div>`,
+ * etc.) — PascalCase component elements are handled by
+ * `extractComponentEventBindings`. Returns bare handler identifiers only;
+ * inline expressions with arguments or arrow functions are excluded.
+ *
+ * These handlers represent direct DOM-event→function relationships and
+ * are emitted as `CALLS` edges (not `BINDS_EVENT_HANDLER`), because native
+ * events are synchronous browser callbacks, not Vue's component-event system.
+ */
+export declare function extractNativeElementEventHandlers(vueContent: string): string[];
+export interface ScriptEmitCall {
+    /** Vue event name passed to `emit()` (e.g. `"action"`, `"update"`). */
+    eventName: string;
+}
+export interface ExtractScriptEmitCallsOptions {
+    /**
+     * How to interpret the input text.
+     * - `full-sfc` (default): input is a full `.vue` SFC string.
+     * - `pre-extracted-script`: input is already the bare script text.
+     */
+    sourceKind?: 'full-sfc' | 'pre-extracted-script';
+}
+/**
+ * Extract `emit('eventName', ...)` calls from a Vue SFC's `<script>` block.
+ *
+ * Scans the raw SFC source (full `.vue` file), extracts the script content,
+ * then finds bare `emit('...')` calls. Only captures literal string event
+ * names — dynamic expressions (`emit(eventName)`) are excluded.
+ *
+ * Returns deduplicated emit declarations.
+ */
+export declare function extractScriptEmitCalls(vueContent: string, options?: ExtractScriptEmitCallsOptions): ScriptEmitCall[];
+/**
+ * Extract variable identifiers from Vue template bound-attribute values.
+ *
+ * Covers `:prop="varName"` and `v-bind:prop="varName"` patterns where
+ * the value is a single plain identifier.  Member-access expressions
+ * (`:key="post.id"`) and literals are excluded by design.
+ *
+ * Returns deduplicated identifier names.
+ */
+export declare function extractTemplateAttributeBindings(vueContent: string): string[];
+export interface VueTemplateEdgeData {
+    /** PascalCase component names referenced in the template. */
+    readonly templateComponents: readonly string[];
+    /** Handler names on native elements (@click="fn"). */
+    readonly nativeEventHandlers: readonly string[];
+    /** Component event bindings (@event="handler" on component elements). */
+    readonly componentEventBindings: readonly ComponentEventBinding[];
+    /** Event names from emit() / this.$emit() calls in the script block. */
+    readonly scriptEmitCalls: readonly ScriptEmitCall[];
+    /** Bound attribute variable names (:prop="varName"). */
+    readonly templateAttributeBindings: readonly string[];
+}
+/**
+ * Extract all template-derived edge data from a Vue SFC in a single pass.
+ *
+ * Parses the `<template>` block once and the `<script>` block once, then
+ * runs all five extractors on the pre-parsed content rather than repeating
+ * the regex on every individual call.  Used by `emitPostResolutionEdges`
+ * to avoid multiple full-file scans per `.vue` file.
+ */
+export declare function extractVueTemplateEdgeData(vueContent: string, options?: ExtractScriptEmitCallsOptions): VueTemplateEdgeData;