gitnexus 1.5.3 → 1.6.0

package/dist/core/ingestion/class-extractors/generic.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig, ClassExtractor } from '../class-types.js';
+export declare function createClassExtractor(config: ClassExtractionConfig): ClassExtractor;

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

@@ -0,0 +1,135 @@
+const DEFAULT_SCOPE_NAME_NODE_TYPES = new Set([
+    'nested_namespace_specifier',
+    'scoped_identifier',
+    'scoped_type_identifier',
+    'qualified_name',
+    'namespace_name',
+    'namespace_identifier',
+    'package_identifier',
+    'type_identifier',
+    'identifier',
+    'name',
+    'constant',
+]);
+const DEFAULT_TYPE_NAME_NODE_TYPES = new Set([
+    'type_identifier',
+    'identifier',
+    'simple_identifier',
+    'namespace_identifier',
+    'constant',
+    'name',
+]);
+const DEFAULT_LABEL_BY_NODE_TYPE = {
+    class_declaration: 'Class',
+    abstract_class_declaration: 'Class',
+    interface_declaration: 'Interface',
+    struct_declaration: 'Struct',
+    record_declaration: 'Record',
+    enum_declaration: 'Enum',
+    class_definition: 'Class',
+    struct_specifier: 'Struct',
+    class_specifier: 'Class',
+    enum_specifier: 'Enum',
+    struct_item: 'Struct',
+    enum_item: 'Enum',
+    class: 'Class',
+    object_declaration: 'Class',
+    companion_object: 'Class',
+    protocol_declaration: 'Interface',
+    extension_declaration: 'Class',
+};
+const CLASS_LIKE_LABELS = new Set([
+    'Class',
+    'Struct',
+    'Interface',
+    'Enum',
+    'Record',
+]);
+const normalizeQualifiedName = (value) => value
+    .replace(/\s+/g, '')
+    .replace(/^::/, '')
+    .replace(/::/g, '.')
+    .replace(/\\/g, '.')
+    .replace(/\.+/g, '.')
+    .replace(/^\.+|\.+$/g, '');
+const splitQualifiedName = (value) => {
+    const normalized = normalizeQualifiedName(value);
+    return normalized ? normalized.split('.').filter(Boolean) : [];
+};
+const extractScopeSegmentsFromNode = (scopeNode, scopeNameNodeTypes) => {
+    const nameNode = scopeNode.childForFieldName?.('name') ??
+        scopeNode.namedChildren?.find((child) => scopeNameNodeTypes.has(child.type));
+    return nameNode ? splitQualifiedName(nameNode.text) : [];
+};
+const extractTypeNameFromNode = (node) => {
+    const nameField = node.childForFieldName?.('name');
+    if (nameField)
+        return nameField.text;
+    const nameChild = node.namedChildren?.find((child) => DEFAULT_TYPE_NAME_NODE_TYPES.has(child.type));
+    return nameChild?.text;
+};
+const isClassLikeLabel = (label) => label !== undefined && label !== null && CLASS_LIKE_LABELS.has(label);
+export function createClassExtractor(config) {
+    const typeDeclarationSet = new Set(config.typeDeclarationNodes);
+    const fileScopeSet = new Set(config.fileScopeNodeTypes ?? []);
+    const ancestorScopeSet = new Set(config.ancestorScopeNodeTypes ?? []);
+    const scopeNameNodeTypes = new Set([
+        ...DEFAULT_SCOPE_NAME_NODE_TYPES,
+        ...(config.scopeNameNodeTypes ?? []),
+    ]);
+    const buildQualifiedName = (node, simpleName) => {
+        let root = node;
+        while (root.parent)
+            root = root.parent;
+        const readScopeSegments = (scopeNode) => config.extractScopeSegments?.(scopeNode) ??
+            extractScopeSegmentsFromNode(scopeNode, scopeNameNodeTypes);
+        const fileScopeSegments = [];
+        for (const child of root.namedChildren ?? []) {
+            if (fileScopeSet.has(child.type)) {
+                fileScopeSegments.push(...readScopeSegments(child));
+            }
+        }
+        const ancestorScopes = [];
+        let current = node.parent;
+        while (current) {
+            if (ancestorScopeSet.has(current.type)) {
+                const segments = readScopeSegments(current);
+                if (segments.length > 0)
+                    ancestorScopes.push(segments);
+            }
+            current = current.parent;
+        }
+        return [
+            ...fileScopeSegments,
+            ...ancestorScopes.reverse().flat(),
+            ...splitQualifiedName(simpleName),
+        ]
+            .filter(Boolean)
+            .join('.');
+    };
+    const extract = (node, fallback) => {
+        if (!typeDeclarationSet.has(node.type))
+            return null;
+        const name = config.extractName?.(node) ?? extractTypeNameFromNode(node) ?? fallback?.name;
+        const type = config.extractType?.(node) ??
+            DEFAULT_LABEL_BY_NODE_TYPE[node.type] ??
+            (isClassLikeLabel(fallback?.type) ? fallback.type : undefined);
+        if (!name || !type)
+            return null;
+        return {
+            name,
+            type,
+            qualifiedName: buildQualifiedName(node, name) || name,
+        };
+    };
+    return {
+        language: config.language,
+        isTypeDeclaration(node) {
+            return typeDeclarationSet.has(node.type);
+        },
+        extract,
+        extractQualifiedName(node, simpleName) {
+            return extract(node, { name: simpleName })?.qualifiedName ?? null;
+        },
+    };
+}

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

@@ -0,0 +1,34 @@
+import type { NodeLabel, SupportedLanguages } from '../../_shared/index.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+export type ClassLikeNodeLabel = Extract<NodeLabel, 'Class' | 'Struct' | 'Interface' | 'Enum' | 'Record'>;
+export interface ExtractedClassSymbol {
+    name: string;
+    type: ClassLikeNodeLabel;
+    qualifiedName: string;
+}
+/**
+ * Cross-language qualified type names are normalized to dot-separated scope
+ * segments:
+ * - file/package scope contributes leading segments when the language has one
+ * - lexical namespace/module/type scope contributes enclosing segments
+ * - the simple type name is always the trailing segment
+ */
+export interface ClassExtractor {
+    language: SupportedLanguages;
+    isTypeDeclaration(node: SyntaxNode): boolean;
+    extract(node: SyntaxNode, fallback?: {
+        name?: string;
+        type?: NodeLabel | null;
+    }): ExtractedClassSymbol | null;
+    extractQualifiedName(node: SyntaxNode, simpleName: string): string | null;
+}
+export interface ClassExtractionConfig {
+    language: SupportedLanguages;
+    typeDeclarationNodes: string[];
+    fileScopeNodeTypes?: string[];
+    ancestorScopeNodeTypes?: string[];
+    scopeNameNodeTypes?: string[];
+    extractName?: (node: SyntaxNode) => string | undefined;
+    extractType?: (node: SyntaxNode) => ClassLikeNodeLabel | undefined;
+    extractScopeSegments?: (node: SyntaxNode) => string[] | null | undefined;
+}

package/dist/core/ingestion/class-types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/ingestion/entry-point-scoring.d.ts

@@ -25,6 +25,7 @@ export declare const ENTRY_POINT_PATTERNS: {
     php: RegExp[];
     ruby: RegExp[];
     dart: RegExp[];
+    vue: any[];
     cobol: any[];
 };
 export interface EntryPointScoreResult {

package/dist/core/ingestion/entry-point-scoring.js

@@ -210,6 +210,7 @@ export const ENTRY_POINT_PATTERNS = {
         /^onEvent$/, // BLoC event handler
         /^mapEventToState$/, // Legacy BLoC pattern
     ],
+    [SupportedLanguages.Vue]: [], // Vue uses TypeScript queries — entry points handled via TS patterns
     [SupportedLanguages.Cobol]: [], // Standalone regex processor — no tree-sitter entry points
 };
 /** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */

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

@@ -1,5 +1,5 @@
 import type { TypeEnvironment } from './type-env.js';
-import type { SymbolTable } from './symbol-table.js';
+import type { SymbolTableReader } from './model/symbol-table.js';
 import { SupportedLanguages } from '../../_shared/index.js';
 /**
  * Visibility levels used across all supported languages.
@@ -42,7 +42,7 @@ export interface FieldExtractorContext {
     /** Type environment for resolution */
     typeEnv: TypeEnvironment;
     /** Symbol table for FQN lookups */
-    symbolTable: SymbolTable;
+    symbolTable: SymbolTableReader;
     /** Current file path */
     filePath: string;
     /** Language ID */

package/dist/core/ingestion/filesystem-walker.js

@@ -1,3 +1,4 @@
+import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import fs from 'fs/promises';
 import path from 'path';
 import { glob } from 'glob';
@@ -20,6 +21,7 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
     const entries = [];
     let processed = 0;
     let skippedLarge = 0;
+    const skippedLargePaths = [];
     for (let start = 0; start < filtered.length; start += READ_CONCURRENCY) {
         const batch = filtered.slice(start, start + READ_CONCURRENCY);
         const results = await Promise.allSettled(batch.map(async (relativePath) => {
@@ -27,6 +29,7 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
             const stat = await fs.stat(fullPath);
             if (stat.size > MAX_FILE_SIZE) {
                 skippedLarge++;
+                skippedLargePaths.push(relativePath.replace(/\\/g, '/'));
                 return null;
             }
             return { path: relativePath.replace(/\\/g, '/'), size: stat.size };
@@ -44,6 +47,11 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
     }
     if (skippedLarge > 0) {
         console.warn(`  Skipped ${skippedLarge} large files (>${MAX_FILE_SIZE / 1024}KB, likely generated/vendored)`);
+        if (isVerboseIngestionEnabled()) {
+            for (const p of skippedLargePaths) {
+                console.warn(`  - ${p}`);
+            }
+        }
     }
     return entries;
 };

package/dist/core/ingestion/framework-detection.d.ts

@@ -139,6 +139,7 @@ export declare const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE: {
         reason: string;
         patterns: string[];
     }[];
+    vue: any[];
     cobol: any[];
 };
 /**

package/dist/core/ingestion/framework-detection.js

@@ -747,6 +747,7 @@ export const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
             patterns: FRAMEWORK_AST_PATTERNS.riverpod,
         },
     ],
+    [SupportedLanguages.Vue]: [], // Vue uses TypeScript AST framework detection
     [SupportedLanguages.Cobol]: [], // Standalone regex processor — no AST framework patterns
 };
 /** Pre-lowercased patterns for O(1) pattern matching at runtime */

package/dist/core/ingestion/heritage-processor.d.ts

@@ -15,22 +15,15 @@
  */
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
-import { SupportedLanguages } from '../../_shared/index.js';
-import type { ExtractedHeritage } from './workers/parse-worker.js';
-import type { ResolutionContext } from './resolution-context.js';
+import type { ExtractedHeritage, HeritageStrategyLookup } from './model/heritage-map.js';
+import type { ResolutionContext } from './model/resolution-context.js';
 /**
- * Determine whether a heritage.extends capture is actually an IMPLEMENTS relationship.
- * Uses the symbol table first (authoritative — Tier 1); falls back to provider-defined
- * heuristics for external symbols not present in the graph:
- *   - interfaceNamePattern: matched against parent name (e.g., /^I[A-Z]/ for C#/Java)
- *   - heritageDefaultEdge: 'IMPLEMENTS' causes all unresolved parents to map to IMPLEMENTS
- *   - All others: default EXTENDS
+ * Derive the heritage-resolution strategy for a language from its
+ * `LanguageProvider`. This is the production wiring that `buildHeritageMap`
+ * and the standalone `resolveExtendsType` call site use — the model layer
+ * itself stays unaware of the provider registry.
  */
-/** Exported for implementor-map construction (C#/Java: `extends` rows in base_list may be interfaces). */
-export declare const resolveExtendsType: (parentName: string, currentFilePath: string, ctx: ResolutionContext, language: SupportedLanguages) => {
-    type: "EXTENDS" | "IMPLEMENTS";
-    idPrefix: string;
-};
+export declare const getHeritageStrategyForLanguage: HeritageStrategyLookup;
 export declare const processHeritage: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
@@ -43,7 +36,7 @@ export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extra
 /**
  * Walk source files with the same heritage captures as parse-worker, producing
  * {@link ExtractedHeritage} rows without mutating the graph. Used on the
- * sequential pipeline path so `buildImplementorMap(..., ctx)` can run before
+ * sequential pipeline path so `buildHeritageMap(..., ctx)` can run before
  * `processCalls` (worker path defers calls until heritage from all chunks exists).
  */
 export declare function extractExtractedHeritageFromFiles(files: {

package/dist/core/ingestion/heritage-processor.js

@@ -21,33 +21,20 @@ import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { getProvider } from './languages/index.js';
 import { getTreeSitterBufferSize } from './constants.js';
-import { TIER_CONFIDENCE } from './resolution-context.js';
+import { resolveExtendsType } from './model/heritage-map.js';
+import { TIER_CONFIDENCE } from './model/resolution-context.js';
 /**
- * Determine whether a heritage.extends capture is actually an IMPLEMENTS relationship.
- * Uses the symbol table first (authoritative — Tier 1); falls back to provider-defined
- * heuristics for external symbols not present in the graph:
- *   - interfaceNamePattern: matched against parent name (e.g., /^I[A-Z]/ for C#/Java)
- *   - heritageDefaultEdge: 'IMPLEMENTS' causes all unresolved parents to map to IMPLEMENTS
- *   - All others: default EXTENDS
+ * Derive the heritage-resolution strategy for a language from its
+ * `LanguageProvider`. This is the production wiring that `buildHeritageMap`
+ * and the standalone `resolveExtendsType` call site use — the model layer
+ * itself stays unaware of the provider registry.
  */
-/** Exported for implementor-map construction (C#/Java: `extends` rows in base_list may be interfaces). */
-export const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
-    const resolved = ctx.resolve(parentName, currentFilePath);
-    if (resolved && resolved.candidates.length > 0) {
-        const isInterface = resolved.candidates[0].type === 'Interface';
-        return isInterface
-            ? { type: 'IMPLEMENTS', idPrefix: 'Interface' }
-            : { type: 'EXTENDS', idPrefix: 'Class' };
-    }
-    // Unresolved symbol — fall back to provider-defined heuristics
-    const provider = getProvider(language);
-    if (provider.interfaceNamePattern?.test(parentName)) {
-        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
-    }
-    if (provider.heritageDefaultEdge === 'IMPLEMENTS') {
-        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
-    }
-    return { type: 'EXTENDS', idPrefix: 'Class' };
+export const getHeritageStrategyForLanguage = (lang) => {
+    const provider = getProvider(lang);
+    return {
+        interfaceNamePattern: provider.interfaceNamePattern,
+        defaultEdge: provider.heritageDefaultEdge ?? 'EXTENDS',
+    };
 };
 const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
     const resolved = ctx.resolve(name, filePath);
@@ -136,7 +123,7 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
                 }
                 const className = captureMap['heritage.class'].text;
                 const parentClassName = captureMap['heritage.extends'].text;
-                const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, ctx, language);
+                const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, ctx, getHeritageStrategyForLanguage(language));
                 const child = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
                 const parent = resolveHeritageId(parentClassName, file.path, ctx, idPrefix);
                 if (child.id && parent.id && child.id !== parent.id) {
@@ -209,7 +196,7 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
             const fileLanguage = getLanguageFromFilename(h.filePath);
             if (!fileLanguage)
                 continue;
-            const { type: relType, idPrefix } = resolveExtendsType(h.parentName, h.filePath, ctx, fileLanguage);
+            const { type: relType, idPrefix } = resolveExtendsType(h.parentName, h.filePath, ctx, getHeritageStrategyForLanguage(fileLanguage));
             const child = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`);
             const parent = resolveHeritageId(h.parentName, h.filePath, ctx, idPrefix);
             if (child.id && parent.id && child.id !== parent.id) {
@@ -260,7 +247,7 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
 /**
  * Walk source files with the same heritage captures as parse-worker, producing
  * {@link ExtractedHeritage} rows without mutating the graph. Used on the
- * sequential pipeline path so `buildImplementorMap(..., ctx)` can run before
+ * sequential pipeline path so `buildHeritageMap(..., ctx)` can run before
  * `processCalls` (worker path defers calls until heritage from all chunks exists).
  */
 export async function extractExtractedHeritageFromFiles(files, astCache) {

package/dist/core/ingestion/import-processor.d.ts

@@ -2,21 +2,11 @@ import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
 import type { LanguageProvider } from './language-provider.js';
 import type { ExtractedImport } from './workers/parse-worker.js';
-import type { ResolutionContext } from './resolution-context.js';
+import type { ResolutionContext } from './model/resolution-context.js';
 import type { ImportResolutionContext } from './import-resolvers/types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
 export type ImportMap = Map<string, Set<string>>;
 export type PackageMap = Map<string, Set<string>>;
-export interface NamedImportBinding {
-    sourcePath: string;
-    exportedName: string;
-}
-export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
-/**
- * Check if a file path is directly inside a package directory identified by its suffix.
- * Used by the symbol resolver for Go and C# directory-level import matching.
- */
-export declare function isFileInPackageDir(filePath: string, dirSuffix: string): boolean;
 export declare function buildImportResolutionContext(allPaths: string[]): ImportResolutionContext;
 /**
  * Clean and preprocess a raw import source text into a resolved import path.

package/dist/core/ingestion/import-processor.js

@@ -32,18 +32,6 @@ function wireImplicitImports(files, importMap, addImportEdge, projectConfig) {
         }
     }
 }
-/**
- * Check if a file path is directly inside a package directory identified by its suffix.
- * Used by the symbol resolver for Go and C# directory-level import matching.
- */
-export function isFileInPackageDir(filePath, dirSuffix) {
-    // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
-    const normalized = '/' + filePath.replace(/\\/g, '/');
-    if (!normalized.includes(dirSuffix))
-        return false;
-    const afterDir = normalized.substring(normalized.indexOf(dirSuffix) + dirSuffix.length);
-    return !afterDir.includes('/');
-}
 // ImportResolutionContext is defined in ./import-resolvers/types.ts — re-exported here for consumers.
 export function buildImportResolutionContext(allPaths) {
     const allFileList = allPaths;

package/dist/core/ingestion/import-resolvers/utils.js

@@ -10,6 +10,7 @@ export const EXTENSIONS = [
     '.ts',
     '.jsx',
     '.js',
+    '.vue',
     '/index.tsx',
     '/index.ts',
     '/index.jsx',

package/dist/core/ingestion/import-resolvers/vue.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Vue import resolver — delegates to TypeScript's standard resolver.
+ *
+ * Vue <script> blocks use the same import syntax as TypeScript (including
+ * tsconfig path aliases like `@/`), so no custom resolution logic is needed.
+ */
+import type { ImportResolverFn } from './types.js';
+export declare const resolveVueImport: ImportResolverFn;

package/dist/core/ingestion/import-resolvers/vue.js

@@ -0,0 +1,9 @@
+/**
+ * Vue import resolver — delegates to TypeScript's standard resolver.
+ *
+ * Vue <script> blocks use the same import syntax as TypeScript (including
+ * tsconfig path aliases like `@/`), so no custom resolution logic is needed.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { resolveStandard } from './standard.js';
+export const resolveVueImport = (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.TypeScript);

package/dist/core/ingestion/language-provider.d.ts

@@ -8,9 +8,10 @@
  * The providers table in `languages/index.ts` uses `satisfies Record<SupportedLanguages, LanguageProvider>`
  * so adding a language to the enum without creating a provider is a compiler error.
  */
-import type { SupportedLanguages } from '../../_shared/index.js';
+import type { SupportedLanguages, MroStrategy } from '../../_shared/index.js';
 import type { LanguageTypeConfig } from './type-extractors/types.js';
 import type { CallRouter } from './call-routing.js';
+import type { ClassExtractor } from './class-types.js';
 import type { ExportChecker } from './export-detection.js';
 import type { FieldExtractor } from './field-extractor.js';
 import type { MethodExtractor } from './method-types.js';
@@ -20,8 +21,6 @@ import type { SyntaxNode } from './utils/ast-helpers.js';
 import type { NodeLabel } from '../../_shared/index.js';
 /** Tree-sitter query captures: capture name → AST node (or undefined if not captured). */
 export type CaptureMap = Record<string, SyntaxNode | undefined>;
-/** MRO strategy for multiple inheritance resolution. */
-export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax';
 /** How a language handles imports — determines wildcard synthesis behavior. */
 export type ImportSemantics = 'named' | 'wildcard' | 'namespace';
 /**
@@ -101,6 +100,10 @@ interface LanguageProviderConfig {
      *  declarations. Produces MethodInfo[] with name, parameters, visibility, isAbstract,
      *  isFinal, annotations metadata. Default: undefined (no method extraction). */
     readonly methodExtractor?: MethodExtractor;
+    /** Class/type extractor for deriving canonical qualified names for class-like symbols.
+     *  Uses the same provider-driven strategy pattern as method/field extraction so
+     *  namespace/package/module rules stay language-specific. */
+    readonly classExtractor?: ClassExtractor;
     /** Extract a semantic description for a definition node (e.g., PHP Eloquent
      *  property arrays, relation method descriptions).
      *  Default: undefined (no description extraction). */