brainbank 0.1.0

package/dist/chunk-EDKSKLX4.js

@@ -0,0 +1,490 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/indexers/code-indexer.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/indexers/chunker.ts
+var CodeChunker = class {
+  static {
+    __name(this, "CodeChunker");
+  }
+  MAX;
+  MIN;
+  OVERLAP;
+  constructor(config = {}) {
+    this.MAX = config.maxLines ?? 80;
+    this.MIN = config.minLines ?? 3;
+    this.OVERLAP = config.overlap ?? 5;
+  }
+  /**
+   * Split file content into semantic chunks.
+   * Small files (< maxLines) become a single chunk.
+   * For JS/TS/Python: detects functions and classes.
+   * For other languages: sliding window with overlap.
+   */
+  chunk(filePath, content, language) {
+    const lines = content.split("\n");
+    if (lines.length <= this.MAX) {
+      return [{
+        filePath,
+        chunkType: "file",
+        startLine: 1,
+        endLine: lines.length,
+        content: content.trim(),
+        language
+      }];
+    }
+    switch (language) {
+      case "typescript":
+      case "javascript":
+        return this._chunkJS(filePath, lines, language);
+      case "python":
+        return this._chunkPython(filePath, lines, language);
+      default:
+        return this._chunkGeneric(filePath, lines, language);
+    }
+  }
+  // ── JS / TS Strategy ────────────────────────────
+  _chunkJS(filePath, lines, language) {
+    const chunks = [];
+    const funcRe = /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/;
+    const constFuncRe = /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/;
+    const classRe = /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/;
+    const arrowRe = /^(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*(?::\s*\S+)?\s*=>/;
+    const interfaceRe = /^(?:export\s+)?(?:interface|type)\s+(\w+)/;
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i].trim();
+      const fm = line.match(funcRe) || line.match(constFuncRe) || line.match(arrowRe);
+      const cm = line.match(classRe);
+      const im = line.match(interfaceRe);
+      if (fm || cm || im) {
+        const name = fm?.[1] || cm?.[1] || im?.[1] || "default";
+        const type = cm ? "class" : im ? "interface" : "function";
+        const start = i;
+        const end = this._findBlockEnd(lines, i);
+        if (end - start >= this.MIN) {
+          if (end - start > this.MAX) {
+            chunks.push(...this._splitLarge(filePath, lines, start, end, name, type, language));
+          } else {
+            const content = lines.slice(start, end + 1).join("\n").trim();
+            chunks.push({
+              filePath,
+              chunkType: type,
+              name,
+              startLine: start + 1,
+              endLine: end + 1,
+              content,
+              language
+            });
+          }
+          i = end + 1;
+          continue;
+        }
+      }
+      i++;
+    }
+    if (chunks.length > 0) {
+      return chunks.filter((c) => c.content.length > 20);
+    }
+    return this._chunkGeneric(filePath, lines, language);
+  }
+  // ── Python Strategy ─────────────────────────────
+  _chunkPython(filePath, lines, language) {
+    const chunks = [];
+    let i = 0;
+    while (i < lines.length) {
+      const funcMatch = lines[i].match(/^(?:async\s+)?def\s+(\w+)/);
+      const classMatch = lines[i].match(/^class\s+(\w+)/);
+      if (funcMatch || classMatch) {
+        const name = funcMatch?.[1] || classMatch?.[1];
+        const type = classMatch ? "class" : "function";
+        const start = i;
+        const baseIndent = (lines[i].match(/^(\s*)/) ?? ["", ""])[1].length;
+        let end = i + 1;
+        while (end < lines.length) {
+          const line = lines[end];
+          if (line.trim() !== "") {
+            const indent = (line.match(/^(\s*)/) ?? ["", ""])[1].length;
+            if (indent <= baseIndent) break;
+          }
+          end++;
+        }
+        end = Math.min(end - 1, lines.length - 1);
+        if (end - start >= this.MIN) {
+          const content = lines.slice(start, end + 1).join("\n").trim();
+          chunks.push({
+            filePath,
+            chunkType: type,
+            name,
+            startLine: start + 1,
+            endLine: end + 1,
+            content,
+            language
+          });
+        }
+        i = end + 1;
+        continue;
+      }
+      i++;
+    }
+    return chunks.length > 0 ? chunks : this._chunkGeneric(filePath, lines, language);
+  }
+  // ── Generic Strategy (sliding window) ───────────
+  _chunkGeneric(filePath, lines, language) {
+    const chunks = [];
+    const step = this.MAX - this.OVERLAP;
+    for (let s = 0; s < lines.length; s += step) {
+      const e = Math.min(s + this.MAX, lines.length);
+      const content = lines.slice(s, e).join("\n").trim();
+      if (content.length > 20) {
+        chunks.push({
+          filePath,
+          chunkType: "block",
+          startLine: s + 1,
+          endLine: e,
+          content,
+          language
+        });
+      }
+      if (e >= lines.length) break;
+    }
+    return chunks;
+  }
+  // ── Block End Detection (brace balance) ─────────
+  _findBlockEnd(lines, start) {
+    let depth = 0;
+    let foundOpen = false;
+    for (let i = start; i < lines.length; i++) {
+      for (const c of lines[i]) {
+        if (c === "{") {
+          depth++;
+          foundOpen = true;
+        }
+        if (c === "}") depth--;
+      }
+      if (foundOpen && depth === 0) return i;
+    }
+    return Math.min(start + this.MAX, lines.length - 1);
+  }
+  // ── Split Large Blocks ──────────────────────────
+  _splitLarge(filePath, lines, start, end, name, type, language) {
+    const chunks = [];
+    const step = this.MAX - this.OVERLAP;
+    let part = 1;
+    for (let s = start; s <= end; s += step) {
+      const e = Math.min(s + this.MAX, end + 1);
+      const content = lines.slice(s, e).join("\n").trim();
+      chunks.push({
+        filePath,
+        chunkType: type,
+        name: `${name} (part ${part++})`,
+        startLine: s + 1,
+        endLine: e,
+        content,
+        language
+      });
+      if (e > end) break;
+    }
+    return chunks;
+  }
+};
+
+// src/indexers/languages.ts
+import path from "path";
+var SUPPORTED_EXTENSIONS = {
+  // TypeScript / JavaScript
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  // Systems
+  ".go": "go",
+  ".rs": "rust",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".hpp": "cpp",
+  // JVM
+  ".java": "java",
+  ".kt": "kotlin",
+  ".scala": "scala",
+  // Scripting
+  ".py": "python",
+  ".rb": "ruby",
+  ".php": "php",
+  ".lua": "lua",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  // Web
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".less": "less",
+  ".svelte": "svelte",
+  ".vue": "vue",
+  // Data / Config
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".xml": "xml",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  // Docs
+  ".md": "markdown",
+  ".mdx": "markdown",
+  // Database
+  ".sql": "sql",
+  ".prisma": "prisma",
+  // Other
+  ".swift": "swift",
+  ".dart": "dart",
+  ".r": "r",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".zig": "zig"
+};
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  // Package managers
+  "node_modules",
+  "bower_components",
+  ".pnpm",
+  // Build output
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".svelte-kit",
+  // Version control
+  ".git",
+  ".hg",
+  ".svn",
+  // IDE / Editor
+  ".idea",
+  ".vscode",
+  // Runtime / Cache
+  "__pycache__",
+  ".pytest_cache",
+  "venv",
+  ".venv",
+  ".env",
+  ".tox",
+  // Coverage / Test artifacts
+  "coverage",
+  ".nyc_output",
+  "htmlcov",
+  // Compiled
+  "target",
+  // Rust, Java
+  ".cargo",
+  "vendor",
+  // Go, PHP
+  // AI / Model cache
+  ".model-cache",
+  ".brainbank",
+  // OS
+  ".DS_Store"
+]);
+var IGNORE_FILES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  "composer.lock",
+  "go.sum"
+]);
+function isSupported(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext in SUPPORTED_EXTENSIONS;
+}
+__name(isSupported, "isSupported");
+function getLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return SUPPORTED_EXTENSIONS[ext];
+}
+__name(getLanguage, "getLanguage");
+function isIgnoredDir(dirName) {
+  return IGNORE_DIRS.has(dirName) || dirName.startsWith(".");
+}
+__name(isIgnoredDir, "isIgnoredDir");
+function isIgnoredFile(fileName) {
+  return IGNORE_FILES.has(fileName);
+}
+__name(isIgnoredFile, "isIgnoredFile");
+
+// src/indexers/code-indexer.ts
+var CodeIndexer = class {
+  static {
+    __name(this, "CodeIndexer");
+  }
+  _chunker = new CodeChunker();
+  _deps;
+  _repoPath;
+  _maxFileSize;
+  constructor(repoPath, deps, maxFileSize = 512e3) {
+    this._deps = deps;
+    this._repoPath = repoPath;
+    this._maxFileSize = maxFileSize;
+  }
+  /**
+   * Index all supported files in the repository.
+   * Skips unchanged files (same content hash).
+   */
+  async index(options = {}) {
+    const { forceReindex = false, onProgress } = options;
+    const files = this._walkRepo(this._repoPath);
+    let indexed = 0, skipped = 0, totalChunks = 0;
+    for (let i = 0; i < files.length; i++) {
+      const filePath = files[i];
+      const rel = path2.relative(this._repoPath, filePath);
+      onProgress?.(rel, i + 1, files.length);
+      let content;
+      try {
+        content = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const hash = this._hash(content);
+      const existing = this._deps.db.prepare(
+        "SELECT file_hash FROM indexed_files WHERE file_path = ?"
+      ).get(rel);
+      if (!forceReindex && existing?.file_hash === hash) {
+        skipped++;
+        continue;
+      }
+      if (existing) {
+        this._deps.db.prepare("DELETE FROM code_chunks WHERE file_path = ?").run(rel);
+      }
+      const ext = path2.extname(filePath).toLowerCase();
+      const language = SUPPORTED_EXTENSIONS[ext] ?? "text";
+      const chunks = this._chunker.chunk(rel, content, language);
+      for (const chunk of chunks) {
+        const text = [
+          `File: ${rel}`,
+          chunk.name ? `${chunk.chunkType}: ${chunk.name}` : chunk.chunkType,
+          chunk.content
+        ].join("\n");
+        const vec = await this._deps.embedding.embed(text);
+        const result = this._deps.db.prepare(
+          `INSERT INTO code_chunks (file_path, chunk_type, name, start_line, end_line, content, language, file_hash)
+                     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(rel, chunk.chunkType, chunk.name ?? null, chunk.startLine, chunk.endLine, chunk.content, language, hash);
+        const id = Number(result.lastInsertRowid);
+        this._deps.db.prepare(
+          "INSERT INTO code_vectors (chunk_id, embedding) VALUES (?, ?)"
+        ).run(id, Buffer.from(vec.buffer));
+        this._deps.hnsw.add(vec, id);
+        this._deps.vectorCache.set(id, vec);
+        totalChunks++;
+      }
+      this._deps.db.prepare(
+        "INSERT OR REPLACE INTO indexed_files (file_path, file_hash) VALUES (?, ?)"
+      ).run(rel, hash);
+      indexed++;
+    }
+    return { indexed, skipped, chunks: totalChunks };
+  }
+  // ── File Walker ─────────────────────────────────
+  _walkRepo(dir, files = []) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return files;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (isIgnoredDir(entry.name)) continue;
+        this._walkRepo(path2.join(dir, entry.name), files);
+      } else if (entry.isFile()) {
+        if (isIgnoredFile(entry.name)) continue;
+        const ext = path2.extname(entry.name).toLowerCase();
+        if (!(ext in SUPPORTED_EXTENSIONS)) continue;
+        const full = path2.join(dir, entry.name);
+        try {
+          if (fs.statSync(full).size <= this._maxFileSize) {
+            files.push(full);
+          }
+        } catch {
+        }
+      }
+    }
+    return files;
+  }
+  // ── FNV-1a Hash ─────────────────────────────────
+  _hash(content) {
+    let h = 2166136261;
+    for (let i = 0; i < content.length; i++) {
+      h ^= content.charCodeAt(i);
+      h = h * 16777619 >>> 0;
+    }
+    return h.toString(16);
+  }
+};
+
+// src/plugins/code.ts
+var CodeModuleImpl = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.name = opts.name ?? "code";
+  }
+  static {
+    __name(this, "CodeModuleImpl");
+  }
+  name;
+  hnsw;
+  indexer;
+  vecCache = /* @__PURE__ */ new Map();
+  async initialize(ctx) {
+    const shared = await ctx.getOrCreateSharedHnsw("code");
+    this.hnsw = shared.hnsw;
+    this.vecCache = shared.vecCache;
+    if (shared.isNew) {
+      ctx.loadVectors("code_vectors", "chunk_id", this.hnsw, this.vecCache);
+    }
+    const repoPath = this.opts.repoPath ?? ctx.config.repoPath;
+    this.indexer = new CodeIndexer(repoPath, {
+      db: ctx.db,
+      hnsw: this.hnsw,
+      vectorCache: this.vecCache,
+      embedding: ctx.embedding
+    }, this.opts.maxFileSize ?? ctx.config.maxFileSize);
+  }
+  async index(options = {}) {
+    return this.indexer.index(options);
+  }
+  stats() {
+    return { hnswSize: this.hnsw.size };
+  }
+};
+function code(opts) {
+  return new CodeModuleImpl(opts);
+}
+__name(code, "code");
+
+export {
+  SUPPORTED_EXTENSIONS,
+  IGNORE_DIRS,
+  isSupported,
+  getLanguage,
+  isIgnoredDir,
+  isIgnoredFile,
+  CodeChunker,
+  CodeIndexer,
+  code
+};
+//# sourceMappingURL=chunk-EDKSKLX4.js.map

package/dist/chunk-EDKSKLX4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/indexers/code-indexer.ts","../src/indexers/chunker.ts","../src/indexers/languages.ts","../src/plugins/code.ts"],"sourcesContent":["/**\n * BrainBank — Code Indexer\n * \n * Walks a repository, chunks source files semantically,\n * embeds each chunk, and stores in SQLite + HNSW.\n * Incremental: only re-indexes files that changed (by content hash).\n */\n\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { CodeChunker } from './chunker.ts';\nimport { SUPPORTED_EXTENSIONS, IGNORE_DIRS, isIgnoredDir, isIgnoredFile } from './languages.ts';\nimport type { Database } from '../storage/database.ts';\nimport type { EmbeddingProvider, ProgressCallback, IndexResult } from '../types.ts';\nimport type { HNSWIndex } from '../vector/hnsw.ts';\n\nexport interface CodeIndexerDeps {\n    db: Database;\n    hnsw: HNSWIndex;\n    vectorCache: Map<number, Float32Array>;\n    embedding: EmbeddingProvider;\n}\n\nexport interface CodeIndexOptions {\n    forceReindex?: boolean;\n    onProgress?: ProgressCallback;\n}\n\nexport class CodeIndexer {\n    private _chunker = new CodeChunker();\n    private _deps: CodeIndexerDeps;\n    private _repoPath: string;\n    private _maxFileSize: number;\n\n    constructor(repoPath: string, deps: CodeIndexerDeps, maxFileSize: number = 512_000) {\n        this._deps = deps;\n        this._repoPath = repoPath;\n        this._maxFileSize = maxFileSize;\n    }\n\n    /**\n     * Index all supported files in the repository.\n     * Skips unchanged files (same content hash).\n     */\n    async index(options: CodeIndexOptions = {}): Promise<IndexResult> {\n        const { forceReindex = false, onProgress } = options;\n        const files = this._walkRepo(this._repoPath);\n        let indexed = 0, skipped = 0, totalChunks = 0;\n\n        for (let i = 0; i < files.length; i++) {\n            const filePath = files[i];\n            const rel = path.relative(this._repoPath, filePath);\n            onProgress?.(rel, i + 1, files.length);\n\n            let content: string;\n            try { content = fs.readFileSync(filePath, 'utf-8'); }\n            catch { continue; }\n\n            const hash = this._hash(content);\n            const existing = this._deps.db.prepare(\n                'SELECT file_hash FROM indexed_files WHERE file_path = ?'\n            ).get(rel) as any;\n\n            if (!forceReindex && existing?.file_hash === hash) {\n                skipped++;\n                continue;\n            }\n\n            // Delete old chunks if re-indexing\n            if (existing) {\n                this._deps.db.prepare('DELETE FROM code_chunks WHERE file_path = ?').run(rel);\n            }\n\n            const ext = path.extname(filePath).toLowerCase();\n            const language = SUPPORTED_EXTENSIONS[ext] ?? 'text';\n            const chunks = this._chunker.chunk(rel, content, language);\n\n            for (const chunk of chunks) {\n                // Build embedding text with file context\n                const text = [\n                    `File: ${rel}`,\n                    chunk.name ? `${chunk.chunkType}: ${chunk.name}` : chunk.chunkType,\n                    chunk.content,\n                ].join('\\n');\n\n                const vec = await this._deps.embedding.embed(text);\n\n                const result = this._deps.db.prepare(\n                    `INSERT INTO code_chunks (file_path, chunk_type, name, start_line, end_line, content, language, file_hash)\n                     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`\n                ).run(rel, chunk.chunkType, chunk.name ?? null, chunk.startLine, chunk.endLine, chunk.content, language, hash);\n\n                const id = Number(result.lastInsertRowid);\n                this._deps.db.prepare(\n                    'INSERT INTO code_vectors (chunk_id, embedding) VALUES (?, ?)'\n                ).run(id, Buffer.from(vec.buffer));\n\n                this._deps.hnsw.add(vec, id);\n                this._deps.vectorCache.set(id, vec);\n                totalChunks++;\n            }\n\n            // Mark file as indexed\n            this._deps.db.prepare(\n                'INSERT OR REPLACE INTO indexed_files (file_path, file_hash) VALUES (?, ?)'\n            ).run(rel, hash);\n            indexed++;\n        }\n\n        return { indexed, skipped, chunks: totalChunks };\n    }\n\n    // ── File Walker ─────────────────────────────────\n\n    private _walkRepo(dir: string, files: string[] = []): string[] {\n        let entries: fs.Dirent[];\n        try { entries = fs.readdirSync(dir, { withFileTypes: true }); }\n        catch { return files; }\n\n        for (const entry of entries) {\n            if (entry.isDirectory()) {\n                if (isIgnoredDir(entry.name)) continue;\n                this._walkRepo(path.join(dir, entry.name), files);\n            } else if (entry.isFile()) {\n                if (isIgnoredFile(entry.name)) continue;\n                const ext = path.extname(entry.name).toLowerCase();\n                if (!(ext in SUPPORTED_EXTENSIONS)) continue;\n\n                const full = path.join(dir, entry.name);\n                try {\n                    if (fs.statSync(full).size <= this._maxFileSize) {\n                        files.push(full);\n                    }\n                } catch {}\n            }\n        }\n        return files;\n    }\n\n    // ── FNV-1a Hash ─────────────────────────────────\n\n    private _hash(content: string): string {\n        let h = 2166136261;\n        for (let i = 0; i < content.length; i++) {\n            h ^= content.charCodeAt(i);\n            h = (h * 16777619) >>> 0;\n        }\n        return h.toString(16);\n    }\n}\n","/**\n * BrainBank — Code Chunker\n * \n * Language-aware code splitting into semantic blocks.\n * Detects functions, classes, and methods using regex + brace balancing.\n * Falls back to sliding window for unsupported languages.\n */\n\nimport type { CodeChunk } from '../types.ts';\n\n// ── Configuration ───────────────────────────────────\n\nexport interface ChunkerConfig {\n    /** Max lines per chunk. Default: 80 */\n    maxLines?: number;\n    /** Min lines for a detected block to be a chunk. Default: 3 */\n    minLines?: number;\n    /** Overlap between adjacent generic chunks. Default: 5 */\n    overlap?: number;\n}\n\n// ── CodeChunker ─────────────────────────────────────\n\nexport class CodeChunker {\n    private MAX: number;\n    private MIN: number;\n    private OVERLAP: number;\n\n    constructor(config: ChunkerConfig = {}) {\n        this.MAX = config.maxLines ?? 80;\n        this.MIN = config.minLines ?? 3;\n        this.OVERLAP = config.overlap ?? 5;\n    }\n\n    /**\n     * Split file content into semantic chunks.\n     * Small files (< maxLines) become a single chunk.\n     * For JS/TS/Python: detects functions and classes.\n     * For other languages: sliding window with overlap.\n     */\n    chunk(filePath: string, content: string, language: string): CodeChunk[] {\n        const lines = content.split('\\n');\n\n        // Small file → single chunk\n        if (lines.length <= this.MAX) {\n            return [{\n                filePath,\n                chunkType: 'file',\n                startLine: 1,\n                endLine: lines.length,\n                content: content.trim(),\n                language,\n            }];\n        }\n\n        switch (language) {\n            case 'typescript':\n            case 'javascript':\n                return this._chunkJS(filePath, lines, language);\n            case 'python':\n                return this._chunkPython(filePath, lines, language);\n            default:\n                return this._chunkGeneric(filePath, lines, language);\n        }\n    }\n\n    // ── JS / TS Strategy ────────────────────────────\n\n    private _chunkJS(filePath: string, lines: string[], language: string): CodeChunk[] {\n        const chunks: CodeChunk[] = [];\n        const funcRe = /^(?:export\\s+)?(?:async\\s+)?function\\s+(\\w+)/;\n        const constFuncRe = /^(?:export\\s+)?(?:const|let|var)\\s+(\\w+)\\s*=\\s*(?:async\\s+)?\\(/;\n        const classRe = /^(?:export\\s+)?(?:abstract\\s+)?class\\s+(\\w+)/;\n        const arrowRe = /^(?:export\\s+)?(?:const|let)\\s+(\\w+)\\s*=\\s*(?:async\\s+)?\\([^)]*\\)\\s*(?::\\s*\\S+)?\\s*=>/;\n        const interfaceRe = /^(?:export\\s+)?(?:interface|type)\\s+(\\w+)/;\n\n        let i = 0;\n        while (i < lines.length) {\n            const line = lines[i].trim();\n            const fm = line.match(funcRe) || line.match(constFuncRe) || line.match(arrowRe);\n            const cm = line.match(classRe);\n            const im = line.match(interfaceRe);\n\n            if (fm || cm || im) {\n                const name = fm?.[1] || cm?.[1] || im?.[1] || 'default';\n                const type = cm ? 'class' : im ? 'interface' : 'function';\n                const start = i;\n                const end = this._findBlockEnd(lines, i);\n\n                if (end - start >= this.MIN) {\n                    if (end - start > this.MAX) {\n                        chunks.push(...this._splitLarge(filePath, lines, start, end, name, type, language));\n                    } else {\n                        const content = lines.slice(start, end + 1).join('\\n').trim();\n                        chunks.push({\n                            filePath,\n                            chunkType: type,\n                            name,\n                            startLine: start + 1,\n                            endLine: end + 1,\n                            content,\n                            language,\n                        });\n                    }\n                    i = end + 1;\n                    continue;\n                }\n            }\n            i++;\n        }\n\n        // If we found semantic chunks, filter noise and return\n        if (chunks.length > 0) {\n            return chunks.filter(c => c.content.length > 20);\n        }\n\n        // Fallback to generic\n        return this._chunkGeneric(filePath, lines, language);\n    }\n\n    // ── Python Strategy ─────────────────────────────\n\n    private _chunkPython(filePath: string, lines: string[], language: string): CodeChunk[] {\n        const chunks: CodeChunk[] = [];\n        let i = 0;\n\n        while (i < lines.length) {\n            const funcMatch = lines[i].match(/^(?:async\\s+)?def\\s+(\\w+)/);\n            const classMatch = lines[i].match(/^class\\s+(\\w+)/);\n\n            if (funcMatch || classMatch) {\n                const name = funcMatch?.[1] || classMatch?.[1]!;\n                const type = classMatch ? 'class' : 'function';\n                const start = i;\n                const baseIndent = (lines[i].match(/^(\\s*)/) ?? ['', ''])[1].length;\n\n                let end = i + 1;\n                while (end < lines.length) {\n                    const line = lines[end];\n                    if (line.trim() !== '') {\n                        const indent = (line.match(/^(\\s*)/) ?? ['', ''])[1].length;\n                        if (indent <= baseIndent) break;\n                    }\n                    end++;\n                }\n                end = Math.min(end - 1, lines.length - 1);\n\n                if (end - start >= this.MIN) {\n                    const content = lines.slice(start, end + 1).join('\\n').trim();\n                    chunks.push({\n                        filePath,\n                        chunkType: type,\n                        name,\n                        startLine: start + 1,\n                        endLine: end + 1,\n                        content,\n                        language,\n                    });\n                }\n                i = end + 1;\n                continue;\n            }\n            i++;\n        }\n\n        return chunks.length > 0 ? chunks : this._chunkGeneric(filePath, lines, language);\n    }\n\n    // ── Generic Strategy (sliding window) ───────────\n\n    private _chunkGeneric(filePath: string, lines: string[], language: string): CodeChunk[] {\n        const chunks: CodeChunk[] = [];\n        const step = this.MAX - this.OVERLAP;\n\n        for (let s = 0; s < lines.length; s += step) {\n            const e = Math.min(s + this.MAX, lines.length);\n            const content = lines.slice(s, e).join('\\n').trim();\n            if (content.length > 20) {\n                chunks.push({\n                    filePath,\n                    chunkType: 'block',\n                    startLine: s + 1,\n                    endLine: e,\n                    content,\n                    language,\n                });\n            }\n            if (e >= lines.length) break;\n        }\n\n        return chunks;\n    }\n\n    // ── Block End Detection (brace balance) ─────────\n\n    private _findBlockEnd(lines: string[], start: number): number {\n        let depth = 0;\n        let foundOpen = false;\n\n        for (let i = start; i < lines.length; i++) {\n            for (const c of lines[i]) {\n                if (c === '{') { depth++; foundOpen = true; }\n                if (c === '}') depth--;\n            }\n            if (foundOpen && depth === 0) return i;\n        }\n\n        // No brace-balanced end found — take up to MAX lines\n        return Math.min(start + this.MAX, lines.length - 1);\n    }\n\n    // ── Split Large Blocks ──────────────────────────\n\n    private _splitLarge(\n        filePath: string,\n        lines: string[],\n        start: number,\n        end: number,\n        name: string,\n        type: string,\n        language: string,\n    ): CodeChunk[] {\n        const chunks: CodeChunk[] = [];\n        const step = this.MAX - this.OVERLAP;\n        let part = 1;\n\n        for (let s = start; s <= end; s += step) {\n            const e = Math.min(s + this.MAX, end + 1);\n            const content = lines.slice(s, e).join('\\n').trim();\n            chunks.push({\n                filePath,\n                chunkType: type,\n                name: `${name} (part ${part++})`,\n                startLine: s + 1,\n                endLine: e,\n                content,\n                language,\n            });\n            if (e > end) break;\n        }\n\n        return chunks;\n    }\n}\n","/**\n * BrainBank — Language Registry\n * \n * Supported file extensions, language mappings, and ignore lists.\n * Controls which files get indexed and how they're chunked.\n */\n\n// ── Supported Extensions ────────────────────────────\n\nexport const SUPPORTED_EXTENSIONS: Record<string, string> = {\n    // TypeScript / JavaScript\n    '.ts': 'typescript',\n    '.tsx': 'typescript',\n    '.js': 'javascript',\n    '.jsx': 'javascript',\n    '.mjs': 'javascript',\n    '.cjs': 'javascript',\n\n    // Systems\n    '.go': 'go',\n    '.rs': 'rust',\n    '.cpp': 'cpp',\n    '.cc': 'cpp',\n    '.c': 'c',\n    '.h': 'c',\n    '.hpp': 'cpp',\n\n    // JVM\n    '.java': 'java',\n    '.kt': 'kotlin',\n    '.scala': 'scala',\n\n    // Scripting\n    '.py': 'python',\n    '.rb': 'ruby',\n    '.php': 'php',\n    '.lua': 'lua',\n    '.sh': 'bash',\n    '.bash': 'bash',\n    '.zsh': 'bash',\n\n    // Web\n    '.html': 'html',\n    '.css': 'css',\n    '.scss': 'scss',\n    '.less': 'less',\n    '.svelte': 'svelte',\n    '.vue': 'vue',\n\n    // Data / Config\n    '.json': 'json',\n    '.yaml': 'yaml',\n    '.yml': 'yaml',\n    '.toml': 'toml',\n    '.xml': 'xml',\n    '.graphql': 'graphql',\n    '.gql': 'graphql',\n\n    // Docs\n    '.md': 'markdown',\n    '.mdx': 'markdown',\n\n    // Database\n    '.sql': 'sql',\n    '.prisma': 'prisma',\n\n    // Other\n    '.swift': 'swift',\n    '.dart': 'dart',\n    '.r': 'r',\n    '.ex': 'elixir',\n    '.exs': 'elixir',\n    '.erl': 'erlang',\n    '.zig': 'zig',\n};\n\n// ── Ignore Directories ──────────────────────────────\n\nexport const IGNORE_DIRS = new Set([\n    // Package managers\n    'node_modules',\n    'bower_components',\n    '.pnpm',\n\n    // Build output\n    'dist',\n    'build',\n    'out',\n    '.next',\n    '.nuxt',\n    '.output',\n    '.svelte-kit',\n\n    // Version control\n    '.git',\n    '.hg',\n    '.svn',\n\n    // IDE / Editor\n    '.idea',\n    '.vscode',\n\n    // Runtime / Cache\n    '__pycache__',\n    '.pytest_cache',\n    'venv',\n    '.venv',\n    '.env',\n    '.tox',\n\n    // Coverage / Test artifacts\n    'coverage',\n    '.nyc_output',\n    'htmlcov',\n\n    // Compiled\n    'target',     // Rust, Java\n    '.cargo',\n    'vendor',     // Go, PHP\n\n    // AI / Model cache\n    '.model-cache',\n    '.brainbank',\n\n    // OS\n    '.DS_Store',\n]);\n\n// ── Ignore Files ────────────────────────────────────\n\nexport const IGNORE_FILES = new Set([\n    'package-lock.json',\n    'yarn.lock',\n    'pnpm-lock.yaml',\n    'bun.lockb',\n    'Cargo.lock',\n    'Gemfile.lock',\n    'poetry.lock',\n    'composer.lock',\n    'go.sum',\n]);\n\n// ── Helpers ─────────────────────────────────────────\n\nimport path from 'node:path';\n\n/** Check if a file extension is supported for indexing. */\nexport function isSupported(filePath: string): boolean {\n    const ext = path.extname(filePath).toLowerCase();\n    return ext in SUPPORTED_EXTENSIONS;\n}\n\n/** Get the language name for a file. Returns undefined if not supported. */\nexport function getLanguage(filePath: string): string | undefined {\n    const ext = path.extname(filePath).toLowerCase();\n    return SUPPORTED_EXTENSIONS[ext];\n}\n\n/** Check if a directory name should be ignored. */\nexport function isIgnoredDir(dirName: string): boolean {\n    return IGNORE_DIRS.has(dirName) || dirName.startsWith('.');\n}\n\n/** Check if a filename should be ignored. */\nexport function isIgnoredFile(fileName: string): boolean {\n    return IGNORE_FILES.has(fileName);\n}\n","/**\n * BrainBank — Code Module\n * \n * Language-aware code indexing for 30+ languages.\n * \n *   import { BrainBank } from 'brainbank';\n *   import { code } from 'brainbank/code';\n *   \n *   const brain = new BrainBank().use(code({ repoPath: '.' }));\n *   \n *   // Multi-repo: namespace to avoid key collisions\n *   brain\n *     .use(code({ repoPath: './frontend', name: 'code:frontend' }))\n *     .use(code({ repoPath: './backend',  name: 'code:backend' }));\n */\n\nimport type { BrainBankModule, ModuleContext } from './types.ts';\nimport type { HNSWIndex } from '../vector/hnsw.ts';\nimport { CodeIndexer } from '../indexers/code-indexer.ts';\nimport type { IndexResult, ProgressCallback } from '../types.ts';\n\nexport interface CodeModuleOptions {\n    /** Repository path to index. Default: '.' */\n    repoPath?: string;\n    /** Maximum file size in bytes. Default: from config */\n    maxFileSize?: number;\n    /** Custom indexer name for multi-repo (e.g. 'code:frontend'). Default: 'code' */\n    name?: string;\n}\n\nclass CodeModuleImpl implements BrainBankModule {\n    readonly name: string;\n    hnsw!: HNSWIndex;\n    indexer!: CodeIndexer;\n    vecCache = new Map<number, Float32Array>();\n\n    constructor(private opts: CodeModuleOptions = {}) {\n        this.name = opts.name ?? 'code';\n    }\n\n    async initialize(ctx: ModuleContext): Promise<void> {\n        // Use shared HNSW so all code indexers (code, code:frontend, etc.) share one index\n        const shared = await ctx.getOrCreateSharedHnsw('code');\n        this.hnsw = shared.hnsw;\n        this.vecCache = shared.vecCache;\n\n        // Only load vectors once (first code indexer to initialize)\n        if (shared.isNew) {\n            ctx.loadVectors('code_vectors', 'chunk_id', this.hnsw, this.vecCache);\n        }\n\n        const repoPath = this.opts.repoPath ?? ctx.config.repoPath;\n        this.indexer = new CodeIndexer(repoPath, {\n            db: ctx.db,\n            hnsw: this.hnsw,\n            vectorCache: this.vecCache,\n            embedding: ctx.embedding,\n        }, this.opts.maxFileSize ?? ctx.config.maxFileSize);\n    }\n\n    async index(options: {\n        forceReindex?: boolean;\n        onProgress?: ProgressCallback;\n    } = {}): Promise<IndexResult> {\n        return this.indexer.index(options);\n    }\n\n    stats(): Record<string, any> {\n        return { hnswSize: this.hnsw.size };\n    }\n}\n\n/** Create a code indexing module. */\nexport function code(opts?: CodeModuleOptions): BrainBankModule {\n    return new CodeModuleImpl(opts);\n}\n"],"mappings":"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","names":["path","path"]}