gitnexus 1.4.1 → 1.4.5

package/dist/core/ingestion/call-routing.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared Ruby call routing logic.
+ *
+ * Ruby expresses imports, heritage (mixins), and property definitions as
+ * method calls rather than syntax-level constructs. This module provides a
+ * routing function used by the CLI call-processor, CLI parse-worker, and
+ * the web call-processor so that the classification logic lives in one place.
+ *
+ * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
+ * two packages have separate build targets (Node native vs WASM/browser).
+ * Keep both copies in sync until a shared package is introduced.
+ */
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/** null = this call was not routed; fall through to default call handling */
+export type CallRoutingResult = RubyCallRouting | null;
+export type CallRouter = (calledName: string, callNode: any) => CallRoutingResult;
+/** Per-language call routing. noRouting = no special routing (normal call processing) */
+export declare const callRouters: Record<SupportedLanguages, CallRouter>;
+export type RubyCallRouting = {
+    kind: 'import';
+    importPath: string;
+    isRelative: boolean;
+} | {
+    kind: 'heritage';
+    items: RubyHeritageItem[];
+} | {
+    kind: 'properties';
+    items: RubyPropertyItem[];
+} | {
+    kind: 'call';
+} | {
+    kind: 'skip';
+};
+export interface RubyHeritageItem {
+    enclosingClass: string;
+    mixinName: string;
+    heritageKind: 'include' | 'extend' | 'prepend';
+}
+export type RubyAccessorType = 'attr_accessor' | 'attr_reader' | 'attr_writer';
+export interface RubyPropertyItem {
+    propName: string;
+    accessorType: RubyAccessorType;
+    startLine: number;
+    endLine: number;
+}
+/**
+ * Classify a Ruby call node and extract its semantic payload.
+ *
+ * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor')
+ * @param callNode   - The tree-sitter `call` AST node
+ * @returns A discriminated union describing the call's semantic role
+ */
+export declare function routeRubyCall(calledName: string, callNode: any): RubyCallRouting;

package/dist/core/ingestion/call-routing.js

@@ -0,0 +1,108 @@
+/**
+ * Shared Ruby call routing logic.
+ *
+ * Ruby expresses imports, heritage (mixins), and property definitions as
+ * method calls rather than syntax-level constructs. This module provides a
+ * routing function used by the CLI call-processor, CLI parse-worker, and
+ * the web call-processor so that the classification logic lives in one place.
+ *
+ * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
+ * two packages have separate build targets (Node native vs WASM/browser).
+ * Keep both copies in sync until a shared package is introduced.
+ */
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/** No-op router: returns null for every call (passthrough to normal processing) */
+const noRouting = () => null;
+/** Per-language call routing. noRouting = no special routing (normal call processing) */
+export const callRouters = {
+    [SupportedLanguages.JavaScript]: noRouting,
+    [SupportedLanguages.TypeScript]: noRouting,
+    [SupportedLanguages.Python]: noRouting,
+    [SupportedLanguages.Java]: noRouting,
+    [SupportedLanguages.Kotlin]: noRouting,
+    [SupportedLanguages.Go]: noRouting,
+    [SupportedLanguages.Rust]: noRouting,
+    [SupportedLanguages.CSharp]: noRouting,
+    [SupportedLanguages.PHP]: noRouting,
+    [SupportedLanguages.Swift]: noRouting,
+    [SupportedLanguages.CPlusPlus]: noRouting,
+    [SupportedLanguages.C]: noRouting,
+    [SupportedLanguages.Ruby]: routeRubyCall,
+};
+// ── Pre-allocated singletons for common return values ────────────────────────
+const CALL_RESULT = { kind: 'call' };
+const SKIP_RESULT = { kind: 'skip' };
+/** Max depth for parent-walking loops to prevent pathological AST traversals */
+const MAX_PARENT_DEPTH = 50;
+// ── Routing function ────────────────────────────────────────────────────────
+/**
+ * Classify a Ruby call node and extract its semantic payload.
+ *
+ * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor')
+ * @param callNode   - The tree-sitter `call` AST node
+ * @returns A discriminated union describing the call's semantic role
+ */
+export function routeRubyCall(calledName, callNode) {
+    // ── require / require_relative → import ─────────────────────────────────
+    if (calledName === 'require' || calledName === 'require_relative') {
+        const argList = callNode.childForFieldName?.('arguments');
+        const stringNode = argList?.children?.find((c) => c.type === 'string');
+        const contentNode = stringNode?.children?.find((c) => c.type === 'string_content');
+        if (!contentNode)
+            return SKIP_RESULT;
+        let importPath = contentNode.text;
+        // Validate: reject null bytes, control chars, excessively long paths
+        if (!importPath || importPath.length > 1024 || /[\x00-\x1f]/.test(importPath)) {
+            return SKIP_RESULT;
+        }
+        const isRelative = calledName === 'require_relative';
+        if (isRelative && !importPath.startsWith('.')) {
+            importPath = './' + importPath;
+        }
+        return { kind: 'import', importPath, isRelative };
+    }
+    // ── include / extend / prepend → heritage (mixin) ──────────────────────
+    if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') {
+        let enclosingClass = null;
+        let current = callNode.parent;
+        let depth = 0;
+        while (current && ++depth <= MAX_PARENT_DEPTH) {
+            if (current.type === 'class' || current.type === 'module') {
+                const nameNode = current.childForFieldName?.('name');
+                if (nameNode) {
+                    enclosingClass = nameNode.text;
+                    break;
+                }
+            }
+            current = current.parent;
+        }
+        if (!enclosingClass)
+            return SKIP_RESULT;
+        const items = [];
+        const argList = callNode.childForFieldName?.('arguments');
+        for (const arg of (argList?.children ?? [])) {
+            if (arg.type === 'constant' || arg.type === 'scope_resolution') {
+                items.push({ enclosingClass, mixinName: arg.text, heritageKind: calledName });
+            }
+        }
+        return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT;
+    }
+    // ── attr_accessor / attr_reader / attr_writer → property definitions ───
+    if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') {
+        const items = [];
+        const argList = callNode.childForFieldName?.('arguments');
+        for (const arg of (argList?.children ?? [])) {
+            if (arg.type === 'simple_symbol') {
+                items.push({
+                    propName: arg.text.startsWith(':') ? arg.text.slice(1) : arg.text,
+                    accessorType: calledName,
+                    startLine: arg.startPosition.row,
+                    endLine: arg.endPosition.row,
+                });
+            }
+        }
+        return items.length > 0 ? { kind: 'properties', items } : SKIP_RESULT;
+    }
+    // ── Everything else → regular call ─────────────────────────────────────
+    return CALL_RESULT;
+}

package/dist/core/ingestion/cluster-enricher.js

@@ -13,12 +13,12 @@ const buildEnrichmentPrompt = (members, heuristicLabel) => {
     const memberList = limitedMembers
         .map(m => `${m.name} (${m.type})`)
         .join(', ');
-    return `Analyze this code cluster and provide a semantic name and short description.
-
-Heuristic: "${heuristicLabel}"
-Members: ${memberList}${members.length > 20 ? ` (+${members.length - 20} more)` : ''}
-
-Reply with JSON only:
+    return `Analyze this code cluster and provide a semantic name and short description.
+
+Heuristic: "${heuristicLabel}"
+Members: ${memberList}${members.length > 20 ? ` (+${members.length - 20} more)` : ''}
+
+Reply with JSON only:
 {"name": "2-4 word semantic name", "description": "One sentence describing purpose"}`;
 };
 // ============================================================================
@@ -115,18 +115,18 @@ export const enrichClustersBatch = async (communities, memberMap, llmClient, bat
             const memberList = limitedMembers
                 .map(m => `${m.name} (${m.type})`)
                 .join(', ');
-            return `Cluster ${idx + 1} (id: ${community.id}):
-Heuristic: "${community.heuristicLabel}"
+            return `Cluster ${idx + 1} (id: ${community.id}):
+Heuristic: "${community.heuristicLabel}"
 Members: ${memberList}`;
         }).join('\n\n');
-        const prompt = `Analyze these code clusters and generate semantic names, keywords, and descriptions.
-
-${batchPrompt}
-
-Output JSON array:
-[
-  {"id": "comm_X", "name": "...", "keywords": [...], "description": "..."},
-  ...
+        const prompt = `Analyze these code clusters and generate semantic names, keywords, and descriptions.
+
+${batchPrompt}
+
+Output JSON array:
+[
+  {"id": "comm_X", "name": "...", "keywords": [...], "description": "..."},
+  ...
 ]`;
         try {
             const response = await llmClient.generate(prompt);

package/dist/core/ingestion/constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Default minimum buffer size for tree-sitter parsing (512 KB).
+ * tree-sitter requires bufferSize >= file size in bytes.
+ */
+export declare const TREE_SITTER_BUFFER_SIZE: number;
+/**
+ * Maximum buffer size cap (32 MB) to prevent OOM on huge files.
+ * Also used as the file-size skip threshold — files larger than this are not parsed.
+ */
+export declare const TREE_SITTER_MAX_BUFFER: number;
+/**
+ * Compute adaptive buffer size for tree-sitter parsing.
+ * Uses 2× file size, clamped between 512 KB and 32 MB.
+ * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
+ */
+export declare const getTreeSitterBufferSize: (contentLength: number) => number;

package/dist/core/ingestion/constants.js

@@ -0,0 +1,16 @@
+/**
+ * Default minimum buffer size for tree-sitter parsing (512 KB).
+ * tree-sitter requires bufferSize >= file size in bytes.
+ */
+export const TREE_SITTER_BUFFER_SIZE = 512 * 1024;
+/**
+ * Maximum buffer size cap (32 MB) to prevent OOM on huge files.
+ * Also used as the file-size skip threshold — files larger than this are not parsed.
+ */
+export const TREE_SITTER_MAX_BUFFER = 32 * 1024 * 1024;
+/**
+ * Compute adaptive buffer size for tree-sitter parsing.
+ * Uses 2× file size, clamped between 512 KB and 32 MB.
+ * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
+ */
+export const getTreeSitterBufferSize = (contentLength) => Math.min(Math.max(contentLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER);

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

@@ -9,6 +9,7 @@
  *
  * This module is language-agnostic - language-specific patterns are defined per language.
  */
+import { SupportedLanguages } from '../../config/supported-languages.js';
 export interface EntryPointScoreResult {
     score: number;
     reasons: string[];
@@ -26,7 +27,7 @@ export interface EntryPointScoreResult {
  * @param calleeCount - Number of functions this function calls
  * @returns Score and array of reasons explaining the score
  */
-export declare function calculateEntryPointScore(name: string, language: string, isExported: boolean, callerCount: number, calleeCount: number, filePath?: string): EntryPointScoreResult;
+export declare function calculateEntryPointScore(name: string, language: SupportedLanguages, isExported: boolean, callerCount: number, calleeCount: number, filePath?: string): EntryPointScoreResult;
 /**
  * Check if a file path is a test file (should be excluded from entry points)
  * Covers common test file patterns across all supported languages

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

@@ -10,8 +10,9 @@
  * This module is language-agnostic - language-specific patterns are defined per language.
  */
 import { detectFrameworkFromPath } from './framework-detection.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
 // ============================================================================
-// NAME PATTERNS - All 9 supported languages
+// NAME PATTERNS - All 11 supported languages
 // ============================================================================
 /**
  * Common entry point naming patterns by language
@@ -34,65 +35,112 @@ const ENTRY_POINT_PATTERNS = {
         /^emit[A-Z]/, // emitEvent
     ],
     // JavaScript/TypeScript
-    'javascript': [
+    [SupportedLanguages.JavaScript]: [
         /^use[A-Z]/, // React hooks (useEffect, etc.)
     ],
-    'typescript': [
+    [SupportedLanguages.TypeScript]: [
         /^use[A-Z]/, // React hooks
     ],
     // Python
-    'python': [
+    [SupportedLanguages.Python]: [
         /^app$/, // Flask/FastAPI app
         /^(get|post|put|delete|patch)_/i, // REST conventions
         /^api_/, // API functions
         /^view_/, // Django views
     ],
     // Java
-    'java': [
+    [SupportedLanguages.Java]: [
         /^do[A-Z]/, // doGet, doPost (Servlets)
         /^create[A-Z]/, // Factory patterns
         /^build[A-Z]/, // Builder patterns
         /Service$/, // UserService
     ],
     // C#
-    'csharp': [
-        /^(Get|Post|Put|Delete)/, // ASP.NET conventions
+    [SupportedLanguages.CSharp]: [
+        /^(Get|Post|Put|Delete|Patch)/, // ASP.NET action methods
         /Action$/, // MVC actions
-        /^On[A-Z]/, // Event handlers
+        /^On[A-Z]/, // Event handlers / Blazor lifecycle
         /Async$/, // Async entry points
+        /^Configure$/, // Startup.Configure
+        /^ConfigureServices$/, // Startup.ConfigureServices
+        /^Handle$/, // MediatR / generic handler
+        /^Execute$/, // Command pattern
+        /^Invoke$/, // Middleware Invoke
+        /^Map[A-Z]/, // Minimal API MapGet, MapPost
+        /Service$/, // Service classes
+        /^Seed/, // Database seeding
     ],
     // Go
-    'go': [
+    [SupportedLanguages.Go]: [
         /Handler$/, // http.Handler pattern
         /^Serve/, // ServeHTTP
         /^New[A-Z]/, // Constructor pattern (returns new instance)
         /^Make[A-Z]/, // Make functions
     ],
     // Rust
-    'rust': [
+    [SupportedLanguages.Rust]: [
         /^(get|post|put|delete)_handler$/i,
         /^handle_/, // handle_request
         /^new$/, // Constructor pattern
         /^run$/, // run entry point
         /^spawn/, // Async spawn
     ],
-    // C - explicit main() boost (critical for C programs)
-    'c': [
+    // C - explicit main() boost plus common C entry point conventions
+    [SupportedLanguages.C]: [
         /^main$/, // THE entry point
-        /^init_/, // Initialization functions
-        /^start_/, // Start functions
-        /^run_/, // Run functions
+        /^init_/, // init_server, init_client
+        /_init$/, // module_init, server_init
+        /^start_/, // start_server
+        /_start$/, // thread_start
+        /^run_/, // run_loop
+        /_run$/, // event_run
+        /^stop_/, // stop_server
+        /_stop$/, // service_stop
+        /^open_/, // open_connection
+        /_open$/, // file_open
+        /^close_/, // close_connection
+        /_close$/, // socket_close
+        /^create_/, // create_session
+        /_create$/, // object_create
+        /^destroy_/, // destroy_session
+        /_destroy$/, // object_destroy
+        /^handle_/, // handle_request
+        /_handler$/, // signal_handler
+        /_callback$/, // event_callback
+        /^cmd_/, // tmux: cmd_new_window, cmd_attach_session
+        /^server_/, // server_start, server_loop
+        /^client_/, // client_connect
+        /^session_/, // session_create
+        /^window_/, // window_resize (tmux)
+        /^key_/, // key_press
+        /^input_/, // input_parse
+        /^output_/, // output_write
+        /^notify_/, // notify_client
+        /^control_/, // control_start
     ],
-    // C++ - same as C plus class patterns
-    'cpp': [
+    // C++ - same as C plus OOP/template patterns
+    [SupportedLanguages.CPlusPlus]: [
         /^main$/, // THE entry point
         /^init_/,
+        /_init$/,
         /^Create[A-Z]/, // Factory patterns
+        /^create_/,
         /^Run$/, // Run methods
+        /^run$/,
         /^Start$/, // Start methods
+        /^start$/,
+        /^handle_/,
+        /_handler$/,
+        /_callback$/,
+        /^OnEvent/, // Event callbacks
+        /^on_/,
+        /::Run$/, // Class::Run
+        /::Start$/, // Class::Start
+        /::Init$/, // Class::Init
+        /::Execute$/, // Class::Execute
     ],
     // Swift / iOS
-    'swift': [
+    [SupportedLanguages.Swift]: [
         /^viewDidLoad$/, // UIKit lifecycle
         /^viewWillAppear$/, // UIKit lifecycle
         /^viewDidAppear$/, // UIKit lifecycle
@@ -111,7 +159,7 @@ const ENTRY_POINT_PATTERNS = {
         /^makeBody$/, // SwiftUI ViewModifier
     ],
     // PHP / Laravel
-    'php': [
+    [SupportedLanguages.PHP]: [
         /Controller$/, // UserController (class name convention)
         /^handle$/, // Job::handle(), Listener::handle()
         /^execute$/, // Command::execute()
@@ -130,7 +178,21 @@ const ENTRY_POINT_PATTERNS = {
         /^save$/, // Repository::save()
         /^delete$/, // Repository::delete()
     ],
+    // Ruby
+    [SupportedLanguages.Ruby]: [
+        /^call$/, // Service objects (MyService.call)
+        /^perform$/, // Background jobs (Sidekiq, ActiveJob)
+        /^execute$/, // Command pattern
+    ],
 };
+/** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */
+const MERGED_ENTRY_POINT_PATTERNS = {};
+const UNIVERSAL_PATTERNS = ENTRY_POINT_PATTERNS['*'] || [];
+for (const [lang, patterns] of Object.entries(ENTRY_POINT_PATTERNS)) {
+    if (lang === '*')
+        continue;
+    MERGED_ENTRY_POINT_PATTERNS[lang] = [...UNIVERSAL_PATTERNS, ...patterns];
+}
 // ============================================================================
 // UTILITY PATTERNS - Functions that should be penalized
 // ============================================================================
@@ -196,9 +258,7 @@ export function calculateEntryPointScore(name, language, isExported, callerCount
     }
     else {
         // Check positive patterns
-        const universalPatterns = ENTRY_POINT_PATTERNS['*'] || [];
-        const langPatterns = ENTRY_POINT_PATTERNS[language] || [];
-        const allPatterns = [...universalPatterns, ...langPatterns];
+        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS;
         if (allPatterns.some(p => p.test(name))) {
             nameMultiplier = 1.5; // Bonus for matching entry point pattern
             reasons.push('entry-pattern');
@@ -253,13 +313,23 @@ export function isTestFile(filePath) {
         p.endsWith('test.swift') ||
         p.includes('uitests/') ||
         // C# test patterns
+        p.endsWith('tests.cs') ||
+        p.endsWith('test.cs') ||
         p.includes('.tests/') ||
-        p.includes('tests.cs') ||
+        p.includes('.test/') ||
+        p.includes('.integrationtests/') ||
+        p.includes('.unittests/') ||
+        p.includes('/testproject/') ||
         // PHP/Laravel test patterns
         p.endsWith('test.php') ||
         p.endsWith('spec.php') ||
         p.includes('/tests/feature/') ||
-        p.includes('/tests/unit/'));
+        p.includes('/tests/unit/') ||
+        // Ruby test patterns
+        p.endsWith('_spec.rb') ||
+        p.endsWith('_test.rb') ||
+        p.includes('/spec/') ||
+        p.includes('/test/fixtures/'));
 }
 /**
  * Check if a file path is likely a utility/helper file

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

@@ -0,0 +1,18 @@
+/**
+ * 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 { SyntaxNode } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * 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 declare const isNodeExported: (node: SyntaxNode, name: string, language: SupportedLanguages) => boolean;