gitnexus 1.4.0 → 1.4.1

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

@@ -1,230 +0,0 @@
-/**
- * Export Detection
- *
- * Determines whether a symbol (function, class, etc.) is exported/public
- * in its language. This is a pure function — safe for use in worker threads.
- *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
- */
-import { findSiblingChild } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-// ============================================================================
-// Per-language export checkers
-// ============================================================================
-/** JS/TS: walk ancestors looking for export_statement or export_specifier. */
-const tsExportChecker = (node, _name) => {
-    let current = node;
-    while (current) {
-        const type = current.type;
-        if (type === 'export_statement' ||
-            type === 'export_specifier' ||
-            (type === 'lexical_declaration' && current.parent?.type === 'export_statement')) {
-            return true;
-        }
-        // Fallback: check if node text starts with 'export ' for edge cases
-        if (current.text?.startsWith('export ')) {
-            return true;
-        }
-        current = current.parent;
-    }
-    return false;
-};
-/** Python: public if no leading underscore (convention). */
-const pythonExportChecker = (_node, name) => !name.startsWith('_');
-/** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */
-const javaExportChecker = (node, _name) => {
-    let current = node;
-    while (current) {
-        if (current.parent) {
-            const parent = current.parent;
-            for (let i = 0; i < parent.childCount; i++) {
-                const child = parent.child(i);
-                if (child?.type === 'modifiers' && child.text?.includes('public')) {
-                    return true;
-                }
-            }
-            if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
-                if (parent.text?.trimStart().startsWith('public')) {
-                    return true;
-                }
-            }
-        }
-        current = current.parent;
-    }
-    return false;
-};
-/** C# declaration node types for sibling modifier scanning. */
-const CSHARP_DECL_TYPES = new Set([
-    'method_declaration', 'local_function_statement', 'constructor_declaration',
-    'class_declaration', 'interface_declaration', 'struct_declaration',
-    'enum_declaration', 'record_declaration', 'record_struct_declaration',
-    'record_class_declaration', 'delegate_declaration',
-    'property_declaration', 'field_declaration', 'event_declaration',
-    'namespace_declaration', 'file_scoped_namespace_declaration',
-]);
-/**
- * C#: modifier nodes are SIBLINGS of the name node inside the declaration.
- * Walk up to the declaration node, then scan its direct children.
- */
-const csharpExportChecker = (node, _name) => {
-    let current = node;
-    while (current) {
-        if (CSHARP_DECL_TYPES.has(current.type)) {
-            for (let i = 0; i < current.childCount; i++) {
-                const child = current.child(i);
-                if (child?.type === 'modifier' && child.text === 'public')
-                    return true;
-            }
-            return false;
-        }
-        current = current.parent;
-    }
-    return false;
-};
-/** Go: uppercase first letter = exported. */
-const goExportChecker = (_node, name) => {
-    if (name.length === 0)
-        return false;
-    const first = name[0];
-    return first === first.toUpperCase() && first !== first.toLowerCase();
-};
-/** Rust declaration node types for sibling visibility_modifier scanning. */
-const RUST_DECL_TYPES = new Set([
-    'function_item', 'struct_item', 'enum_item', 'trait_item', 'impl_item',
-    'union_item', 'type_item', 'const_item', 'static_item', 'mod_item',
-    'use_declaration', 'associated_type', 'function_signature_item',
-]);
-/**
- * Rust: visibility_modifier is a SIBLING of the name node within the declaration node
- * (function_item, struct_item, etc.), not a parent. Walk up to the declaration node,
- * then scan its direct children.
- */
-const rustExportChecker = (node, _name) => {
-    let current = node;
-    while (current) {
-        if (RUST_DECL_TYPES.has(current.type)) {
-            for (let i = 0; i < current.childCount; i++) {
-                const child = current.child(i);
-                if (child?.type === 'visibility_modifier' && child.text?.startsWith('pub'))
-                    return true;
-            }
-            return false;
-        }
-        current = current.parent;
-    }
-    return false;
-};
-/**
- * Kotlin: default visibility is public (unlike Java).
- * visibility_modifier is inside modifiers, a sibling of the name node within the declaration.
- */
-const kotlinExportChecker = (node, _name) => {
-    let current = node;
-    while (current) {
-        if (current.parent) {
-            const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
-            if (visMod) {
-                const text = visMod.text;
-                if (text === 'private' || text === 'internal' || text === 'protected')
-                    return false;
-                if (text === 'public')
-                    return true;
-            }
-        }
-        current = current.parent;
-    }
-    // No visibility modifier = public (Kotlin default)
-    return true;
-};
-/**
- * C/C++: functions without 'static' storage class have external linkage by default,
- * making them globally accessible (equivalent to exported). Only functions explicitly
- * marked 'static' are file-scoped (not exported). C++ anonymous namespaces
- * (namespace { ... }) also give internal linkage.
- */
-const cCppExportChecker = (node, _name) => {
-    let cur = node;
-    while (cur) {
-        if (cur.type === 'function_definition' || cur.type === 'declaration') {
-            // Check for 'static' storage class specifier as a direct child node.
-            // This avoids reading the full function text (which can be very large).
-            for (let i = 0; i < cur.childCount; i++) {
-                const child = cur.child(i);
-                if (child?.type === 'storage_class_specifier' && child.text === 'static')
-                    return false;
-            }
-        }
-        // C++ anonymous namespace: namespace_definition with no name child = internal linkage
-        if (cur.type === 'namespace_definition') {
-            const hasName = cur.childForFieldName?.('name');
-            if (!hasName)
-                return false;
-        }
-        cur = cur.parent;
-    }
-    return true; // Top-level C/C++ functions default to external linkage
-};
-/** PHP: check for visibility modifier or top-level scope. */
-const phpExportChecker = (node, _name) => {
-    let current = node;
-    while (current) {
-        if (current.type === 'class_declaration' ||
-            current.type === 'interface_declaration' ||
-            current.type === 'trait_declaration' ||
-            current.type === 'enum_declaration') {
-            return true;
-        }
-        if (current.type === 'visibility_modifier') {
-            return current.text === 'public';
-        }
-        current = current.parent;
-    }
-    // Top-level functions are globally accessible
-    return true;
-};
-/** Swift: check for 'public' or 'open' access modifiers. */
-const swiftExportChecker = (node, _name) => {
-    let current = node;
-    while (current) {
-        if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
-            const text = current.text || '';
-            if (text.includes('public') || text.includes('open'))
-                return true;
-        }
-        current = current.parent;
-    }
-    return false;
-};
-// ============================================================================
-// Exhaustive dispatch table — satisfies enforces all SupportedLanguages are covered
-// ============================================================================
-const exportCheckers = {
-    [SupportedLanguages.JavaScript]: tsExportChecker,
-    [SupportedLanguages.TypeScript]: tsExportChecker,
-    [SupportedLanguages.Python]: pythonExportChecker,
-    [SupportedLanguages.Java]: javaExportChecker,
-    [SupportedLanguages.CSharp]: csharpExportChecker,
-    [SupportedLanguages.Go]: goExportChecker,
-    [SupportedLanguages.Rust]: rustExportChecker,
-    [SupportedLanguages.Kotlin]: kotlinExportChecker,
-    [SupportedLanguages.C]: cCppExportChecker,
-    [SupportedLanguages.CPlusPlus]: cCppExportChecker,
-    [SupportedLanguages.PHP]: phpExportChecker,
-    [SupportedLanguages.Swift]: swiftExportChecker,
-};
-// ============================================================================
-// Public API
-// ============================================================================
-/**
- * Check if a tree-sitter node is exported/public in its language.
- * @param node - The tree-sitter AST node
- * @param name - The symbol name
- * @param language - The programming language
- * @returns true if the symbol is exported/public
- */
-export const isNodeExported = (node, name, language) => {
-    const checker = exportCheckers[language];
-    if (!checker)
-        return false;
-    return checker(node, name);
-};

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

@@ -1,46 +0,0 @@
-/** TypeScript path alias config parsed from tsconfig.json */
-export interface TsconfigPaths {
-    /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
-    aliases: Map<string, string>;
-    /** Base URL for path resolution (relative to repo root) */
-    baseUrl: string;
-}
-/** Go module config parsed from go.mod */
-export interface GoModuleConfig {
-    /** Module path (e.g., "github.com/user/repo") */
-    modulePath: string;
-}
-/** PHP Composer PSR-4 autoload config */
-export interface ComposerConfig {
-    /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
-    psr4: Map<string, string>;
-}
-/** C# project config parsed from .csproj files */
-export interface CSharpProjectConfig {
-    /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
-    rootNamespace: string;
-    /** Directory containing the .csproj file */
-    projectDir: string;
-}
-/** Swift Package Manager module config */
-export interface SwiftPackageConfig {
-    /** Map of target name -> source directory path (e.g., "SiuperModel" -> "Package/Sources/SiuperModel") */
-    targets: Map<string, string>;
-}
-/**
- * Parse tsconfig.json to extract path aliases.
- * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
- */
-export declare function loadTsconfigPaths(repoRoot: string): Promise<TsconfigPaths | null>;
-/**
- * Parse go.mod to extract module path.
- */
-export declare function loadGoModulePath(repoRoot: string): Promise<GoModuleConfig | null>;
-/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
-export declare function loadComposerConfig(repoRoot: string): Promise<ComposerConfig | null>;
-/**
- * Parse .csproj files to extract RootNamespace.
- * Scans the repo root for .csproj files and returns configs for each.
- */
-export declare function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]>;
-export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;

package/dist/core/ingestion/language-config.js

@@ -1,167 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-const isDev = process.env.NODE_ENV === 'development';
-// ============================================================================
-// LANGUAGE-SPECIFIC CONFIG LOADERS
-// ============================================================================
-/**
- * Parse tsconfig.json to extract path aliases.
- * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
- */
-export async function loadTsconfigPaths(repoRoot) {
-    const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json'];
-    for (const filename of candidates) {
-        try {
-            const tsconfigPath = path.join(repoRoot, filename);
-            const raw = await fs.readFile(tsconfigPath, 'utf-8');
-            // Strip JSON comments (// and /* */ style) for robustness
-            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
-            const tsconfig = JSON.parse(stripped);
-            const compilerOptions = tsconfig.compilerOptions;
-            if (!compilerOptions?.paths)
-                continue;
-            const baseUrl = compilerOptions.baseUrl || '.';
-            const aliases = new Map();
-            for (const [pattern, targets] of Object.entries(compilerOptions.paths)) {
-                if (!Array.isArray(targets) || targets.length === 0)
-                    continue;
-                const target = targets[0];
-                // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/"
-                const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern;
-                const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target;
-                aliases.set(aliasPrefix, targetPrefix);
-            }
-            if (aliases.size > 0) {
-                if (isDev) {
-                    console.log(`📦 Loaded ${aliases.size} path aliases from ${filename}`);
-                }
-                return { aliases, baseUrl };
-            }
-        }
-        catch {
-            // File doesn't exist or isn't valid JSON - try next
-        }
-    }
-    return null;
-}
-/**
- * Parse go.mod to extract module path.
- */
-export async function loadGoModulePath(repoRoot) {
-    try {
-        const goModPath = path.join(repoRoot, 'go.mod');
-        const content = await fs.readFile(goModPath, 'utf-8');
-        const match = content.match(/^module\s+(\S+)/m);
-        if (match) {
-            if (isDev) {
-                console.log(`📦 Loaded Go module path: ${match[1]}`);
-            }
-            return { modulePath: match[1] };
-        }
-    }
-    catch {
-        // No go.mod
-    }
-    return null;
-}
-/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
-export async function loadComposerConfig(repoRoot) {
-    try {
-        const composerPath = path.join(repoRoot, 'composer.json');
-        const raw = await fs.readFile(composerPath, 'utf-8');
-        const composer = JSON.parse(raw);
-        const psr4Raw = composer.autoload?.['psr-4'] ?? {};
-        const psr4Dev = composer['autoload-dev']?.['psr-4'] ?? {};
-        const merged = { ...psr4Raw, ...psr4Dev };
-        const psr4 = new Map();
-        for (const [ns, dir] of Object.entries(merged)) {
-            const nsNorm = ns.replace(/\\+$/, '');
-            const dirNorm = dir.replace(/\\/g, '/').replace(/\/+$/, '');
-            psr4.set(nsNorm, dirNorm);
-        }
-        if (isDev) {
-            console.log(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`);
-        }
-        return { psr4 };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Parse .csproj files to extract RootNamespace.
- * Scans the repo root for .csproj files and returns configs for each.
- */
-export async function loadCSharpProjectConfig(repoRoot) {
-    const configs = [];
-    // BFS scan for .csproj files up to 5 levels deep, cap at 100 dirs to avoid runaway scanning
-    const scanQueue = [{ dir: repoRoot, depth: 0 }];
-    const maxDepth = 5;
-    const maxDirs = 100;
-    let dirsScanned = 0;
-    while (scanQueue.length > 0 && dirsScanned < maxDirs) {
-        const { dir, depth } = scanQueue.shift();
-        dirsScanned++;
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory() && depth < maxDepth) {
-                    // Skip common non-project directories
-                    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bin' || entry.name === 'obj')
-                        continue;
-                    scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
-                }
-                if (entry.isFile() && entry.name.endsWith('.csproj')) {
-                    try {
-                        const csprojPath = path.join(dir, entry.name);
-                        const content = await fs.readFile(csprojPath, 'utf-8');
-                        const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
-                        const rootNamespace = nsMatch
-                            ? nsMatch[1].trim()
-                            : entry.name.replace(/\.csproj$/, '');
-                        const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
-                        configs.push({ rootNamespace, projectDir });
-                        if (isDev) {
-                            console.log(`📦 Loaded C# project: ${entry.name} (namespace: ${rootNamespace}, dir: ${projectDir})`);
-                        }
-                    }
-                    catch {
-                        // Can't read .csproj
-                    }
-                }
-            }
-        }
-        catch {
-            // Can't read directory
-        }
-    }
-    return configs;
-}
-export async function loadSwiftPackageConfig(repoRoot) {
-    // Swift imports are module-name based (e.g., `import SiuperModel`)
-    // SPM convention: Sources/<TargetName>/ or Package/Sources/<TargetName>/
-    // We scan for these directories to build a target map
-    const targets = new Map();
-    const sourceDirs = ['Sources', 'Package/Sources', 'src'];
-    for (const sourceDir of sourceDirs) {
-        try {
-            const fullPath = path.join(repoRoot, sourceDir);
-            const entries = await fs.readdir(fullPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    targets.set(entry.name, sourceDir + '/' + entry.name);
-                }
-            }
-        }
-        catch {
-            // Directory doesn't exist
-        }
-    }
-    if (targets.size > 0) {
-        if (isDev) {
-            console.log(`📦 Loaded ${targets.size} Swift package targets`);
-        }
-        return { targets };
-    }
-    return null;
-}

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

@@ -1,45 +0,0 @@
-/**
- * MRO (Method Resolution Order) Processor
- *
- * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
- * each ancestor via HAS_METHOD edges, detects method-name collisions across
- * parents, and applies language-specific resolution rules to emit OVERRIDES edges.
- *
- * Language-specific rules:
- * - C++:       leftmost base class in declaration order wins
- * - C#/Java:   class method wins over interface default; multiple interface
- *              methods with same name are ambiguous (null resolution)
- * - Python:    C3 linearization determines MRO; first in linearized order wins
- * - Rust:      no auto-resolution — requires qualified syntax, resolvedTo = null
- * - Default:   single inheritance — first definition wins
- *
- * OVERRIDES edge direction: Class → Method (not Method → Method).
- * The source is the child class that inherits conflicting methods,
- * the target is the winning ancestor method node.
- * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method)
- */
-import { KnowledgeGraph } from '../graph/types.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-export interface MROEntry {
-    classId: string;
-    className: string;
-    language: SupportedLanguages;
-    mro: string[];
-    ambiguities: MethodAmbiguity[];
-}
-export interface MethodAmbiguity {
-    methodName: string;
-    definedIn: Array<{
-        classId: string;
-        className: string;
-        methodId: string;
-    }>;
-    resolvedTo: string | null;
-    reason: string;
-}
-export interface MROResult {
-    entries: MROEntry[];
-    overrideEdges: number;
-    ambiguityCount: number;
-}
-export declare function computeMRO(graph: KnowledgeGraph): MROResult;