gitnexus 1.6.6-rc.52 → 1.6.6-rc.53

package/dist/core/ingestion/finalize-orchestrator.js

@@ -94,6 +94,7 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
         // AFTER `finalizeScopeModel` returns, before `resolveReferenceSites`
         // consumes the bundle. Most languages leave it empty.
         bindingAugmentations: new Map(),
+        workspaceFqnBindings: new Map(),
         referenceSites: Object.freeze([...allReferenceSites]),
         sccs: finalizeOut.sccs,
         stats: finalizeOut.stats,

package/dist/core/ingestion/languages/php/namespace-siblings.d.ts

@@ -26,6 +26,30 @@
  */
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+interface PhpFileStructure {
+    /** The declared namespace (backslash-separated), or '' for global namespace. */
+    readonly namespace: string;
+}
+/**
+ * Extract a PHP namespace declaration from raw source without tree-sitter.
+ *
+ * Single-pass line scanner that skips heredoc/nowdoc bodies, block
+ * comments, and single-line comments before matching. This avoids the
+ * false positives that a multiline regex produces when `namespace` appears
+ * inside a heredoc, nowdoc, string, or comment.
+ */
+export declare function extractNamespaceViaScanner(content: string): string;
+/**
+ * Extract the declared namespace from a PHP file's source.
+ * Uses the cached AST tree when available to avoid re-parsing.
+ *
+ * When no cached tree is available (worker-parsed files can't transfer
+ * native Tree objects across MessageChannels), uses a line scanner
+ * instead of re-parsing every file with tree-sitter. For 16K+ PHP files
+ * this eliminates ~16K tree-sitter re-parses during the namespace-siblings
+ * pass. See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
+ */
+export declare function extractPhpFileStructure(content: string, cachedTree: unknown): PhpFileStructure;
 export interface PhpSiblingInputs {
     readonly fileContents: ReadonlyMap<string, string>;
     readonly treeCache?: {
@@ -49,3 +73,4 @@ export declare function getPhpNamespaceForFile(filePath: string): string;
  * explicit `use` imports (`origin: 'import'`) and local declarations.
  */
 export declare function populatePhpNamespaceSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, inputs: PhpSiblingInputs): void;
+export {};

package/dist/core/ingestion/languages/php/namespace-siblings.js

@@ -24,22 +24,85 @@
  * to extract namespace declarations — same AST that `extractParsedFile`
  * already parsed, reused via `treeCache` to avoid double-parsing.
  */
-import { getPhpParser } from './query.js';
-import { getTreeSitterBufferSize } from '../../constants.js';
-import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+const NAMESPACE_RE = /^\s*namespace\s+([\w\\]+)\s*[;{]/i;
+const HEREDOC_START_RE = /<<<\s*['"]?(\w+)['"]?\s*$/;
+/**
+ * Extract a PHP namespace declaration from raw source without tree-sitter.
+ *
+ * Single-pass line scanner that skips heredoc/nowdoc bodies, block
+ * comments, and single-line comments before matching. This avoids the
+ * false positives that a multiline regex produces when `namespace` appears
+ * inside a heredoc, nowdoc, string, or comment.
+ */
+export function extractNamespaceViaScanner(content) {
+    const lines = content.split('\n');
+    let inBlockComment = false;
+    let heredocDelimiter = null;
+    for (const raw of lines) {
+        if (heredocDelimiter !== null) {
+            const trimmed = raw.trim();
+            if (trimmed === heredocDelimiter + ';' || trimmed === heredocDelimiter) {
+                heredocDelimiter = null;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (raw.includes('*/')) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        let line = raw;
+        const blockStart = line.indexOf('/*');
+        if (blockStart >= 0) {
+            const blockEnd = line.indexOf('*/', blockStart + 2);
+            if (blockEnd >= 0) {
+                line = line.slice(0, blockStart) + line.slice(blockEnd + 2);
+            }
+            else {
+                line = line.slice(0, blockStart);
+                inBlockComment = true;
+            }
+        }
+        const slashIdx = line.indexOf('//');
+        const hashIdx = line.indexOf('#');
+        if (slashIdx >= 0 && (hashIdx < 0 || slashIdx < hashIdx)) {
+            line = line.slice(0, slashIdx);
+        }
+        else if (hashIdx >= 0) {
+            line = line.slice(0, hashIdx);
+        }
+        const heredocMatch = raw.match(HEREDOC_START_RE);
+        if (heredocMatch) {
+            heredocDelimiter = heredocMatch[1];
+            continue;
+        }
+        const stripped = line.replace(/<\?php/gi, '').replace(/declare\s*\([^)]*\)\s*;?/gi, '');
+        const nsMatch = stripped.match(NAMESPACE_RE);
+        if (nsMatch) {
+            return nsMatch[1];
+        }
+    }
+    return '';
+}
 /**
  * Extract the declared namespace from a PHP file's source.
  * Uses the cached AST tree when available to avoid re-parsing.
+ *
+ * When no cached tree is available (worker-parsed files can't transfer
+ * native Tree objects across MessageChannels), uses a line scanner
+ * instead of re-parsing every file with tree-sitter. For 16K+ PHP files
+ * this eliminates ~16K tree-sitter re-parses during the namespace-siblings
+ * pass. See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
  */
-function extractPhpFileStructure(content, cachedTree) {
-    const tree = cachedTree ??
-        parseSourceSafe(getPhpParser(), content, undefined, {
-            bufferSize: getTreeSitterBufferSize(content),
-        });
+export function extractPhpFileStructure(content, cachedTree) {
+    if (!cachedTree) {
+        return { namespace: extractNamespaceViaScanner(content) };
+    }
     // Walk top-level nodes looking for namespace_definition.
     // PHP files have at most one namespace declaration (PSR-4 convention).
     // `namespace_definition` has a `name:` field of type `namespace_name`.
-    const root = tree.rootNode;
+    const root = cachedTree.rootNode;
     for (let i = 0; i < root.namedChildCount; i++) {
         const child = root.namedChild(i);
         if (child === null)
@@ -194,38 +257,31 @@ export function populatePhpNamespaceSiblings(parsedFiles, indexes, inputs) {
             }
         }
     }
-    // Step 3b: Inject fully-qualified-name bindings into every PHP file's
-    // Module scope. PHP `\App\Models\User` (leading-backslash FQN) and
-    // `App\Models\User` (already-qualified relative) on a parameter or
-    // typed receiver must resolve to the exact namespace-qualified class
-    // regardless of which simple-name `User` the caller's `use` imports
-    // shadowed. The shared `findClassBindingInScope` scope-chain walk
-    // consumes these augmentations via `lookupBindingsAt`, so adding the
-    // qualified key on every file's module scope routes FQN-receivers to
-    // the right def. Codex PR #1497 review, finding 1.
+    // Step 3b: Register FQN bindings in a workspace-level map instead of
+    // per-scope augmentations. PHP `\App\Models\User` and `App\Models\User`
+    // must resolve regardless of which file the lookup originates from.
+    // `lookupBindingsAt` consults `workspaceFqnBindings` as a third source.
     //
-    // Cost: O(PHP files × class-like defs in the workspace) augmentation
-    // entries. Bounded and acceptable in practice — typical PHP projects
-    // have hundreds of files and classes, not tens of thousands.
-    for (const parsed of parsedFiles) {
-        const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
-        if (moduleScope === undefined)
+    // Cost: O(class-like defs) entries — NOT O(files × classDefs). For 16K
+    // PHP files with 5K classes, this is 5K entries instead of 80M.
+    const fqnMap = indexes.workspaceFqnBindings;
+    for (const [ns, bucket] of buckets) {
+        if (ns === '')
             continue;
-        const moduleScopeId = moduleScope.id;
-        for (const [ns, bucket] of buckets) {
-            if (ns === '')
-                continue; // global-namespace classes have no qualified form to register
-            for (const def of bucket.classDefs) {
-                const q = def.qualifiedName ?? '';
-                const simpleName = q.includes('\\') ? q.slice(q.lastIndexOf('\\') + 1) : q;
-                if (simpleName === '')
-                    continue;
-                const fqn = `${ns}\\${simpleName}`;
-                const arr = getAugmentationBucket(augmentations, moduleScopeId, fqn);
-                if (arr.some((b) => b.def.nodeId === def.nodeId))
-                    continue;
-                arr.push({ def, origin: 'namespace' });
+        for (const def of bucket.classDefs) {
+            const q = def.qualifiedName ?? '';
+            const simpleName = q.includes('\\') ? q.slice(q.lastIndexOf('\\') + 1) : q;
+            if (simpleName === '')
+                continue;
+            const fqn = `${ns}\\${simpleName}`;
+            let arr = fqnMap.get(fqn);
+            if (arr === undefined) {
+                arr = [];
+                fqnMap.set(fqn, arr);
             }
+            if (arr.some((b) => b.def.nodeId === def.nodeId))
+                continue;
+            arr.push({ def, origin: 'namespace' });
         }
     }
     // Step 4: Mirror return-type bindings from same-namespace sibling files.

package/dist/core/ingestion/model/scope-resolution-indexes.d.ts

@@ -63,6 +63,12 @@ export interface ScopeResolutionIndexes {
      *  are returned first and win duplicate `def.nodeId` metadata, with
      *  unique augmentations appended after. See I8. */
     readonly bindingAugmentations: ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>;
+    /** Workspace-level FQN binding lookup. Populated by PHP namespace-
+     *  siblings Step 3b as a shared map instead of per-scope duplication.
+     *  Consulted by `lookupBindingsAt` as a third source after finalized
+     *  and per-scope augmented bindings. Keys are backslash-separated FQNs
+     *  (e.g. `App\Models\User`). */
+    readonly workspaceFqnBindings: ReadonlyMap<string, readonly BindingRef[]>;
     /** Pre-resolution usage facts; consumed by the resolution phase. */
     readonly referenceSites: readonly ReferenceSite[];
     /** SCC condensation of the file-level import graph — callers that want

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -124,6 +124,15 @@ export const scopeResolutionPhase = {
                     }
                 },
             }, provider);
+            // Release file contents and pre-extracted entries after each language
+            // to reduce memory pressure. For large codebases (16K+ PHP files),
+            // holding all source code simultaneously with scope trees causes OOM.
+            // See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
+            files.length = 0;
+            contents.clear();
+            for (const fp of filePaths) {
+                preExtractedByPath.delete(fp);
+            }
             anyRan = true;
             totalFiles += stats.filesProcessed;
             totalImports += stats.importsEmitted;

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -44,24 +44,40 @@ const EMPTY_BINDINGS = Object.freeze([]);
 export function lookupBindingsAt(scopeId, name, scopes) {
     const finalized = scopes.bindings.get(scopeId)?.get(name);
     const augmented = scopes.bindingAugmentations.get(scopeId)?.get(name);
+    const workspace = scopes.workspaceFqnBindings?.get(name);
     const fLen = finalized?.length ?? 0;
     const aLen = augmented?.length ?? 0;
-    if (fLen === 0 && aLen === 0)
+    const wLen = workspace?.length ?? 0;
+    if (fLen === 0 && aLen === 0 && wLen === 0)
         return EMPTY_BINDINGS;
-    if (aLen === 0)
+    if (aLen === 0 && wLen === 0)
         return finalized;
-    if (fLen === 0)
+    if (fLen === 0 && wLen === 0)
         return augmented;
+    if (fLen === 0 && aLen === 0)
+        return workspace;
     const seen = new Set();
     const out = [];
-    for (const r of finalized) {
-        seen.add(r.def.nodeId);
-        out.push(r);
+    if (fLen > 0) {
+        for (const r of finalized) {
+            seen.add(r.def.nodeId);
+            out.push(r);
+        }
     }
-    for (const r of augmented) {
-        if (seen.has(r.def.nodeId))
-            continue;
-        out.push(r);
+    if (aLen > 0) {
+        for (const r of augmented) {
+            if (seen.has(r.def.nodeId))
+                continue;
+            seen.add(r.def.nodeId);
+            out.push(r);
+        }
+    }
+    if (wLen > 0) {
+        for (const r of workspace) {
+            if (seen.has(r.def.nodeId))
+                continue;
+            out.push(r);
+        }
     }
     return out;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.52",
+  "version": "1.6.6-rc.53",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",