gitnexus 1.6.2-rc.9 → 1.6.2

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/_shared/mro-strategy.d.ts

@@ -1,19 +1,41 @@
 /**
- * MRO (Method Resolution Order) strategy — shared between CLI and any
- * future consumer that reasons about multiple-inheritance semantics.
- *
- * Lives in `gitnexus-shared` so the low-level resolution module
- * (`core/ingestion/model/resolve.ts`) does not need to import from
- * `languages/` — keeping the `model/` layer free of language-registry
- * coupling.
- *
- * Strategy semantics:
- * - `first-wins`:       BFS ancestor walk, first match wins (default).
- * - `leftmost-base`:    BFS ancestor walk, leftmost base wins (C++).
- * - `c3`:               C3-linearized ancestor order, first match wins (Python).
- * - `implements-split`: BFS walk, first match wins (Java/C#/Kotlin) — full
- *                       interface-default ambiguity is handled at graph level.
- * - `qualified-syntax`: No auto-resolution (Rust — requires `<T as Trait>::m`).
+ * MRO (Method Resolution Order) strategy — shared canonical definition.
+ *
+ * Lives in `gitnexus-shared` so `model/resolve.ts` and `mro-processor.ts` share
+ * the type without importing the language registry (avoids circular coupling).
+ *
+ * `first-wins` (default, Java/C#/Kotlin/Go/Swift/Dart):
+ *   BFS ancestor walk in declaration order; first match wins.
+ *
+ * `leftmost-base` (C++):
+ *   BFS walk; HeritageMap preserves source insertion order, so BFS naturally
+ *   picks the leftmost base in diamond inheritance.
+ *
+ * `c3` (Python):
+ *   C3-linearization; falls back to BFS on cyclic/inconsistent hierarchy.
+ *   See model/resolve.ts § c3Linearize.
+ *
+ * `implements-split` (Java/C#/Kotlin):
+ *   Low-level lookup is BFS; graph-level mro-processor detects and warns on
+ *   interface-default method ambiguity.
+ *
+ * `qualified-syntax` (Rust):
+ *   No auto-resolution — `lookupMethodByOwnerWithMRO` returns undefined immediately.
+ *   Rust requires explicit `<Type as Trait>::method` syntax.
+ *
+ * `ruby-mixin` (Ruby):
+ *   Kind-aware walk that does NOT short-circuit on direct owner first (`prepend`
+ *   must beat the class's own method). Walk order:
+ *     1. Prepend providers (reverse declaration — last-prepended wins)
+ *     2. Direct owner's own methods
+ *     3. Include providers (reverse declaration)
+ *     4. Transitive ancestors (BFS fallback)
+ *   Singleton dispatch: caller passes `ancestryOverride` (extend providers only);
+ *   becomes a simple left-to-right scan. Miss NEVER falls through to file-scoped
+ *   lookup — null-routes or honors `fallback`.
+ *
+ * @see model/resolve.ts § lookupMethodByOwnerWithMRO
+ * @see languages/ruby.ts § selectDispatch
  */
-export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax';
+export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax' | 'ruby-mixin';
 //# sourceMappingURL=mro-strategy.d.ts.map

package/dist/_shared/mro-strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mro-strategy.d.ts","sourceRoot":"","sources":["../src/mro-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,IAAI,GACJ,eAAe,GACf,kBAAkB,GAClB,kBAAkB,CAAC"}
+{"version":3,"file":"mro-strategy.d.ts","sourceRoot":"","sources":["../src/mro-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,IAAI,GACJ,eAAe,GACf,kBAAkB,GAClB,kBAAkB,GAClB,YAAY,CAAC"}

package/dist/cli/ai-context.js

@@ -70,19 +70,6 @@ This project is indexed by GitNexus as **${projectName}**${noStats ? '' : ` (${s
 - When exploring unfamiliar code, use \`gitnexus_query({query: "concept"})\` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance.
 - When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use \`gitnexus_context({name: "symbolName"})\`.
 
-## When Debugging
-
-1. \`gitnexus_query({query: "<error or symptom>"})\` — find execution flows related to the issue
-2. \`gitnexus_context({name: "<suspect function>"})\` — see all callers, callees, and process participation
-3. \`READ gitnexus://repo/${projectName}/process/{processName}\` — trace the full execution flow step by step
-4. For regressions: \`gitnexus_detect_changes({scope: "compare", base_ref: "main"})\` — see what your branch changed
-
-## When Refactoring
-
-- **Renaming**: MUST use \`gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})\` first. Review the preview — graph edits are safe, text_search edits need manual review. Then run with \`dry_run: false\`.
-- **Extracting/Splitting**: MUST run \`gitnexus_context({name: "target"})\` to see all incoming/outgoing refs, then \`gitnexus_impact({target: "target", direction: "upstream"})\` to find all external callers before moving code.
-- After any refactor: run \`gitnexus_detect_changes({scope: "all"})\` to verify only expected files changed.
-
 ## Never Do
 
 - NEVER edit a function, class, or method without first running \`gitnexus_impact\` on it.
@@ -90,25 +77,6 @@ This project is indexed by GitNexus as **${projectName}**${noStats ? '' : ` (${s
 - NEVER rename symbols with find-and-replace — use \`gitnexus_rename\` which understands the call graph.
 - NEVER commit changes without running \`gitnexus_detect_changes()\` to check affected scope.
 
-## Tools Quick Reference
-
-| Tool | When to use | Command |
-|------|-------------|---------|
-| \`query\` | Find code by concept | \`gitnexus_query({query: "auth validation"})\` |
-| \`context\` | 360-degree view of one symbol | \`gitnexus_context({name: "validateUser"})\` |
-| \`impact\` | Blast radius before editing | \`gitnexus_impact({target: "X", direction: "upstream"})\` |
-| \`detect_changes\` | Pre-commit scope check | \`gitnexus_detect_changes({scope: "staged"})\` |
-| \`rename\` | Safe multi-file rename | \`gitnexus_rename({symbol_name: "old", new_name: "new", dry_run: true})\` |
-| \`cypher\` | Custom graph queries | \`gitnexus_cypher({query: "MATCH ..."})\` |
-
-## Impact Risk Levels
-
-| Depth | Meaning | Action |
-|-------|---------|--------|
-| d=1 | WILL BREAK — direct callers/importers | MUST update these |
-| d=2 | LIKELY AFFECTED — indirect deps | Should test |
-| d=3 | MAY NEED TESTING — transitive | Test if critical path |
-
 ## Resources
 
 | Resource | Use for |
@@ -118,32 +86,6 @@ This project is indexed by GitNexus as **${projectName}**${noStats ? '' : ` (${s
 | \`gitnexus://repo/${projectName}/processes\` | All execution flows |
 | \`gitnexus://repo/${projectName}/process/{name}\` | Step-by-step execution trace |
 
-## Self-Check Before Finishing
-
-Before completing any code modification task, verify:
-1. \`gitnexus_impact\` was run for all modified symbols
-2. No HIGH/CRITICAL risk warnings were ignored
-3. \`gitnexus_detect_changes()\` confirms changes match expected scope
-4. All d=1 (WILL BREAK) dependents were updated
-
-## Keeping the Index Fresh
-
-After committing code changes, the GitNexus index becomes stale. Re-run analyze to update it:
-
-\`\`\`bash
-npx gitnexus analyze
-\`\`\`
-
-If the index previously included embeddings, preserve them by adding \`--embeddings\`:
-
-\`\`\`bash
-npx gitnexus analyze --embeddings
-\`\`\`
-
-To check whether embeddings exist, inspect \`.gitnexus/meta.json\` — the \`stats.embeddings\` field shows the count (0 means no embeddings). **Running analyze without \`--embeddings\` will delete any previously generated embeddings.**
-
-> Claude Code users: A PostToolUse hook handles this automatically after \`git commit\` and \`git merge\`.
-
 ${groupNames && groupNames.length > 0
         ? `## Cross-Repo Groups
 

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;
+};