@winci/local-rag 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@winci/local-rag",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Semantic search for your codebase — local-first RAG MCP server with hybrid search, AST-aware chunking, and usage analytics",
   "type": "module",
   "license": "MIT",
@@ -41,7 +41,7 @@
   "dependencies": {
     "@huggingface/transformers": "^3.4.0",
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "code-chunk": "^0.1.13",
+    "@winci/bun-chunk": "^0.1.0",
     "gray-matter": "^4.0.3",
     "sqlite-vec": "^0.1.6",
     "zod": "^4.3.6"

package/src/indexing/chunker.ts

@@ -1,4 +1,4 @@
-import { chunk as astChunk } from "code-chunk";
+import { chunk as astChunk } from "@winci/bun-chunk";
 import { log } from "../utils/log";
 
 export interface ChunkImport {
@@ -97,18 +97,23 @@ async function _chunkText(
   // Try AST-aware chunking for supported code files (even small ones, for import/export extraction)
   if (AST_SUPPORTED.has(extension)) {
     try {
-      const astChunks = await astChunk(filePath || `file${extension}`, text, {
-        maxChunkSize: chunkSize,
-      });
+      const astChunks = await astChunk(filePath || `file${extension}`, text);
       if (astChunks.length > 0) {
-        return astChunks.map((c, i) => ({
-          text: c.text,
-          index: i,
-          imports: c.context.imports.map((im) => ({ name: im.name, source: im.source })),
-          exports: c.context.entities
-            .filter((e) => e.type === "export" || e.type === "function" || e.type === "class" || e.type === "interface" || e.type === "type" || e.type === "enum")
-            .map((e) => ({ name: e.name, type: e.type })),
-        }));
+        return astChunks.map((c, i) => {
+          const chunk: Chunk = {
+            text: c.text,
+            index: i,
+            startLine: c.startLine + 1, // bun-chunk is 0-indexed, local-rag is 1-indexed
+            endLine: c.endLine + 1,
+          };
+          if (c.type === "import") {
+            chunk.imports = parseImportText(c.text);
+          }
+          if (c.name && c.type !== "import" && c.type !== "block") {
+            chunk.exports = [{ name: c.name, type: c.type }];
+          }
+          return chunk;
+        });
       }
     } catch (err) {
       log.debug(`AST chunking failed for ${filePath || extension}, using heuristic: ${err instanceof Error ? err.message : err}`, "chunker");
@@ -201,6 +206,29 @@ function assignLineNumbers(chunks: Chunk[], fullText: string): void {
   }
 }
 
+/** Extract import name and source from an import statement text */
+function parseImportText(text: string): ChunkImport[] {
+  // Match: import { foo } from "bar" / import foo from "bar" / import * as foo from "bar"
+  const match = text.match(/from\s+["']([^"']+)["']/);
+  if (!match) {
+    // import "side-effect" or Python: import foo / from foo import bar
+    const pyImport = text.match(/^import\s+(\S+)/);
+    if (pyImport) return [{ name: pyImport[1], source: pyImport[1] }];
+    const pyFrom = text.match(/^from\s+(\S+)\s+import\s+(.+)/);
+    if (pyFrom) return [{ name: pyFrom[2].trim(), source: pyFrom[1] }];
+    // Go/Rust: use/import with path
+    const quotedPath = text.match(/["']([^"']+)["']/);
+    if (quotedPath) return [{ name: quotedPath[1].split("/").pop()!, source: quotedPath[1] }];
+    return [];
+  }
+  const source = match[1];
+  const nameMatch = text.match(/import\s+(?:\{([^}]+)\}|(\w+)|\*\s+as\s+(\w+))/);
+  const name = nameMatch
+    ? (nameMatch[1]?.trim() || nameMatch[2] || nameMatch[3] || source)
+    : source;
+  return [{ name, source }];
+}
+
 function splitMarkdown(text: string): string[] {
   // Split on heading boundaries (## or ###)
   const parts = text.split(/(?=^#{1,3}\s)/m);