gitnexus 1.6.5-rc.9 → 1.6.5

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

@@ -45,6 +45,7 @@ import { generateId } from '../../../lib/utils.js';
 import { preprocessImportPath } from '../import-processor.js';
 import { extractVueScript, extractTemplateComponents, isVueSetupTopLevel, } from '../vue-sfc-extractor.js';
 import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from '../utils/method-props.js';
+import { extractTemplateArguments, templateArgumentsIdTag } from '../utils/template-arguments.js';
 import { extractParsedFile } from '../scope-extractor-bridge.js';
 import { logger } from '../../logger.js';
 // ============================================================================
@@ -1167,6 +1168,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         sourceId: srcId,
                         receiverText,
                         propertyName,
+                        line: captureMap['assignment'].startPosition.row + 1,
                         ...(receiverTypeName ? { receiverTypeName } : {}),
                     });
                 }
@@ -1544,6 +1546,20 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 })
                 : null;
             const nodeLabel = extractedClassSymbol?.type ?? defaultNodeLabel;
+            const isClassLikeLabel = nodeLabel === 'Class' ||
+                nodeLabel === 'Struct' ||
+                nodeLabel === 'Interface' ||
+                nodeLabel === 'Enum' ||
+                nodeLabel === 'Record';
+            if (isClassLikeLabel &&
+                provider.classExtractor?.shouldSkipClassCapture?.({
+                    captureMap,
+                    definitionNode,
+                    nameNode,
+                    nodeLabel,
+                }) === true) {
+                continue;
+            }
             // Dedup: variable captures (Const/Static/Variable) may overlap with higher-priority
             // captures (e.g. `const fn = () => {}` matches both @definition.function and @definition.const).
             // Skip variable captures whose definition node was already processed.
@@ -1633,7 +1649,26 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 arityTag += typeTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, language, groups);
                 arityTag += constTagForId(defMethodMap, nodeName, arityForId, defMethodInfo, groups);
             }
-            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${arityTag}`);
+            const classTemplateArguments = extractedClassSymbol?.templateArguments ??
+                provider.classExtractor?.extractTemplateArgumentsFromCapture?.({
+                    captureMap,
+                    definitionNode,
+                    nameNode,
+                }) ??
+                (captureMap['template-arguments']
+                    ? extractTemplateArguments(captureMap['template-arguments'].text)
+                    : undefined) ??
+                (nameNode && nameNode.text ? extractTemplateArguments(nameNode.text) : undefined);
+            const classTemplateTag = (nodeLabel === 'Class' ||
+                nodeLabel === 'Struct' ||
+                nodeLabel === 'Interface' ||
+                nodeLabel === 'Enum' ||
+                nodeLabel === 'Record') &&
+                classTemplateArguments !== undefined &&
+                classTemplateArguments.length > 0
+                ? templateArgumentsIdTag(classTemplateArguments)
+                : '';
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${classTemplateTag}${arityTag}`);
             const classNodeForSymbol = definitionNode || nameNode;
             const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
                 (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
@@ -1742,6 +1777,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         ? isVueSetupTopLevel(nameNode || definitionNode)
                         : cachedExportCheck(provider.exportChecker, nameNode || definitionNode, nodeName),
                     ...(qualifiedTypeName !== undefined ? { qualifiedName: qualifiedTypeName } : {}),
+                    ...(classTemplateArguments !== undefined && classTemplateArguments.length > 0
+                        ? { templateArguments: classTemplateArguments }
+                        : {}),
                     ...(frameworkHint
                         ? {
                             astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
@@ -1765,6 +1803,9 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 parameterTypes: methodProps.parameterTypes,
                 returnType: methodProps.returnType,
                 ...(declaredType !== undefined ? { declaredType } : {}),
+                ...(classTemplateArguments !== undefined && classTemplateArguments.length > 0
+                    ? { templateArguments: classTemplateArguments }
+                    : {}),
                 ...(enclosingClassId ? { ownerId: enclosingClassId } : {}),
                 visibility: methodProps.visibility,
                 isStatic: methodProps.isStatic,

package/dist/core/lbug/lbug-adapter.d.ts

@@ -41,6 +41,19 @@ export declare const getDatabase: () => lbug.Database | null;
  * analyze` and either already happened or will happen on the next run.
  */
 export declare const isReadOnlyDbError: (err: unknown) => boolean;
+/**
+ * Acquire a cross-process init lock for `dbPath`.
+ * Uses `O_CREAT | O_EXCL` for atomic create-or-fail semantics.
+ *
+ * Returns a release function that removes the lock file. The release
+ * function is idempotent and safe to call even if the lock was already
+ * cleaned up externally.
+ *
+ * Throws if the lock cannot be acquired after `INIT_LOCK_MAX_ATTEMPTS`.
+ */
+export declare const acquireInitLock: (dbPath: string) => Promise<() => Promise<void>>;
+/** Exported for testing — returns the lock file path for a given dbPath. */
+export declare const _initLockPathForTest: (dbPath: string) => string;
 export declare const initLbug: (dbPath: string) => Promise<{
     db: lbug.Database;
     conn: lbug.Connection;
@@ -150,6 +163,32 @@ export declare const deleteNodesForFile: (filePath: string, dbPath?: string) =>
     deletedNodes: number;
 }>;
 export declare const getEmbeddingTableName: () => string;
+/**
+ * Return the distinct repo-relative paths of files that import
+ * `targetFilePath` according to the IMPORTS edges currently in the
+ * DB. Used by the incremental writeback path to expand the
+ * "files-to-rewrite" set so that files importing a changed file get
+ * their edges (which may have been refined by cross-file resolution)
+ * re-emitted, rather than left stale in the DB.
+ *
+ * The DB query reads the *previous* run's state — pre-pipeline, before
+ * any nodes are deleted — so the returned importers are "files that
+ * USED TO import the target". That's the right set to invalidate:
+ * those are the files whose edges in the DB might no longer match
+ * what cross-file resolution produces given the changed file's new
+ * exports.
+ */
+export declare const queryImporters: (targetFilePath: string) => Promise<string[]>;
+/**
+ * Drop every Community and Process node (and their MEMBER_OF /
+ * STEP_IN_PROCESS edges via DETACH DELETE). Used at the start of an
+ * incremental run so the communities and processes phases regenerate
+ * them from scratch on the merged graph — required for the
+ * "Leiden runs on the FULL graph" correctness invariant.
+ */
+export declare const deleteAllCommunitiesAndProcesses: () => Promise<{
+    nodesDeleted: number;
+}>;
 /**
  * Load the FTS extension on the supplied connection (or the singleton
  * writable connection when none is given).