@winci/local-rag 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@winci/local-rag",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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/cli/setup.ts

@@ -2,7 +2,7 @@ import { existsSync } from "fs";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { join, resolve } from "path";
 import { createInterface } from "readline";
-import { writeDefaultConfig } from "../config";
+import { loadConfig } from "../config";
 
 const MARKER = "<!-- local-rag -->";
 
@@ -69,7 +69,8 @@ export interface SetupResult {
 export async function ensureConfig(projectDir: string): Promise<string | null> {
   const configPath = join(projectDir, ".rag", "config.json");
   if (existsSync(configPath)) return null;
-  await writeDefaultConfig(projectDir);
+  // loadConfig auto-creates the file with defaults if missing
+  await loadConfig(projectDir);
   return "Created .rag/config.json";
 }
 

package/src/config/index.ts

@@ -23,28 +23,40 @@ export type RagConfig = z.infer<typeof RagConfigSchema>;
 
 const DEFAULT_CONFIG: RagConfig = {
   include: [
+    // Source code — AST-aware chunking
+    "**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx",
+    "**/*.py",
+    "**/*.go",
+    "**/*.rs",
+    "**/*.java",
+    // Source code — heuristic chunking
+    "**/*.c", "**/*.cpp", "**/*.h", "**/*.hpp",
+    "**/*.rb",
+    "**/*.swift",
     // Markdown & plain text
-    "**/*.md", "**/*.txt",
+    "**/*.md", "**/*.mdx", "**/*.markdown", "**/*.txt",
     // Build / task runners (no extension or prefix-named)
     "**/Makefile", "**/makefile", "**/GNUmakefile",
     "**/Dockerfile", "**/Dockerfile.*",
     "**/Jenkinsfile", "**/Jenkinsfile.*",
     "**/Vagrantfile", "**/Gemfile", "**/Rakefile",
     "**/Brewfile", "**/Procfile",
+    // Shell & scripting
+    "**/*.sh", "**/*.bash", "**/*.zsh", "**/*.fish",
     // Structured data & config
     "**/*.yaml", "**/*.yml",
     "**/*.json",
     "**/*.toml",
     "**/*.xml",
-    // Shell & scripting
-    "**/*.sh", "**/*.bash", "**/*.zsh",
     // Infrastructure / schema languages
     "**/*.tf",
     "**/*.proto",
     "**/*.graphql", "**/*.gql",
     "**/*.sql",
     "**/*.mod",
+    // API collections
     "**/*.bru",
+    // Stylesheets
     "**/*.css", "**/*.scss", "**/*.less",
   ],
   exclude: ["node_modules/**", ".git/**", "dist/**", ".rag/**"],
@@ -60,28 +72,30 @@ const DEFAULT_CONFIG: RagConfig = {
 };
 
 /**
- * Load config from .rag/config.json, merged with defaults.
- * Note: array fields (include, exclude) from user config *replace* the defaults
- * entirely — they are not merged. This lets users fully control which files are indexed.
+ * Load config from .rag/config.json.
+ * If the file doesn't exist, writes the defaults there first so users can
+ * edit the file directly — no hidden merge logic, what's on disk is what runs.
  */
 export async function loadConfig(projectDir: string): Promise<RagConfig> {
-  const configPath = join(projectDir, ".rag", "config.json");
+  const ragDir = join(projectDir, ".rag");
+  const configPath = join(ragDir, "config.json");
 
   if (!existsSync(configPath)) {
+    await mkdir(ragDir, { recursive: true });
+    await writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
     return { ...DEFAULT_CONFIG };
   }
 
   const raw = await readFile(configPath, "utf-8");
-  let userConfig: unknown;
+  let parsed: unknown;
   try {
-    userConfig = JSON.parse(raw);
+    parsed = JSON.parse(raw);
   } catch {
     log.warn(`Invalid JSON in ${configPath}, using defaults`, "config");
     return { ...DEFAULT_CONFIG };
   }
 
-  const merged = { ...DEFAULT_CONFIG, ...(userConfig as Record<string, unknown>) };
-  const result = RagConfigSchema.safeParse(merged);
+  const result = RagConfigSchema.safeParse(parsed);
 
   if (!result.success) {
     const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
@@ -91,11 +105,3 @@ export async function loadConfig(projectDir: string): Promise<RagConfig> {
 
   return result.data;
 }
-
-export async function writeDefaultConfig(projectDir: string): Promise<string> {
-  const ragDir = join(projectDir, ".rag");
-  await mkdir(ragDir, { recursive: true });
-  const configPath = join(ragDir, "config.json");
-  await writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
-  return configPath;
-}

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);