@vpxa/kb 0.1.13 → 0.1.16

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

@@ -1,12 +1,15 @@
-import type { ChunkMetadata, RawChunk } from '@kb/core';
-import type { IChunker } from './chunker.interface.js';
-export declare class GenericChunker implements IChunker {
-    private readonly maxChunkSize;
-    private readonly overlap;
-    constructor(options?: {
-        maxChunkSize?: number;
-        overlap?: number;
-    });
-    chunk(content: string, metadata: ChunkMetadata): RawChunk[];
+import { IChunker } from "./chunker.interface.js";
+import { ChunkMetadata, RawChunk } from "@kb/core";
+
+//#region packages/chunker/src/generic-chunker.d.ts
+declare class GenericChunker implements IChunker {
+  private readonly maxChunkSize;
+  private readonly overlap;
+  constructor(options?: {
+    maxChunkSize?: number;
+    overlap?: number;
+  });
+  chunk(content: string, metadata: ChunkMetadata): RawChunk[];
 }
-//# sourceMappingURL=generic-chunker.d.ts.map
+//#endregion
+export { GenericChunker };

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

@@ -1,5 +1,5 @@
-import{CHUNK_SIZES as p}from"../../core/dist/index.js";class C{maxChunkSize;overlap;constructor(n){this.maxChunkSize=n?.maxChunkSize??p.default.max,this.overlap=n?.overlap??p.default.overlap}chunk(n,h){if(n.length<=this.maxChunkSize)return[{text:n,sourcePath:h.sourcePath,contentType:h.contentType,chunkIndex:0,totalChunks:1,startLine:1,endLine:n.split(`
-`).length}];const c=n.split(`
-`),r=[];let e=[],s=0,l=1;for(let u=0;u<c.length;u++){const t=c[u];if(s+t.length+1>this.maxChunkSize&&e.length>0){r.push({text:e.join(`
-`),sourcePath:h.sourcePath,contentType:h.contentType,chunkIndex:r.length,totalChunks:0,startLine:l,endLine:l+e.length-1});const o=[];let a=0;for(let i=e.length-1;i>=0&&!(a+e[i].length+1>this.overlap);i--)o.unshift(e[i]),a+=e[i].length+1;l=l+e.length-o.length,e=[...o,t],s=a+t.length+1}else e.push(t),s+=t.length+1}return e.length>0&&r.push({text:e.join(`
-`),sourcePath:h.sourcePath,contentType:h.contentType,chunkIndex:r.length,totalChunks:0,startLine:l,endLine:l+e.length-1}),r.map((u,t)=>({...u,chunkIndex:t,totalChunks:r.length}))}}export{C as GenericChunker};
+import{CHUNK_SIZES as e}from"../../core/dist/index.js";var t=class{maxChunkSize;overlap;constructor(t){this.maxChunkSize=t?.maxChunkSize??e.default.max,this.overlap=t?.overlap??e.default.overlap}chunk(e,t){if(e.length<=this.maxChunkSize)return[{text:e,sourcePath:t.sourcePath,contentType:t.contentType,chunkIndex:0,totalChunks:1,startLine:1,endLine:e.split(`
+`).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};

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

@@ -1,8 +1,19 @@
-export { type CallEdge, extractCallEdges } from './call-graph-extractor.js';
-export type { IChunker } from './chunker.interface.js';
-export { createChunker } from './chunker-factory.js';
-export { CodeChunker } from './code-chunker.js';
-export { GenericChunker } from './generic-chunker.js';
-export { MarkdownChunker } from './markdown-chunker.js';
-export { initializeTreeSitter, TreeSitterChunker, TreeSitterRuntime, } from './treesitter-chunker.js';
-//# sourceMappingURL=index.d.ts.map
+import { CallEdge as CallEdge$1, extractCallEdges } from "./call-graph-extractor.js";
+import { IChunker } from "./chunker.interface.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 { 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{extractCallEdges as t}from"./call-graph-extractor.js";import{createChunker as n}from"./chunker-factory.js";import{CodeChunker as p}from"./code-chunker.js";import{GenericChunker as f}from"./generic-chunker.js";import{MarkdownChunker as m}from"./markdown-chunker.js";import{initializeTreeSitter as x,TreeSitterChunker as a,TreeSitterRuntime as h}from"./treesitter-chunker.js";export{p as CodeChunker,f as GenericChunker,m as MarkdownChunker,a as TreeSitterChunker,h as TreeSitterRuntime,n as createChunker,t as extractCallEdges,x 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

@@ -1,14 +1,17 @@
-import type { ChunkMetadata, RawChunk } from '@kb/core';
-import type { IChunker } from './chunker.interface.js';
-export declare class MarkdownChunker implements IChunker {
-    private readonly maxChunkSize;
-    private readonly minChunkSize;
-    constructor(options?: {
-        maxChunkSize?: number;
-        minChunkSize?: number;
-    });
-    chunk(content: string, metadata: ChunkMetadata): RawChunk[];
-    private splitByHeadings;
-    private splitByParagraphs;
+import { IChunker } from "./chunker.interface.js";
+import { ChunkMetadata, RawChunk } from "@kb/core";
+
+//#region packages/chunker/src/markdown-chunker.d.ts
+declare class MarkdownChunker implements IChunker {
+  private readonly maxChunkSize;
+  private readonly minChunkSize;
+  constructor(options?: {
+    maxChunkSize?: number;
+    minChunkSize?: number;
+  });
+  chunk(content: string, metadata: ChunkMetadata): RawChunk[];
+  private splitByHeadings;
+  private splitByParagraphs;
 }
-//# sourceMappingURL=markdown-chunker.d.ts.map
+//#endregion
+export { MarkdownChunker };

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

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

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

package/packages/chunker/src/queries/go/entry-points.scm

@@ -0,0 +1,20 @@
+; Go entry-point detection queries
+; Captures: @node (declaration), @name (function name)
+
+; func main()
+(function_declaration
+  name: (identifier) @name
+  (#eq? @name "main")) @node
+
+; func init()
+(function_declaration
+  name: (identifier) @name
+  (#eq? @name "init")) @node
+
+; http.HandleFunc / http.Handle
+(call_expression
+  function: (selector_expression
+    operand: (identifier) @_pkg
+    field: (field_identifier) @name
+    (#eq? @_pkg "http")
+    (#match? @name "^Handle"))) @node

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

@@ -0,0 +1,6 @@
+; Go import extraction queries
+; Captures: @node (import spec), @source (path string)
+
+; Each individual import spec (works for both single and block imports)
+(import_spec
+  path: (interpreted_string_literal) @source) @node

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

@@ -0,0 +1,25 @@
+; Go pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; Interface type definition
+(type_declaration
+  (type_spec
+    name: (type_identifier) @name
+    type: (interface_type))) @node
+
+; Goroutine launch
+(go_statement
+  (call_expression
+    function: (identifier) @name)) @node
+
+; Channel creation: make(chan T)
+(call_expression
+  function: (identifier) @name
+  (#eq? @name "make")) @node
+
+; sync primitives (field of type sync.Mutex, sync.WaitGroup, etc.)
+(field_declaration
+  type: (qualified_type
+    package: (package_identifier) @_pkg
+    name: (type_identifier) @name
+    (#eq? @_pkg "sync"))) @node

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

@@ -0,0 +1,26 @@
+; Go symbol extraction queries
+; Captures: @node (declaration), @name (identifier)
+; Export convention: uppercase first letter = exported (checked by extractor)
+
+; Function declaration
+(function_declaration
+  name: (identifier) @name) @node
+
+; Method declaration (receiver function)
+(method_declaration
+  name: (field_identifier) @name) @node
+
+; Type declaration (struct, interface, type alias)
+(type_declaration
+  (type_spec
+    name: (type_identifier) @name)) @node
+
+; Const declaration
+(const_declaration
+  (const_spec
+    name: (identifier) @name)) @node
+
+; Var declaration
+(var_declaration
+  (var_spec
+    name: (identifier) @name)) @node

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

@@ -0,0 +1,10 @@
+; Java call extraction queries
+; Captures: @node (call), @callee (method/constructor name)
+
+; foo(args) / this.foo(args) / obj.method(args)
+(method_invocation
+  name: (identifier) @callee) @node
+
+; new Foo(args)
+(object_creation_expression
+  type: (type_identifier) @callee) @node

package/packages/chunker/src/queries/java/entry-points.scm

@@ -0,0 +1,27 @@
+; Java entry-point detection queries
+; Captures: @node (declaration), @name (class/method name)
+
+; public static void main(String[] args)
+(method_declaration
+  (modifiers) @_mods
+  type: (void_type)
+  name: (identifier) @name
+  (#eq? @name "main")
+  (#match? @_mods "public")
+  (#match? @_mods "static")) @node
+
+; @SpringBootApplication class
+(class_declaration
+  (modifiers
+    (marker_annotation
+      name: (identifier) @_ann
+      (#eq? @_ann "SpringBootApplication")))
+  name: (identifier) @name) @node
+
+; @RestController / @Controller class
+(class_declaration
+  (modifiers
+    (marker_annotation
+      name: (identifier) @_ann
+      (#match? @_ann "^(RestController|Controller)$")))
+  name: (identifier) @name) @node

package/packages/chunker/src/queries/java/imports.scm

@@ -0,0 +1,11 @@
+; Java import extraction queries
+; Captures: @node (import), @source (fully qualified path)
+
+; import com.example.Foo;
+; import static com.example.Foo.bar;
+(import_declaration
+  (scoped_identifier) @source) @node
+
+; import Foo; (single identifier, rare)
+(import_declaration
+  (identifier) @source) @node

package/packages/chunker/src/queries/java/patterns.scm

@@ -0,0 +1,27 @@
+; Java pattern detection queries
+; Captures: @node (pattern site), @name (identifier)
+
+; Singleton: private constructor
+(class_declaration
+  name: (identifier) @name
+  body: (class_body
+    (constructor_declaration
+      (modifiers) @_mods
+      (#match? @_mods "private")))) @node
+
+; Factory: static method named create/build/of/from
+(method_declaration
+  (modifiers) @_mods
+  name: (identifier) @name
+  (#match? @_mods "static")
+  (#match? @name "^(create|build|of|from|new)")) @node
+
+; Builder class
+(class_declaration
+  name: (identifier) @name
+  (#match? @name "Builder")) @node
+
+; DI/framework annotations
+(marker_annotation
+  name: (identifier) @name
+  (#match? @name "^(Singleton|Component|Service|Repository|Controller|Bean)$")) @node