gitnexus 1.4.6 → 1.4.8

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -1,5 +1,8 @@
 import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { type MixedChainStep } from '../utils.js';
 import type { ConstructorBinding } from '../type-env.js';
+import type { NamedBinding } from '../import-resolution.js';
+import type { NodeLabel } from '../../graph/types.js';
 interface ParsedNode {
     id: string;
     label: string;
@@ -14,6 +17,7 @@ interface ParsedNode {
         astFrameworkReason?: string;
         description?: string;
         parameterCount?: number;
+        requiredParameterCount?: number;
         returnType?: string;
     };
 }
@@ -21,7 +25,7 @@ interface ParsedRelationship {
     id: string;
     sourceId: string;
     targetId: string;
-    type: 'DEFINES' | 'HAS_METHOD';
+    type: 'DEFINES' | 'HAS_METHOD' | 'HAS_PROPERTY';
     confidence: number;
     reason: string;
 }
@@ -29,9 +33,12 @@ interface ParsedSymbol {
     filePath: string;
     name: string;
     nodeId: string;
-    type: string;
+    type: NodeLabel;
     parameterCount?: number;
+    requiredParameterCount?: number;
+    parameterTypes?: string[];
     returnType?: string;
+    declaredType?: string;
     ownerId?: string;
 }
 export interface ExtractedImport {
@@ -39,10 +46,7 @@ export interface ExtractedImport {
     rawImportPath: string;
     language: SupportedLanguages;
     /** Named bindings from the import (e.g., import {User as U} → [{local:'U', exported:'User'}]) */
-    namedBindings?: {
-        local: string;
-        exported: string;
-    }[];
+    namedBindings?: NamedBinding[];
 }
 export interface ExtractedCall {
     filePath: string;
@@ -57,13 +61,25 @@ export interface ExtractedCall {
     /** Resolved type name of the receiver (e.g., 'User' for user.save() when user: User) */
     receiverTypeName?: string;
     /**
-     * Chained call names when the receiver is itself a call expression.
-     * For `svc.getUser().save()`, the `save` ExtractedCall gets receiverCallChain = ['getUser']
-     * with receiverName = 'svc'.  The chain is ordered outermost-last, e.g.:
-     *   `a.b().c().d()` → calledName='d', receiverCallChain=['b','c'], receiverName='a'
+     * Unified mixed chain when the receiver is a chain of field accesses and/or method calls.
+     * Steps are ordered base-first (innermost to outermost). Examples:
+     *   `svc.getUser().save()`        → chain=[{kind:'call',name:'getUser'}], receiverName='svc'
+     *   `user.address.save()`         → chain=[{kind:'field',name:'address'}], receiverName='user'
+     *   `svc.getUser().address.save()` → chain=[{kind:'call',name:'getUser'},{kind:'field',name:'address'}]
      * Length is capped at MAX_CHAIN_DEPTH (3).
      */
-    receiverCallChain?: string[];
+    receiverMixedChain?: MixedChainStep[];
+}
+export interface ExtractedAssignment {
+    filePath: string;
+    /** generateId of enclosing function, or generateId('File', filePath) for top-level */
+    sourceId: string;
+    /** Receiver text (e.g., 'user' from user.address = value) */
+    receiverText: string;
+    /** Property name being written (e.g., 'address') */
+    propertyName: string;
+    /** Resolved type name of the receiver if available from TypeEnv */
+    receiverTypeName?: string;
 }
 export interface ExtractedHeritage {
     filePath: string;
@@ -87,15 +103,24 @@ export interface FileConstructorBindings {
     filePath: string;
     bindings: ConstructorBinding[];
 }
+/** File-scope type bindings from TypeEnv fixpoint — used for cross-file ExportedTypeMap. */
+export interface FileTypeEnvBindings {
+    filePath: string;
+    /** [varName, typeName] pairs from file scope (scope = '') */
+    bindings: [string, string][];
+}
 export interface ParseWorkerResult {
     nodes: ParsedNode[];
     relationships: ParsedRelationship[];
     symbols: ParsedSymbol[];
     imports: ExtractedImport[];
     calls: ExtractedCall[];
+    assignments: ExtractedAssignment[];
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
     constructorBindings: FileConstructorBindings[];
+    /** File-scope type bindings from TypeEnv fixpoint for exported symbol collection. */
+    typeEnvBindings: FileTypeEnvBindings[];
     skippedLanguages: Record<string, number>;
     fileCount: number;
 }

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

@@ -28,15 +28,15 @@ try {
     Kotlin = _require('tree-sitter-kotlin');
 }
 catch { }
-import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, CALL_EXPRESSION_TYPES, extractCallChain, } from '../utils.js';
+import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, getLabelFromCaptures, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, } from '../utils.js';
 import { buildTypeEnv } from '../type-env.js';
 import { isNodeExported } from '../export-detection.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
 import { typeConfigs } from '../type-extractors/index.js';
 import { generateId } from '../../../lib/utils.js';
-import { extractNamedBindings } from '../named-binding-extraction.js';
-import { appendKotlinWildcard } from '../resolvers/index.js';
+import { namedBindingExtractors, preprocessImportPath } from '../import-resolution.js';
 import { callRouters } from '../call-routing.js';
+import { extractPropertyDeclaredType } from '../type-extractors/shared.js';
 // ============================================================================
 // Worker-local parser + language map
 // ============================================================================
@@ -96,61 +96,7 @@ const findEnclosingFunctionId = (node, filePath) => {
     }
     return null;
 };
-// ============================================================================
-// Label detection from capture map
-// ============================================================================
-const getLabelFromCaptures = (captureMap) => {
-    // Skip imports (handled separately) and calls
-    if (captureMap['import'] || captureMap['call'])
-        return null;
-    if (!captureMap['name'])
-        return null;
-    if (captureMap['definition.function'])
-        return 'Function';
-    if (captureMap['definition.class'])
-        return 'Class';
-    if (captureMap['definition.interface'])
-        return 'Interface';
-    if (captureMap['definition.method'])
-        return 'Method';
-    if (captureMap['definition.struct'])
-        return 'Struct';
-    if (captureMap['definition.enum'])
-        return 'Enum';
-    if (captureMap['definition.namespace'])
-        return 'Namespace';
-    if (captureMap['definition.module'])
-        return 'Module';
-    if (captureMap['definition.trait'])
-        return 'Trait';
-    if (captureMap['definition.impl'])
-        return 'Impl';
-    if (captureMap['definition.type'])
-        return 'TypeAlias';
-    if (captureMap['definition.const'])
-        return 'Const';
-    if (captureMap['definition.static'])
-        return 'Static';
-    if (captureMap['definition.typedef'])
-        return 'Typedef';
-    if (captureMap['definition.macro'])
-        return 'Macro';
-    if (captureMap['definition.union'])
-        return 'Union';
-    if (captureMap['definition.property'])
-        return 'Property';
-    if (captureMap['definition.record'])
-        return 'Record';
-    if (captureMap['definition.delegate'])
-        return 'Delegate';
-    if (captureMap['definition.annotation'])
-        return 'Annotation';
-    if (captureMap['definition.constructor'])
-        return 'Constructor';
-    if (captureMap['definition.template'])
-        return 'Template';
-    return 'CodeElement';
-};
+// Label detection moved to shared getLabelFromCaptures in utils.ts
 // DEFINITION_CAPTURE_KEYS and getDefinitionNodeFromCaptures imported from ../utils.js
 // ============================================================================
 // Process a batch of files
@@ -162,9 +108,11 @@ const processBatch = (files, onProgress) => {
         symbols: [],
         imports: [],
         calls: [],
+        assignments: [],
         heritage: [],
         routes: [],
         constructorBindings: [],
+        typeEnvBindings: [],
         skippedLanguages: {},
         fileCount: 0,
     };
@@ -725,13 +673,6 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         }
         result.fileCount++;
         onFileProcessed?.();
-        // Build per-file type environment + constructor bindings in a single AST walk.
-        // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
-        const typeEnv = buildTypeEnv(tree, language);
-        const callRouter = callRouters[language];
-        if (typeEnv.constructorBindings.length > 0) {
-            result.constructorBindings.push({ filePath: file.path, bindings: [...typeEnv.constructorBindings] });
-        }
         let matches;
         try {
             matches = query.matches(tree.rootNode);
@@ -740,6 +681,51 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             console.warn(`Query execution failed for ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
             continue;
         }
+        // Pre-pass: extract heritage from query matches to build parentMap for buildTypeEnv.
+        // Heritage edges (EXTENDS/IMPLEMENTS) are created by heritage-processor which runs
+        // in PARALLEL with call-processor, so the graph edges don't exist when buildTypeEnv
+        // runs. This pre-pass makes parent class information available for type resolution.
+        const fileParentMap = new Map();
+        for (const match of matches) {
+            const captureMap = {};
+            for (const c of match.captures) {
+                captureMap[c.name] = c.node;
+            }
+            if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
+                const className = captureMap['heritage.class'].text;
+                const parentName = captureMap['heritage.extends'].text;
+                // Skip Go named fields (only anonymous fields are struct embedding)
+                const extendsNode = captureMap['heritage.extends'];
+                const fieldDecl = extendsNode.parent;
+                if (fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name'))
+                    continue;
+                let parents = fileParentMap.get(className);
+                if (!parents) {
+                    parents = [];
+                    fileParentMap.set(className, parents);
+                }
+                if (!parents.includes(parentName))
+                    parents.push(parentName);
+            }
+        }
+        // Build per-file type environment + constructor bindings in a single AST walk.
+        // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
+        const parentMap = fileParentMap;
+        const typeEnv = buildTypeEnv(tree, language, { parentMap });
+        const callRouter = callRouters[language];
+        if (typeEnv.constructorBindings.length > 0) {
+            result.constructorBindings.push({ filePath: file.path, bindings: [...typeEnv.constructorBindings] });
+        }
+        // Extract file-scope bindings for ExportedTypeMap (closes worker/sequential quality gap).
+        // Sequential path uses collectExportedBindings(typeEnv) directly; worker path serializes
+        // these bindings so the main thread can merge them into ExportedTypeMap.
+        const fileScope = typeEnv.env.get('');
+        if (fileScope && fileScope.size > 0) {
+            const bindings = [];
+            for (const [name, type] of fileScope)
+                bindings.push([name, type]);
+            result.typeEnvBindings.push({ filePath: file.path, bindings });
+        }
         for (const match of matches) {
             const captureMap = {};
             for (const c of match.captures) {
@@ -747,10 +733,11 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             }
             // Extract import paths before skipping
             if (captureMap['import'] && captureMap['import.source']) {
-                const rawImportPath = language === SupportedLanguages.Kotlin
-                    ? appendKotlinWildcard(captureMap['import.source'].text.replace(/['"<>]/g, ''), captureMap['import'])
-                    : captureMap['import.source'].text.replace(/['"<>]/g, '');
-                const namedBindings = extractNamedBindings(captureMap['import'], language);
+                const rawImportPath = preprocessImportPath(captureMap['import.source'].text, captureMap['import'], language);
+                if (!rawImportPath)
+                    continue;
+                const extractor = namedBindingExtractors[language];
+                const namedBindings = extractor ? extractor(captureMap['import']) : undefined;
                 result.imports.push({
                     filePath: file.path,
                     rawImportPath,
@@ -759,6 +746,28 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 });
                 continue;
             }
+            // Extract assignment sites (field write access)
+            if (captureMap['assignment'] && captureMap['assignment.receiver'] && captureMap['assignment.property']) {
+                const receiverText = captureMap['assignment.receiver'].text;
+                const propertyName = captureMap['assignment.property'].text;
+                if (receiverText && propertyName) {
+                    const srcId = findEnclosingFunctionId(captureMap['assignment'], file.path)
+                        || generateId('File', file.path);
+                    let receiverTypeName;
+                    if (typeEnv) {
+                        receiverTypeName = typeEnv.lookup(receiverText, captureMap['assignment']) ?? undefined;
+                    }
+                    result.assignments.push({
+                        filePath: file.path,
+                        sourceId: srcId,
+                        receiverText,
+                        propertyName,
+                        ...(receiverTypeName ? { receiverTypeName } : {}),
+                    });
+                }
+                if (!captureMap['call'])
+                    continue;
+            }
             // Extract call sites
             if (captureMap['call']) {
                 const callNameNode = captureMap['call.name'];
@@ -811,6 +820,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                     nodeId,
                                     type: 'Property',
                                     ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
+                                    ...(item.declaredType ? { declaredType: item.declaredType } : {}),
                                 });
                                 const fileId = generateId('File', file.path);
                                 const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
@@ -824,10 +834,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                                 });
                                 if (propEnclosingClassId) {
                                     result.relationships.push({
-                                        id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`),
+                                        id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
                                         sourceId: propEnclosingClassId,
                                         targetId: nodeId,
-                                        type: 'HAS_METHOD',
+                                        type: 'HAS_PROPERTY',
                                         confidence: 1.0,
                                         reason: '',
                                     });
@@ -844,26 +854,19 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         const callForm = inferCallForm(callNode, callNameNode);
                         let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
                         let receiverTypeName = receiverName ? typeEnv.lookup(receiverName, callNode) : undefined;
-                        let receiverCallChain;
-                        // When the receiver is a call_expression (e.g. svc.getUser().save()),
-                        // extractReceiverName returns undefined because it refuses complex expressions.
-                        // Instead, walk the receiver node to build a call chain for deferred resolution.
-                        // We capture the base receiver name so processCallsFromExtracted can look it up
-                        // from constructor bindings. receiverTypeName is intentionally left unset here —
-                        // the chain resolver in processCallsFromExtracted needs the base type as input and
-                        // produces the final receiver type as output.
+                        let receiverMixedChain;
+                        // When the receiver is a complex expression (call chain, field chain, or mixed),
+                        // extractReceiverName returns undefined. Walk the receiver node to build a unified
+                        // mixed chain for deferred resolution in processCallsFromExtracted.
                         if (callForm === 'member' && receiverName === undefined && !receiverTypeName) {
                             const receiverNode = extractReceiverNode(callNameNode);
-                            if (receiverNode && CALL_EXPRESSION_TYPES.has(receiverNode.type)) {
-                                const extracted = extractCallChain(receiverNode);
-                                if (extracted) {
-                                    receiverCallChain = extracted.chain;
-                                    // Set receiverName to the base object so Step 1 in processCallsFromExtracted
-                                    // can resolve it via constructor bindings to a base type for the chain.
+                            if (receiverNode) {
+                                const extracted = extractMixedChain(receiverNode);
+                                if (extracted && extracted.chain.length > 0) {
+                                    receiverMixedChain = extracted.chain;
                                     receiverName = extracted.baseReceiverName;
-                                    // Also try the type environment immediately (covers explicitly-typed locals
-                                    // and annotated parameters like `fn process(svc: &UserService)`).
-                                    // This sets a base type that chain resolution (Step 2) will use as input.
+                                    // Try the type environment immediately for the base receiver
+                                    // (covers explicitly-typed locals and annotated parameters).
                                     if (receiverName) {
                                         receiverTypeName = typeEnv.lookup(receiverName, callNode);
                                     }
@@ -878,7 +881,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                             ...(callForm !== undefined ? { callForm } : {}),
                             ...(receiverName !== undefined ? { receiverName } : {}),
                             ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                            ...(receiverCallChain !== undefined ? { receiverCallChain } : {}),
+                            ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}),
                         });
                     }
                 }
@@ -923,7 +926,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     continue;
                 }
             }
-            const nodeLabel = getLabelFromCaptures(captureMap);
+            const nodeLabel = getLabelFromCaptures(captureMap, language);
             if (!nodeLabel)
                 continue;
             const nameNode = captureMap['name'];
@@ -947,10 +950,15 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
                 : null;
             let parameterCount;
+            let requiredParameterCount;
+            let parameterTypes;
             let returnType;
+            let declaredType;
             if (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') {
                 const sig = extractMethodSignature(definitionNode);
                 parameterCount = sig.parameterCount;
+                requiredParameterCount = sig.requiredParameterCount;
+                parameterTypes = sig.parameterTypes;
                 returnType = sig.returnType;
                 // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
                 // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
@@ -963,6 +971,11 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     }
                 }
             }
+            else if (nodeLabel === 'Property' && definitionNode) {
+                // Extract the declared type for property/field nodes.
+                // Walk the definition node for type annotation children.
+                declaredType = extractPropertyDeclaredType(definitionNode);
+            }
             result.nodes.push({
                 id: nodeId,
                 label: nodeLabel,
@@ -979,6 +992,8 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     } : {}),
                     ...(description !== undefined ? { description } : {}),
                     ...(parameterCount !== undefined ? { parameterCount } : {}),
+                    ...(requiredParameterCount !== undefined ? { requiredParameterCount } : {}),
+                    ...(parameterTypes !== undefined ? { parameterTypes } : {}),
                     ...(returnType !== undefined ? { returnType } : {}),
                 },
             });
@@ -992,7 +1007,10 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 nodeId,
                 type: nodeLabel,
                 ...(parameterCount !== undefined ? { parameterCount } : {}),
+                ...(requiredParameterCount !== undefined ? { requiredParameterCount } : {}),
+                ...(parameterTypes !== undefined ? { parameterTypes } : {}),
                 ...(returnType !== undefined ? { returnType } : {}),
+                ...(declaredType !== undefined ? { declaredType } : {}),
                 ...(enclosingClassId ? { ownerId: enclosingClassId } : {}),
             });
             const fileId = generateId('File', file.path);
@@ -1005,13 +1023,14 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 confidence: 1.0,
                 reason: '',
             });
-            // ── HAS_METHOD: link method/constructor/property to enclosing class ──
+            // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ──
             if (enclosingClassId) {
+                const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD';
                 result.relationships.push({
-                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
+                    id: generateId(memberEdgeType, `${enclosingClassId}->${nodeId}`),
                     sourceId: enclosingClassId,
                     targetId: nodeId,
-                    type: 'HAS_METHOD',
+                    type: memberEdgeType,
                     confidence: 1.0,
                     reason: '',
                 });
@@ -1030,7 +1049,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
+    imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], typeEnvBindings: [], skippedLanguages: {}, fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -1039,9 +1058,11 @@ const mergeResult = (target, src) => {
     target.symbols.push(...src.symbols);
     target.imports.push(...src.imports);
     target.calls.push(...src.calls);
+    target.assignments.push(...src.assignments);
     target.heritage.push(...src.heritage);
     target.routes.push(...src.routes);
     target.constructorBindings.push(...src.constructorBindings);
+    target.typeEnvBindings.push(...src.typeEnvBindings);
     for (const [lang, count] of Object.entries(src.skippedLanguages)) {
         target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
     }
@@ -1064,7 +1085,7 @@ parentPort.on('message', (msg) => {
         if (msg && msg.type === 'flush') {
             parentPort.postMessage({ type: 'result', data: accumulated });
             // Reset for potential reuse
-            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], typeEnvBindings: [], skippedLanguages: {}, fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }

package/dist/core/lbug/csv-generator.js

@@ -208,6 +208,8 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
     const codeElemWriter = new BufferedCSVWriter(path.join(csvDir, 'codeelement.csv'), codeElementHeader);
     const communityWriter = new BufferedCSVWriter(path.join(csvDir, 'community.csv'), 'id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount');
     const processWriter = new BufferedCSVWriter(path.join(csvDir, 'process.csv'), 'id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId');
+    // Section nodes have an extra 'level' column
+    const sectionWriter = new BufferedCSVWriter(path.join(csvDir, 'section.csv'), 'id,name,filePath,startLine,endLine,level,content,description');
     // Multi-language node types share the same CSV shape (no isExported column)
     const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description';
     const MULTI_LANG_TYPES = ['Struct', 'Enum', 'Macro', 'Typedef', 'Union', 'Namespace', 'Trait', 'Impl',
@@ -292,6 +294,20 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                 ].join(','));
                 break;
             }
+            case 'Section': {
+                const content = await extractContent(node, contentCache);
+                await sectionWriter.addRow([
+                    escapeCSVField(node.id),
+                    escapeCSVField(node.properties.name || ''),
+                    escapeCSVField(node.properties.filePath || ''),
+                    escapeCSVNumber(node.properties.startLine, -1),
+                    escapeCSVNumber(node.properties.endLine, -1),
+                    escapeCSVNumber(node.properties.level, 1),
+                    escapeCSVField(content),
+                    escapeCSVField(node.properties.description || ''),
+                ].join(','));
+                break;
+            }
             default: {
                 // Code element nodes (Function, Class, Interface, CodeElement)
                 const writer = codeWriterMap[node.label];
@@ -329,7 +345,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
         }
     }
     // Finish all node writers
-    const allWriters = [fileWriter, folderWriter, functionWriter, classWriter, interfaceWriter, methodWriter, codeElemWriter, communityWriter, processWriter, ...multiLangWriters.values()];
+    const allWriters = [fileWriter, folderWriter, functionWriter, classWriter, interfaceWriter, methodWriter, codeElemWriter, communityWriter, processWriter, sectionWriter, ...multiLangWriters.values()];
     await Promise.all(allWriters.map(w => w.finish()));
     // --- Stream relationship CSV ---
     const relCsvPath = path.join(csvDir, 'relations.csv');
@@ -353,6 +369,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
         ['Interface', interfaceWriter], ['Method', methodWriter],
         ['CodeElement', codeElemWriter],
         ['Community', communityWriter], ['Process', processWriter],
+        ['Section', sectionWriter],
         ...Array.from(multiLangWriters.entries()).map(([name, w]) => [name, w]),
     ];
     for (const [name, writer] of tableMap) {

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

@@ -1,5 +1,13 @@
 import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
+/** Expose the current Database for pool adapter reuse in tests. */
+export declare const getDatabase: () => lbug.Database | null;
+/**
+ * Return true when the error message indicates that another process holds
+ * an exclusive lock on the LadybugDB file (e.g. `gitnexus analyze` or
+ * `gitnexus serve` running at the same time).
+ */
+export declare const isDbBusyError: (err: unknown) => boolean;
 export declare const initLbug: (dbPath: string) => Promise<{
     db: lbug.Database;
     conn: lbug.Connection;
@@ -7,6 +15,10 @@ export declare const initLbug: (dbPath: string) => Promise<{
 /**
  * Execute multiple queries against one repo DB atomically.
  * While the callback runs, no other request can switch the active DB.
+ *
+ * Automatically retries up to DB_LOCK_RETRY_ATTEMPTS times when the
+ * database is busy (e.g. `gitnexus analyze` holds the write lock).
+ * Each retry waits DB_LOCK_RETRY_DELAY_MS * attempt milliseconds.
  */
 export declare const withLbugDb: <T>(dbPath: string, operation: () => Promise<T>) => Promise<T>;
 export type LbugProgressCallback = (message: string) => void;