gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/workers/parse-worker.js

@@ -1,4 +1,5 @@
 import { parentPort, threadId, workerData } from 'node:worker_threads';
+import { createRequire } from 'node:module';
 import { boundCallableStartPosition, localIdentity, nestedCallableQualifiedName, positionQualifiedCallableName, } from './callable-id.js';
 import Parser from 'tree-sitter';
 import JavaScript from 'tree-sitter-javascript';
@@ -58,6 +59,13 @@ try {
     C = requireVendoredGrammar('tree-sitter-c');
 }
 catch { }
+// @tree-sitter-grammars/tree-sitter-zig is an optionalDependency — may not be installed
+const _require = createRequire(import.meta.url);
+let Zig = null;
+try {
+    Zig = _require('@tree-sitter-grammars/tree-sitter-zig');
+}
+catch { }
 import { getLanguageFromFilename } from '../../../_shared/index.js';
 import { buildDefinitionPreScan, FUNCTION_NODE_TYPES, findAncestorBeforeBoundary, findSplitBodyCallableAncestor, SPLIT_SIGNATURE_NODE_TYPES, getDefinitionNodeFromCaptures, findEnclosingClassInfo, findObjectLiteralBindingInfo, isArrayContainedObjectLiteralMember, findReturnShapeOwnerInfo, isReturnShapeProperty, findMemberAssignmentOwnerInfo, isCjsDefaultExportAssignment, getLabelFromCaptures, genericFuncName, inferFunctionLabel, isSuppressedConcreteTypedefDuplicate, isValueDefinitionLabel, isQualifiableScopeLabel, MEMBER_OWNER_NODE_TYPES, qualifyByEnclosingModScope, qualifyRustImplTargetByModScope, CLASS_CONTAINER_TYPES, PARAMETER_LIST_NODE_TYPES, LOCAL_SCOPE_BODY_NODE_TYPES, } from '../utils/ast-helpers.js';
 import { isPositionQualifiedLocalLabel } from '../utils/callable-labels.js';
@@ -144,6 +152,7 @@ const languageMap = {
     [SupportedLanguages.Vue]: TypeScript.typescript,
     ...(Dart ? { [SupportedLanguages.Dart]: Dart } : {}),
     ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
+    ...(Zig ? { [SupportedLanguages.Zig]: Zig } : {}),
 };
 /**
  * Check if a language grammar is available in this worker.
@@ -204,6 +213,25 @@ function findEnclosingClassNode(node) {
     }
     return null;
 }
+/**
+ * `findEnclosingClassNode`, extended with the provider's file-level owner:
+ * when no container encloses `node` but the language says the FILE itself is
+ * a type (`resolveFileTypeOwner`, e.g. a Zig file-struct), the tree root is
+ * the owner node the method/field extractors should read members from. Same
+ * root, same name as `findEnclosingClassInfo`'s root branch, so member ids and
+ * owner ids agree.
+ */
+function findEnclosingClassNodeOrFileOwner(node, provider, filePath) {
+    const container = findEnclosingClassNode(node);
+    if (container !== null)
+        return container;
+    if (provider.resolveFileTypeOwner === undefined)
+        return null;
+    let root = node;
+    while (root.parent)
+        root = root.parent;
+    return provider.resolveFileTypeOwner(root, filePath) !== null ? root : null;
+}
 /**
  * For C++ out-of-class method definitions (e.g. `void Foo::bar() {}`), extract the
  * class name from the qualified_identifier scope and find the class declaration in the
@@ -477,7 +505,7 @@ const callableOwnQualifiedName = (fnNode, filePath, provider) => {
     }
     const prefix = enclosingCallablePrefix(fnNode, filePath, provider);
     const classInfo = prefix === undefined
-        ? cachedFindEnclosingClassInfo(fnNode, filePath, provider.resolveEnclosingOwner)
+        ? cachedFindEnclosingClassInfo(fnNode, filePath, provider.resolveEnclosingOwner, undefined, provider.resolveFileTypeOwner, provider.resolveContainerTypeOwner)
         : null;
     const objectOwner = prefix === undefined && classInfo === null && shouldObjectOwnerQualifyCallable(finalLabel)
         ? findObjectLiteralBindingInfo(fnNode, filePath, { includeOwnerName: true })?.ownerName
@@ -523,7 +551,7 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                         finalLabel = override;
                 }
                 // Qualify with enclosing class to match definition-phase node IDs
-                const classInfo = cachedFindEnclosingClassInfo(current, filePath, provider.resolveEnclosingOwner);
+                const classInfo = cachedFindEnclosingClassInfo(current, filePath, provider.resolveEnclosingOwner, undefined, provider.resolveFileTypeOwner, provider.resolveContainerTypeOwner);
                 const encLang = getLanguageFromFilename(filePath);
                 const standaloneMethodInfo = (finalLabel === 'Method' || finalLabel === 'Constructor') &&
                     encLang === SupportedLanguages.Go &&
@@ -573,7 +601,11 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                             : standaloneMethodInfo.parameters.length;
                     }
                     else {
-                        const classNode = findEnclosingClassNode(current) ?? findClassNodeByQualifiedName(current);
+                        // Same owner lookup as the definition-phase Method id builder: a Zig
+                        // file-struct's top-level fn is owned by the file root, and its
+                        // id carries the `#<arity>` suffix only if that owner is found.
+                        const classNode = findEnclosingClassNodeOrFileOwner(current, provider, filePath) ??
+                            findClassNodeByQualifiedName(current);
                         if (classNode && encLang) {
                             const methodMap = getMethodInfo(classNode, provider, {
                                 filePath,
@@ -613,7 +645,7 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
                         finalLabel = override;
                 }
                 // Qualify custom result with enclosing class
-                const classInfo = cachedFindEnclosingClassInfo(current.previousSibling ?? current, filePath, provider.resolveEnclosingOwner);
+                const classInfo = cachedFindEnclosingClassInfo(current.previousSibling ?? current, filePath, provider.resolveEnclosingOwner, undefined, provider.resolveFileTypeOwner, provider.resolveContainerTypeOwner);
                 // Same nesting rule as the generic branch above (#2699). Anchored on
                 // `sigNode`-equivalent (`current.previousSibling ?? current`) so Dart,
                 // whose body is a SIBLING of the signature, walks from the same node
@@ -663,11 +695,11 @@ const findEnclosingFunctionId = (node, filePath, provider) => {
     return null;
 };
 /** Cached wrapper for findEnclosingClassInfo — avoids repeated parent walks. */
-const cachedFindEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, getQualifiedOwnerName) => {
+const cachedFindEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, getQualifiedOwnerName, resolveFileTypeOwner, resolveContainerTypeOwner) => {
     const cached = classIdCache.get(node);
     if (cached !== undefined)
         return cached;
-    const result = findEnclosingClassInfo(node, filePath, resolveEnclosingOwner, getQualifiedOwnerName);
+    const result = findEnclosingClassInfo(node, filePath, resolveEnclosingOwner, getQualifiedOwnerName, resolveFileTypeOwner, resolveContainerTypeOwner);
     classIdCache.set(node, result);
     return result;
 };
@@ -946,6 +978,7 @@ export function extractORMQueries(filePath, content, out) {
 // import the function and its types directly from `route-extractors/`.
 import { extractFastAPIRouterBindings } from '../route-extractors/fastapi-router-bindings.js';
 import { parseConstOperands, } from '../route-extractors/python-const-resolver.js';
+import { unfoldableDeclarationsOf } from '../route-extractors/constant-resolver.js';
 /**
  * Report a non-fatal worker issue to the pool over IPC so a caught error is not
  * invisible to the operator (#2264). The pool logs it on the main thread AND
@@ -1025,6 +1058,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             continue;
         }
         const provider = getProvider(language);
+        // Owner map for provider.synthesizeStructureMembers: type-declaration AST
+        // node id → graph node id for classes THIS file's capture loop materialized.
+        // Keyed by in-memory AST identity (never persisted); filled below.
+        const classOwnersByNodeId = new Map();
         // #2687: ONE pass over `matches` yields both suppression sets — the
         // definition-name claims by rank (callable > Property > value), so the dedup
         // below cannot depend on tree-sitter's match order, and the concrete-typedef
@@ -1210,12 +1247,14 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     const httpMethod = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(method)
                         ? method
                         : 'GET';
+                    const handlerName = provider.decoratorRouteHandlerName?.(decoratorNode);
                     const base = {
                         filePath: file.path,
                         httpMethod,
                         decoratorName,
                         lineNumber: decoratorNode.startPosition.row + lineOffset,
                         ...(decoratorReceiver ? { decoratorReceiver } : {}),
+                        ...(handlerName ? { handlerName } : {}),
                     };
                     if (decoratorArgStr) {
                         // String-literal path (the fast path, unchanged). Empty-string
@@ -1409,7 +1448,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                 const propGetQualifiedOwnerName = provider.classExtractor?.qualifiedNodeId === true
                                     ? (node, simpleName) => provider.classExtractor.extractQualifiedName(node, simpleName)
                                     : undefined;
-                                const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner, propGetQualifiedOwnerName);
+                                const propEnclosingInfo = cachedFindEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner, propGetQualifiedOwnerName, provider.resolveFileTypeOwner, provider.resolveContainerTypeOwner);
                                 const propEnclosingClassId = propEnclosingInfo?.qualifiedClassId ?? propEnclosingInfo?.classId ?? null;
                                 // Enrich routed properties with FieldExtractor metadata
                                 let routedFieldMap;
@@ -1568,6 +1607,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 ? provider.classExtractor.extract(definitionNode, {
                     name: nameNode?.text,
                     type: defaultNodeLabel,
+                    filePath: file.path,
                 })
                 : null;
             const nodeLabel = extractedClassSymbol?.type ?? defaultNodeLabel;
@@ -1575,7 +1615,8 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 nodeLabel === 'Struct' ||
                 nodeLabel === 'Interface' ||
                 nodeLabel === 'Enum' ||
-                nodeLabel === 'Record';
+                nodeLabel === 'Record' ||
+                nodeLabel === 'Union';
             if (isClassLikeLabel &&
                 provider.classExtractor?.shouldSkipClassCapture?.({
                     captureMap,
@@ -1755,7 +1796,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 findAncestorBeforeBoundary(propOwnerNode, LOCAL_SCOPE_BODY_NODE_TYPES, CLASS_CONTAINER_TYPES) !== null &&
                 findAncestorBeforeBoundary(propOwnerNode, PARAMETER_LIST_NODE_TYPES, LOCAL_SCOPE_BODY_NODE_TYPES) === null;
             const enclosingClassInfo = needsOwner && !isFunctionLocalProperty
-                ? cachedFindEnclosingClassInfo(nameNode || definitionNode, file.path, provider.resolveEnclosingOwner, getQualifiedOwnerName)
+                ? cachedFindEnclosingClassInfo(nameNode || definitionNode, file.path, provider.resolveEnclosingOwner, getQualifiedOwnerName, provider.resolveFileTypeOwner, provider.resolveContainerTypeOwner)
                 : null;
             const enclosingClassId = enclosingClassInfo?.qualifiedClassId ?? enclosingClassInfo?.classId ?? null;
             // A Method with no enclosing class container is owned by a NAMED binding
@@ -1946,7 +1987,8 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 // returnType, isAbstract/isFinal/annotations, visibility, and more.
                 let enrichedByMethodExtractor = false;
                 if (provider.methodExtractor && definitionNode) {
-                    const classNode = findEnclosingClassNode(definitionNode) ?? findClassNodeByQualifiedName(definitionNode);
+                    const classNode = findEnclosingClassNodeOrFileOwner(definitionNode, provider, file.path) ??
+                        findClassNodeByQualifiedName(definitionNode);
                     if (classNode) {
                         const methodMap = getMethodInfo(classNode, provider, {
                             filePath: file.path,
@@ -2109,7 +2151,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             if (nodeLabel === 'Property' && definitionNode) {
                 // FieldExtractor is the single source of truth when available
                 if (provider.fieldExtractor && typeEnv) {
-                    const classNode = findEnclosingClassNode(definitionNode);
+                    const classNode = findEnclosingClassNodeOrFileOwner(definitionNode, provider, file.path);
                     if (classNode) {
                         const fieldMap = getFieldInfo(classNode, provider, {
                             typeEnv,
@@ -2169,6 +2211,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 const definitionProperties = runDefinitionPropertiesExtractor(provider.definitionPropertiesExtractor, {
                     nodeLabel,
                     nodeName,
+                    filePath: file.path,
                     definitionNode,
                     parsedImports: parsedFile?.parsedImports ?? [],
                     isExported,
@@ -2248,6 +2291,14 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     ? { annotations: methodProps.annotations }
                     : {}),
             });
+            // Class-like definitions register their AST node id → graph node id for
+            // provider.synthesizeStructureMembers. The definition node is the same
+            // type-declaration AST node that the provider-specific planner receives.
+            if (isClassLikeLabel &&
+                definitionNode &&
+                provider.classExtractor?.isTypeDeclaration(definitionNode)) {
+                classOwnersByNodeId.set(definitionNode.id, nodeId);
+            }
             // Object-literal callables remain file definitions as well as members of
             // their exported binding. Class members still use HAS_METHOD alone.
             const isTopLevelObjectCallable = objectLiteralBindingInfo?.ownerName !== undefined &&
@@ -2316,7 +2367,13 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         // without booting a worker.
         if (provider.extractModuleConstants && shouldHarvestModuleConstants(provider, parseContent)) {
             const constants = provider.extractModuleConstants(tree);
-            if (constants.literals.size > 0 || constants.exprs.size > 0 || constants.imports.size > 0) {
+            const topLevelDeclarations = constants.topLevelDeclarations;
+            if (constants.literals.size > 0 ||
+                constants.exprs.size > 0 ||
+                constants.imports.size > 0 ||
+                (constants.wildcardImports?.length ?? 0) > 0 ||
+                unfoldableDeclarationsOf(constants).size > 0 ||
+                (topLevelDeclarations instanceof Set && topLevelDeclarations.size > 0)) {
                 (result.moduleConstants ??= []).push({ filePath: file.path, constants });
             }
         }
@@ -2337,6 +2394,18 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             if (springTypes.length > 0)
                 (result.springTypes ??= []).push(...springTypes);
         }
+        if (provider.synthesizeStructureMembers) {
+            const synthetic = provider.synthesizeStructureMembers(tree, file.path, classOwnersByNodeId);
+            for (const node of synthetic.nodes) {
+                result.nodes.push(node);
+            }
+            for (const sym of synthetic.symbols) {
+                result.symbols.push(sym);
+            }
+            for (const rel of synthetic.relationships) {
+                result.relationships.push(rel);
+            }
+        }
         // Vue: emit CALLS edges for components used in <template>
         if (language === SupportedLanguages.Vue) {
             const templateComponents = extractTemplateComponents(file.content);
@@ -2469,8 +2538,10 @@ parentPort.on('message', (msg) => {
                     persistDurableParsedFileShardSync(DURABLE_PARSED_FILE_STORAGE_PATH, msg.chunkHash, threadId, seq, accumulated.parsedFiles);
                 }
                 if (PARSED_FILE_STORE_STORAGE_PATH) {
-                    persistParsedFileShardSync(PARSED_FILE_STORE_STORAGE_PATH, `w${threadId}-${seq}`, accumulated.parsedFiles);
-                    accumulated.parsedFiles = [];
+                    const wrote = persistParsedFileShardSync(PARSED_FILE_STORE_STORAGE_PATH, `w${threadId}-${seq}`, accumulated.parsedFiles);
+                    if (wrote) {
+                        accumulated.parsedFiles = [];
+                    }
                 }
             }
             postResultCloneSafe(accumulated);

package/dist/core/install-context.d.ts

@@ -0,0 +1,4 @@
+/** True only for a persistent npm global or project-local installation. */
+export declare function updateEligibleInstall(entryPath?: string, env?: NodeJS.ProcessEnv): Promise<boolean>;
+/** Synchronous entry-point variant for pre-Commander startup checks. */
+export declare function updateEligibleInstallSync(entryPath?: string, env?: NodeJS.ProcessEnv): boolean;

package/dist/core/install-context.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+const EPHEMERAL_SEGMENTS = new Set(['_npx', '_cacache']);
+const EPHEMERAL_DLX_OWNERS = new Set(['pnpm', 'yarn']);
+function isInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function hasEphemeralMarker(candidate) {
+    const normalized = candidate.replaceAll('\\', '/').toLowerCase();
+    const segments = normalized.split('/').filter(Boolean);
+    if (segments.some((segment) => EPHEMERAL_SEGMENTS.has(segment)))
+        return true;
+    // `dlx` is only ephemeral next to a package-manager owner (pnpm dlx / yarn
+    // dlx). A project directory that happens to be named `dlx` is a normal install.
+    if (segments.includes('dlx') && segments.some((segment) => EPHEMERAL_DLX_OWNERS.has(segment))) {
+        return true;
+    }
+    return normalized.includes('/.bun/install/cache/') || normalized.includes('/bun/install/cache/');
+}
+function findPackageDir(entryPath) {
+    let current = path.dirname(path.resolve(entryPath));
+    for (;;) {
+        if (path.basename(current) === 'gitnexus' &&
+            path.basename(path.dirname(current)) === 'node_modules') {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+/**
+ * Pure classification shared by the async and sync variants. Realpath
+ * resolution deliberately makes a linked node_modules entry point at its
+ * development checkout, which is therefore ineligible.
+ */
+function classifyEligibility(probes) {
+    const { realEntry, env, realCache, packageDir, packageDirHasGit, realPrefix } = probes;
+    const corroboratingPaths = [
+        realEntry,
+        env.npm_execpath,
+        env.npm_config_cache && path.resolve(env.npm_config_cache),
+    ].filter((value) => Boolean(value));
+    if (corroboratingPaths.some(hasEphemeralMarker))
+        return false;
+    if (realCache && isInside(realCache, realEntry))
+        return false;
+    // Published packages do not carry .git. This also rejects unusual installs
+    // copied wholesale from a checkout.
+    if (!packageDir || packageDirHasGit)
+        return false;
+    if (realPrefix && isInside(realPrefix, realEntry))
+        return true;
+    // A package rooted at node_modules/gitnexus is a persistent project-local
+    // install after ephemeral/cache layouts have been excluded above.
+    return true;
+}
+let memoizedEligible;
+/** True only for a persistent npm global or project-local installation. */
+export async function updateEligibleInstall(entryPath, env = process.env) {
+    const useMemo = entryPath === undefined && env === process.env;
+    if (useMemo && memoizedEligible !== undefined)
+        return memoizedEligible;
+    const result = await classifyAsync(entryPath ?? process.argv[1] ?? '', env);
+    if (useMemo)
+        memoizedEligible = result;
+    return result;
+}
+async function classifyAsync(entryPath, env) {
+    if (!entryPath)
+        return false;
+    try {
+        const realEntry = await fs.realpath(entryPath);
+        const realCache = env.npm_config_cache
+            ? await fs
+                .realpath(env.npm_config_cache)
+                .catch(() => path.resolve(env.npm_config_cache))
+            : null;
+        const packageDir = findPackageDir(realEntry);
+        const packageDirHasGit = packageDir
+            ? await fs
+                .access(path.join(packageDir, '.git'))
+                .then(() => true)
+                .catch(() => false)
+            : false;
+        const realPrefix = env.npm_config_prefix
+            ? await fs.realpath(env.npm_config_prefix).catch(() => path.resolve(env.npm_config_prefix))
+            : null;
+        return classifyEligibility({
+            realEntry,
+            env,
+            realCache,
+            packageDir,
+            packageDirHasGit,
+            realPrefix,
+        });
+    }
+    catch {
+        return false;
+    }
+}
+/** Synchronous entry-point variant for pre-Commander startup checks. */
+export function updateEligibleInstallSync(entryPath, env = process.env) {
+    const useMemo = entryPath === undefined && env === process.env;
+    if (useMemo && memoizedEligible !== undefined)
+        return memoizedEligible;
+    const result = classifySync(entryPath ?? process.argv[1] ?? '', env);
+    if (useMemo)
+        memoizedEligible = result;
+    return result;
+}
+function classifySync(entryPath, env) {
+    if (!entryPath)
+        return false;
+    try {
+        const realEntry = fsSync.realpathSync(entryPath);
+        let realCache = null;
+        if (env.npm_config_cache) {
+            try {
+                realCache = fsSync.realpathSync(env.npm_config_cache);
+            }
+            catch {
+                realCache = path.resolve(env.npm_config_cache);
+            }
+        }
+        const packageDir = findPackageDir(realEntry);
+        const packageDirHasGit = packageDir ? fsSync.existsSync(path.join(packageDir, '.git')) : false;
+        let realPrefix = null;
+        if (env.npm_config_prefix) {
+            try {
+                realPrefix = fsSync.realpathSync(env.npm_config_prefix);
+            }
+            catch {
+                realPrefix = path.resolve(env.npm_config_prefix);
+            }
+        }
+        return classifyEligibility({
+            realEntry,
+            env,
+            realCache,
+            packageDir,
+            packageDirHasGit,
+            realPrefix,
+        });
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/lbug/csv-generator.d.ts

@@ -53,6 +53,15 @@ export declare const shouldFlushCSVBuffer: (byteCount: number) => boolean;
 export declare const sanitizeUTF8: (str: string) => string;
 export declare const escapeCSVField: (value: string | number | undefined | null) => string;
 export declare const escapeCSVNumber: (value: number | undefined | null, defaultValue?: number) => string;
+/**
+ * A numeric column that may legitimately have NO value.
+ *
+ * `escapeCSVNumber` substitutes a sentinel (-1) for absence, which is right
+ * where every row has a span and wrong where absence is the fact being
+ * recorded. An empty field is loaded as NULL by COPY, so the column can say
+ * "there is no line here" instead of pointing at line -1.
+ */
+export declare const escapeCSVNullableNumber: (value: unknown) => string;
 /**
  * Did this text come from a binary payload? Density of non-printables over the
  * first {@link BINARY_SAMPLE_CHARS} characters, above 10%.
@@ -106,7 +115,7 @@ export declare const isBinaryContent: (content: string) => boolean;
 export declare const normalizeFtsText: (text: string) => string;
 /** Canonical relationship CSV header — shared by the emit pass and the
  * `splitRelCsvByLabelPair` differential oracle. */
-export declare const REL_CSV_HEADER = "from,to,type,confidence,reason,step";
+export declare const REL_CSV_HEADER = "from,to,type,confidence,reason,step,staticGated";
 /** Build the escaped CSV row (no trailing newline) for one relationship.
  * Single source of the relationship row bytes — used by the emit pass and by
  * the byte-identity differential test that feeds the legacy split oracle. */