@vpxa/kb 0.1.15 → 0.1.16

package/packages/chunker/dist/chunker-factory.d.ts

@@ -3,9 +3,17 @@ import { IChunker } from "./chunker.interface.js";
 //#region packages/chunker/src/chunker-factory.d.ts
 /**
  * Create the appropriate chunker for a file extension.
- * Prefers tree-sitter AST-based chunking when available; falls back to regex-based.
+ *
+ * Uses WASM tree-sitter AST-based chunking when available.
+ * Falls back to regex-based CodeChunker.
+ *
+ * **Breaking change**: Now returns `Promise<IChunker>` because WASM init is async.
  */
-declare function createChunker(fileExtension: string): IChunker;
+declare function createChunker(fileExtension: string): Promise<IChunker>;
+/**
+ * Create a chunker synchronously (legacy API).
+ * Uses whatever runtime is already initialized.
+ */
+declare function createChunkerSync(fileExtension: string): IChunker;
 //#endregion
-export { createChunker };
-//# sourceMappingURL=chunker-factory.d.ts.map
+export { createChunker, createChunkerSync };

package/packages/chunker/dist/chunker-factory.js

@@ -1,2 +1 @@
-import{CodeChunker as e}from"./code-chunker.js";import{TreeSitterChunker as t,TreeSitterRuntime as n}from"./treesitter-chunker.js";import{GenericChunker as r}from"./generic-chunker.js";import{MarkdownChunker as i}from"./markdown-chunker.js";function a(a){let o=a.toLowerCase();switch(o){case`.md`:case`.mdx`:return new i;case`.ts`:case`.tsx`:case`.mts`:case`.cts`:case`.js`:case`.jsx`:case`.mjs`:case`.cjs`:case`.py`:case`.go`:case`.rs`:case`.java`:{let r=n.get();return r?.hasLanguage(o)?new t(r):new e}default:return new r}}export{a as createChunker};
-//# sourceMappingURL=chunker-factory.js.map
+import{SUPPORTED_EXTENSIONS as e}from"./wasm/languages.js";import{WasmRuntime as t}from"./wasm/runtime.js";import{CodeChunker as n}from"./code-chunker.js";import{GenericChunker as r}from"./generic-chunker.js";import{MarkdownChunker as i}from"./markdown-chunker.js";import{WasmChunker as a}from"./wasm-chunker.js";async function o(o){let s=o.toLowerCase();switch(s){case`.md`:case`.mdx`:return new i;case`.ts`:case`.tsx`:case`.mts`:case`.cts`:case`.js`:case`.jsx`:case`.mjs`:case`.cjs`:case`.py`:case`.go`:case`.rs`:case`.java`:if(e.has(s)){let e=await t.initialize();if(e)return await e.loadLanguage(s),new a}return new n;default:return new r}}function s(e){let o=e.toLowerCase();switch(o){case`.md`:case`.mdx`:return new i;case`.ts`:case`.tsx`:case`.mts`:case`.cts`:case`.js`:case`.jsx`:case`.mjs`:case`.cjs`:case`.py`:case`.go`:case`.rs`:case`.java`:return t.get()?.isLanguageLoaded(o)?new a:new n;default:return new r}}export{o as createChunker,s as createChunkerSync};

package/packages/chunker/dist/chunker.interface.d.ts

@@ -10,5 +10,4 @@ interface IChunker {
   chunk(content: string, metadata: ChunkMetadata): RawChunk[];
 }
 //#endregion
-export { IChunker };
-//# sourceMappingURL=chunker.interface.d.ts.map
+export { IChunker };

package/packages/chunker/dist/code-chunker.d.ts

@@ -14,5 +14,4 @@ declare class CodeChunker implements IChunker {
   private getLineNumber;
 }
 //#endregion
-export { CodeChunker };
-//# sourceMappingURL=code-chunker.d.ts.map
+export { CodeChunker };

package/packages/chunker/dist/code-chunker.js

@@ -8,5 +8,4 @@ import{CHUNK_SIZES as e}from"../../core/dist/index.js";var t=class{maxChunkSize;
 `),r=[],i=[],a=0;for(let e of n)a+e.length+1>t&&i.length>0?(r.push(i.join(`
 `)),i=[e],a=e.length):(i.push(e),a+=e.length+1);return i.length>0&&r.push(i.join(`
 `)),r}getLineNumber(e,t){return e.slice(0,t).split(`
-`).length}};export{t as CodeChunker};
-//# sourceMappingURL=code-chunker.js.map
+`).length}};export{t as CodeChunker};

package/packages/chunker/dist/extractors/call-extractor.d.ts

@@ -0,0 +1,24 @@
+//#region packages/chunker/src/extractors/call-extractor.d.ts
+/**
+ * AST-based call extractor.
+ *
+ * Replaces regex-based call graph analysis with tree-sitter AST queries.
+ * Returns `CallEdge[]` compatible with the existing call-graph-extractor.
+ */
+interface CallEdge {
+  callerFile: string;
+  callerName: string;
+  calleeName: string;
+  line: number;
+}
+/**
+ * Extract call edges from source code using AST queries.
+ *
+ * @param content - The source code to analyze.
+ * @param ext - The file extension (e.g., `.ts`, `.py`).
+ * @param filePath - The file path for the returned CallEdge records.
+ * @returns Array of extracted call edges, or empty array if language unsupported.
+ */
+declare function extractCalls(content: string, ext: string, filePath?: string): Promise<CallEdge[]>;
+//#endregion
+export { CallEdge, extractCalls };

package/packages/chunker/dist/extractors/call-extractor.js

@@ -0,0 +1 @@
+import{WasmRuntime as e}from"../wasm/runtime.js";import{QueryExecutor as t}from"../wasm/query-executor.js";const n=new t,r=new Set([`function_declaration`,`method_definition`,`arrow_function`,`function_definition`,`method_declaration`,`constructor_declaration`,`function_declaration`,`method_declaration`,`function_item`]);async function i(t,r,i=``){let o=await e.ensure(),s=await o.parse(t,r);if(!s)return[];let c=o.getLanguage(r);return c?n.execute(s.rootNode,c,r,`calls`).map(e=>a(e,s.rootNode,i)).filter(e=>e!==null):[]}function a(e,t,n){let r=e.captures.get(`callee`);if(!r)return null;let i=e.captures.get(`node`);return{callerFile:n,callerName:o(i?.node??r.node),calleeName:r.text,line:(i?.startLine??r.startLine)+1}}function o(e){let t=e.parent;for(;t;){if(r.has(t.type)){let e=s(t);if(e)return e}t=t.parent}return`<module>`}function s(e){let t=e.childForFieldName(`name`);if(t)return t.text;for(let t of e.children)if(t.type===`identifier`||t.type===`property_identifier`||t.type===`field_identifier`)return t.text;return null}export{i as extractCalls};

package/packages/chunker/dist/extractors/entry-point-detector.d.ts

@@ -0,0 +1,14 @@
+import { EntryPoint } from "./types.js";
+
+//#region packages/chunker/src/extractors/entry-point-detector.d.ts
+/**
+ * Detect entry points from source code using AST queries.
+ *
+ * @param content - The source code to analyze.
+ * @param ext - The file extension (e.g., `.ts`, `.py`).
+ * @param filePath - The file path for the returned EntryPoint records.
+ * @returns Array of detected entry points, or empty array if language unsupported.
+ */
+declare function detectEntryPoints(content: string, ext: string, filePath?: string): Promise<EntryPoint[]>;
+//#endregion
+export { detectEntryPoints };

package/packages/chunker/dist/extractors/entry-point-detector.js

@@ -0,0 +1 @@
+import{WasmRuntime as e}from"../wasm/runtime.js";import{QueryExecutor as t}from"../wasm/query-executor.js";const n=new t,r={handler:`lambda-handler`,lambdaHandler:`lambda-handler`,main:`main`,__name__:`main`,app:`server`,server:`server`,router:`server`,urlpatterns:`server`,init:`main`},i={SpringBootApplication:`server`,RestController:`server`,Controller:`server`};async function a(t,r,i=``){let a=await e.ensure(),s=await a.parse(t,r);if(!s)return[];let c=a.getLanguage(r);if(!c)return[];let l=n.execute(s.rootNode,c,r,`entry-points`),u=[],d=new Set;for(let e of l){let t=o(e,r,i);if(t){let e=`${t.name}:${t.type}`;d.has(e)||(d.add(e),u.push(t))}}return u}function o(e,t,n){let a=e.captures.get(`name`);if(!a)return null;let o=a.text,s=e.captures.get(`_parent`);if(s){let e=s.text;if([`Construct`,`Stack`,`NestedStack`,`Stage`].includes(e))return{name:o,type:`cdk-construct`,filePath:n}}let c=e.captures.get(`_ann`);if(c){let e=i[c.text];if(e)return{name:o,type:e,filePath:n}}let l=r[o];return l?{name:o,type:l,filePath:n}:t===`.go`&&o.toLowerCase().startsWith(`handle`)?{name:o,type:`server`,filePath:n,trigger:`HTTP handler`}:{name:o,type:`main`,filePath:n}}export{a as detectEntryPoints};

package/packages/chunker/dist/extractors/import-extractor.d.ts

@@ -0,0 +1,14 @@
+import { ImportInfo } from "./types.js";
+
+//#region packages/chunker/src/extractors/import-extractor.d.ts
+/**
+ * Extract imports from source code using AST queries.
+ *
+ * @param content - The source code to analyze.
+ * @param ext - The file extension (e.g., `.ts`, `.py`).
+ * @param filePath - The file path for the returned ImportInfo records.
+ * @returns Array of extracted imports, or empty array if language unsupported.
+ */
+declare function extractImports(content: string, ext: string, filePath?: string): Promise<ImportInfo[]>;
+//#endregion
+export { extractImports };

package/packages/chunker/dist/extractors/import-extractor.js

@@ -0,0 +1 @@
+import{WasmRuntime as e}from"../wasm/runtime.js";import{QueryExecutor as t}from"../wasm/query-executor.js";const n=new t;async function r(t,r,c=``){let l=await e.ensure(),u=await l.parse(t,r);if(!u)return[];let d=l.getLanguage(r);if(!d)return[];let f=n.execute(u.rootNode,d,r,`imports`),p=[];for(let e of f){let t=e.captures.get(`source`);if(!t){let t=e.captures.get(`node`);if(t){let e=s(t.text,r);e&&p.push({source:e.source,specifiers:e.specifiers,filePath:c,isExternal:a(e.source,r),confidence:`high`})}continue}let n=t.text,l=i(n,r),u=o(e.captures.get(`node`)?.text??``,r,l);p.push({source:l,specifiers:u,filePath:c,isExternal:a(l,r),confidence:`high`})}return p}function i(e,t){let n=e.replace(/^['"`]|['"`]$/g,``);return t===`.go`&&(n=n.replace(/^"|"$/g,``)),n}function a(e,t){return t===`.py`?!e.startsWith(`.`):t===`.go`?e.includes(`/`)||e.includes(`.`):t===`.java`?!0:t===`.rs`?!e.startsWith(`self`)&&!e.startsWith(`super`)&&!e.startsWith(`crate`):!e.startsWith(`.`)&&!e.startsWith(`/`)}function o(e,t,n){if(!e)return[n];if(t===`.py`){let t=e.match(/import\s+(.+)$/m);return t?t[1].split(`,`).map(e=>e.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean):[n]}if(t===`.java`){let e=n.split(`.`);return[e[e.length-1]]}if(t===`.go`){let e=n.split(`/`);return[e[e.length-1]]}if(t===`.rs`){if(n.includes(`{`)){let e=n.match(/\{([^}]+)\}/);if(e)return e[1].split(`,`).map(e=>e.trim()).filter(Boolean)}let e=n.split(`::`);return[e[e.length-1]]}let r=e.match(/\{([^}]+)\}/);if(r)return r[1].split(`,`).map(e=>e.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);let i=e.match(/import\s+(\w+)/);return i?[i[1]]:[n]}function s(e,t){if(t===`.py`){let t=e.match(/^import\s+([\w.]+)/);if(t)return{source:t[1],specifiers:[t[1]]}}return null}export{r as extractImports};

package/packages/chunker/dist/extractors/pattern-detector.d.ts

@@ -0,0 +1,14 @@
+import { PatternMatch } from "./types.js";
+
+//#region packages/chunker/src/extractors/pattern-detector.d.ts
+/**
+ * Detect design patterns from source code using AST queries.
+ *
+ * @param content - The source code to analyze.
+ * @param ext - The file extension (e.g., `.ts`, `.py`).
+ * @param filePath - The file path for location info.
+ * @returns Array of detected patterns, or empty array if language unsupported.
+ */
+declare function detectPatterns(content: string, ext: string, filePath?: string): Promise<PatternMatch[]>;
+//#endregion
+export { detectPatterns };

package/packages/chunker/dist/extractors/pattern-detector.js

@@ -0,0 +1 @@
+import{WasmRuntime as e}from"../wasm/runtime.js";import{QueryExecutor as t}from"../wasm/query-executor.js";const n=new t;async function r(t,r,a=``){let o=await e.ensure(),s=await o.parse(t,r);if(!s)return[];let c=o.getLanguage(r);if(!c)return[];let l=n.execute(s.rootNode,c,r,`patterns`),u=new Map;for(let e of l){let t=i(e,r);if(!t)continue;let n=e.captures.get(`name`),o=`${a}:${(e.captures.get(`node`)?.startLine??n?.startLine??0)+1}`,s=u.get(t.pattern);s?s.locations.push(o):u.set(t.pattern,{description:t.description,locations:[o]})}let d=[];for(let[e,{description:t,locations:n}]of u)d.push({pattern:e,description:t,locations:n,confidence:`high`});return d}function i(e,t){let n=e.captures.get(`name`)?.text;if(!n)return null;let r=e.captures.get(`node`)?.nodeType??``;if(/^(create|build)[A-Z]/.test(n)||/^(of|from|new)[A-Z]/.test(n))return{pattern:`factory`,description:`Factory function/method`};if(/^(register|bind)$/.test(n))return{pattern:`dependency-injection`,description:`DI container registration`};if(/^(Injectable|Component|Service|Controller|Module|Singleton|Repository|Bean)$/.test(n))return{pattern:`dependency-injection`,description:`Framework DI annotation`};if(/^(Map|WeakMap|Set)$/.test(n))return{pattern:`cached-instance`,description:`Cached Map/Set instance`};if(t===`.py`){if(n===`__new__`)return{pattern:`singleton`,description:`Singleton pattern (__new__ override)`};if(n===`__enter__`)return{pattern:`context-manager`,description:`Context manager pattern`};if(r===`decorated_definition`)return{pattern:`decorator`,description:`Decorator usage`}}if(t===`.go`){if(r===`type_declaration`)return{pattern:`interface`,description:`Interface definition`};if(r===`go_statement`)return{pattern:`concurrency`,description:`Goroutine concurrency pattern`};if(n===`make`)return{pattern:`concurrency`,description:`Channel/make pattern`}}if(t===`.rs`){if(r===`impl_item`)return{pattern:`trait-impl`,description:`Trait implementation`};if(r===`attribute_item`){if(n===`derive`)return{pattern:`derive`,description:`Derive macro attribute`};if(n===`test`)return{pattern:`test`,description:`Test attribute`}}}if(t===`.java`){if(r===`class_declaration`)return{pattern:`singleton`,description:`Singleton pattern (private constructor)`};if(r===`marker_annotation`)return{pattern:`dependency-injection`,description:`Framework DI annotation`}}if(/\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/.test(t)){if(r===`class_declaration`)return{pattern:`singleton`,description:`Singleton pattern (private constructor)`};if(r===`decorator`)return{pattern:`decorator`,description:`Framework decorator pattern`}}return{pattern:r||`unknown`,description:`Detected pattern: ${n}`}}export{r as detectPatterns};

package/packages/chunker/dist/extractors/scope-resolver.d.ts

@@ -0,0 +1,26 @@
+//#region packages/chunker/src/extractors/scope-resolver.d.ts
+/**
+ * AST-based scope resolver.
+ *
+ * NEW capability: resolves the enclosing scope (function/class/module) for any
+ * AST node. Used by other extractors to determine caller context.
+ */
+interface ScopeInfo {
+  /** Name of the enclosing scope (or '<module>' for top-level). */
+  name: string;
+  /** The scope type (function, class, module). */
+  type: 'function' | 'class' | 'module';
+  /** 1-based start line of the scope. */
+  line: number;
+}
+/**
+ * Resolve the enclosing scope chain for a given line in source code.
+ *
+ * @param content - The source code to analyze.
+ * @param ext - The file extension.
+ * @param targetLine - 1-based line number to resolve scope for.
+ * @returns Array of scopes from innermost to outermost, ending with module.
+ */
+declare function resolveScopes(content: string, ext: string, targetLine: number): Promise<ScopeInfo[]>;
+//#endregion
+export { ScopeInfo, resolveScopes };

package/packages/chunker/dist/extractors/scope-resolver.js

@@ -0,0 +1 @@
+import{WasmRuntime as e}from"../wasm/runtime.js";const t=new Set([`function_declaration`,`method_definition`,`arrow_function`,`class_declaration`,`function_definition`,`class_definition`,`method_declaration`,`constructor_declaration`,`class_declaration`,`function_declaration`,`method_declaration`,`function_item`,`impl_item`]);async function n(t,n,a){let o=await(await e.ensure()).parse(t,n);if(!o)return[{name:`<module>`,type:`module`,line:1}];let s=r(o.rootNode,a-1);if(!s)return[{name:`<module>`,type:`module`,line:1}];let c=[];return i(s,c),c.push({name:`<module>`,type:`module`,line:1}),c}function r(e,t){let n=null;function r(e){if(e.startPosition.row<=t&&e.endPosition.row>=t){n=e;for(let t of e.children)r(t)}}return r(e),n}function i(e,n){let r=e.parent;for(;r;){if(t.has(r.type)){let e=a(r),t=o(r.type);n.push({name:e??`<anonymous>`,type:t,line:r.startPosition.row+1})}r=r.parent}}function a(e){let t=e.childForFieldName(`name`);if(t)return t.text;for(let t of e.children)if(t.type===`identifier`||t.type===`type_identifier`||t.type===`property_identifier`||t.type===`field_identifier`)return t.text;return null}function o(e){return e.includes(`class`)||e===`impl_item`?`class`:`function`}export{n as resolveScopes};

package/packages/chunker/dist/extractors/symbol-extractor.d.ts

@@ -0,0 +1,14 @@
+import { SymbolInfo } from "./types.js";
+
+//#region packages/chunker/src/extractors/symbol-extractor.d.ts
+/**
+ * Extract symbols from source code using AST queries.
+ *
+ * @param content - The source code to analyze.
+ * @param ext - The file extension (e.g., `.ts`, `.py`).
+ * @param filePath - The file path for the returned SymbolInfo records.
+ * @returns Array of extracted symbols, or empty array if language unsupported.
+ */
+declare function extractSymbols(content: string, ext: string, filePath?: string): Promise<SymbolInfo[]>;
+//#endregion
+export { extractSymbols };

package/packages/chunker/dist/extractors/symbol-extractor.js

@@ -0,0 +1 @@
+import{WasmRuntime as e}from"../wasm/runtime.js";import{QueryExecutor as t}from"../wasm/query-executor.js";const n=new t,r={function_declaration:`function`,class_declaration:`class`,interface_declaration:`interface`,type_alias_declaration:`type`,enum_declaration:`enum`,lexical_declaration:`const`,method_definition:`method`,public_field_definition:`variable`,field_definition:`variable`,function_definition:`function`,class_definition:`class`,expression_statement:`variable`,method_declaration:`method`,constructor_declaration:`method`,field_declaration:`variable`,type_spec:`type`,type_declaration:`type`,const_spec:`const`,var_spec:`variable`,function_item:`function`,struct_item:`class`,enum_item:`enum`,trait_item:`interface`,impl_item:`type`,const_item:`const`,static_item:`variable`,type_item:`type`};async function i(t,r,i=``){let o=await e.ensure(),s=await o.parse(t,r);if(!s)return[];let c=o.getLanguage(r);return c?a(n.execute(s.rootNode,c,r,`symbols`),r,i):[]}function a(e,t,n){let i=new Map;for(let n of e){let e=n.captures.get(`name`);if(!e)continue;let r=`${e.text}:${(n.captures.get(`node`)?.startLine??e.startLine)+1}`,a=o(n,t),s=i.get(r);(!s||!s.exported&&a)&&i.set(r,{match:n,exported:a})}let a=[];for(let{match:e,exported:o}of i.values()){let i=e.captures.get(`name`),l=e.captures.get(`node`);if(!i)continue;let u=r[l?.nodeType??i.nodeType]??`variable`,d=(l?.startLine??i.startLine)+1,f=s(u,l?.node,t);a.push({name:i.text,kind:f,exported:o,filePath:n,line:d,signature:c(l?.node,f)})}return a}function o(e,t){if(e.captures.has(`exported`))return!0;let n=e.captures.get(`name`)?.text;if(!n)return!1;if(t===`.py`)return!n.startsWith(`_`);if(t===`.go`)return/^[A-Z]/.test(n);if(t===`.java`){let t=e.captures.get(`node`)?.text??``;return/\bpublic\b/.test(t)}return!1}function s(e,t,n){if(n===`.go`&&e===`type`&&t?.children){let e=t.type===`type_declaration`?t.children.flatMap(e=>e.children??[]):t.children;for(let t of e){if(t.type===`interface_type`)return`interface`;if(t.type===`struct_type`)return`class`}}return e}function c(e,t){if(e){if(t===`function`||t===`method`)return l(e);if(t===`class`)return u(e);if(t===`interface`)return f(e)}}function l(e){let t=e.childForFieldName(`parameters`)??e.childForFieldName(`parameter_list`),n=e.childForFieldName(`return_type`)??e.childForFieldName(`type`),r=e.childForFieldName(`result`);if(!t){for(let t of e.children)if(t.type===`formal_parameters`||t.type===`parameter_list`||t.type===`parameters`){let e=t.text;return n&&(e+=n.text),r&&(e+=` ${r.text}`),e.length>120?`${e.slice(0,117)}...`:e}return}let i=t.text;return n&&(i+=n.text),r&&(i+=` ${r.text}`),i.length>120?`${i.slice(0,117)}...`:i}function u(e){let t=e.childForFieldName(`body`)??e.childForFieldName(`field_declaration_list`);if(!t){for(let t of e.children)if(t.type===`struct_type`||t.type===`class_body`)return d(t);return}return d(t)}function d(e){let t=[];for(let n of e.children){if(n.type===`method_definition`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}if(n.type===`method_declaration`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}if(n.type===`field_declaration`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}if(n.type===`function_definition`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}}if(t.length===0)return;let n=t.join(`, `);return n.length>120?`${n.slice(0,117)}...`:n}function f(e){let t=e.childForFieldName(`body`);if(!t){for(let t of e.children)if(t.type===`interface_type`)return p(t);return}return p(t)}function p(e){let t=[];for(let n of e.children){if(n.type===`property_signature`||n.type===`method_signature`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}if(n.type===`method_declaration`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}if(n.type===`method_spec`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}if(n.type===`function_signature_item`||n.type===`declaration_list`){let e=n.childForFieldName(`name`);e&&t.push(e.text)}}if(t.length===0)return;let n=t.join(`, `);return n.length>120?`${n.slice(0,117)}...`:n}export{i as extractSymbols};

package/packages/chunker/dist/extractors/types.d.ts

@@ -0,0 +1,36 @@
+//#region packages/chunker/src/extractors/types.d.ts
+/**
+ * Shared type definitions for AST extractors.
+ *
+ * These types match the interfaces in `@kb/analyzers/types.ts` so that
+ * downstream consumers can seamlessly switch from regex-based to AST-based extraction.
+ */
+interface SymbolInfo {
+  name: string;
+  kind: 'function' | 'class' | 'interface' | 'type' | 'const' | 'enum' | 'variable' | 'method';
+  exported: boolean;
+  filePath: string;
+  line: number;
+  signature?: string;
+}
+interface ImportInfo {
+  source: string;
+  specifiers: string[];
+  filePath: string;
+  isExternal: boolean;
+  confidence: 'high' | 'medium' | 'low';
+}
+interface PatternMatch {
+  pattern: string;
+  description: string;
+  locations: string[];
+  confidence: 'high' | 'medium' | 'low';
+}
+interface EntryPoint {
+  name: string;
+  type: 'lambda-handler' | 'main' | 'bin' | 'server' | 'cli' | 'test' | 'cdk-construct';
+  filePath: string;
+  trigger?: string;
+}
+//#endregion
+export { EntryPoint, ImportInfo, PatternMatch, SymbolInfo };

package/packages/chunker/dist/extractors/types.js

@@ -0,0 +1 @@
+export{};

package/packages/chunker/dist/generic-chunker.d.ts

@@ -12,5 +12,4 @@ declare class GenericChunker implements IChunker {
   chunk(content: string, metadata: ChunkMetadata): RawChunk[];
 }
 //#endregion
-export { GenericChunker };
-//# sourceMappingURL=generic-chunker.d.ts.map
+export { GenericChunker };

package/packages/chunker/dist/generic-chunker.js

@@ -2,5 +2,4 @@ import{CHUNK_SIZES as e}from"../../core/dist/index.js";var t=class{maxChunkSize;
 `).length}];let n=e.split(`
 `),r=[],i=[],a=0,o=1;for(let e=0;e<n.length;e++){let s=n[e];if(a+s.length+1>this.maxChunkSize&&i.length>0){r.push({text:i.join(`
 `),sourcePath:t.sourcePath,contentType:t.contentType,chunkIndex:r.length,totalChunks:0,startLine:o,endLine:o+i.length-1});let e=[],n=0;for(let t=i.length-1;t>=0&&!(n+i[t].length+1>this.overlap);t--)e.unshift(i[t]),n+=i[t].length+1;o=o+i.length-e.length,i=[...e,s],a=n+s.length+1}else i.push(s),a+=s.length+1}return i.length>0&&r.push({text:i.join(`
-`),sourcePath:t.sourcePath,contentType:t.contentType,chunkIndex:r.length,totalChunks:0,startLine:o,endLine:o+i.length-1}),r.map((e,t)=>({...e,chunkIndex:t,totalChunks:r.length}))}};export{t as GenericChunker};
-//# sourceMappingURL=generic-chunker.js.map
+`),sourcePath:t.sourcePath,contentType:t.contentType,chunkIndex:r.length,totalChunks:0,startLine:o,endLine:o+i.length-1}),r.map((e,t)=>({...e,chunkIndex:t,totalChunks:r.length}))}};export{t as GenericChunker};

package/packages/chunker/dist/index.d.ts

@@ -1,8 +1,19 @@
-import { CallEdge, extractCallEdges } from "./call-graph-extractor.js";
+import { CallEdge as CallEdge$1, extractCallEdges } from "./call-graph-extractor.js";
 import { IChunker } from "./chunker.interface.js";
-import { createChunker } from "./chunker-factory.js";
+import { createChunker, createChunkerSync } from "./chunker-factory.js";
 import { CodeChunker } from "./code-chunker.js";
+import { CallEdge, extractCalls } from "./extractors/call-extractor.js";
+import { EntryPoint, ImportInfo, PatternMatch, SymbolInfo } from "./extractors/types.js";
+import { detectEntryPoints } from "./extractors/entry-point-detector.js";
+import { extractImports } from "./extractors/import-extractor.js";
+import { detectPatterns } from "./extractors/pattern-detector.js";
+import { ScopeInfo, resolveScopes } from "./extractors/scope-resolver.js";
+import { extractSymbols } from "./extractors/symbol-extractor.js";
 import { GenericChunker } from "./generic-chunker.js";
 import { MarkdownChunker } from "./markdown-chunker.js";
-import { TreeSitterChunker, TreeSitterRuntime, initializeTreeSitter } from "./treesitter-chunker.js";
-export { type CallEdge, CodeChunker, GenericChunker, type IChunker, MarkdownChunker, TreeSitterChunker, TreeSitterRuntime, createChunker, extractCallEdges, initializeTreeSitter };
+import { SUPPORTED_EXTENSIONS, resolveGrammarPath, resolveParserWasmPath } from "./wasm/languages.js";
+import { WasmLanguage, WasmParser, WasmParserModule, WasmPoint, WasmQuery, WasmQueryCapture, WasmQueryMatch, WasmSyntaxNode, WasmTree } from "./wasm/types.js";
+import { CaptureInfo, QueryExecutor, QueryResult, QueryType } from "./wasm/query-executor.js";
+import { WasmRuntime, initializeWasm } from "./wasm/runtime.js";
+import { WasmChunker } from "./wasm-chunker.js";
+export { type CallEdge as AstCallEdge, type CallEdge$1 as CallEdge, type CaptureInfo, CodeChunker, type EntryPoint, GenericChunker, type IChunker, type ImportInfo, MarkdownChunker, type PatternMatch, QueryExecutor, type QueryResult, type QueryType, SUPPORTED_EXTENSIONS, type ScopeInfo, type SymbolInfo, WasmChunker, type WasmLanguage, type WasmParser, type WasmParserModule, type WasmPoint, type WasmQuery, type WasmQueryCapture, type WasmQueryMatch, WasmRuntime, type WasmSyntaxNode, type WasmTree, createChunker, createChunkerSync, detectEntryPoints, detectPatterns, extractCallEdges, extractCalls, extractImports, extractSymbols, initializeWasm, resolveGrammarPath, resolveParserWasmPath, resolveScopes };

package/packages/chunker/dist/index.js

@@ -1 +1 @@
-import{CodeChunker as e}from"./code-chunker.js";import{TreeSitterChunker as t,TreeSitterRuntime as n,initializeTreeSitter as r}from"./treesitter-chunker.js";import{extractCallEdges as i}from"./call-graph-extractor.js";import{GenericChunker as a}from"./generic-chunker.js";import{MarkdownChunker as o}from"./markdown-chunker.js";import{createChunker as s}from"./chunker-factory.js";export{e as CodeChunker,a as GenericChunker,o as MarkdownChunker,t as TreeSitterChunker,n as TreeSitterRuntime,s as createChunker,i as extractCallEdges,r as initializeTreeSitter};
+import{SUPPORTED_EXTENSIONS as e,resolveGrammarPath as t,resolveParserWasmPath as n}from"./wasm/languages.js";import{WasmRuntime as r,initializeWasm as i}from"./wasm/runtime.js";import{extractCallEdges as a}from"./call-graph-extractor.js";import{CodeChunker as o}from"./code-chunker.js";import{GenericChunker as s}from"./generic-chunker.js";import{MarkdownChunker as c}from"./markdown-chunker.js";import{WasmChunker as l}from"./wasm-chunker.js";import{createChunker as u,createChunkerSync as d}from"./chunker-factory.js";import{QueryExecutor as f}from"./wasm/query-executor.js";import{extractCalls as p}from"./extractors/call-extractor.js";import{detectEntryPoints as m}from"./extractors/entry-point-detector.js";import{extractImports as h}from"./extractors/import-extractor.js";import{detectPatterns as g}from"./extractors/pattern-detector.js";import{resolveScopes as _}from"./extractors/scope-resolver.js";import{extractSymbols as v}from"./extractors/symbol-extractor.js";export{o as CodeChunker,s as GenericChunker,c as MarkdownChunker,f as QueryExecutor,e as SUPPORTED_EXTENSIONS,l as WasmChunker,r as WasmRuntime,u as createChunker,d as createChunkerSync,m as detectEntryPoints,g as detectPatterns,a as extractCallEdges,p as extractCalls,h as extractImports,v as extractSymbols,i as initializeWasm,t as resolveGrammarPath,n as resolveParserWasmPath,_ as resolveScopes};

package/packages/chunker/dist/markdown-chunker.d.ts

@@ -14,5 +14,4 @@ declare class MarkdownChunker implements IChunker {
   private splitByParagraphs;
 }
 //#endregion
-export { MarkdownChunker };
-//# sourceMappingURL=markdown-chunker.d.ts.map
+export { MarkdownChunker };

package/packages/chunker/dist/markdown-chunker.js

@@ -1,4 +1,3 @@
 import{CHUNK_SIZES as e}from"../../core/dist/index.js";var t=class{maxChunkSize;minChunkSize;constructor(t){this.maxChunkSize=t?.maxChunkSize??e.markdown.max,this.minChunkSize=t?.minChunkSize??e.markdown.min}chunk(e,t){let n=this.splitByHeadings(e),r=[];for(let e of n){if(e.text.trim().length<this.minChunkSize&&r.length>0){let t=r[r.length-1];t.text+=`\n\n${e.text}`,t.endLine=e.endLine;continue}if(e.text.length>this.maxChunkSize){let n=this.splitByParagraphs(e.text,this.maxChunkSize),i=e.startLine;for(let a of n){let n=a.split(`
 `).length;r.push({text:a,sourcePath:t.sourcePath,contentType:t.contentType,headingPath:e.headingPath,chunkIndex:r.length,totalChunks:0,startLine:i,endLine:i+n-1}),i+=n}}else r.push({text:e.text,sourcePath:t.sourcePath,contentType:t.contentType,headingPath:e.headingPath,chunkIndex:r.length,totalChunks:0,startLine:e.startLine,endLine:e.endLine})}return r.map((e,t)=>({...e,chunkIndex:t,totalChunks:r.length}))}splitByHeadings(e){let t=e.split(`
-`),n=[],r=null,i=[],a=!1;for(let e=0;e<t.length;e++){/^```/.test(t[e])&&(a=!a);let o=a?null:t[e].match(/^(#{1,6})\s+(.+)/);if(o){r&&n.push(r);let a=o[1].length,s=o[2].trim();for(;i.length>=a;)i.pop();i.push(`${`#`.repeat(a)} ${s}`),r={text:t[e],headingPath:i.join(` > `),startLine:e+1,endLine:e+1}}else r?(r.text+=`\n${t[e]}`,r.endLine=e+1):r={text:t[e],headingPath:`(intro)`,startLine:e+1,endLine:e+1}}return r&&n.push(r),n}splitByParagraphs(e,t){let n=e.split(/\n\n+/),r=[],i=``;for(let e of n)`${i}\n\n${e}`.length>t&&i.length>0?(r.push(i.trim()),i=e):i=i?`${i}\n\n${e}`:e;return i.trim()&&r.push(i.trim()),r}};export{t as MarkdownChunker};
-//# sourceMappingURL=markdown-chunker.js.map
+`),n=[],r=null,i=[],a=!1;for(let e=0;e<t.length;e++){/^```/.test(t[e])&&(a=!a);let o=a?null:t[e].match(/^(#{1,6})\s+(.+)/);if(o){r&&n.push(r);let a=o[1].length,s=o[2].trim();for(;i.length>=a;)i.pop();i.push(`${`#`.repeat(a)} ${s}`),r={text:t[e],headingPath:i.join(` > `),startLine:e+1,endLine:e+1}}else r?(r.text+=`\n${t[e]}`,r.endLine=e+1):r={text:t[e],headingPath:`(intro)`,startLine:e+1,endLine:e+1}}return r&&n.push(r),n}splitByParagraphs(e,t){let n=e.split(/\n\n+/),r=[],i=``;for(let e of n)`${i}\n\n${e}`.length>t&&i.length>0?(r.push(i.trim()),i=e):i=i?`${i}\n\n${e}`:e;return i.trim()&&r.push(i.trim()),r}};export{t as MarkdownChunker};

package/packages/chunker/dist/wasm/languages.d.ts

@@ -0,0 +1,18 @@
+//#region packages/chunker/src/wasm/languages.d.ts
+/**
+ * Language registry for web-tree-sitter WASM grammars.
+ *
+ * Maps file extensions to vendored .wasm grammar file names
+ * and resolves their absolute paths on disk.
+ */
+/** All supported extensions. */
+declare const SUPPORTED_EXTENSIONS: Set<string>;
+/**
+ * Resolve the absolute path to a vendored .wasm grammar file for a given extension.
+ * Returns null if the extension is not supported or the file doesn't exist.
+ */
+declare function resolveGrammarPath(ext: string): string | null;
+/** Resolve the parser runtime WASM path. */
+declare function resolveParserWasmPath(): string | null;
+//#endregion
+export { SUPPORTED_EXTENSIONS, resolveGrammarPath, resolveParserWasmPath };

package/packages/chunker/dist/wasm/languages.js

@@ -0,0 +1 @@
+import{dirname as e,join as t}from"node:path";import{existsSync as n}from"node:fs";import{fileURLToPath as r}from"node:url";const i=t(e(r(import.meta.url)),`..`,`..`,`wasm`),a={".ts":`tree-sitter-typescript.wasm`,".tsx":`tree-sitter-typescript.wasm`,".mts":`tree-sitter-typescript.wasm`,".cts":`tree-sitter-typescript.wasm`,".js":`tree-sitter-javascript.wasm`,".jsx":`tree-sitter-javascript.wasm`,".mjs":`tree-sitter-javascript.wasm`,".cjs":`tree-sitter-javascript.wasm`,".py":`tree-sitter-python.wasm`,".go":`tree-sitter-go.wasm`,".rs":`tree-sitter-rust.wasm`,".java":`tree-sitter-java.wasm`},o=new Set(Object.keys(a));function s(e){let r=a[e];if(!r)return null;let o=t(i,r);return n(o)?o:null}function c(){let e=t(i,`tree-sitter.wasm`);return n(e)?e:null}export{o as SUPPORTED_EXTENSIONS,s as resolveGrammarPath,c as resolveParserWasmPath};

package/packages/chunker/dist/wasm/query-executor.d.ts

@@ -0,0 +1,70 @@
+import { WasmLanguage, WasmSyntaxNode } from "./types.js";
+
+//#region packages/chunker/src/wasm/query-executor.d.ts
+/** Known query types that can be loaded. */
+type QueryType = 'symbols' | 'imports' | 'calls' | 'patterns' | 'entry-points';
+/** Structured result from a single query match. */
+interface QueryResult {
+  /** The pattern index within the .scm file that matched. */
+  pattern: number;
+  /** All captures in this match, keyed by capture name → node info. */
+  captures: Map<string, CaptureInfo>;
+}
+/** Information about a single captured node. */
+interface CaptureInfo {
+  /** The capture name (e.g., 'name', 'node', 'kind'). */
+  name: string;
+  /** The captured node's text content. */
+  text: string;
+  /** AST node type (e.g., 'function_declaration', 'identifier'). */
+  nodeType: string;
+  /** 0-based start line. */
+  startLine: number;
+  /** 0-based end line. */
+  endLine: number;
+  /** 0-based start column. */
+  startColumn: number;
+  /** 0-based end column. */
+  endColumn: number;
+  /** The raw AST node (for advanced traversal). */
+  node: WasmSyntaxNode;
+}
+declare class QueryExecutor {
+  /** Cache: `"typescript:symbols"` → compiled WasmQuery */
+  private queryCache;
+  /** Cache: loaded .scm source text to avoid re-reading disk. */
+  private scmCache;
+  /**
+   * Execute a query type against a parsed AST tree.
+   *
+   * @param rootNode - The root node of a parsed AST tree.
+   * @param language - The Language object for the parsed file.
+   * @param ext - The file extension (e.g., `.ts`).
+   * @param queryType - Which query to execute (e.g., `'symbols'`).
+   * @returns Array of structured results, or empty array if query not found.
+   */
+  execute(rootNode: WasmSyntaxNode, language: WasmLanguage, ext: string, queryType: QueryType): QueryResult[];
+  /**
+   * Execute a query and return flat captures instead of grouped matches.
+   * Useful when you care about individual nodes, not match grouping.
+   */
+  executeCaptures(rootNode: WasmSyntaxNode, language: WasmLanguage, ext: string, queryType: QueryType): CaptureInfo[];
+  /**
+   * Execute a raw .scm query string (not from file) against a tree.
+   * Useful for ad-hoc queries and testing.
+   */
+  executeRaw(rootNode: WasmSyntaxNode, language: WasmLanguage, scmSource: string): QueryResult[];
+  /**
+   * Get (or compile and cache) a query for the given language + type.
+   * Returns null if the .scm file doesn't exist.
+   */
+  private getOrCompile;
+  /** Load .scm file content, cached. Returns null if file not found. */
+  private loadScm;
+  /** Clear all caches. */
+  dispose(): void;
+  /** Resolve the directory path for a language's queries. */
+  static resolveQueryDir(langDir: string): string;
+}
+//#endregion
+export { CaptureInfo, QueryExecutor, QueryResult, QueryType };

package/packages/chunker/dist/wasm/query-executor.js

@@ -0,0 +1 @@
+import{dirname as e,join as t}from"node:path";import{createLogger as n}from"../../../core/dist/index.js";import{existsSync as r,readFileSync as i}from"node:fs";import{fileURLToPath as a}from"node:url";const o=n(`query-executor`),s=e(a(import.meta.url));function c(){let e=t(s,`..`,`queries`);if(r(e))return e;let n=t(s,`..`,`..`,`src`,`queries`);return r(n)?n:e}const l=c(),u={".ts":`typescript`,".tsx":`typescript`,".mts":`typescript`,".cts":`typescript`,".js":`javascript`,".jsx":`javascript`,".mjs":`javascript`,".cjs":`javascript`,".py":`python`,".go":`go`,".rs":`rust`,".java":`java`};var d=class{queryCache=new Map;scmCache=new Map;execute(e,t,n,r){let i=this.getOrCompile(t,n,r);return i?i.matches(e).map(e=>f(e)):[]}executeCaptures(e,t,n,r){let i=this.getOrCompile(t,n,r);return i?i.captures(e).map(e=>p(e)):[]}executeRaw(e,t,n){return t.query(n).matches(e).map(e=>f(e))}getOrCompile(e,t,n){let r=u[t];if(!r)return null;let i=`${r}:${n}`,a=this.queryCache.get(i);if(a)return a;let s=this.loadScm(r,n);if(!s)return null;try{let t=e.query(s);return this.queryCache.set(i,t),t}catch(e){throw o.warn(`Failed to compile query`,{langDir:r,queryType:n,error:String(e)}),Error(`Failed to compile ${r}/${n}.scm: ${String(e)}`)}}loadScm(e,n){let r=`${e}:${n}`,a=this.scmCache.get(r);if(a!==void 0)return a;let s=t(l,e,`${n}.scm`);try{let e=i(s,`utf-8`);return this.scmCache.set(r,e),e}catch{return o.info(`Query file not found (graceful skip)`,{langDir:e,queryType:n}),null}}dispose(){this.queryCache.clear(),this.scmCache.clear()}static resolveQueryDir(e){return t(l,e)}};function f(e){let t=new Map;for(let n of e.captures)t.set(n.name,p(n));return{pattern:e.pattern,captures:t}}function p(e){let{node:t}=e;return{name:e.name,text:t.text,nodeType:t.type,startLine:t.startPosition.row,endLine:t.endPosition.row,startColumn:t.startPosition.column,endColumn:t.endPosition.column,node:t}}export{d as QueryExecutor};

package/packages/chunker/dist/wasm/runtime.d.ts

@@ -0,0 +1,44 @@
+import { WasmLanguage, WasmParser, WasmTree } from "./types.js";
+
+//#region packages/chunker/src/wasm/runtime.d.ts
+declare class WasmRuntime {
+  private static instance;
+  private parser;
+  private languages;
+  /** Track which grammar files have been loaded (by path) to avoid re-loading. */
+  private loadedGrammars;
+  /** Initialize the singleton runtime. Returns the instance or null on failure. */
+  static initialize(): Promise<WasmRuntime | null>;
+  /** Get the current runtime (null if not initialized). */
+  static get(): WasmRuntime | null;
+  /** Ensure the runtime is initialized, initializing if needed. */
+  static ensure(): Promise<WasmRuntime>;
+  /** Reset the singleton (for testing). */
+  static dispose(): void;
+  private init;
+  /**
+   * Load a language grammar for a file extension (lazy, cached).
+   * Returns the Language object or null if unsupported/unavailable.
+   */
+  loadLanguage(ext: string): Promise<WasmLanguage | null>;
+  /**
+   * Parse source code and return the AST tree.
+   * Lazily loads the grammar on first use for the given extension.
+   */
+  parse(content: string, ext: string): Promise<WasmTree | null>;
+  /** Check if a grammar is available (loaded or loadable) for the given extension. */
+  hasLanguage(ext: string): boolean;
+  /** Check if a grammar is already loaded for the given extension. */
+  isLanguageLoaded(ext: string): boolean;
+  /** Get the underlying parser instance (for advanced query usage). */
+  getParser(): WasmParser | null;
+  /** Get a loaded language by extension (null if not loaded yet). */
+  getLanguage(ext: string): WasmLanguage | null;
+}
+/**
+ * Initialize the WASM runtime. Call once at startup.
+ * Returns true if the runtime is available, false otherwise.
+ */
+declare function initializeWasm(): Promise<boolean>;
+//#endregion
+export { WasmRuntime, initializeWasm };

package/packages/chunker/dist/wasm/runtime.js

@@ -0,0 +1 @@
+import{SUPPORTED_EXTENSIONS as e,resolveGrammarPath as t,resolveParserWasmPath as n}from"./languages.js";import{createLogger as r}from"../../../core/dist/index.js";const i=r(`wasm-runtime`);async function a(){return(await import(`web-tree-sitter`)).default}var o=class r{static instance=null;parser=null;languages=new Map;loadedGrammars=new Map;static async initialize(){if(r.instance)return r.instance;let e=new r;return await e.init()?(r.instance=e,e):null}static get(){return r.instance}static async ensure(){let e=r.get();if(e)return e;let t=await r.initialize();if(!t)throw Error(`Failed to initialize WASM tree-sitter runtime`);return t}static dispose(){r.instance&&=(r.instance.parser?.delete(),r.instance.parser=null,r.instance.languages.clear(),r.instance.loadedGrammars.clear(),null)}async init(){try{let e=n();if(!e)return i.warn(`Parser WASM file not found`),!1;let t=await a();return await t.init({locateFile:()=>e}),this.parser=new t,i.info(`WASM tree-sitter parser initialized`),!0}catch(e){return i.warn(`Failed to initialize WASM tree-sitter`,{error:String(e)}),!1}}async loadLanguage(e){let n=this.languages.get(e);if(n)return n;let r=t(e);if(!r)return null;let o=this.loadedGrammars.get(r);if(o)return this.languages.set(e,o),o;try{let t=await(await a()).Language.load(r);return this.loadedGrammars.set(r,t),this.languages.set(e,t),i.info(`Loaded grammar`,{ext:e}),t}catch(t){return i.warn(`Failed to load grammar`,{ext:e,error:String(t)}),null}}async parse(e,t){if(!this.parser)return null;let n=await this.loadLanguage(t);return n?(this.parser.setLanguage(n),this.parser.parse(e)):null}hasLanguage(t){return e.has(t)}isLanguageLoaded(e){return this.languages.has(e)}getParser(){return this.parser}getLanguage(e){return this.languages.get(e)??null}};async function s(){return await o.initialize()!==null}export{o as WasmRuntime,s as initializeWasm};

package/packages/chunker/dist/wasm/types.d.ts

@@ -0,0 +1,84 @@
+//#region packages/chunker/src/wasm/types.d.ts
+/**
+ * Minimal type definitions for web-tree-sitter 0.24.x.
+ *
+ * web-tree-sitter uses `export = Parser` (CJS-style) which doesn't interop
+ * cleanly with ESM `import type` under `moduleResolution: NodeNext` without
+ * `esModuleInterop`. We define our own interfaces for the subset we use.
+ */
+interface WasmPoint {
+  row: number;
+  column: number;
+}
+interface WasmSyntaxNode {
+  type: string;
+  text: string;
+  startPosition: WasmPoint;
+  endPosition: WasmPoint;
+  startIndex: number;
+  endIndex: number;
+  children: WasmSyntaxNode[];
+  namedChildren: WasmSyntaxNode[];
+  childCount: number;
+  namedChildCount: number;
+  parent: WasmSyntaxNode | null;
+  nextSibling: WasmSyntaxNode | null;
+  previousSibling: WasmSyntaxNode | null;
+  nextNamedSibling: WasmSyntaxNode | null;
+  previousNamedSibling: WasmSyntaxNode | null;
+  isNamed: boolean;
+  firstChild: WasmSyntaxNode | null;
+  lastChild: WasmSyntaxNode | null;
+  firstNamedChild: WasmSyntaxNode | null;
+  lastNamedChild: WasmSyntaxNode | null;
+  childForFieldName(fieldName: string): WasmSyntaxNode | null;
+  descendantsOfType(types: string | string[], startPosition?: WasmPoint, endPosition?: WasmPoint): WasmSyntaxNode[];
+}
+interface WasmTree {
+  rootNode: WasmSyntaxNode;
+  delete(): void;
+}
+interface WasmLanguage {
+  query(source: string): WasmQuery;
+  readonly version: number;
+  readonly fieldCount: number;
+}
+interface WasmQuery {
+  matches(rootNode: WasmSyntaxNode, options?: {
+    startPosition?: WasmPoint;
+    endPosition?: WasmPoint;
+    matchLimit?: number;
+  }): WasmQueryMatch[];
+  captures(rootNode: WasmSyntaxNode, options?: {
+    startPosition?: WasmPoint;
+    endPosition?: WasmPoint;
+    matchLimit?: number;
+  }): WasmQueryCapture[];
+  captureNames: string[];
+  delete(): void;
+}
+interface WasmQueryMatch {
+  pattern: number;
+  captures: WasmQueryCapture[];
+}
+interface WasmQueryCapture {
+  name: string;
+  node: WasmSyntaxNode;
+}
+interface WasmParser {
+  parse(input: string): WasmTree;
+  setLanguage(language: WasmLanguage | null): void;
+  delete(): void;
+}
+/** The Parser constructor + statics as returned by web-tree-sitter. */
+interface WasmParserModule {
+  new (): WasmParser;
+  init(moduleOptions?: {
+    locateFile?: (scriptName: string, scriptDirectory: string) => string;
+  }): Promise<void>;
+  Language: {
+    load(input: string | Uint8Array): Promise<WasmLanguage>;
+  };
+}
+//#endregion
+export { WasmLanguage, WasmParser, WasmParserModule, WasmPoint, WasmQuery, WasmQueryCapture, WasmQueryMatch, WasmSyntaxNode, WasmTree };

package/packages/chunker/dist/wasm/types.js

@@ -0,0 +1 @@
+export{};

package/packages/chunker/dist/wasm-chunker.d.ts

@@ -0,0 +1,23 @@
+import { IChunker } from "./chunker.interface.js";
+import { ChunkMetadata, RawChunk } from "@kb/core";
+
+//#region packages/chunker/src/wasm-chunker.d.ts
+declare class WasmChunker implements IChunker {
+  private readonly maxChunkSize;
+  constructor(options?: {
+    maxChunkSize?: number;
+  });
+  chunk(content: string, metadata: ChunkMetadata): RawChunk[];
+  /** Find declaration boundaries from AST top-level children. */
+  private findAstBoundaries;
+  /** Build RawChunk[] from AST boundaries, grouping consecutive preamble items. */
+  private buildChunks;
+  /** Split text by lines respecting max chunk size. */
+  private splitByLines;
+  /** Extract file extension from path. */
+  private extractExt;
+  /** Fallback: return the whole content as a single chunk. */
+  private singleChunk;
+}
+//#endregion
+export { WasmChunker };

package/packages/chunker/dist/wasm-chunker.js

@@ -0,0 +1,6 @@
+import{WasmRuntime as e}from"./wasm/runtime.js";import{CHUNK_SIZES as t}from"../../core/dist/index.js";const n=new Set([`function_declaration`,`class_declaration`,`interface_declaration`,`type_alias_declaration`,`enum_declaration`,`lexical_declaration`,`variable_declaration`,`export_statement`,`function_definition`,`class_definition`,`decorated_definition`,`class_declaration`,`interface_declaration`,`enum_declaration`,`function_declaration`,`method_declaration`,`type_declaration`,`function_item`,`struct_item`,`enum_item`,`trait_item`,`impl_item`,`const_item`,`static_item`,`type_item`]),r=new Set([`import_statement`,`import_from_statement`,`import_declaration`,`package_declaration`,`use_declaration`,`extern_crate_declaration`,`import_spec`,`package_clause`]);var i=class{maxChunkSize;constructor(e){this.maxChunkSize=e?.maxChunkSize??t.code.max}chunk(t,n){let r=e.get();if(!r)return this.singleChunk(t,n);let i=this.extractExt(n.sourcePath),a=r.getLanguage(i);if(!a)return this.singleChunk(t,n);let o=r.getParser();if(!o)return this.singleChunk(t,n);o.setLanguage(a);let s=o.parse(t);if(!s)return this.singleChunk(t,n);let c=this.findAstBoundaries(s.rootNode,t);return c.length===0?this.singleChunk(t,n):this.buildChunks(c,t,n)}findAstBoundaries(e,t){let i=[];for(let t of e.children){if(!t.isNamed)continue;let e=n.has(t.type),a=r.has(t.type);(e||a)&&i.push({startOffset:t.startIndex,endOffset:t.endIndex,startLine:t.startPosition.row+1,endLine:t.endPosition.row+1,isPreamble:a})}return i}buildChunks(e,t,n){let r=[],i=null,a=0,o=0;for(let s of e){if(s.isPreamble){i===null&&(i=s.startLine),a=s.endOffset,o=s.endLine;continue}if(i!==null){let e=t.slice(0,a).trim();e.length>0&&r.push({text:`// File: ${n.sourcePath}\n${e}`,sourcePath:n.sourcePath,contentType:n.contentType,chunkIndex:0,totalChunks:0,startLine:i,endLine:o}),i=null}let e=t.slice(s.startOffset,s.endOffset).trim();if(e=`// File: ${n.sourcePath}\n`+e,e.length>this.maxChunkSize){let t=this.splitByLines(e,this.maxChunkSize),i=s.startLine;for(let e of t){let t=e.split(`
+`).length;r.push({text:e,sourcePath:n.sourcePath,contentType:n.contentType,chunkIndex:0,totalChunks:0,startLine:i,endLine:i+t-1}),i+=t}}else r.push({text:e,sourcePath:n.sourcePath,contentType:n.contentType,chunkIndex:0,totalChunks:0,startLine:s.startLine,endLine:s.endLine})}if(i!==null){let e=t.slice(0,a).trim();e.length>0&&r.push({text:`// File: ${n.sourcePath}\n${e}`,sourcePath:n.sourcePath,contentType:n.contentType,chunkIndex:0,totalChunks:0,startLine:i,endLine:o})}return r.map((e,t)=>({...e,chunkIndex:t,totalChunks:r.length}))}splitByLines(e,t){let n=e.split(`
+`),r=[],i=[],a=0;for(let e of n)a+e.length+1>t&&i.length>0&&(r.push(i.join(`
+`)),i=[],a=0),i.push(e),a+=e.length+1;return i.length>0&&r.push(i.join(`
+`)),r}extractExt(e){let t=e.lastIndexOf(`.`);return t>=0?e.slice(t).toLowerCase():``}singleChunk(e,t){return[{text:`// File: ${t.sourcePath}\n${e}`,sourcePath:t.sourcePath,contentType:t.contentType,chunkIndex:0,totalChunks:1,startLine:1,endLine:e.split(`
+`).length}]}};export{i as WasmChunker};

package/packages/chunker/src/queries/go/calls.scm

@@ -0,0 +1,11 @@
+; Go call extraction queries
+; Captures: @node (call), @callee (function name)
+
+; foo(args) — direct function call
+(call_expression
+  function: (identifier) @callee) @node
+
+; pkg.Foo(args) — qualified/selector call
+(call_expression
+  function: (selector_expression
+    field: (field_identifier) @callee)) @node