gitnexus 1.6.2-rc.2 → 1.6.2-rc.21

package/dist/_shared/lbug/schema-constants.d.ts

@@ -7,7 +7,7 @@
  * Full DDL schemas remain in each package's own schema.ts because
  * the CLI uses native LadybugDB and the web uses WASM.
  */
-export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Section", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool"];
+export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Section", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Variable", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module", "Route", "Tool"];
 export type NodeTableName = (typeof NODE_TABLES)[number];
 export declare const REL_TABLE_NAME = "CodeRelation";
 export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "HAS_METHOD", "HAS_PROPERTY", "ACCESSES", "METHOD_OVERRIDES", "OVERRIDES", "METHOD_IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "HANDLES_ROUTE", "FETCHES", "HANDLES_TOOL", "ENTRY_POINT_OF", "WRAPS", "QUERIES"];

package/dist/_shared/lbug/schema-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,8UA+Bd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,iSAqBZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}
+{"version":3,"file":"schema-constants.d.ts","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,0VAgCd,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C,eAAO,MAAM,SAAS,iSAqBZ,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}

package/dist/_shared/lbug/schema-constants.js

@@ -29,6 +29,7 @@ export const NODE_TABLES = [
     'TypeAlias',
     'Const',
     'Static',
+    'Variable',
     'Property',
     'Record',
     'Delegate',

package/dist/_shared/lbug/schema-constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;CACE,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;CACD,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}
+{"version":3,"file":"schema-constants.js","sourceRoot":"","sources":["../../src/lbug/schema-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,WAAW;IACX,QAAQ;IACR,aAAa;IACb,WAAW;IACX,SAAS;IACT,SAAS;IACT,QAAQ;IACR,MAAM;IACN,OAAO;IACP,SAAS;IACT,OAAO;IACP,WAAW;IACX,OAAO;IACP,MAAM;IACN,WAAW;IACX,OAAO;IACP,QAAQ;IACR,UAAU;IACV,UAAU;IACV,QAAQ;IACR,UAAU;IACV,YAAY;IACZ,aAAa;IACb,UAAU;IACV,QAAQ;IACR,OAAO;IACP,MAAM;CACE,CAAC;AAIX,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,UAAU;IACV,SAAS;IACT,SAAS;IACT,OAAO;IACP,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,cAAc;IACd,UAAU;IACV,kBAAkB;IAClB,WAAW,EAAE,mEAAmE;IAChF,mBAAmB;IACnB,WAAW;IACX,iBAAiB;IACjB,eAAe;IACf,SAAS;IACT,cAAc;IACd,gBAAgB;IAChB,OAAO;IACP,SAAS;CACD,CAAC;AAIX,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}

package/dist/cli/analyze.js

@@ -114,9 +114,11 @@ export const analyzeCommand = async (inputPath, options) => {
     const origLog = console.log.bind(console);
     const origWarn = console.warn.bind(console);
     const origError = console.error.bind(console);
+    let barCurrentValue = 0;
     const barLog = (...args) => {
         process.stdout.write('\x1b[2K\r');
         origLog(args.map((a) => (typeof a === 'string' ? a : String(a))).join(' '));
+        bar.update(barCurrentValue);
     };
     console.log = barLog;
     console.warn = barLog;
@@ -125,6 +127,7 @@ export const analyzeCommand = async (inputPath, options) => {
     let lastPhaseLabel = 'Initializing...';
     let phaseStart = Date.now();
     const updateBar = (value, phaseLabel) => {
+        barCurrentValue = value;
         if (phaseLabel !== lastPhaseLabel) {
             lastPhaseLabel = phaseLabel;
             phaseStart = Date.now();

package/dist/core/embeddings/ast-utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared AST utilities for the embedding pipeline.
+ * Centralizes parser caching and tree-sitter node lookups
+ * used by both chunker.ts and structural-extractor.ts.
+ */
+/**
+ * Ensure parser is initialized and language is loaded, then parse content.
+ * Returns null if language is unavailable or parsing fails.
+ */
+export declare const ensureAndParse: (content: string, filePath: string) => Promise<any | null>;
+/**
+ * Find the first function/method-like declaration in a snippet AST.
+ * Used by the chunker when parsing node.content where absolute line
+ * numbers don't apply.
+ */
+export declare const findFunctionNode: (root: any) => any | null;
+/**
+ * Find the first class/struct/interface/enum-like declaration in an AST.
+ * Used when parsing node.content (a snippet, not a full file) where
+ * absolute line numbers don't apply.
+ */
+export declare const findDeclarationNode: (root: any) => any | null;

package/dist/core/embeddings/ast-utils.js

@@ -0,0 +1,105 @@
+/**
+ * Shared AST utilities for the embedding pipeline.
+ * Centralizes parser caching and tree-sitter node lookups
+ * used by both chunker.ts and structural-extractor.ts.
+ */
+import { getLanguageFromFilename } from '../../_shared/index.js';
+import { createParserForLanguage, isLanguageAvailable, resolveLanguageKey, } from '../tree-sitter/parser-loader.js';
+const parserCache = new Map();
+/**
+ * Ensure parser is initialized and language is loaded, then parse content.
+ * Returns null if language is unavailable or parsing fails.
+ */
+export const ensureAndParse = async (content, filePath) => {
+    const language = getLanguageFromFilename(filePath);
+    if (!language)
+        return null;
+    if (!isLanguageAvailable(language))
+        return null;
+    const parserKey = resolveLanguageKey(language, filePath);
+    let parserInstance = parserCache.get(parserKey);
+    if (!parserInstance) {
+        parserInstance = await createParserForLanguage(language, filePath);
+        parserCache.set(parserKey, parserInstance);
+    }
+    return parserInstance.parse(content);
+};
+const FUNCTION_LIKE_TYPES = new Set([
+    'function_declaration',
+    'function_definition',
+    'method_declaration',
+    'method_definition',
+    'function_item',
+    'function_signature_item',
+    'arrow_function',
+    'function_expression',
+    'generator_function_declaration',
+    'generator_function',
+    'async_function_declaration',
+    'async_arrow_function',
+    'constructor_declaration',
+    'constructor_definition',
+    'compact_constructor_declaration',
+    'short_function_declaration',
+    'proc_declaration',
+    'func_literal',
+    'local_function_statement',
+    'anonymous_function',
+    'lambda_literal',
+    'init_declaration',
+    'deinit_declaration',
+]);
+/**
+ * Find the first function/method-like declaration in a snippet AST.
+ * Used by the chunker when parsing node.content where absolute line
+ * numbers don't apply.
+ */
+export const findFunctionNode = (root) => {
+    if (FUNCTION_LIKE_TYPES.has(root.type))
+        return root;
+    for (let i = 0; i < root.namedChildCount; i++) {
+        const child = root.namedChild(i);
+        if (!child)
+            continue;
+        if (FUNCTION_LIKE_TYPES.has(child.type))
+            return child;
+        const found = findFunctionNode(child);
+        if (found)
+            return found;
+    }
+    return null;
+};
+/**
+ * Find the first class/struct/interface/enum-like declaration in an AST.
+ * Used when parsing node.content (a snippet, not a full file) where
+ * absolute line numbers don't apply.
+ */
+export const findDeclarationNode = (root) => {
+    const CLASS_LIKE_TYPES = new Set([
+        'class_declaration',
+        'class_definition',
+        'struct_declaration',
+        'struct_item',
+        'interface_declaration',
+        'interface_definition',
+        'enum_declaration',
+        'enum_item',
+        'type_declaration', // Go: type X struct
+        'declaration', // Go: type X struct
+        'object_declaration', // Kotlin: object
+        'impl_item', // Rust: impl
+    ]);
+    if (CLASS_LIKE_TYPES.has(root.type))
+        return root;
+    for (let i = 0; i < root.namedChildCount; i++) {
+        const child = root.namedChild(i);
+        if (!child)
+            continue;
+        if (CLASS_LIKE_TYPES.has(child.type))
+            return child;
+        const found = findDeclarationNode(child);
+        if (found)
+            return found;
+    }
+    return null;
+};

package/dist/core/embeddings/character-chunk.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Character-based sliding window chunking (pure, no tree-sitter dependency)
+ */
+export interface Chunk {
+    text: string;
+    chunkIndex: number;
+    startOffset: number;
+    endOffset: number;
+    startLine: number;
+    endLine: number;
+}
+export declare const characterChunk: (content: string, startLine: number, endLine: number, chunkSize?: number, overlap?: number) => Chunk[];

package/dist/core/embeddings/character-chunk.js

@@ -0,0 +1,43 @@
+/**
+ * Character-based sliding window chunking (pure, no tree-sitter dependency)
+ */
+import { buildLineIndex, resolveChunkLines } from './line-index.js';
+export const characterChunk = (content, startLine, endLine, chunkSize = 1200, overlap = 120) => {
+    if (content.length <= chunkSize) {
+        return [
+            {
+                text: content,
+                chunkIndex: 0,
+                startOffset: 0,
+                endOffset: content.length,
+                startLine,
+                endLine,
+            },
+        ];
+    }
+    const chunks = [];
+    let offset = 0;
+    const lineOffsets = buildLineIndex(content);
+    while (offset < content.length) {
+        const end = Math.min(offset + chunkSize, content.length);
+        const chunkText = content.slice(offset, end);
+        const lineRange = resolveChunkLines(lineOffsets, offset, end, startLine);
+        chunks.push({
+            text: chunkText,
+            chunkIndex: chunks.length,
+            startOffset: offset,
+            endOffset: end,
+            startLine: lineRange.startLine,
+            endLine: lineRange.endLine,
+        });
+        offset = end - overlap;
+        if (offset >= content.length)
+            break;
+        if (end >= content.length)
+            break;
+        if (offset <= (chunks.length > 1 ? end - chunkSize : 0)) {
+            offset = end;
+        }
+    }
+    return chunks;
+};

package/dist/core/embeddings/chunker.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Chunker Module
+ *
+ * Splits code nodes into chunks for embedding.
+ * - Function/Method: AST-aware chunking by statement boundaries
+ * - Other types: character-based sliding window fallback
+ * - Short content (≤ chunkSize): no chunking
+ */
+export { type Chunk, characterChunk } from './character-chunk.js';
+import type { Chunk } from './character-chunk.js';
+/**
+ * Main chunkNode function: dispatches by label
+ */
+export declare const chunkNode: (label: string, content: string, filePath: string, startLine: number, endLine: number, chunkSize?: number, overlap?: number) => Promise<Chunk[]>;

package/dist/core/embeddings/chunker.js

@@ -0,0 +1,234 @@
+/**
+ * Chunker Module
+ *
+ * Splits code nodes into chunks for embedding.
+ * - Function/Method: AST-aware chunking by statement boundaries
+ * - Other types: character-based sliding window fallback
+ * - Short content (≤ chunkSize): no chunking
+ */
+export { characterChunk } from './character-chunk.js';
+import { characterChunk } from './character-chunk.js';
+import { ensureAndParse, findDeclarationNode, findFunctionNode } from './ast-utils.js';
+import { buildLineIndex, resolveChunkLines } from './line-index.js';
+/**
+ * Main chunkNode function: dispatches by label
+ */
+export const chunkNode = async (label, content, filePath, startLine, endLine, chunkSize = 1200, overlap = 120) => {
+    // Content fits in one chunk — no splitting needed
+    if (content.length <= chunkSize) {
+        return [
+            {
+                text: content,
+                chunkIndex: 0,
+                startOffset: 0,
+                endOffset: content.length,
+                startLine,
+                endLine,
+            },
+        ];
+    }
+    // Only function-like labels get AST chunking
+    if (label === 'Function' || label === 'Method' || label === 'Constructor') {
+        try {
+            const astChunks = await astChunk(content, filePath, startLine, endLine, chunkSize, overlap);
+            if (astChunks.length > 0)
+                return astChunks;
+        }
+        catch {
+            // AST parsing failed — fall through to character fallback
+        }
+    }
+    if (label === 'Class' || label === 'Interface') {
+        try {
+            const declarationChunks = await declarationChunk(label, content, filePath, startLine, endLine, chunkSize, overlap);
+            if (declarationChunks.length > 0)
+                return declarationChunks;
+        }
+        catch {
+            // AST parsing failed — fall through to character fallback
+        }
+    }
+    // Character-based fallback for everything else
+    return characterChunk(content, startLine, endLine, chunkSize, overlap);
+};
+/**
+ * AST-based chunking for Function/Method
+ * Parse snippet content, locate the function declaration node,
+ * split body by statement boundaries.
+ */
+const astChunk = async (content, filePath, startLine, endLine, chunkSize, overlap) => {
+    const tree = await ensureAndParse(content, filePath);
+    if (!tree)
+        return [];
+    const root = tree.rootNode;
+    const lineOffsets = buildLineIndex(content);
+    // Find the function/method declaration in the snippet AST.
+    // tree-sitter parses node.content (a snippet), so rows are relative (0-based).
+    const targetNode = findFunctionNode(root);
+    if (!targetNode)
+        return [];
+    // Get the body (statements) via childForFieldName('body')
+    const bodyNode = targetNode.childForFieldName('body');
+    if (!bodyNode)
+        return [];
+    // Extract individual statements
+    const statements = [];
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+        const child = bodyNode.namedChild(i);
+        if (!child)
+            continue;
+        statements.push({
+            startIndex: child.startIndex,
+            endIndex: child.endIndex,
+        });
+    }
+    if (statements.length === 0)
+        return [];
+    return chunkByUnits(content, lineOffsets, startLine, chunkSize, overlap, statements, targetNode.startIndex, targetNode.endIndex, true, true);
+};
+const DECLARATION_BODY_NODE_TYPES = new Set([
+    'class_body',
+    'object_type',
+    'declaration_list',
+    'interface_body',
+]);
+const FIELD_LIKE_MEMBER_TYPES = new Set([
+    'field_definition',
+    'public_field_definition',
+    'property_definition',
+    'property_signature',
+    'variable_declarator',
+    'lexical_declaration',
+    'pair',
+    'enum_assignment',
+]);
+const declarationChunk = async (label, content, filePath, startLine, endLine, chunkSize, overlap) => {
+    const tree = await ensureAndParse(content, filePath);
+    if (!tree)
+        return [];
+    const targetNode = findDeclarationNode(tree.rootNode);
+    if (!targetNode)
+        return [];
+    const bodyNode = getDeclarationBodyNode(targetNode);
+    if (!bodyNode)
+        return [];
+    const members = collectDeclarationUnits(bodyNode, label);
+    if (members.length === 0)
+        return [];
+    return chunkByUnits(content, buildLineIndex(content), startLine, chunkSize, overlap, members, targetNode.startIndex, targetNode.endIndex, false, false);
+};
+const buildChunk = (content, lineOffsets, chunkIndex, startOffset, endOffset, baseStartLine) => {
+    const lineRange = resolveChunkLines(lineOffsets, startOffset, endOffset, baseStartLine);
+    return {
+        text: content.slice(startOffset, endOffset),
+        chunkIndex,
+        startOffset,
+        endOffset,
+        startLine: lineRange.startLine,
+        endLine: lineRange.endLine,
+    };
+};
+const chunkByUnits = (content, lineOffsets, baseStartLine, chunkSize, overlap, units, containerStartOffset, containerEndOffset, includeContainerPrefixOnFirstChunk, includeContainerSuffixOnLastChunk) => {
+    const chunks = [];
+    let chunkStartUnitIdx = 0;
+    while (chunkStartUnitIdx < units.length) {
+        const chunkStartOffset = chunkStartUnitIdx === 0 && includeContainerPrefixOnFirstChunk
+            ? containerStartOffset
+            : units[chunkStartUnitIdx].startIndex;
+        let chunkEndUnitIdx = chunkStartUnitIdx;
+        let candidateEndOffset = chunkEndUnitIdx === units.length - 1 && includeContainerSuffixOnLastChunk
+            ? containerEndOffset
+            : units[chunkEndUnitIdx].endIndex;
+        while (chunkEndUnitIdx + 1 < units.length) {
+            const nextEndOffset = chunkEndUnitIdx + 1 === units.length - 1 && includeContainerSuffixOnLastChunk
+                ? containerEndOffset
+                : units[chunkEndUnitIdx + 1].endIndex;
+            if (nextEndOffset - chunkStartOffset > chunkSize)
+                break;
+            chunkEndUnitIdx += 1;
+            candidateEndOffset = nextEndOffset;
+        }
+        if (candidateEndOffset - chunkStartOffset > chunkSize) {
+            const oversizedUnit = units[chunkStartUnitIdx];
+            const oversizedLineRange = resolveChunkLines(lineOffsets, oversizedUnit.startIndex, oversizedUnit.endIndex, baseStartLine);
+            const oversizedChunks = characterChunk(content.slice(oversizedUnit.startIndex, oversizedUnit.endIndex), oversizedLineRange.startLine, oversizedLineRange.endLine, chunkSize, overlap).map((chunk, offsetIdx) => ({
+                ...chunk,
+                chunkIndex: chunks.length + offsetIdx,
+                startOffset: chunk.startOffset + oversizedUnit.startIndex,
+                endOffset: chunk.endOffset + oversizedUnit.startIndex,
+            }));
+            chunks.push(...oversizedChunks);
+            chunkStartUnitIdx += 1;
+            continue;
+        }
+        chunks.push(buildChunk(content, lineOffsets, chunks.length, chunkStartOffset, candidateEndOffset, baseStartLine));
+        if (chunkEndUnitIdx === units.length - 1) {
+            break;
+        }
+        const nextChunkStartUnitIdx = findOverlapStartIndex(units, chunkStartUnitIdx, chunkEndUnitIdx, overlap);
+        if (nextChunkStartUnitIdx <= chunkStartUnitIdx) {
+            chunkStartUnitIdx = chunkEndUnitIdx + 1;
+        }
+        else {
+            chunkStartUnitIdx = nextChunkStartUnitIdx;
+        }
+    }
+    return chunks;
+};
+const findOverlapStartIndex = (statements, chunkStartStmtIdx, chunkEndStmtIdx, overlapSize) => {
+    if (overlapSize <= 0)
+        return chunkEndStmtIdx + 1;
+    let overlapStartIdx = chunkEndStmtIdx;
+    while (overlapStartIdx > chunkStartStmtIdx) {
+        const overlapLength = statements[chunkEndStmtIdx].endIndex - statements[overlapStartIdx - 1].startIndex;
+        if (overlapLength > overlapSize)
+            break;
+        overlapStartIdx -= 1;
+    }
+    return overlapStartIdx;
+};
+const getDeclarationBodyNode = (node) => {
+    const bodyNode = node.childForFieldName?.('body');
+    if (bodyNode)
+        return bodyNode;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (DECLARATION_BODY_NODE_TYPES.has(child.type))
+            return child;
+    }
+    return null;
+};
+const collectDeclarationUnits = (bodyNode, label) => {
+    const members = [];
+    for (let i = 0; i < bodyNode.namedChildCount; i++) {
+        const child = bodyNode.namedChild(i);
+        if (!child)
+            continue;
+        members.push({
+            startIndex: child.startIndex,
+            endIndex: child.endIndex,
+            groupable: label === 'Class' && FIELD_LIKE_MEMBER_TYPES.has(child.type),
+        });
+    }
+    if (members.length === 0)
+        return [];
+    const grouped = [];
+    let current = members[0];
+    for (let i = 1; i < members.length; i++) {
+        const next = members[i];
+        if (current.groupable && next.groupable) {
+            current = {
+                startIndex: current.startIndex,
+                endIndex: next.endIndex,
+                groupable: true,
+            };
+            continue;
+        }
+        grouped.push({ startIndex: current.startIndex, endIndex: current.endIndex });
+        current = next;
+    }
+    grouped.push({ startIndex: current.startIndex, endIndex: current.endIndex });
+    return grouped;
+};

package/dist/core/embeddings/embedder.js

@@ -131,6 +131,11 @@ export const initEmbedder = async (onProgress, config = {}, forceDevice) => {
         try {
             // Configure transformers.js environment
             env.allowLocalModels = false;
+            // Default cache to user-writable location. transformers.js defaults to
+            // ./node_modules/.cache inside its own install dir, which is unwritable
+            // when gitnexus is installed globally (e.g. /usr/lib/node_modules/).
+            // Respect HF_HOME if set, otherwise fall back to ~/.cache/huggingface.
+            env.cacheDir = process.env.HF_HOME ?? `${process.env.HOME}/.cache/huggingface`;
             const isDev = process.env.NODE_ENV === 'development';
             if (isDev) {
                 console.log(`🧠 Loading embedding model: ${finalConfig.modelId}`);

package/dist/core/embeddings/embedding-pipeline.d.ts

@@ -3,16 +3,34 @@
  *
  * Orchestrates the background embedding process:
  * 1. Query embeddable nodes from LadybugDB
- * 2. Generate text representations
- * 3. Batch embed using transformers.js
- * 4. Update LadybugDB with embeddings
+ * 2. Generate text representations with enriched metadata
+ * 3. Chunk long nodes, batch embed
+ * 4. Update LadybugDB with chunk-aware embeddings
  * 5. Create vector index for semantic search
  */
-import { type EmbeddingProgress, type EmbeddingConfig, type SemanticSearchResult } from './types.js';
+import { type EmbeddingProgress, type EmbeddingConfig, type EmbeddableNode, type SemanticSearchResult, type EmbeddingContext } from './types.js';
+/**
+ * Compute a stable content fingerprint for an embeddable node.
+ * Used to detect when the underlying text has changed so stale vectors
+ * can be replaced (DELETE-then-INSERT, the Kuzu-sanctioned pattern for
+ * vector-indexed rows).
+ */
+export declare const contentHashForNode: (node: EmbeddableNode, config?: Partial<EmbeddingConfig>) => string;
 /**
  * Progress callback type
  */
 export type EmbeddingProgressCallback = (progress: EmbeddingProgress) => void;
+/**
+ * Batch INSERT chunk-aware embeddings into CodeEmbedding table
+ */
+export declare const batchInsertEmbeddings: (executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>, updates: Array<{
+    nodeId: string;
+    chunkIndex: number;
+    startLine: number;
+    endLine: number;
+    embedding: number[];
+    contentHash?: string;
+}>) => Promise<void>;
 /**
  * Run the embedding pipeline
  *
@@ -21,31 +39,18 @@ export type EmbeddingProgressCallback = (progress: EmbeddingProgress) => void;
  * @param onProgress - Callback for progress updates
  * @param config - Optional configuration override
  * @param skipNodeIds - Optional set of node IDs that already have embeddings (incremental mode)
+ * @param context - Optional repo/server context for metadata enrichment
+ * @param existingEmbeddings - Optional map of nodeId → contentHash for incremental mode.
+ *        Nodes whose hash matches are skipped; nodes with a changed hash are DELETE'd
+ *        and re-embedded; nodes not in the map are embedded fresh.
+
  */
-export declare const runEmbeddingPipeline: (executeQuery: (cypher: string) => Promise<any[]>, executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>, onProgress: EmbeddingProgressCallback, config?: Partial<EmbeddingConfig>, skipNodeIds?: Set<string>) => Promise<void>;
+export declare const runEmbeddingPipeline: (executeQuery: (cypher: string) => Promise<any[]>, executeWithReusedStatement: (cypher: string, paramsList: Array<Record<string, any>>) => Promise<void>, onProgress: EmbeddingProgressCallback, config?: Partial<EmbeddingConfig>, skipNodeIds?: Set<string>, context?: EmbeddingContext, existingEmbeddings?: Map<string, string>) => Promise<void>;
 /**
- * Perform semantic search using the vector index
- *
- * Uses CodeEmbedding table and queries each node table to get metadata
- *
- * @param executeQuery - Function to execute Cypher queries
- * @param query - Search query text
- * @param k - Number of results to return (default: 10)
- * @param maxDistance - Maximum distance threshold (default: 0.5)
- * @returns Array of search results ordered by relevance
+ * Perform semantic search using the vector index with chunk deduplication
  */
 export declare const semanticSearch: (executeQuery: (cypher: string) => Promise<any[]>, query: string, k?: number, maxDistance?: number) => Promise<SemanticSearchResult[]>;
 /**
  * Semantic search with graph expansion (flattened results)
- *
- * Note: With multi-table schema, graph traversal is simplified.
- * Returns semantic matches with their metadata.
- * For full graph traversal, use execute_vector_cypher tool directly.
- *
- * @param executeQuery - Function to execute Cypher queries
- * @param query - Search query text
- * @param k - Number of initial semantic matches (default: 5)
- * @param _hops - Unused (kept for API compatibility).
- * @returns Semantic matches with metadata
  */
 export declare const semanticSearchWithContext: (executeQuery: (cypher: string) => Promise<any[]>, query: string, k?: number, _hops?: number) => Promise<any[]>;