gitnexus 1.4.8 → 1.4.10

package/dist/core/ingestion/{ast-helpers.js → utils/ast-helpers.js}

@@ -1,6 +1,5 @@
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import { generateId } from '../../lib/utils.js';
-import { extractSimpleTypeName } from './type-extractors/shared.js';
+import { generateId } from '../../../lib/utils.js';
+import { extractSimpleTypeName } from '../type-extractors/shared.js';
 /**
  * Ordered list of definition capture keys for tree-sitter query matches.
  * Used to extract the definition node from a capture map.
@@ -75,6 +74,9 @@ export const FUNCTION_NODE_TYPES = new Set([
     // Ruby
     'method', // def foo
     'singleton_method', // def self.foo
+    // Dart
+    'function_signature',
+    'method_signature',
 ]);
 /**
  * Node types for standard function declarations that need C/C++ declarator handling.
@@ -135,39 +137,23 @@ export function isKotlinClassMethod(captureNode) {
     }
     return false;
 }
-/**
- * C/C++: check if a Function capture is inside a class/struct body.
- * If true, the function is already captured by @definition.method and should be skipped
- * to prevent double-indexing in globalIndex.
- */
-export function isCppDuplicateClassFunction(functionNode, nodeLabel, language) {
-    if (nodeLabel !== 'Function')
-        return false;
-    if (language !== SupportedLanguages.CPlusPlus && language !== SupportedLanguages.C)
-        return false;
-    let ancestor = functionNode?.parent;
-    while (ancestor) {
-        if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
-            return true;
-        ancestor = ancestor.parent;
-    }
-    return false;
-}
 /**
  * Determine the graph node label from a tree-sitter capture map.
- * Handles language-specific reclassification (C/C++ duplicate skipping, Kotlin Method promotion).
+ * Handles language-specific reclassification via the provider's labelOverride hook
+ * (e.g. C/C++ duplicate skipping, Kotlin Method promotion).
  * Returns null if the capture should be skipped (import, call, C/C++ duplicate, missing name).
  */
-export function getLabelFromCaptures(captureMap, language) {
+export function getLabelFromCaptures(captureMap, provider) {
     if (captureMap['import'] || captureMap['call'])
         return null;
     if (!captureMap['name'] && !captureMap['definition.constructor'])
         return null;
     if (captureMap['definition.function']) {
-        if (isCppDuplicateClassFunction(captureMap['definition.function'], 'Function', language))
-            return null;
-        if (language === SupportedLanguages.Kotlin && isKotlinClassMethod(captureMap['definition.function']))
-            return 'Method';
+        if (provider.labelOverride) {
+            const override = provider.labelOverride(captureMap['definition.function'], 'Function');
+            if (override !== 'Function')
+                return override;
+        }
         return 'Function';
     }
     if (captureMap['definition.class'])
@@ -410,11 +396,6 @@ export const extractFunctionName = (node) => {
                 }
             }
             funcName = nameNode?.text;
-            // Kotlin: function_declaration inside a class_body is a method, not a top-level function.
-            // Must match the label assigned in parse-worker.ts for consistent generateId() output.
-            if (funcName && node.type === 'function_declaration' && isKotlinClassMethod(node)) {
-                label = 'Method';
-            }
         }
     }
     else if (node.type === 'impl_item') {
@@ -499,6 +480,45 @@ export const extractFunctionName = (node) => {
         funcName = nameNode?.text;
         label = 'Method';
     }
+    else if (node.type === 'function_signature') {
+        // Dart: top-level function signatures
+        let nameNode = node.childForFieldName?.('name');
+        if (!nameNode) {
+            for (let i = 0; i < node.childCount; i++) {
+                const c = node.child(i);
+                if (c?.type === 'identifier') {
+                    nameNode = c;
+                    break;
+                }
+            }
+        }
+        funcName = nameNode?.text ?? null;
+    }
+    else if (node.type === 'method_signature') {
+        // Dart: method_signature wraps function_signature
+        let funcSig = null;
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_signature') {
+                funcSig = c;
+                break;
+            }
+        }
+        if (funcSig) {
+            let nameNode = funcSig.childForFieldName?.('name');
+            if (!nameNode) {
+                for (let i = 0; i < funcSig.childCount; i++) {
+                    const c = funcSig.child(i);
+                    if (c?.type === 'identifier') {
+                        nameNode = c;
+                        break;
+                    }
+                }
+            }
+            funcName = nameNode?.text ?? null;
+        }
+        label = 'Method';
+    }
     return { funcName, label };
 };
 /** Argument list node types shared between extractMethodSignature and countCallArguments. */
@@ -522,6 +542,7 @@ export const extractMethodSignature = (node) => {
     const paramListTypes = new Set([
         'formal_parameters', 'parameters', 'parameter_list',
         'function_parameters', 'method_parameters', 'function_value_parameters',
+        'formal_parameter_list', // Dart
     ]);
     // Node types that indicate variadic/rest parameters
     const VARIADIC_PARAM_TYPES = new Set([
@@ -654,6 +675,18 @@ export const extractMethodSignature = (node) => {
             }
         }
     }
+    // Swift fallback: tree-sitter-swift places `parameter` nodes as direct children of
+    // function_declaration without a wrapping parameters/function_parameters list node.
+    // When no parameter list was found, count direct `parameter` children on the node.
+    if (!parameterList && parameterCount === 0) {
+        for (const child of node.namedChildren) {
+            if (child.type === 'parameter') {
+                if (!hasDefaultValue(child))
+                    requiredCount++;
+                parameterCount++;
+            }
+        }
+    }
     // Return type extraction — language-specific field names
     // Go: 'result' field is either a type_identifier or parameter_list (multi-return)
     const goResult = node.childForFieldName?.('result');
@@ -736,3 +769,49 @@ export const extractMethodSignature = (node) => {
         ? requiredCount : undefined;
     return { parameterCount, requiredParameterCount, parameterTypes: hasTypes ? paramTypes : undefined, returnType };
 };
+// ============================================================================
+// Generic AST traversal helpers (shared by parse-worker + php-helpers)
+// ============================================================================
+/** Walk an AST node depth-first, returning the first descendant with the given type. */
+export function findDescendant(node, type) {
+    if (node.type === type)
+        return node;
+    for (const child of (node.children ?? [])) {
+        const found = findDescendant(child, type);
+        if (found)
+            return found;
+    }
+    return null;
+}
+/** Extract the text content from a string or encapsed_string AST node. */
+export function extractStringContent(node) {
+    if (!node)
+        return null;
+    const content = node.children?.find((c) => c.type === 'string_content');
+    if (content)
+        return content.text;
+    if (node.type === 'string_content')
+        return node.text;
+    return null;
+}
+/** Check if a C/C++ function_definition is inside a class or struct body.
+ *  Used by the C/C++ labelOverride to skip duplicate function captures
+ *  that are already covered by definition.method queries. */
+export function isCppInsideClassOrStruct(functionNode) {
+    let ancestor = functionNode?.parent ?? null;
+    while (ancestor) {
+        if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
+            return true;
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
+/** Find the first direct named child of a tree-sitter node matching the given type. */
+export function findChild(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === type)
+            return child;
+    }
+    return null;
+}

package/dist/core/ingestion/{call-analysis.js → utils/call-analysis.js}

@@ -61,6 +61,7 @@ const MEMBER_ACCESS_NODE_TYPES = new Set([
     'selector_expression', // Go: obj.Method()
     'navigation_suffix', // Kotlin/Swift: obj.method() — nameNode sits inside navigation_suffix
     'member_binding_expression', // C#: user?.Method() — null-conditional access
+    'unconditional_assignable_selector', // Dart: obj.method() — nameNode inside selector > unconditional_assignable_selector
 ]);
 /**
  * Call node types that are inherently constructor invocations.
@@ -179,6 +180,15 @@ export const extractReceiverName = (nameNode) => {
             receiver = receiver.firstChild;
         }
     }
+    // Dart: unconditional_assignable_selector is inside a `selector`, which is a sibling
+    // of the receiver in the expression_statement.  For `user.save()`, the previous named
+    // sibling of the `selector` is `identifier [user]`.
+    if (!receiver && parent.type === 'unconditional_assignable_selector') {
+        const selectorNode = parent.parent; // selector [.save]
+        if (selectorNode) {
+            receiver = selectorNode.previousNamedSibling;
+        }
+    }
     // C# null-conditional: user?.Save() → conditional_access_expression wraps member_binding_expression
     if (!receiver && parent.type === 'member_binding_expression') {
         const condAccess = parent.parent;
@@ -249,6 +259,13 @@ export const extractReceiverNode = (nameNode) => {
             receiver = receiver.firstChild;
         }
     }
+    // Dart: unconditional_assignable_selector — receiver is previous sibling of the selector
+    if (!receiver && parent.type === 'unconditional_assignable_selector') {
+        const selectorNode = parent.parent;
+        if (selectorNode) {
+            receiver = selectorNode.previousNamedSibling;
+        }
+    }
     if (!receiver && parent.type === 'member_binding_expression') {
         const condAccess = parent.parent;
         if (condAccess?.type === 'conditional_access_expression') {
@@ -479,6 +496,26 @@ export function extractMixedChain(receiverNode) {
                 return { chain, baseReceiverName: innerObject.text || undefined };
             }
         }
+        else if (current.type === 'selector') {
+            // ── Dart: flat selector siblings (user.address.save() uses selector nodes) ──
+            // Extract field name from unconditional_assignable_selector child
+            const uas = current.namedChildren?.find((c) => c.type === 'unconditional_assignable_selector');
+            const propertyName = uas?.namedChildren?.find((c) => c.type === 'identifier')?.text;
+            if (!propertyName)
+                break;
+            chain.unshift({ kind: 'field', name: propertyName });
+            // Walk to previous sibling for the next step in the chain
+            const prev = current.previousNamedSibling;
+            if (!prev)
+                break;
+            if (prev.type === 'selector') {
+                current = prev;
+            }
+            else {
+                // Base receiver (identifier or other terminal)
+                return { chain, baseReceiverName: prev.text || undefined };
+            }
+        }
         else {
             // Simple identifier — this is the base receiver
             return chain.length > 0

package/dist/core/ingestion/utils/event-loop.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Yield control to the event loop so spinners/progress can render.
+ * Call periodically in hot loops to prevent UI freezes.
+ */
+export declare const yieldToEventLoop: () => Promise<void>;

package/dist/core/ingestion/utils/event-loop.js

@@ -0,0 +1,5 @@
+/**
+ * Yield control to the event loop so spinners/progress can render.
+ * Call periodically in hot loops to prevent UI freezes.
+ */
+export const yieldToEventLoop = () => new Promise(resolve => setImmediate(resolve));

package/dist/core/ingestion/utils/language-detection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Language Detection — maps file paths to SupportedLanguages enum values.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+/**
+ * Map file extension to SupportedLanguage enum.
+ * Returns null if the file extension is not recognized.
+ */
+export declare const getLanguageFromFilename: (filename: string) => SupportedLanguages | null;

package/dist/core/ingestion/utils/language-detection.js

@@ -0,0 +1,70 @@
+/**
+ * Language Detection — maps file paths to SupportedLanguages enum values.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+/** Ruby extensionless filenames recognised as Ruby source */
+const RUBY_EXTENSIONLESS_FILES = new Set(['Rakefile', 'Gemfile', 'Guardfile', 'Vagrantfile', 'Brewfile']);
+/**
+ * Map file extension to SupportedLanguage enum.
+ * Returns null if the file extension is not recognized.
+ */
+export const getLanguageFromFilename = (filename) => {
+    // TypeScript (including TSX)
+    if (filename.endsWith('.tsx'))
+        return SupportedLanguages.TypeScript;
+    if (filename.endsWith('.ts'))
+        return SupportedLanguages.TypeScript;
+    // JavaScript (including JSX)
+    if (filename.endsWith('.jsx'))
+        return SupportedLanguages.JavaScript;
+    if (filename.endsWith('.js'))
+        return SupportedLanguages.JavaScript;
+    // Python
+    if (filename.endsWith('.py'))
+        return SupportedLanguages.Python;
+    // Java
+    if (filename.endsWith('.java'))
+        return SupportedLanguages.Java;
+    // C source files
+    if (filename.endsWith('.c'))
+        return SupportedLanguages.C;
+    // C++ (all common extensions, including .h)
+    // .h is parsed as C++ because tree-sitter-cpp is a strict superset of C, so pure-C
+    // headers parse correctly, and C++ headers (classes, templates) are handled properly.
+    if (filename.endsWith('.cpp') || filename.endsWith('.cc') || filename.endsWith('.cxx') ||
+        filename.endsWith('.h') || filename.endsWith('.hpp') || filename.endsWith('.hxx') || filename.endsWith('.hh'))
+        return SupportedLanguages.CPlusPlus;
+    // C#
+    if (filename.endsWith('.cs'))
+        return SupportedLanguages.CSharp;
+    // Go
+    if (filename.endsWith('.go'))
+        return SupportedLanguages.Go;
+    // Rust
+    if (filename.endsWith('.rs'))
+        return SupportedLanguages.Rust;
+    // Kotlin
+    if (filename.endsWith('.kt') || filename.endsWith('.kts'))
+        return SupportedLanguages.Kotlin;
+    // PHP (all common extensions)
+    if (filename.endsWith('.php') || filename.endsWith('.phtml') ||
+        filename.endsWith('.php3') || filename.endsWith('.php4') ||
+        filename.endsWith('.php5') || filename.endsWith('.php8')) {
+        return SupportedLanguages.PHP;
+    }
+    // Ruby (extensions)
+    if (filename.endsWith('.rb') || filename.endsWith('.rake') || filename.endsWith('.gemspec')) {
+        return SupportedLanguages.Ruby;
+    }
+    // Ruby (extensionless files)
+    const basename = filename.split('/').pop() || filename;
+    if (RUBY_EXTENSIONLESS_FILES.has(basename)) {
+        return SupportedLanguages.Ruby;
+    }
+    // Swift (extensions)
+    if (filename.endsWith('.swift'))
+        return SupportedLanguages.Swift;
+    if (filename.endsWith('.dart'))
+        return SupportedLanguages.Dart;
+    return null;
+};

package/dist/core/ingestion/utils/verbose.d.ts

@@ -0,0 +1 @@
+export declare const isVerboseIngestionEnabled: () => boolean;

package/dist/core/ingestion/utils/verbose.js

@@ -0,0 +1,7 @@
+export const isVerboseIngestionEnabled = () => {
+    const raw = process.env.GITNEXUS_VERBOSE;
+    if (!raw)
+        return false;
+    const value = raw.toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes';
+};

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -1,7 +1,7 @@
 import { SupportedLanguages } from '../../../config/supported-languages.js';
-import { type MixedChainStep } from '../utils.js';
+import { type MixedChainStep } from '../utils/call-analysis.js';
 import type { ConstructorBinding } from '../type-env.js';
-import type { NamedBinding } from '../import-resolution.js';
+import type { NamedBinding } from '../named-bindings/types.js';
 import type { NodeLabel } from '../../graph/types.js';
 interface ParsedNode {
     id: string;
@@ -19,6 +19,10 @@ interface ParsedNode {
         parameterCount?: number;
         requiredParameterCount?: number;
         returnType?: string;
+        declaredType?: string;
+        visibility?: string;
+        isStatic?: boolean;
+        isReadonly?: boolean;
     };
 }
 interface ParsedRelationship {
@@ -40,6 +44,9 @@ interface ParsedSymbol {
     returnType?: string;
     declaredType?: string;
     ownerId?: string;
+    visibility?: string;
+    isStatic?: boolean;
+    isReadonly?: boolean;
 }
 export interface ExtractedImport {
     filePath: string;
@@ -98,6 +105,31 @@ export interface ExtractedRoute {
     prefix: string | null;
     lineNumber: number;
 }
+export interface ExtractedFetchCall {
+    filePath: string;
+    fetchURL: string;
+    lineNumber: number;
+}
+export interface ExtractedDecoratorRoute {
+    filePath: string;
+    routePath: string;
+    httpMethod: string;
+    decoratorName: string;
+    lineNumber: number;
+}
+export interface ExtractedToolDef {
+    filePath: string;
+    toolName: string;
+    description: string;
+    lineNumber: number;
+}
+export interface ExtractedORMQuery {
+    filePath: string;
+    orm: 'prisma' | 'supabase';
+    model: string;
+    method: string;
+    lineNumber: number;
+}
 /** Constructor bindings keyed by filePath for cross-file type resolution */
 export interface FileConstructorBindings {
     filePath: string;
@@ -118,6 +150,10 @@ export interface ParseWorkerResult {
     assignments: ExtractedAssignment[];
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
+    fetchCalls: ExtractedFetchCall[];
+    decoratorRoutes: ExtractedDecoratorRoute[];
+    toolDefs: ExtractedToolDef[];
+    ormQueries: ExtractedORMQuery[];
     constructorBindings: FileConstructorBindings[];
     /** File-scope type bindings from TypeEnv fixpoint for exported symbol collection. */
     typeEnvBindings: FileTypeEnvBindings[];
@@ -128,4 +164,9 @@ export interface ParseWorkerInput {
     path: string;
     content: string;
 }
+/**
+ * Extract ORM query calls from file content via regex.
+ * Appends results to the provided array (avoids allocation when no matches).
+ */
+export declare function extractORMQueries(filePath: string, content: string, out: ExtractedORMQuery[]): void;
 export {};