raggrep 0.1.4 → 0.1.6

package/dist/index.js

@@ -76,7 +76,8 @@ var init_config = __esm(() => {
     ".go",
     ".rs",
     ".java",
-    ".md"
+    ".md",
+    ".txt"
   ];
 });
 
@@ -89,20 +90,40 @@ var init_entities = __esm(() => {
 // src/infrastructure/config/configLoader.ts
 import * as path from "path";
 import * as fs from "fs/promises";
-function getRaggrepDir(rootDir, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir);
+import * as os from "os";
+import * as crypto from "crypto";
+function hashPath(inputPath) {
+  return crypto.createHash("sha256").update(inputPath).digest("hex").slice(0, 12);
+}
+function getRaggrepDir(rootDir, _config = DEFAULT_CONFIG) {
+  const absoluteRoot = path.resolve(rootDir);
+  const projectHash = hashPath(absoluteRoot);
+  return path.join(RAGGREP_TEMP_BASE, projectHash);
+}
+function getIndexLocation(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  const projectHash = hashPath(absoluteRoot);
+  return {
+    indexDir: path.join(RAGGREP_TEMP_BASE, projectHash),
+    projectRoot: absoluteRoot,
+    projectHash
+  };
 }
 function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "index", moduleId);
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "index", moduleId);
 }
 function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "index", moduleId, "manifest.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "index", moduleId, "manifest.json");
 }
 function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "manifest.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "manifest.json");
 }
 function getConfigPath(rootDir, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "config.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "config.json");
 }
 async function loadConfig(rootDir) {
   const configPath = getConfigPath(rootDir, DEFAULT_CONFIG);
@@ -129,10 +150,11 @@ function getEmbeddingConfigFromModule(moduleConfig) {
     showProgress: options.showProgress !== false
   };
 }
-var DEFAULT_CONFIG, EMBEDDING_MODELS;
+var DEFAULT_CONFIG, RAGGREP_TEMP_BASE, EMBEDDING_MODELS;
 var init_configLoader = __esm(() => {
   init_entities();
   DEFAULT_CONFIG = createDefaultConfig();
+  RAGGREP_TEMP_BASE = path.join(os.tmpdir(), "raggrep-indexes");
   EMBEDDING_MODELS = {
     "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
     "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
@@ -248,1932 +270,2763 @@ function normalizeScore(score, midpoint = 5) {
 }
 var BM25_K1 = 1.5, BM25_B = 0.75;
 
-// src/modules/core/symbols.ts
-function extractSymbols(content) {
-  const symbols = [];
-  const seenSymbols = new Set;
-  const lines = content.split(`
-`);
-  for (const { type, pattern, exported } of SYMBOL_PATTERNS) {
-    pattern.lastIndex = 0;
-    let match;
-    while ((match = pattern.exec(content)) !== null) {
-      const name = match[1];
-      const symbolKey = `${name}:${type}`;
-      if (seenSymbols.has(symbolKey))
+// src/introspection/projectDetector.ts
+import * as path2 from "path";
+import * as fs2 from "fs/promises";
+function detectScopeFromName(name) {
+  const nameLower = name.toLowerCase();
+  for (const [scope, keywords] of Object.entries(SCOPE_KEYWORDS)) {
+    if (scope === "unknown")
+      continue;
+    for (const keyword of keywords) {
+      if (nameLower.includes(keyword)) {
+        return scope;
+      }
+    }
+  }
+  return "unknown";
+}
+async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
+  if (depth > MAX_SCAN_DEPTH)
+    return [];
+  const results = [];
+  const fullDir = currentDir ? path2.join(rootDir, currentDir) : rootDir;
+  try {
+    const entries = await fs2.readdir(fullDir, { withFileTypes: true });
+    const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
+    if (hasPackageJson && currentDir) {
+      const info = await parsePackageJson(rootDir, currentDir);
+      if (info) {
+        results.push(info);
+      }
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
         continue;
-      seenSymbols.add(symbolKey);
-      const beforeMatch = content.substring(0, match.index);
-      const line = beforeMatch.split(`
-`).length;
-      symbols.push({
-        name,
-        type,
-        line,
-        isExported: exported
-      });
+      if (SKIP_DIRS.has(entry.name))
+        continue;
+      const subPath = currentDir ? `${currentDir}/${entry.name}` : entry.name;
+      const subResults = await scanForPackageJsons(rootDir, subPath, depth + 1);
+      results.push(...subResults);
+    }
+  } catch {}
+  return results;
+}
+async function parsePackageJson(rootDir, relativePath) {
+  try {
+    const packageJsonPath = path2.join(rootDir, relativePath, "package.json");
+    const content = await fs2.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const name = pkg.name || path2.basename(relativePath);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    let type = "unknown";
+    if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
+      type = "app";
+    } else if (deps["express"] || deps["fastify"] || deps["koa"] || deps["hono"]) {
+      type = "service";
+    } else if (pkg.main || pkg.exports) {
+      type = "library";
     }
+    const hasWorkspaces = Boolean(pkg.workspaces);
+    return { name, relativePath, type, hasWorkspaces };
+  } catch {
+    return null;
   }
-  return symbols.sort((a, b) => a.line - b.line);
 }
-function symbolsToKeywords(symbols) {
-  const keywords = new Set;
-  for (const symbol of symbols) {
-    keywords.add(symbol.name.toLowerCase());
-    const parts = symbol.name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
-    for (const part of parts) {
-      if (part.length > 2) {
-        keywords.add(part);
+async function detectProjectStructure(rootDir) {
+  const projectMap = new Map;
+  let isMonorepo = false;
+  try {
+    const entries = await fs2.readdir(rootDir, { withFileTypes: true });
+    const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    const monorepoPatterns = ["apps", "packages", "libs", "services"];
+    const hasMonorepoStructure = monorepoPatterns.some((p) => dirNames.includes(p));
+    if (hasMonorepoStructure) {
+      isMonorepo = true;
+      for (const pattern of monorepoPatterns) {
+        if (!dirNames.includes(pattern))
+          continue;
+        const patternDir = path2.join(rootDir, pattern);
+        try {
+          const subDirs = await fs2.readdir(patternDir, { withFileTypes: true });
+          for (const subDir of subDirs) {
+            if (!subDir.isDirectory())
+              continue;
+            const projectRoot = `${pattern}/${subDir.name}`;
+            const type = getProjectType(pattern);
+            projectMap.set(projectRoot, {
+              name: subDir.name,
+              root: projectRoot,
+              type
+            });
+          }
+        } catch {}
+      }
+    }
+    const packageJsons = await scanForPackageJsons(rootDir);
+    for (const pkg of packageJsons) {
+      if (pkg.hasWorkspaces) {
+        isMonorepo = true;
+      }
+      if (packageJsons.length > 1) {
+        isMonorepo = true;
+      }
+      projectMap.set(pkg.relativePath, {
+        name: pkg.name,
+        root: pkg.relativePath,
+        type: pkg.type
+      });
+    }
+    let rootType = "unknown";
+    try {
+      const rootPkgPath = path2.join(rootDir, "package.json");
+      const rootPkg = JSON.parse(await fs2.readFile(rootPkgPath, "utf-8"));
+      if (rootPkg.workspaces) {
+        isMonorepo = true;
+      }
+      const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
+      if (deps["next"] || deps["react"] || deps["vue"]) {
+        rootType = "app";
+      } else if (deps["express"] || deps["fastify"] || deps["koa"]) {
+        rootType = "service";
       }
+    } catch {}
+    const projects = Array.from(projectMap.values()).sort((a, b) => a.root.length - b.root.length);
+    return {
+      projects,
+      isMonorepo,
+      rootType: isMonorepo ? undefined : rootType
+    };
+  } catch {
+    return {
+      projects: [],
+      isMonorepo: false,
+      rootType: "unknown"
+    };
+  }
+}
+function getProjectType(patternDir) {
+  switch (patternDir) {
+    case "apps":
+      return "app";
+    case "packages":
+    case "libs":
+      return "library";
+    case "services":
+      return "service";
+    case "scripts":
+    case "tools":
+      return "script";
+    default:
+      return "unknown";
+  }
+}
+function findProjectForFile(filepath, structure) {
+  const normalizedPath = filepath.replace(/\\/g, "/");
+  const matches = [];
+  for (const project of structure.projects) {
+    if (normalizedPath === project.root || normalizedPath.startsWith(project.root + "/")) {
+      matches.push(project);
     }
   }
-  return Array.from(keywords);
+  if (matches.length > 0) {
+    return matches.reduce((best, current) => current.root.length > best.root.length ? current : best);
+  }
+  for (const { pattern, type } of PROJECT_PATTERNS) {
+    const match = normalizedPath.match(pattern);
+    if (match) {
+      return {
+        name: match[1],
+        root: match[0],
+        type
+      };
+    }
+  }
+  return {
+    name: "root",
+    root: "",
+    type: structure.rootType ?? "unknown"
+  };
 }
-var SYMBOL_PATTERNS;
-var init_symbols = __esm(() => {
-  SYMBOL_PATTERNS = [
+var MAX_SCAN_DEPTH = 4, SKIP_DIRS, PROJECT_PATTERNS, SCOPE_KEYWORDS;
+var init_projectDetector = __esm(() => {
+  SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    "coverage",
+    ".raggrep"
+  ]);
+  PROJECT_PATTERNS = [
+    { pattern: /^apps\/([^/]+)/, type: "app", defaultScope: "unknown" },
+    { pattern: /^packages\/([^/]+)/, type: "library", defaultScope: "shared" },
+    { pattern: /^libs\/([^/]+)/, type: "library", defaultScope: "shared" },
+    { pattern: /^services\/([^/]+)/, type: "service", defaultScope: "backend" },
+    { pattern: /^scripts\/([^/]+)/, type: "script", defaultScope: "tooling" },
+    { pattern: /^tools\/([^/]+)/, type: "script", defaultScope: "tooling" }
+  ];
+  SCOPE_KEYWORDS = {
+    frontend: [
+      "web",
+      "webapp",
+      "frontend",
+      "client",
+      "ui",
+      "app",
+      "mobile",
+      "react",
+      "vue",
+      "angular",
+      "next",
+      "nuxt"
+    ],
+    backend: [
+      "api",
+      "server",
+      "backend",
+      "service",
+      "worker",
+      "lambda",
+      "functions"
+    ],
+    shared: ["shared", "common", "utils", "lib", "core", "types", "models"],
+    tooling: [
+      "scripts",
+      "tools",
+      "cli",
+      "devtools",
+      "build",
+      "config",
+      "infra"
+    ],
+    unknown: []
+  };
+});
+
+// src/introspection/conventions/entryPoints.ts
+import * as path3 from "path";
+function getParentFolder(filepath) {
+  const dir = path3.dirname(filepath);
+  return path3.basename(dir);
+}
+var entryPointConventions;
+var init_entryPoints = __esm(() => {
+  entryPointConventions = [
     {
-      type: "function",
-      pattern: /^export\s+(?:async\s+)?function\s+(\w+)/gm,
-      exported: true
+      id: "index-file",
+      name: "Index/Barrel File",
+      description: "Module entry point that typically re-exports from other files",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return /^index\.(ts|tsx|js|jsx|mjs|cjs)$/.test(filename);
+      },
+      keywords: ["entry", "barrel", "exports", "module"],
+      dynamicKeywords: (filepath) => {
+        const parent = getParentFolder(filepath);
+        if (["src", "lib", "dist", "build", ".", ""].includes(parent)) {
+          return [];
+        }
+        return [parent.toLowerCase()];
+      }
     },
     {
-      type: "function",
-      pattern: /^export\s+(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/gm,
-      exported: true
+      id: "main-file",
+      name: "Main Entry Point",
+      description: "Application main entry point",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return /^main\.(ts|tsx|js|jsx|mjs|cjs)$/.test(filename);
+      },
+      keywords: ["entry", "main", "entrypoint", "bootstrap", "startup"]
     },
     {
-      type: "class",
-      pattern: /^export\s+(?:abstract\s+)?class\s+(\w+)/gm,
-      exported: true
+      id: "app-component",
+      name: "Root App Component",
+      description: "Root application component (React, Vue, etc.)",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return /^App\.(tsx|jsx|vue|svelte)$/.test(filename);
+      },
+      keywords: ["root", "app", "application", "component", "main"]
     },
     {
-      type: "interface",
-      pattern: /^export\s+interface\s+(\w+)/gm,
-      exported: true
+      id: "deno-mod",
+      name: "Deno Module Entry",
+      description: "Deno module entry point",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "mod.ts";
+      },
+      keywords: ["entry", "module", "deno", "exports"],
+      dynamicKeywords: (filepath) => {
+        const parent = getParentFolder(filepath);
+        if (["src", "lib", ".", ""].includes(parent)) {
+          return [];
+        }
+        return [parent.toLowerCase()];
+      }
     },
     {
-      type: "type",
-      pattern: /^export\s+type\s+(\w+)/gm,
-      exported: true
+      id: "python-init",
+      name: "Python Package Init",
+      description: "Python package initialization file",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "__init__.py";
+      },
+      keywords: ["entry", "package", "init", "python", "module"],
+      dynamicKeywords: (filepath) => {
+        const parent = getParentFolder(filepath);
+        if (["src", "lib", ".", ""].includes(parent)) {
+          return [];
+        }
+        return [parent.toLowerCase()];
+      }
     },
     {
-      type: "enum",
-      pattern: /^export\s+(?:const\s+)?enum\s+(\w+)/gm,
-      exported: true
+      id: "rust-lib",
+      name: "Rust Library Entry",
+      description: "Rust library crate entry point",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "lib.rs" || filename === "main.rs";
+      },
+      keywords: ["entry", "crate", "rust", "module"]
+    }
+  ];
+});
+
+// src/introspection/conventions/configFiles.ts
+var configFileConventions;
+var init_configFiles = __esm(() => {
+  configFileConventions = [
+    {
+      id: "package-json",
+      name: "Package.json",
+      description: "Node.js package manifest",
+      category: "configuration",
+      match: (filepath, filename) => filename === "package.json",
+      keywords: ["package", "dependencies", "npm", "scripts", "manifest", "node"]
     },
     {
-      type: "variable",
-      pattern: /^export\s+(?:const|let|var)\s+(\w+)\s*(?::|=)/gm,
-      exported: true
+      id: "pnpm-workspace",
+      name: "PNPM Workspace",
+      description: "PNPM monorepo workspace configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "pnpm-workspace.yaml" || filename === "pnpm-workspace.yml",
+      keywords: ["workspace", "monorepo", "pnpm", "packages"]
     },
     {
-      type: "function",
-      pattern: /^export\s+default\s+(?:async\s+)?function\s+(\w+)/gm,
-      exported: true
+      id: "yarn-lock",
+      name: "Yarn Lock",
+      description: "Yarn dependency lock file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "yarn.lock",
+      keywords: ["dependencies", "lock", "yarn", "versions"]
     },
     {
-      type: "class",
-      pattern: /^export\s+default\s+class\s+(\w+)/gm,
-      exported: true
+      id: "package-lock",
+      name: "Package Lock",
+      description: "NPM dependency lock file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "package-lock.json",
+      keywords: ["dependencies", "lock", "npm", "versions"]
     },
     {
-      type: "function",
-      pattern: /^(?:async\s+)?function\s+(\w+)/gm,
-      exported: false
+      id: "bun-lockb",
+      name: "Bun Lock",
+      description: "Bun dependency lock file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "bun.lockb" || filename === "bun.lock",
+      keywords: ["dependencies", "lock", "bun", "versions"]
     },
     {
-      type: "function",
-      pattern: /^(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/gm,
-      exported: false
+      id: "tsconfig",
+      name: "TypeScript Config",
+      description: "TypeScript compiler configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "tsconfig.json" || filename.startsWith("tsconfig.") && filename.endsWith(".json"),
+      keywords: [
+        "typescript",
+        "config",
+        "compiler",
+        "ts",
+        "settings",
+        "paths",
+        "types"
+      ]
     },
     {
-      type: "class",
-      pattern: /^(?:abstract\s+)?class\s+(\w+)/gm,
-      exported: false
+      id: "jsconfig",
+      name: "JavaScript Config",
+      description: "JavaScript project configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "jsconfig.json",
+      keywords: ["javascript", "config", "compiler", "js", "settings", "paths"]
     },
     {
-      type: "interface",
-      pattern: /^interface\s+(\w+)/gm,
-      exported: false
+      id: "eslint-config",
+      name: "ESLint Config",
+      description: "ESLint linting configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".eslintrc" || filename === ".eslintrc.js" || filename === ".eslintrc.cjs" || filename === ".eslintrc.json" || filename === ".eslintrc.yml" || filename === ".eslintrc.yaml" || filename === "eslint.config.js" || filename === "eslint.config.mjs" || filename === "eslint.config.cjs",
+      keywords: ["eslint", "linting", "lint", "rules", "code quality"]
     },
     {
-      type: "type",
-      pattern: /^type\s+(\w+)/gm,
-      exported: false
+      id: "prettier-config",
+      name: "Prettier Config",
+      description: "Prettier code formatting configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".prettierrc" || filename === ".prettierrc.js" || filename === ".prettierrc.cjs" || filename === ".prettierrc.json" || filename === ".prettierrc.yml" || filename === ".prettierrc.yaml" || filename === "prettier.config.js" || filename === "prettier.config.cjs" || filename === "prettier.config.mjs",
+      keywords: ["prettier", "formatting", "format", "code style", "style"]
     },
     {
-      type: "enum",
-      pattern: /^(?:const\s+)?enum\s+(\w+)/gm,
-      exported: false
+      id: "biome-config",
+      name: "Biome Config",
+      description: "Biome linting and formatting configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "biome.json" || filename === "biome.jsonc",
+      keywords: ["biome", "linting", "formatting", "lint", "format"]
     },
     {
-      type: "function",
-      pattern: /^def\s+(\w+)\s*\(/gm,
-      exported: false
+      id: "vite-config",
+      name: "Vite Config",
+      description: "Vite build tool configuration",
+      category: "build",
+      match: (filepath, filename) => filename === "vite.config.ts" || filename === "vite.config.js" || filename === "vite.config.mjs",
+      keywords: ["vite", "bundler", "build", "dev server", "hmr"]
     },
     {
-      type: "class",
-      pattern: /^class\s+(\w+)(?:\s*\(|:)/gm,
-      exported: false
+      id: "webpack-config",
+      name: "Webpack Config",
+      description: "Webpack bundler configuration",
+      category: "build",
+      match: (filepath, filename) => filename === "webpack.config.js" || filename === "webpack.config.ts" || filename.startsWith("webpack.") && (filename.endsWith(".js") || filename.endsWith(".ts")),
+      keywords: ["webpack", "bundler", "build", "loaders", "plugins"]
     },
     {
-      type: "function",
-      pattern: /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/gm,
-      exported: false
+      id: "rollup-config",
+      name: "Rollup Config",
+      description: "Rollup bundler configuration",
+      category: "build",
+      match: (filepath, filename) => filename === "rollup.config.js" || filename === "rollup.config.ts" || filename === "rollup.config.mjs",
+      keywords: ["rollup", "bundler", "build", "esm", "bundle"]
     },
     {
-      type: "type",
-      pattern: /^type\s+(\w+)\s+(?:struct|interface)/gm,
-      exported: false
+      id: "esbuild-config",
+      name: "esbuild Config",
+      description: "esbuild bundler configuration",
+      category: "build",
+      match: (filepath, filename) => filename === "esbuild.config.js" || filename === "esbuild.config.ts" || filename === "esbuild.config.mjs",
+      keywords: ["esbuild", "bundler", "build", "fast"]
     },
     {
-      type: "function",
-      pattern: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm,
-      exported: false
+      id: "jest-config",
+      name: "Jest Config",
+      description: "Jest testing framework configuration",
+      category: "test",
+      match: (filepath, filename) => filename === "jest.config.js" || filename === "jest.config.ts" || filename === "jest.config.mjs" || filename === "jest.config.cjs" || filename === "jest.config.json",
+      keywords: ["jest", "testing", "test", "unit test", "config"]
     },
     {
-      type: "type",
-      pattern: /^(?:pub\s+)?struct\s+(\w+)/gm,
-      exported: false
+      id: "vitest-config",
+      name: "Vitest Config",
+      description: "Vitest testing framework configuration",
+      category: "test",
+      match: (filepath, filename) => filename === "vitest.config.ts" || filename === "vitest.config.js" || filename === "vitest.config.mts",
+      keywords: ["vitest", "testing", "test", "unit test", "config"]
     },
     {
-      type: "enum",
-      pattern: /^(?:pub\s+)?enum\s+(\w+)/gm,
-      exported: false
+      id: "playwright-config",
+      name: "Playwright Config",
+      description: "Playwright E2E testing configuration",
+      category: "test",
+      match: (filepath, filename) => filename === "playwright.config.ts" || filename === "playwright.config.js",
+      keywords: ["playwright", "testing", "e2e", "end-to-end", "browser test"]
     },
     {
-      type: "interface",
-      pattern: /^(?:pub\s+)?trait\s+(\w+)/gm,
-      exported: false
+      id: "cypress-config",
+      name: "Cypress Config",
+      description: "Cypress E2E testing configuration",
+      category: "test",
+      match: (filepath, filename) => filename === "cypress.config.ts" || filename === "cypress.config.js" || filename === "cypress.json",
+      keywords: ["cypress", "testing", "e2e", "end-to-end", "browser test"]
+    },
+    {
+      id: "tailwind-config",
+      name: "Tailwind Config",
+      description: "Tailwind CSS configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "tailwind.config.js" || filename === "tailwind.config.ts" || filename === "tailwind.config.cjs" || filename === "tailwind.config.mjs",
+      keywords: ["tailwind", "css", "styling", "utility", "design"]
+    },
+    {
+      id: "postcss-config",
+      name: "PostCSS Config",
+      description: "PostCSS configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "postcss.config.js" || filename === "postcss.config.cjs" || filename === "postcss.config.mjs" || filename === ".postcssrc" || filename === ".postcssrc.json",
+      keywords: ["postcss", "css", "styling", "transforms"]
+    },
+    {
+      id: "env-file",
+      name: "Environment File",
+      description: "Environment variables file",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".env" || filename === ".env.local" || filename === ".env.development" || filename === ".env.production" || filename === ".env.test" || filename.startsWith(".env."),
+      keywords: ["environment", "env", "variables", "secrets", "config"]
+    },
+    {
+      id: "env-example",
+      name: "Environment Example",
+      description: "Example environment variables file",
+      category: "documentation",
+      match: (filepath, filename) => filename === ".env.example" || filename === ".env.sample" || filename === ".env.template",
+      keywords: ["environment", "env", "example", "template", "setup"]
+    },
+    {
+      id: "dockerfile",
+      name: "Dockerfile",
+      description: "Docker container image definition",
+      category: "deployment",
+      match: (filepath, filename) => filename === "Dockerfile" || filename.startsWith("Dockerfile."),
+      keywords: ["docker", "container", "image", "deployment", "build"]
+    },
+    {
+      id: "docker-compose",
+      name: "Docker Compose",
+      description: "Docker Compose multi-container configuration",
+      category: "deployment",
+      match: (filepath, filename) => filename === "docker-compose.yml" || filename === "docker-compose.yaml" || filename === "compose.yml" || filename === "compose.yaml" || filename.startsWith("docker-compose."),
+      keywords: ["docker", "compose", "containers", "services", "deployment"]
+    },
+    {
+      id: "github-actions",
+      name: "GitHub Actions Workflow",
+      description: "GitHub Actions CI/CD workflow",
+      category: "deployment",
+      match: (filepath) => filepath.includes(".github/workflows/") && filepath.endsWith(".yml"),
+      keywords: ["github", "actions", "ci", "cd", "workflow", "automation"]
+    },
+    {
+      id: "vercel-config",
+      name: "Vercel Config",
+      description: "Vercel deployment configuration",
+      category: "deployment",
+      match: (filepath, filename) => filename === "vercel.json",
+      keywords: ["vercel", "deployment", "hosting", "serverless"]
+    },
+    {
+      id: "netlify-config",
+      name: "Netlify Config",
+      description: "Netlify deployment configuration",
+      category: "deployment",
+      match: (filepath, filename) => filename === "netlify.toml",
+      keywords: ["netlify", "deployment", "hosting", "functions"]
+    },
+    {
+      id: "gitignore",
+      name: "Git Ignore",
+      description: "Git ignored files configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".gitignore",
+      keywords: ["git", "ignore", "version control", "excluded"]
+    },
+    {
+      id: "gitattributes",
+      name: "Git Attributes",
+      description: "Git file attributes configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".gitattributes",
+      keywords: ["git", "attributes", "version control", "line endings"]
+    },
+    {
+      id: "readme",
+      name: "README",
+      description: "Project documentation",
+      category: "documentation",
+      match: (filepath, filename) => filename.toLowerCase() === "readme.md" || filename.toLowerCase() === "readme",
+      keywords: [
+        "readme",
+        "documentation",
+        "docs",
+        "overview",
+        "getting started"
+      ]
+    },
+    {
+      id: "changelog",
+      name: "Changelog",
+      description: "Project changelog",
+      category: "documentation",
+      match: (filepath, filename) => filename.toLowerCase() === "changelog.md" || filename.toLowerCase() === "changelog",
+      keywords: ["changelog", "changes", "releases", "history", "versions"]
+    },
+    {
+      id: "contributing",
+      name: "Contributing Guide",
+      description: "Contribution guidelines",
+      category: "documentation",
+      match: (filepath, filename) => filename.toLowerCase() === "contributing.md" || filename.toLowerCase() === "contributing",
+      keywords: ["contributing", "contribution", "guidelines", "development"]
+    },
+    {
+      id: "license",
+      name: "License",
+      description: "Project license",
+      category: "documentation",
+      match: (filepath, filename) => filename.toLowerCase() === "license" || filename.toLowerCase() === "license.md" || filename.toLowerCase() === "license.txt",
+      keywords: ["license", "legal", "copyright", "terms"]
     }
   ];
 });
 
-// src/modules/core/index.ts
-var exports_core = {};
-__export(exports_core, {
-  CoreModule: () => CoreModule
+// src/introspection/conventions/frameworks/nextjs.ts
+var nextjsConventions, nextjsFramework;
+var init_nextjs = __esm(() => {
+  nextjsConventions = [
+    {
+      id: "next-config",
+      name: "Next.js Config",
+      description: "Next.js framework configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "next.config.js" || filename === "next.config.mjs" || filename === "next.config.ts",
+      keywords: ["nextjs", "next", "config", "framework", "settings"]
+    },
+    {
+      id: "next-env",
+      name: "Next.js Environment Types",
+      description: "Next.js TypeScript environment declarations",
+      category: "types",
+      match: (filepath, filename) => filename === "next-env.d.ts",
+      keywords: ["nextjs", "types", "typescript", "declarations"]
+    },
+    {
+      id: "next-layout",
+      name: "Next.js Layout",
+      description: "Next.js layout component (App Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "layout.tsx" || filename === "layout.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "layout", "wrapper", "template", "app router"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/app\/(.+?)\/layout\./);
+        if (match) {
+          const segments = match[1].split("/").filter((s) => !s.startsWith("(") && !s.startsWith("["));
+          return segments.map((s) => s.toLowerCase());
+        }
+        if (filepath === "app/layout.tsx" || filepath === "app/layout.js") {
+          return ["root", "main"];
+        }
+        return [];
+      }
+    },
+    {
+      id: "next-page",
+      name: "Next.js Page",
+      description: "Next.js page component (App Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "page.tsx" || filename === "page.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "page", "route", "view", "app router"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/app\/(.+?)\/page\./);
+        if (match) {
+          const segments = match[1].split("/").filter((s) => !s.startsWith("(")).map((s) => s.replace(/^\[(.+?)\]$/, "$1"));
+          return segments.map((s) => s.toLowerCase());
+        }
+        if (filepath === "app/page.tsx" || filepath === "app/page.js") {
+          return ["home", "index", "root"];
+        }
+        return [];
+      }
+    },
+    {
+      id: "next-loading",
+      name: "Next.js Loading",
+      description: "Next.js loading UI component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "loading.tsx" || filename === "loading.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "loading", "suspense", "skeleton", "spinner"]
+    },
+    {
+      id: "next-error",
+      name: "Next.js Error",
+      description: "Next.js error boundary component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "error.tsx" || filename === "error.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "error", "boundary", "fallback", "catch"]
+    },
+    {
+      id: "next-not-found",
+      name: "Next.js Not Found",
+      description: "Next.js 404 page component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "not-found.tsx" || filename === "not-found.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "404", "not found", "missing", "error"]
+    },
+    {
+      id: "next-template",
+      name: "Next.js Template",
+      description: "Next.js template component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "template.tsx" || filename === "template.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "template", "wrapper", "app router"]
+    },
+    {
+      id: "next-route-handler",
+      name: "Next.js Route Handler",
+      description: "Next.js API route handler (App Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "route.ts" || filename === "route.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "api", "route", "handler", "endpoint", "rest"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/app\/api\/(.+?)\/route\./);
+        if (match) {
+          const segments = match[1].split("/").filter((s) => !s.startsWith("(")).map((s) => s.replace(/^\[(.+?)\]$/, "$1"));
+          return ["api", ...segments.map((s) => s.toLowerCase())];
+        }
+        return ["api"];
+      }
+    },
+    {
+      id: "next-middleware",
+      name: "Next.js Middleware",
+      description: "Next.js edge middleware",
+      category: "framework",
+      match: (filepath, filename) => filename === "middleware.ts" || filename === "middleware.js",
+      keywords: ["nextjs", "middleware", "edge", "request", "interceptor"]
+    },
+    {
+      id: "next-global-error",
+      name: "Next.js Global Error",
+      description: "Next.js global error handler",
+      category: "framework",
+      match: (filepath, filename) => filename === "global-error.tsx" || filename === "global-error.js",
+      keywords: ["nextjs", "error", "global", "boundary", "catch"]
+    },
+    {
+      id: "next-pages-api",
+      name: "Next.js API Route (Pages)",
+      description: "Next.js API route (Pages Router)",
+      category: "framework",
+      match: (filepath) => filepath.includes("/pages/api/") || filepath.startsWith("pages/api/"),
+      keywords: ["nextjs", "api", "route", "handler", "endpoint", "pages router"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/pages\/api\/(.+?)\.(ts|js)/);
+        if (match) {
+          const segments = match[1].split("/").map((s) => s.replace(/^\[(.+?)\]$/, "$1"));
+          return ["api", ...segments.map((s) => s.toLowerCase())];
+        }
+        return ["api"];
+      }
+    },
+    {
+      id: "next-pages-document",
+      name: "Next.js Document",
+      description: "Next.js custom document (Pages Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "_document.tsx" || filename === "_document.js") && (filepath.includes("/pages/") || filepath.startsWith("pages/")),
+      keywords: ["nextjs", "document", "html", "head", "body", "pages router"]
+    },
+    {
+      id: "next-pages-app",
+      name: "Next.js App (Pages)",
+      description: "Next.js custom app (Pages Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "_app.tsx" || filename === "_app.js") && (filepath.includes("/pages/") || filepath.startsWith("pages/")),
+      keywords: ["nextjs", "app", "wrapper", "provider", "pages router"]
+    }
+  ];
+  nextjsFramework = {
+    id: "nextjs",
+    name: "Next.js",
+    detect: (filepath) => {
+      return filepath === "next.config.js" || filepath === "next.config.mjs" || filepath === "next.config.ts" || filepath.includes("/app/page.") || filepath.includes("/pages/_app.");
+    },
+    conventions: nextjsConventions
+  };
 });
-import * as path2 from "path";
-import * as fs2 from "fs/promises";
 
-class CoreModule {
-  id = "core";
-  name = "Core Search";
-  description = "Language-agnostic text search with symbol extraction";
-  version = "1.0.0";
-  symbolIndex = new Map;
-  bm25Index = null;
-  rootDir = "";
-  async initialize(_config) {}
-  async indexFile(filepath, content, ctx) {
-    this.rootDir = ctx.rootDir;
-    const symbols = extractSymbols(content);
-    const symbolKeywords = symbolsToKeywords(symbols);
-    const contentTokens = tokenize(content);
-    const allTokens = [...new Set([...contentTokens, ...symbolKeywords])];
-    const chunks = this.createChunks(filepath, content, symbols);
-    const stats = await ctx.getFileStats(filepath);
-    this.symbolIndex.set(filepath, {
-      filepath,
-      symbols,
-      tokens: allTokens
-    });
-    const moduleData = {
-      symbols,
-      tokens: allTokens
-    };
-    return {
-      filepath,
-      lastModified: stats.lastModified,
-      chunks,
-      moduleData
-    };
-  }
-  createChunks(filepath, content, symbols) {
-    const lines = content.split(`
-`);
-    const chunks = [];
-    for (let start = 0;start < lines.length; start += LINES_PER_CHUNK - CHUNK_OVERLAP) {
-      const end = Math.min(start + LINES_PER_CHUNK, lines.length);
-      const chunkLines = lines.slice(start, end);
-      const chunkContent = chunkLines.join(`
-`);
-      const chunkSymbols = symbols.filter((s) => s.line >= start + 1 && s.line <= end);
-      let chunkType = "block";
-      let chunkName;
-      let isExported = false;
-      if (chunkSymbols.length > 0) {
-        const primarySymbol = chunkSymbols[0];
-        chunkType = this.symbolTypeToChunkType(primarySymbol.type);
-        chunkName = primarySymbol.name;
-        isExported = primarySymbol.isExported;
+// src/introspection/conventions/frameworks/convex.ts
+var convexConventions, convexFramework;
+var init_convex = __esm(() => {
+  convexConventions = [
+    {
+      id: "convex-config",
+      name: "Convex Config",
+      description: "Convex project configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "convex.json",
+      keywords: ["convex", "config", "backend", "settings"]
+    },
+    {
+      id: "convex-schema",
+      name: "Convex Schema",
+      description: "Convex database schema definition",
+      category: "framework",
+      match: (filepath, filename) => filename === "schema.ts" && (filepath.includes("/convex/") || filepath.startsWith("convex/")),
+      keywords: ["convex", "schema", "database", "tables", "types", "model"]
+    },
+    {
+      id: "convex-function",
+      name: "Convex Function File",
+      description: "Convex backend function file",
+      category: "framework",
+      match: (filepath, filename, extension) => (extension === ".ts" || extension === ".js") && (filepath.includes("/convex/") || filepath.startsWith("convex/")) && !filepath.includes("/_generated/") && filename !== "schema.ts" && !filename.startsWith("_"),
+      keywords: ["convex", "function", "backend", "query", "mutation", "action"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/convex\/(.+?)\.(ts|js)/);
+        if (match) {
+          const name = match[1].replace(/\//g, " ").split(" ").pop() || "";
+          if (name && !["schema", "http", "crons"].includes(name)) {
+            return [name.toLowerCase()];
+          }
+        }
+        return [];
       }
-      const chunkId = `${filepath}:${start + 1}-${end}`;
-      chunks.push({
-        id: chunkId,
-        content: chunkContent,
-        startLine: start + 1,
-        endLine: end,
-        type: chunkType,
-        name: chunkName,
-        isExported
-      });
-      if (end >= lines.length)
-        break;
-    }
-    return chunks;
-  }
-  symbolTypeToChunkType(symbolType) {
-    switch (symbolType) {
-      case "function":
-      case "method":
-        return "function";
-      case "class":
-        return "class";
-      case "interface":
-        return "interface";
-      case "type":
-        return "type";
-      case "enum":
-        return "enum";
-      case "variable":
-        return "variable";
-      default:
-        return "block";
+    },
+    {
+      id: "convex-http",
+      name: "Convex HTTP Routes",
+      description: "Convex HTTP endpoint definitions",
+      category: "framework",
+      match: (filepath, filename) => filename === "http.ts" && (filepath.includes("/convex/") || filepath.startsWith("convex/")),
+      keywords: ["convex", "http", "routes", "api", "endpoints", "rest"]
+    },
+    {
+      id: "convex-crons",
+      name: "Convex Cron Jobs",
+      description: "Convex scheduled function definitions",
+      category: "framework",
+      match: (filepath, filename) => filename === "crons.ts" && (filepath.includes("/convex/") || filepath.startsWith("convex/")),
+      keywords: [
+        "convex",
+        "crons",
+        "scheduled",
+        "jobs",
+        "background",
+        "recurring"
+      ]
+    },
+    {
+      id: "convex-generated",
+      name: "Convex Generated",
+      description: "Convex auto-generated files",
+      category: "framework",
+      match: (filepath) => filepath.includes("/convex/_generated/") || filepath.startsWith("convex/_generated/"),
+      keywords: ["convex", "generated", "types", "api"]
+    },
+    {
+      id: "convex-auth",
+      name: "Convex Auth",
+      description: "Convex authentication configuration",
+      category: "framework",
+      match: (filepath, filename) => filename === "auth.ts" && (filepath.includes("/convex/") || filepath.startsWith("convex/")),
+      keywords: ["convex", "auth", "authentication", "login", "users"]
+    },
+    {
+      id: "convex-auth-config",
+      name: "Convex Auth Config",
+      description: "Convex auth configuration file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "auth.config.ts",
+      keywords: ["convex", "auth", "config", "providers", "oauth"]
     }
+  ];
+  convexFramework = {
+    id: "convex",
+    name: "Convex",
+    detect: (filepath) => {
+      return filepath === "convex.json" || filepath.startsWith("convex/") || filepath.includes("/convex/");
+    },
+    conventions: convexConventions
+  };
+});
+
+// src/introspection/conventions/frameworks/index.ts
+function getAllFrameworkConventions() {
+  return frameworkProviders.flatMap((f) => f.conventions);
+}
+var frameworkProviders;
+var init_frameworks = __esm(() => {
+  init_nextjs();
+  init_convex();
+  init_nextjs();
+  init_convex();
+  frameworkProviders = [
+    nextjsFramework,
+    convexFramework
+  ];
+});
+
+// src/introspection/conventions/index.ts
+import * as path4 from "path";
+function getAllConventions() {
+  return [
+    ...entryPointConventions,
+    ...configFileConventions,
+    ...getAllFrameworkConventions()
+  ];
+}
+function getConventions() {
+  return [
+    ...getAllConventions(),
+    ...typeDefinitionConventions,
+    ...testFileConventions
+  ];
+}
+function getConventionKeywords(filepath) {
+  const conventions = getConventions();
+  const filename = path4.basename(filepath);
+  const extension = path4.extname(filepath);
+  const keywords = new Set;
+  for (const convention of conventions) {
+    try {
+      if (convention.match(filepath, filename, extension)) {
+        for (const keyword of convention.keywords) {
+          keywords.add(keyword.toLowerCase());
+        }
+        if (convention.dynamicKeywords) {
+          const dynamicKws = convention.dynamicKeywords(filepath);
+          for (const kw of dynamicKws) {
+            if (kw && kw.length > 1) {
+              keywords.add(kw.toLowerCase());
+            }
+          }
+        }
+      }
+    } catch {}
   }
-  async finalize(ctx) {
-    const config = ctx.config;
-    const coreDir = path2.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
-    await fs2.mkdir(coreDir, { recursive: true });
-    this.bm25Index = new BM25Index;
-    for (const [filepath, entry] of this.symbolIndex) {
-      this.bm25Index.addDocument(filepath, entry.tokens);
+  return Array.from(keywords);
+}
+var typeDefinitionConventions, testFileConventions;
+var init_conventions = __esm(() => {
+  init_entryPoints();
+  init_configFiles();
+  init_frameworks();
+  init_entryPoints();
+  init_configFiles();
+  init_frameworks();
+  typeDefinitionConventions = [
+    {
+      id: "dts-file",
+      name: "TypeScript Declaration",
+      description: "TypeScript type declaration file",
+      category: "types",
+      match: (filepath, filename) => filename.endsWith(".d.ts"),
+      keywords: ["types", "declarations", "typescript", "definitions"]
+    },
+    {
+      id: "types-file",
+      name: "Types File",
+      description: "TypeScript types file",
+      category: "types",
+      match: (filepath, filename) => filename.endsWith(".types.ts") || filename === "types.ts",
+      keywords: ["types", "definitions", "typescript", "interfaces"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/([^/]+)\.types\.ts$/);
+        if (match) {
+          return [match[1].toLowerCase()];
+        }
+        return [];
+      }
+    },
+    {
+      id: "types-folder",
+      name: "Types Folder File",
+      description: "File in a types folder",
+      category: "types",
+      match: (filepath) => filepath.includes("/types/") || filepath.startsWith("types/"),
+      keywords: ["types", "definitions"]
     }
-    const symbolIndexData = {
-      version: this.version,
-      lastUpdated: new Date().toISOString(),
-      files: Object.fromEntries(this.symbolIndex),
-      bm25Data: this.bm25Index.serialize()
-    };
-    await fs2.writeFile(path2.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
-    console.log(`  [Core] Symbol index built with ${this.symbolIndex.size} files`);
-  }
-  async search(query, ctx, options) {
-    const config = ctx.config;
-    const topK = options?.topK ?? DEFAULT_TOP_K;
-    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
-    if (this.symbolIndex.size === 0) {
-      await this.loadSymbolIndex(ctx.rootDir, config);
-    }
-    if (!this.bm25Index || this.symbolIndex.size === 0) {
-      return [];
-    }
-    const queryTokens = tokenize(query);
-    const bm25Results = this.bm25Index.search(query, topK * 2);
-    const bm25Scores = new Map(bm25Results.map((r) => [r.id, r.score]));
-    const symbolMatches = this.findSymbolMatches(queryTokens);
-    const results = [];
-    for (const filepath of this.symbolIndex.keys()) {
-      const entry = this.symbolIndex.get(filepath);
-      const bm25Score = bm25Scores.get(filepath) ?? 0;
-      const symbolScore = symbolMatches.get(filepath) ?? 0;
-      if (bm25Score === 0 && symbolScore === 0)
-        continue;
-      const combinedScore = 0.6 * normalizeScore(bm25Score) + 0.4 * symbolScore;
-      if (combinedScore >= minScore) {
-        const fileIndex = await ctx.loadFileIndex(filepath);
-        if (!fileIndex)
-          continue;
-        const bestChunk = this.findBestChunk(fileIndex.chunks, queryTokens, entry.symbols);
-        results.push({
-          filepath,
-          chunk: bestChunk,
-          score: combinedScore,
-          moduleId: this.id,
-          context: {
-            bm25Score: normalizeScore(bm25Score),
-            symbolScore
-          }
-        });
+  ];
+  testFileConventions = [
+    {
+      id: "test-file",
+      name: "Test File",
+      description: "Unit/integration test file",
+      category: "test",
+      match: (filepath, filename) => filename.includes(".test.") || filename.includes(".spec.") || filename.includes("_test."),
+      keywords: ["test", "spec", "unit test"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/([^/]+)\.(test|spec)\./);
+        if (match) {
+          return [match[1].toLowerCase()];
+        }
+        return [];
       }
+    },
+    {
+      id: "test-folder",
+      name: "Test Folder File",
+      description: "File in a test folder",
+      category: "test",
+      match: (filepath) => filepath.includes("/__tests__/") || filepath.includes("/test/") || filepath.includes("/tests/") || filepath.startsWith("__tests__/") || filepath.startsWith("test/") || filepath.startsWith("tests/"),
+      keywords: ["test", "testing"]
     }
-    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  ];
+});
+
+// src/introspection/fileIntrospector.ts
+import * as path5 from "path";
+function introspectFile(filepath, structure, fileContent) {
+  const normalizedPath = filepath.replace(/\\/g, "/");
+  const segments = normalizedPath.split("/").filter((s) => s.length > 0);
+  const filename = segments[segments.length - 1] || "";
+  const ext = path5.extname(filename);
+  const project = findProjectForFile(normalizedPath, structure);
+  const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
+  const layer = detectLayer(segments, filename);
+  const domain = detectDomain(segments);
+  const scope = detectScope(segments, project, layer);
+  let framework;
+  if (fileContent) {
+    framework = detectFramework(fileContent);
   }
-  findSymbolMatches(queryTokens) {
-    const matches = new Map;
-    for (const [filepath, entry] of this.symbolIndex) {
-      let matchScore = 0;
-      for (const symbol of entry.symbols) {
-        const symbolName = symbol.name.toLowerCase();
-        const symbolParts = symbolsToKeywords([symbol]);
-        for (const token of queryTokens) {
-          if (symbolName === token) {
-            matchScore += symbol.isExported ? 1 : 0.8;
-          } else if (symbolName.includes(token) || token.includes(symbolName)) {
-            matchScore += symbol.isExported ? 0.5 : 0.4;
-          } else if (symbolParts.some((p) => p === token)) {
-            matchScore += symbol.isExported ? 0.3 : 0.2;
-          }
-        }
-      }
-      if (matchScore > 0) {
-        matches.set(filepath, Math.min(1, matchScore / queryTokens.length));
+  return {
+    filepath: normalizedPath,
+    project,
+    scope,
+    layer,
+    domain,
+    language,
+    framework,
+    depth: segments.length - 1,
+    pathSegments: segments.slice(0, -1)
+  };
+}
+function detectLayer(segments, filename) {
+  const filenameLower = filename.toLowerCase();
+  for (const [layer, patterns] of Object.entries(LAYER_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (filenameLower.includes(pattern)) {
+        return layer;
       }
     }
-    return matches;
   }
-  findBestChunk(chunks, queryTokens, symbols) {
-    let bestChunk = chunks[0];
-    let bestScore = 0;
-    for (const chunk of chunks) {
-      let score = 0;
-      const chunkContent = chunk.content.toLowerCase();
-      for (const token of queryTokens) {
-        if (chunkContent.includes(token)) {
-          score += 1;
-        }
-      }
-      if (chunk.name) {
-        const nameLower = chunk.name.toLowerCase();
-        for (const token of queryTokens) {
-          if (nameLower.includes(token)) {
-            score += 2;
-          }
-        }
-      }
-      if (chunk.isExported) {
-        score += 0.5;
-      }
-      if (score > bestScore) {
-        bestScore = score;
-        bestChunk = chunk;
+  for (let i = segments.length - 2;i >= 0; i--) {
+    const segment = segments[i].toLowerCase();
+    for (const [layer, patterns] of Object.entries(LAYER_PATTERNS)) {
+      if (patterns.includes(segment)) {
+        return layer;
       }
     }
-    return bestChunk;
   }
-  async loadSymbolIndex(rootDir, config) {
-    const coreDir = path2.join(getRaggrepDir(rootDir, config), "index", "core");
-    const symbolsPath = path2.join(coreDir, "symbols.json");
-    try {
-      const content = await fs2.readFile(symbolsPath, "utf-8");
-      const data = JSON.parse(content);
-      this.symbolIndex = new Map(Object.entries(data.files));
-      if (data.bm25Data) {
-        this.bm25Index = BM25Index.deserialize(data.bm25Data);
+  return;
+}
+function detectDomain(segments) {
+  const skipSegments = new Set([
+    "src",
+    "lib",
+    "app",
+    "apps",
+    "packages",
+    "services",
+    "modules",
+    "features",
+    ...Object.values(LAYER_PATTERNS).flat()
+  ]);
+  for (const segment of segments) {
+    const segmentLower = segment.toLowerCase();
+    if (skipSegments.has(segmentLower))
+      continue;
+    if (DOMAIN_PATTERNS.includes(segmentLower)) {
+      return segmentLower;
+    }
+    for (const domain of DOMAIN_PATTERNS) {
+      if (segmentLower.startsWith(domain) || segmentLower.endsWith(domain)) {
+        return domain;
       }
-    } catch (error) {
-      this.symbolIndex = new Map;
-      this.bm25Index = null;
     }
   }
-  async dispose() {
-    this.symbolIndex.clear();
-    this.bm25Index = null;
-  }
+  return;
 }
-var DEFAULT_MIN_SCORE = 0.1, DEFAULT_TOP_K = 20, LINES_PER_CHUNK = 50, CHUNK_OVERLAP = 10;
-var init_core = __esm(() => {
-  init_config2();
-  init_symbols();
-});
-
-// src/infrastructure/embeddings/transformersEmbedding.ts
-import { pipeline, env } from "@xenova/transformers";
-import * as path3 from "path";
-import * as os from "os";
-
-class TransformersEmbeddingProvider {
-  pipeline = null;
-  config;
-  isInitializing = false;
-  initPromise = null;
-  constructor(config) {
-    this.config = {
-      model: config?.model ?? "all-MiniLM-L6-v2",
-      showProgress: config?.showProgress ?? true
-    };
+function detectScope(segments, project, layer) {
+  const projectScope = detectScopeFromName(project.name);
+  if (projectScope !== "unknown") {
+    return projectScope;
   }
-  async initialize(config) {
-    if (config) {
-      if (config.model !== this.config.model) {
-        this.pipeline = null;
-      }
-      this.config = { ...this.config, ...config };
+  if (layer) {
+    switch (layer) {
+      case "controller":
+      case "repository":
+      case "middleware":
+        return "backend";
+      case "presentation":
+        return "frontend";
+      case "util":
+      case "model":
+        return "shared";
+      case "test":
+        return "tooling";
     }
-    await this.ensurePipeline();
   }
-  async ensurePipeline() {
-    if (this.pipeline) {
-      return;
+  for (const segment of segments) {
+    const segmentLower = segment.toLowerCase();
+    if (["server", "api", "backend"].includes(segmentLower)) {
+      return "backend";
     }
-    if (this.isInitializing && this.initPromise) {
-      return this.initPromise;
+    if (["client", "web", "frontend", "ui"].includes(segmentLower)) {
+      return "frontend";
     }
-    this.isInitializing = true;
-    this.initPromise = (async () => {
-      const modelId = EMBEDDING_MODELS2[this.config.model];
-      if (this.config.showProgress) {
-        console.log(`
-  Loading embedding model: ${this.config.model}`);
-        console.log(`  Cache: ${CACHE_DIR}`);
+    if (["shared", "common", "lib", "libs"].includes(segmentLower)) {
+      return "shared";
+    }
+  }
+  return "unknown";
+}
+function detectFramework(content) {
+  for (const [framework, indicators] of Object.entries(FRAMEWORK_INDICATORS)) {
+    for (const indicator of indicators) {
+      if (content.includes(`from '${indicator}`) || content.includes(`from "${indicator}`) || content.includes(`require('${indicator}`) || content.includes(`require("${indicator}`)) {
+        return framework;
       }
-      try {
-        this.pipeline = await pipeline("feature-extraction", modelId, {
-          progress_callback: this.config.showProgress ? (progress) => {
-            if (progress.status === "progress" && progress.file) {
-              const pct = progress.progress ? Math.round(progress.progress) : 0;
-              process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
-            } else if (progress.status === "done" && progress.file) {
-              process.stdout.write(`\r  Downloaded ${progress.file}              
-`);
-            }
-          } : undefined
-        });
-        if (this.config.showProgress) {
-          console.log(`  Model ready.
-`);
-        }
-      } catch (error) {
-        this.pipeline = null;
-        throw new Error(`Failed to load embedding model: ${error}`);
-      } finally {
-        this.isInitializing = false;
-        this.initPromise = null;
-      }
-    })();
-    return this.initPromise;
-  }
-  async getEmbedding(text) {
-    await this.ensurePipeline();
-    if (!this.pipeline) {
-      throw new Error("Embedding pipeline not initialized");
     }
-    const output = await this.pipeline(text, {
-      pooling: "mean",
-      normalize: true
-    });
-    return Array.from(output.data);
   }
-  async getEmbeddings(texts) {
-    if (texts.length === 0)
-      return [];
-    await this.ensurePipeline();
-    if (!this.pipeline) {
-      throw new Error("Embedding pipeline not initialized");
-    }
-    const results = [];
-    for (let i = 0;i < texts.length; i += BATCH_SIZE) {
-      const batch = texts.slice(i, i + BATCH_SIZE);
-      const outputs = await Promise.all(batch.map(async (text) => {
-        const output = await this.pipeline(text, {
-          pooling: "mean",
-          normalize: true
-        });
-        return Array.from(output.data);
-      }));
-      results.push(...outputs);
-    }
-    return results;
+  return;
+}
+function introspectionToKeywords(intro) {
+  const keywords = [];
+  const filename = path5.basename(intro.filepath);
+  const filenameWithoutExt = filename.replace(/\.[^.]+$/, "");
+  const filenameParts = filenameWithoutExt.split(/[-_.]/).flatMap((part) => part.split(/(?=[A-Z])/)).map((part) => part.toLowerCase()).filter((part) => part.length > 1);
+  keywords.push(...filenameParts);
+  keywords.push(filenameWithoutExt.toLowerCase());
+  if (intro.project.name && intro.project.name !== "root") {
+    keywords.push(intro.project.name.toLowerCase());
   }
-  getDimension() {
-    return EMBEDDING_DIMENSION;
+  if (intro.scope !== "unknown") {
+    keywords.push(intro.scope);
   }
-  getModelName() {
-    return this.config.model;
+  if (intro.layer) {
+    keywords.push(intro.layer);
   }
-  async dispose() {
-    this.pipeline = null;
+  if (intro.domain) {
+    keywords.push(intro.domain);
   }
-}
-function configureEmbeddings(config) {
-  const newConfig = { ...globalConfig, ...config };
-  if (newConfig.model !== globalConfig.model) {
-    globalProvider = null;
+  if (intro.language !== "unknown") {
+    keywords.push(intro.language);
   }
-  globalConfig = newConfig;
-}
-function getEmbeddingConfig() {
-  return { ...globalConfig };
-}
-async function ensureGlobalProvider() {
-  if (!globalProvider) {
-    globalProvider = new TransformersEmbeddingProvider(globalConfig);
-    await globalProvider.initialize();
+  if (intro.framework) {
+    keywords.push(intro.framework);
   }
-  return globalProvider;
-}
-async function getEmbedding(text) {
-  const provider = await ensureGlobalProvider();
-  return provider.getEmbedding(text);
-}
-async function getEmbeddings(texts) {
-  const provider = await ensureGlobalProvider();
-  return provider.getEmbeddings(texts);
+  const skipSegments = new Set(["src", "lib", "index"]);
+  for (const segment of intro.pathSegments) {
+    if (!skipSegments.has(segment.toLowerCase()) && segment.length > 2) {
+      keywords.push(segment.toLowerCase());
+    }
+  }
+  const conventionKeywords = getConventionKeywords(intro.filepath);
+  keywords.push(...conventionKeywords);
+  return [...new Set(keywords)];
 }
-var CACHE_DIR, EMBEDDING_MODELS2, EMBEDDING_DIMENSION = 384, BATCH_SIZE = 32, globalProvider = null, globalConfig;
-var init_transformersEmbedding = __esm(() => {
-  CACHE_DIR = path3.join(os.homedir(), ".cache", "raggrep", "models");
-  env.cacheDir = CACHE_DIR;
-  env.allowLocalModels = true;
-  EMBEDDING_MODELS2 = {
-    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
-    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
-    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
-    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2"
+var LAYER_PATTERNS, DOMAIN_PATTERNS, FRAMEWORK_INDICATORS, EXTENSION_TO_LANGUAGE;
+var init_fileIntrospector = __esm(() => {
+  init_projectDetector();
+  init_conventions();
+  LAYER_PATTERNS = {
+    controller: ["controller", "api", "routes", "route", "handler"],
+    service: ["service", "logic", "usecase", "usecases", "handler"],
+    repository: ["repository", "repo", "dao", "store", "persistence"],
+    model: [
+      "model",
+      "models",
+      "entity",
+      "entities",
+      "schema",
+      "schemas",
+      "types",
+      "type"
+    ],
+    util: ["util", "utils", "helper", "helpers", "common", "lib"],
+    config: ["config", "configuration", "settings"],
+    middleware: ["middleware", "middlewares"],
+    domain: ["domain"],
+    infrastructure: ["infrastructure", "infra"],
+    application: ["application", "app"],
+    presentation: [
+      "presentation",
+      "ui",
+      "views",
+      "view",
+      "component",
+      "components"
+    ],
+    test: ["test", "tests", "spec", "specs", "__tests__", "e2e"]
   };
-  globalConfig = {
-    model: "all-MiniLM-L6-v2",
-    showProgress: true
+  DOMAIN_PATTERNS = [
+    "auth",
+    "authentication",
+    "user",
+    "users",
+    "account",
+    "accounts",
+    "profile",
+    "profiles",
+    "product",
+    "products",
+    "item",
+    "items",
+    "catalog",
+    "order",
+    "orders",
+    "cart",
+    "checkout",
+    "payment",
+    "payments",
+    "billing",
+    "subscription",
+    "subscriptions",
+    "notification",
+    "notifications",
+    "email",
+    "sms",
+    "report",
+    "reports",
+    "analytics",
+    "metrics",
+    "dashboard",
+    "admin",
+    "settings",
+    "search",
+    "chat",
+    "message",
+    "messages",
+    "feed",
+    "post",
+    "posts",
+    "comment",
+    "comments",
+    "media",
+    "upload",
+    "file",
+    "files",
+    "storage",
+    "cache",
+    "session",
+    "log",
+    "logs",
+    "audit"
+  ];
+  FRAMEWORK_INDICATORS = {
+    nextjs: ["next", "next/"],
+    express: ["express"],
+    fastify: ["fastify"],
+    react: ["react"],
+    vue: ["vue"],
+    angular: ["@angular/"],
+    nestjs: ["@nestjs/"],
+    koa: ["koa"]
+  };
+  EXTENSION_TO_LANGUAGE = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".swift": "swift",
+    ".rb": "ruby",
+    ".php": "php",
+    ".cs": "csharp",
+    ".cpp": "cpp",
+    ".c": "c",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".md": "markdown",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml"
   };
 });
 
-// src/infrastructure/embeddings/index.ts
-var init_embeddings = __esm(() => {
-  init_transformersEmbedding();
-});
+// src/introspection/index.ts
+import * as path6 from "path";
+import * as fs3 from "fs/promises";
 
-// src/domain/services/similarity.ts
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
+class IntrospectionIndex {
+  rootDir;
+  structure = null;
+  files = new Map;
+  config = {};
+  constructor(rootDir) {
+    this.rootDir = rootDir;
   }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0;i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
+  async initialize() {
+    this.structure = await detectProjectStructure(this.rootDir);
+    try {
+      const configPath = path6.join(this.rootDir, ".raggrep", "config.json");
+      const configContent = await fs3.readFile(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      this.config = config.introspection || {};
+    } catch {}
   }
-  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-  if (magnitude === 0)
-    return 0;
-  return dotProduct / magnitude;
-}
-
-// src/modules/language/typescript/parseCode.ts
-import * as ts from "typescript";
-function parseCode(content, filepath) {
-  const ext = filepath.split(".").pop()?.toLowerCase();
-  if (["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"].includes(ext || "")) {
-    return parseTypeScript(content, filepath);
+  getStructure() {
+    return this.structure;
   }
-  return parseGenericCode(content);
-}
-function parseTypeScript(content, filepath) {
-  const chunks = [];
-  const lines = content.split(`
-`);
-  const sourceFile = ts.createSourceFile(filepath, content, ts.ScriptTarget.Latest, true, filepath.endsWith(".tsx") || filepath.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
-  function getLineNumbers(node) {
-    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-    return {
-      startLine: start.line + 1,
-      endLine: end.line + 1
-    };
+  addFile(filepath, content) {
+    if (!this.structure) {
+      throw new Error("IntrospectionIndex not initialized");
+    }
+    const intro = introspectFile(filepath, this.structure, content);
+    this.applyOverrides(intro);
+    this.files.set(filepath, intro);
+    return intro;
   }
-  function getNodeText(node) {
-    return node.getText(sourceFile);
+  getFile(filepath) {
+    return this.files.get(filepath);
   }
-  function isExported(node) {
-    if (!ts.canHaveModifiers(node))
-      return false;
-    const modifiers = ts.getModifiers(node);
-    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+  getAllFiles() {
+    return Array.from(this.files.values());
   }
-  function getJSDoc(node) {
-    const jsDocNodes = ts.getJSDocCommentsAndTags(node);
-    if (jsDocNodes.length === 0)
+  applyOverrides(intro) {
+    if (!this.config.projects)
       return;
-    return jsDocNodes.map((doc) => doc.getText(sourceFile)).join(`
-`);
-  }
-  function getFunctionName(node) {
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      return node.name.text;
-    }
-    if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
-      return node.name.text;
+    for (const [projectPath, overrides] of Object.entries(this.config.projects)) {
+      if (intro.filepath.startsWith(projectPath + "/") || intro.project.root === projectPath) {
+        if (overrides.scope) {
+          intro.scope = overrides.scope;
+        }
+        if (overrides.framework) {
+          intro.framework = overrides.framework;
+        }
+        break;
+      }
     }
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-      return node.name.text;
+  }
+  async save(config) {
+    const introDir = path6.join(getRaggrepDir(this.rootDir, config), "introspection");
+    await fs3.mkdir(introDir, { recursive: true });
+    const projectPath = path6.join(introDir, "_project.json");
+    await fs3.writeFile(projectPath, JSON.stringify({
+      version: "1.0.0",
+      lastUpdated: new Date().toISOString(),
+      structure: this.structure
+    }, null, 2));
+    for (const [filepath, intro] of this.files) {
+      const introFilePath = path6.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs3.mkdir(path6.dirname(introFilePath), { recursive: true });
+      await fs3.writeFile(introFilePath, JSON.stringify(intro, null, 2));
     }
-    return;
+    console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
   }
-  function visit(node) {
-    const { startLine, endLine } = getLineNumbers(node);
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "function",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
+  async load(config) {
+    const introDir = path6.join(getRaggrepDir(this.rootDir, config), "introspection");
+    try {
+      const projectPath = path6.join(introDir, "_project.json");
+      const projectContent = await fs3.readFile(projectPath, "utf-8");
+      const projectData = JSON.parse(projectContent);
+      this.structure = projectData.structure;
+      await this.loadFilesRecursive(path6.join(introDir, "files"), "");
+    } catch {
+      this.structure = null;
+      this.files.clear();
     }
-    if (ts.isVariableStatement(node)) {
-      for (const decl of node.declarationList.declarations) {
-        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
-          const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
-          chunks.push({
-            content: getNodeText(node),
-            startLine,
-            endLine,
-            type: "function",
-            name,
-            isExported: isExported(node),
-            jsDoc: getJSDoc(node)
-          });
-          return;
+  }
+  async loadFilesRecursive(basePath, prefix) {
+    try {
+      const entries = await fs3.readdir(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path6.join(basePath, entry.name);
+        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          await this.loadFilesRecursive(entryPath, relativePath);
+        } else if (entry.name.endsWith(".json")) {
+          const content = await fs3.readFile(entryPath, "utf-8");
+          const intro = JSON.parse(content);
+          this.files.set(intro.filepath, intro);
         }
       }
-    }
-    if (ts.isClassDeclaration(node) && node.name) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "class",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isInterfaceDeclaration(node)) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "interface",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isTypeAliasDeclaration(node)) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "type",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isEnumDeclaration(node)) {
-      chunks.push({
-        content: getNodeText(node),
-        startLine,
-        endLine,
-        type: "enum",
-        name: node.name.text,
-        isExported: isExported(node),
-        jsDoc: getJSDoc(node)
-      });
-      return;
-    }
-    if (ts.isVariableStatement(node) && isExported(node)) {
-      for (const decl of node.declarationList.declarations) {
-        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
-          continue;
-        }
-        const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
-        chunks.push({
-          content: getNodeText(node),
-          startLine,
-          endLine,
-          type: "variable",
-          name,
-          isExported: true,
-          jsDoc: getJSDoc(node)
-        });
-      }
-      return;
-    }
-    ts.forEachChild(node, visit);
-  }
-  ts.forEachChild(sourceFile, visit);
-  if (chunks.length === 0) {
-    return parseGenericCode(content);
-  }
-  return chunks;
-}
-function parseGenericCode(content) {
-  const chunks = [];
-  const lines = content.split(`
-`);
-  const CHUNK_SIZE = 30;
-  const OVERLAP = 5;
-  if (lines.length <= CHUNK_SIZE) {
-    return [
-      {
-        content,
-        startLine: 1,
-        endLine: lines.length,
-        type: "file"
-      }
-    ];
+    } catch {}
   }
-  for (let i = 0;i < lines.length; i += CHUNK_SIZE - OVERLAP) {
-    const endIdx = Math.min(i + CHUNK_SIZE, lines.length);
-    chunks.push({
-      content: lines.slice(i, endIdx).join(`
-`),
-      startLine: i + 1,
-      endLine: endIdx,
-      type: "block"
-    });
-    if (endIdx >= lines.length)
-      break;
+  clear() {
+    this.files.clear();
+    this.structure = null;
   }
-  return chunks;
-}
-function generateChunkId(filepath, startLine, endLine) {
-  const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
-  return `${safePath}-${startLine}-${endLine}`;
 }
-var init_parseCode = () => {};
-
-// src/infrastructure/storage/fileIndexStorage.ts
-var init_fileIndexStorage = __esm(() => {
-  init_entities();
+var init_introspection = __esm(() => {
+  init_projectDetector();
+  init_fileIntrospector();
+  init_config2();
+  init_fileIntrospector();
+  init_projectDetector();
 });
 
-// src/domain/services/keywords.ts
-function extractKeywords(content, name, maxKeywords = 50) {
-  const keywords = new Set;
-  if (name) {
-    keywords.add(name.toLowerCase());
-    const parts = name.split(/(?=[A-Z])/).map((p) => p.toLowerCase());
-    parts.forEach((p) => p.length > 2 && keywords.add(p));
-  }
-  const identifierRegex = /\b([a-zA-Z_][a-zA-Z0-9_]{2,})\b/g;
-  let match;
-  while ((match = identifierRegex.exec(content)) !== null) {
-    const word = match[1].toLowerCase();
-    if (!COMMON_KEYWORDS.has(word) && word.length > 2) {
-      keywords.add(word);
+// src/modules/core/symbols.ts
+function extractSymbols(content) {
+  const symbols = [];
+  const seenSymbols = new Set;
+  const lines = content.split(`
+`);
+  for (const { type, pattern, exported } of SYMBOL_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const name = match[1];
+      const symbolKey = `${name}:${type}`;
+      if (seenSymbols.has(symbolKey))
+        continue;
+      seenSymbols.add(symbolKey);
+      const beforeMatch = content.substring(0, match.index);
+      const line = beforeMatch.split(`
+`).length;
+      symbols.push({
+        name,
+        type,
+        line,
+        isExported: exported
+      });
     }
   }
-  return Array.from(keywords).slice(0, maxKeywords);
-}
-function splitIdentifier(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).map((s) => s.toLowerCase()).filter((s) => s.length > 1);
+  return symbols.sort((a, b) => a.line - b.line);
 }
-function extractPathKeywords(filepath) {
+function symbolsToKeywords(symbols) {
   const keywords = new Set;
-  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
-  const segments = pathWithoutExt.split(/[/\\]/);
-  for (const segment of segments) {
-    if (segment.length < 2)
-      continue;
-    const lower = segment.toLowerCase();
-    if (!COMMON_KEYWORDS.has(lower) && lower.length > 2) {
-      keywords.add(lower);
-    }
-    const parts = splitIdentifier(segment);
+  for (const symbol of symbols) {
+    keywords.add(symbol.name.toLowerCase());
+    const parts = symbol.name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
     for (const part of parts) {
-      if (!COMMON_KEYWORDS.has(part) && part.length > 2) {
+      if (part.length > 2) {
         keywords.add(part);
       }
     }
   }
   return Array.from(keywords);
 }
-function parsePathContext(filepath) {
-  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
-  const allSegments = pathWithoutExt.split(/[/\\]/);
-  const filename = allSegments[allSegments.length - 1];
-  const dirSegments = allSegments.slice(0, -1);
-  const keywords = extractPathKeywords(filepath);
-  let layer;
-  const allLower = [...dirSegments, filename].map((s) => s.toLowerCase()).join(" ");
-  const filenameLower = filename.toLowerCase();
-  for (const [layerName, patterns] of Object.entries(LAYER_PATTERNS)) {
-    for (const pattern of patterns) {
-      if (filenameLower.includes(pattern)) {
-        layer = layerName;
-        break;
-      }
-      if (dirSegments.some((s) => s.toLowerCase() === pattern)) {
-        layer = layerName;
-        break;
-      }
-    }
-    if (layer)
-      break;
-  }
-  let domain;
-  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS).flat());
-  const reversedSegments = [...dirSegments].reverse();
-  for (const segment of reversedSegments) {
-    const lower = segment.toLowerCase();
-    if (["src", "lib", "app", "packages", "modules"].includes(lower))
-      continue;
-    if (layerPatternSet.has(lower))
-      continue;
-    if (lower.length > 2) {
-      domain = lower;
-      break;
-    }
-  }
-  return {
-    segments: dirSegments,
-    layer,
-    domain,
-    depth: dirSegments.length,
-    keywords
-  };
-}
-function formatPathContextForEmbedding(pathContext) {
-  const parts = [];
-  if (pathContext.domain) {
-    parts.push(pathContext.domain);
-  }
-  if (pathContext.layer) {
-    parts.push(pathContext.layer);
-  }
-  const significantSegments = pathContext.segments.slice(-3).filter((s) => s.length > 2 && !["src", "lib", "app"].includes(s.toLowerCase()));
-  if (significantSegments.length > 0) {
-    parts.push(...significantSegments.map((s) => s.toLowerCase()));
-  }
-  if (parts.length === 0)
-    return "";
-  const unique = [...new Set(parts)];
-  return `[${unique.join(" ")}]`;
-}
-var COMMON_KEYWORDS, LAYER_PATTERNS;
-var init_keywords = __esm(() => {
-  COMMON_KEYWORDS = new Set([
-    "const",
-    "let",
-    "var",
-    "function",
-    "class",
-    "interface",
-    "type",
-    "enum",
-    "export",
-    "import",
-    "from",
-    "return",
-    "async",
-    "await",
-    "new",
-    "this",
-    "true",
-    "false",
-    "null",
-    "undefined",
-    "if",
-    "else",
-    "for",
-    "while",
-    "switch",
-    "case",
-    "break",
-    "continue",
-    "try",
-    "catch",
-    "finally",
-    "throw",
-    "typeof",
-    "instanceof",
-    "void",
-    "delete",
-    "in",
-    "of",
-    "string",
-    "number",
-    "boolean",
-    "any",
-    "unknown",
-    "never",
-    "object",
-    "public",
-    "private",
-    "protected",
-    "static",
-    "readonly",
-    "abstract",
-    "implements",
-    "extends",
-    "super",
-    "get",
-    "set",
-    "constructor",
-    "the",
-    "and",
-    "for",
-    "not",
-    "with",
-    "are",
-    "was",
-    "has",
-    "have"
-  ]);
-  LAYER_PATTERNS = {
-    controller: ["controller", "controllers", "handler", "handlers", "route", "routes", "api"],
-    service: ["service", "services", "usecase", "usecases", "application"],
-    repository: ["repository", "repositories", "repo", "repos", "dao", "store", "storage"],
-    model: ["model", "models", "entity", "entities", "schema", "schemas"],
-    util: ["util", "utils", "utility", "utilities", "helper", "helpers", "common", "shared"],
-    config: ["config", "configs", "configuration", "settings"],
-    middleware: ["middleware", "middlewares", "interceptor", "interceptors"],
-    domain: ["domain", "core", "business"],
-    infrastructure: ["infrastructure", "infra", "external", "adapters"],
-    presentation: ["presentation", "view", "views", "component", "components", "ui"],
-    test: ["test", "tests", "spec", "specs", "__tests__", "__test__"]
-  };
+var SYMBOL_PATTERNS;
+var init_symbols = __esm(() => {
+  SYMBOL_PATTERNS = [
+    {
+      type: "function",
+      pattern: /^export\s+(?:async\s+)?function\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "function",
+      pattern: /^export\s+(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/gm,
+      exported: true
+    },
+    {
+      type: "class",
+      pattern: /^export\s+(?:abstract\s+)?class\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "interface",
+      pattern: /^export\s+interface\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "type",
+      pattern: /^export\s+type\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "enum",
+      pattern: /^export\s+(?:const\s+)?enum\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "variable",
+      pattern: /^export\s+(?:const|let|var)\s+(\w+)\s*(?::|=)/gm,
+      exported: true
+    },
+    {
+      type: "function",
+      pattern: /^export\s+default\s+(?:async\s+)?function\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "class",
+      pattern: /^export\s+default\s+class\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "function",
+      pattern: /^(?:async\s+)?function\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/gm,
+      exported: false
+    },
+    {
+      type: "class",
+      pattern: /^(?:abstract\s+)?class\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "interface",
+      pattern: /^interface\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "type",
+      pattern: /^type\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "enum",
+      pattern: /^(?:const\s+)?enum\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^def\s+(\w+)\s*\(/gm,
+      exported: false
+    },
+    {
+      type: "class",
+      pattern: /^class\s+(\w+)(?:\s*\(|:)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/gm,
+      exported: false
+    },
+    {
+      type: "type",
+      pattern: /^type\s+(\w+)\s+(?:struct|interface)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "type",
+      pattern: /^(?:pub\s+)?struct\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "enum",
+      pattern: /^(?:pub\s+)?enum\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "interface",
+      pattern: /^(?:pub\s+)?trait\s+(\w+)/gm,
+      exported: false
+    }
+  ];
+});
+
+// src/modules/core/index.ts
+var exports_core = {};
+__export(exports_core, {
+  CoreModule: () => CoreModule
+});
+import * as path7 from "path";
+import * as fs4 from "fs/promises";
+
+class CoreModule {
+  id = "core";
+  name = "Core Search";
+  description = "Language-agnostic text search with symbol extraction";
+  version = "1.0.0";
+  symbolIndex = new Map;
+  bm25Index = null;
+  rootDir = "";
+  async initialize(_config) {}
+  async indexFile(filepath, content, ctx) {
+    this.rootDir = ctx.rootDir;
+    const symbols = extractSymbols(content);
+    const symbolKeywords = symbolsToKeywords(symbols);
+    const contentTokens = tokenize(content);
+    const intro = ctx.getIntrospection?.(filepath);
+    const introKeywords = intro ? introspectionToKeywords(intro) : [];
+    const allTokens = [...new Set([...contentTokens, ...symbolKeywords, ...introKeywords])];
+    const chunks = this.createChunks(filepath, content, symbols);
+    const stats = await ctx.getFileStats(filepath);
+    this.symbolIndex.set(filepath, {
+      filepath,
+      symbols,
+      tokens: allTokens
+    });
+    const moduleData = {
+      symbols,
+      tokens: allTokens
+    };
+    return {
+      filepath,
+      lastModified: stats.lastModified,
+      chunks,
+      moduleData
+    };
+  }
+  createChunks(filepath, content, symbols) {
+    const lines = content.split(`
+`);
+    const chunks = [];
+    for (let start = 0;start < lines.length; start += LINES_PER_CHUNK - CHUNK_OVERLAP) {
+      const end = Math.min(start + LINES_PER_CHUNK, lines.length);
+      const chunkLines = lines.slice(start, end);
+      const chunkContent = chunkLines.join(`
+`);
+      const chunkSymbols = symbols.filter((s) => s.line >= start + 1 && s.line <= end);
+      let chunkType = "block";
+      let chunkName;
+      let isExported = false;
+      if (chunkSymbols.length > 0) {
+        const primarySymbol = chunkSymbols[0];
+        chunkType = this.symbolTypeToChunkType(primarySymbol.type);
+        chunkName = primarySymbol.name;
+        isExported = primarySymbol.isExported;
+      }
+      const chunkId = `${filepath}:${start + 1}-${end}`;
+      chunks.push({
+        id: chunkId,
+        content: chunkContent,
+        startLine: start + 1,
+        endLine: end,
+        type: chunkType,
+        name: chunkName,
+        isExported
+      });
+      if (end >= lines.length)
+        break;
+    }
+    return chunks;
+  }
+  symbolTypeToChunkType(symbolType) {
+    switch (symbolType) {
+      case "function":
+      case "method":
+        return "function";
+      case "class":
+        return "class";
+      case "interface":
+        return "interface";
+      case "type":
+        return "type";
+      case "enum":
+        return "enum";
+      case "variable":
+        return "variable";
+      default:
+        return "block";
+    }
+  }
+  async finalize(ctx) {
+    const config = ctx.config;
+    const coreDir = path7.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
+    await fs4.mkdir(coreDir, { recursive: true });
+    this.bm25Index = new BM25Index;
+    for (const [filepath, entry] of this.symbolIndex) {
+      this.bm25Index.addDocument(filepath, entry.tokens);
+    }
+    const symbolIndexData = {
+      version: this.version,
+      lastUpdated: new Date().toISOString(),
+      files: Object.fromEntries(this.symbolIndex),
+      bm25Data: this.bm25Index.serialize()
+    };
+    await fs4.writeFile(path7.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
+    console.log(`  [Core] Symbol index built with ${this.symbolIndex.size} files`);
+  }
+  async search(query, ctx, options) {
+    const config = ctx.config;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    if (this.symbolIndex.size === 0) {
+      await this.loadSymbolIndex(ctx.rootDir, config);
+    }
+    if (!this.bm25Index || this.symbolIndex.size === 0) {
+      return [];
+    }
+    const queryTokens = tokenize(query);
+    const bm25Results = this.bm25Index.search(query, topK * 2);
+    const bm25Scores = new Map(bm25Results.map((r) => [r.id, r.score]));
+    const symbolMatches = this.findSymbolMatches(queryTokens);
+    const results = [];
+    for (const filepath of this.symbolIndex.keys()) {
+      const entry = this.symbolIndex.get(filepath);
+      const bm25Score = bm25Scores.get(filepath) ?? 0;
+      const symbolScore = symbolMatches.get(filepath) ?? 0;
+      if (bm25Score === 0 && symbolScore === 0)
+        continue;
+      const combinedScore = 0.6 * normalizeScore(bm25Score) + 0.4 * symbolScore;
+      if (combinedScore >= minScore) {
+        const fileIndex = await ctx.loadFileIndex(filepath);
+        if (!fileIndex)
+          continue;
+        const bestChunk = this.findBestChunk(fileIndex.chunks, queryTokens, entry.symbols);
+        results.push({
+          filepath,
+          chunk: bestChunk,
+          score: combinedScore,
+          moduleId: this.id,
+          context: {
+            bm25Score: normalizeScore(bm25Score),
+            symbolScore
+          }
+        });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  findSymbolMatches(queryTokens) {
+    const matches = new Map;
+    for (const [filepath, entry] of this.symbolIndex) {
+      let matchScore = 0;
+      for (const symbol of entry.symbols) {
+        const symbolName = symbol.name.toLowerCase();
+        const symbolParts = symbolsToKeywords([symbol]);
+        for (const token of queryTokens) {
+          if (symbolName === token) {
+            matchScore += symbol.isExported ? 1 : 0.8;
+          } else if (symbolName.includes(token) || token.includes(symbolName)) {
+            matchScore += symbol.isExported ? 0.5 : 0.4;
+          } else if (symbolParts.some((p) => p === token)) {
+            matchScore += symbol.isExported ? 0.3 : 0.2;
+          }
+        }
+      }
+      if (matchScore > 0) {
+        matches.set(filepath, Math.min(1, matchScore / queryTokens.length));
+      }
+    }
+    return matches;
+  }
+  findBestChunk(chunks, queryTokens, symbols) {
+    let bestChunk = chunks[0];
+    let bestScore = 0;
+    for (const chunk of chunks) {
+      let score = 0;
+      const chunkContent = chunk.content.toLowerCase();
+      for (const token of queryTokens) {
+        if (chunkContent.includes(token)) {
+          score += 1;
+        }
+      }
+      if (chunk.name) {
+        const nameLower = chunk.name.toLowerCase();
+        for (const token of queryTokens) {
+          if (nameLower.includes(token)) {
+            score += 2;
+          }
+        }
+      }
+      if (chunk.isExported) {
+        score += 0.5;
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestChunk = chunk;
+      }
+    }
+    return bestChunk;
+  }
+  async loadSymbolIndex(rootDir, config) {
+    const coreDir = path7.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path7.join(coreDir, "symbols.json");
+    try {
+      const content = await fs4.readFile(symbolsPath, "utf-8");
+      const data = JSON.parse(content);
+      this.symbolIndex = new Map(Object.entries(data.files));
+      if (data.bm25Data) {
+        this.bm25Index = BM25Index.deserialize(data.bm25Data);
+      }
+    } catch (error) {
+      this.symbolIndex = new Map;
+      this.bm25Index = null;
+    }
+  }
+  async dispose() {
+    this.symbolIndex.clear();
+    this.bm25Index = null;
+  }
+}
+var DEFAULT_MIN_SCORE = 0.1, DEFAULT_TOP_K = 20, LINES_PER_CHUNK = 50, CHUNK_OVERLAP = 10;
+var init_core = __esm(() => {
+  init_config2();
+  init_introspection();
+  init_symbols();
 });
 
-// src/infrastructure/storage/symbolicIndex.ts
-import * as fs3 from "fs/promises";
-import * as path4 from "path";
+// src/infrastructure/embeddings/transformersEmbedding.ts
+import { pipeline, env } from "@xenova/transformers";
+import * as path8 from "path";
+import * as os2 from "os";
 
-class SymbolicIndex {
-  meta = null;
-  fileSummaries = new Map;
-  bm25Index = null;
-  symbolicPath;
-  moduleId;
-  constructor(indexDir, moduleId) {
-    this.symbolicPath = path4.join(indexDir, "index", moduleId, "symbolic");
-    this.moduleId = moduleId;
+class TransformersEmbeddingProvider {
+  pipeline = null;
+  config;
+  isInitializing = false;
+  initPromise = null;
+  constructor(config) {
+    this.config = {
+      model: config?.model ?? "all-MiniLM-L6-v2",
+      showProgress: config?.showProgress ?? true
+    };
   }
-  async initialize() {
-    try {
-      await this.load();
-    } catch {
-      this.meta = {
-        version: "1.0.0",
-        lastUpdated: new Date().toISOString(),
-        moduleId: this.moduleId,
-        fileCount: 0,
-        bm25Data: {
-          avgDocLength: 0,
-          documentFrequencies: {},
-          totalDocs: 0
-        }
-      };
-      this.bm25Index = new BM25Index;
+  async initialize(config) {
+    if (config) {
+      if (config.model !== this.config.model) {
+        this.pipeline = null;
+      }
+      this.config = { ...this.config, ...config };
     }
+    await this.ensurePipeline();
   }
-  addFile(summary) {
-    this.fileSummaries.set(summary.filepath, summary);
+  async ensurePipeline() {
+    if (this.pipeline) {
+      return;
+    }
+    if (this.isInitializing && this.initPromise) {
+      return this.initPromise;
+    }
+    this.isInitializing = true;
+    this.initPromise = (async () => {
+      const modelId = EMBEDDING_MODELS2[this.config.model];
+      if (this.config.showProgress) {
+        console.log(`
+  Loading embedding model: ${this.config.model}`);
+        console.log(`  Cache: ${CACHE_DIR}`);
+      }
+      try {
+        this.pipeline = await pipeline("feature-extraction", modelId, {
+          progress_callback: this.config.showProgress ? (progress) => {
+            if (progress.status === "progress" && progress.file) {
+              const pct = progress.progress ? Math.round(progress.progress) : 0;
+              process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
+            } else if (progress.status === "done" && progress.file) {
+              process.stdout.write(`\r  Downloaded ${progress.file}              
+`);
+            }
+          } : undefined
+        });
+        if (this.config.showProgress) {
+          console.log(`  Model ready.
+`);
+        }
+      } catch (error) {
+        this.pipeline = null;
+        throw new Error(`Failed to load embedding model: ${error}`);
+      } finally {
+        this.isInitializing = false;
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
   }
-  removeFile(filepath) {
-    return this.fileSummaries.delete(filepath);
+  async getEmbedding(text) {
+    await this.ensurePipeline();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const output = await this.pipeline(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    return Array.from(output.data);
   }
-  buildBM25Index() {
-    this.bm25Index = new BM25Index;
-    for (const [filepath, summary] of this.fileSummaries) {
-      const content = [
-        ...summary.keywords,
-        ...summary.exports,
-        ...extractPathKeywords(filepath)
-      ].join(" ");
-      this.bm25Index.addDocuments([{ id: filepath, content }]);
+  async getEmbeddings(texts) {
+    if (texts.length === 0)
+      return [];
+    await this.ensurePipeline();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
     }
-    if (this.meta) {
-      this.meta.fileCount = this.fileSummaries.size;
-      this.meta.bm25Data.totalDocs = this.fileSummaries.size;
+    const results = [];
+    for (let i = 0;i < texts.length; i += BATCH_SIZE) {
+      const batch = texts.slice(i, i + BATCH_SIZE);
+      const outputs = await Promise.all(batch.map(async (text) => {
+        const output = await this.pipeline(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        return Array.from(output.data);
+      }));
+      results.push(...outputs);
     }
+    return results;
   }
-  findCandidates(query, maxCandidates = 20) {
-    if (!this.bm25Index) {
-      return Array.from(this.fileSummaries.keys());
-    }
-    const results = this.bm25Index.search(query, maxCandidates);
-    return results.map((r) => r.id);
+  getDimension() {
+    return EMBEDDING_DIMENSION;
   }
-  getAllFiles() {
-    return Array.from(this.fileSummaries.keys());
+  getModelName() {
+    return this.config.model;
   }
-  getFileSummary(filepath) {
-    return this.fileSummaries.get(filepath);
+  async dispose() {
+    this.pipeline = null;
   }
-  async save() {
-    if (!this.meta)
-      throw new Error("Index not initialized");
-    this.meta.lastUpdated = new Date().toISOString();
-    this.meta.fileCount = this.fileSummaries.size;
-    await fs3.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path4.join(this.symbolicPath, "_meta.json");
-    await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
-    for (const [filepath, summary] of this.fileSummaries) {
-      const summaryPath = this.getFileSummaryPath(filepath);
-      await fs3.mkdir(path4.dirname(summaryPath), { recursive: true });
-      await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
-    }
+}
+function configureEmbeddings(config) {
+  const newConfig = { ...globalConfig, ...config };
+  if (newConfig.model !== globalConfig.model) {
+    globalProvider = null;
   }
-  async load() {
-    const metaPath = path4.join(this.symbolicPath, "_meta.json");
-    const metaContent = await fs3.readFile(metaPath, "utf-8");
-    this.meta = JSON.parse(metaContent);
-    this.fileSummaries.clear();
-    await this.loadFileSummariesRecursive(this.symbolicPath);
-    this.buildBM25Index();
+  globalConfig = newConfig;
+}
+function getEmbeddingConfig() {
+  return { ...globalConfig };
+}
+async function ensureGlobalProvider() {
+  if (!globalProvider) {
+    globalProvider = new TransformersEmbeddingProvider(globalConfig);
+    await globalProvider.initialize();
   }
-  async loadFileSummariesRecursive(dir) {
-    try {
-      const entries = await fs3.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path4.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await this.loadFileSummariesRecursive(fullPath);
-        } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
-          try {
-            const content = await fs3.readFile(fullPath, "utf-8");
-            const summary = JSON.parse(content);
-            if (summary.filepath) {
-              this.fileSummaries.set(summary.filepath, summary);
-            }
-          } catch {}
-        }
-      }
-    } catch {}
+  return globalProvider;
+}
+async function getEmbedding(text) {
+  const provider = await ensureGlobalProvider();
+  return provider.getEmbedding(text);
+}
+async function getEmbeddings(texts) {
+  const provider = await ensureGlobalProvider();
+  return provider.getEmbeddings(texts);
+}
+var CACHE_DIR, EMBEDDING_MODELS2, EMBEDDING_DIMENSION = 384, BATCH_SIZE = 32, globalProvider = null, globalConfig;
+var init_transformersEmbedding = __esm(() => {
+  CACHE_DIR = path8.join(os2.homedir(), ".cache", "raggrep", "models");
+  env.cacheDir = CACHE_DIR;
+  env.allowLocalModels = true;
+  EMBEDDING_MODELS2 = {
+    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
+    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
+    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
+    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2"
+  };
+  globalConfig = {
+    model: "all-MiniLM-L6-v2",
+    showProgress: true
+  };
+});
+
+// src/infrastructure/embeddings/index.ts
+var init_embeddings = __esm(() => {
+  init_transformersEmbedding();
+});
+
+// src/domain/services/similarity.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
   }
-  getFileSummaryPath(filepath) {
-    const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path4.join(this.symbolicPath, jsonPath);
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0)
+    return 0;
+  return dotProduct / magnitude;
+}
+
+// src/modules/language/typescript/parseCode.ts
+import * as ts from "typescript";
+function parseCode(content, filepath) {
+  const ext = filepath.split(".").pop()?.toLowerCase();
+  if (["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"].includes(ext || "")) {
+    return parseTypeScript(content, filepath);
+  }
+  return parseGenericCode(content);
+}
+function parseTypeScript(content, filepath) {
+  const chunks = [];
+  const lines = content.split(`
+`);
+  const sourceFile = ts.createSourceFile(filepath, content, ts.ScriptTarget.Latest, true, filepath.endsWith(".tsx") || filepath.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  function getLineNumbers(node) {
+    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+      startLine: start.line + 1,
+      endLine: end.line + 1
+    };
   }
-  async deleteFileSummary(filepath) {
-    try {
-      await fs3.unlink(this.getFileSummaryPath(filepath));
-    } catch {}
-    this.fileSummaries.delete(filepath);
+  function getNodeText(node) {
+    return node.getText(sourceFile);
   }
-  async exists() {
-    try {
-      const metaPath = path4.join(this.symbolicPath, "_meta.json");
-      await fs3.access(metaPath);
-      return true;
-    } catch {
+  function isExported(node) {
+    if (!ts.canHaveModifiers(node))
       return false;
-    }
+    const modifiers = ts.getModifiers(node);
+    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
   }
-  get size() {
-    return this.fileSummaries.size;
+  function getJSDoc(node) {
+    const jsDocNodes = ts.getJSDocCommentsAndTags(node);
+    if (jsDocNodes.length === 0)
+      return;
+    return jsDocNodes.map((doc) => doc.getText(sourceFile)).join(`
+`);
   }
-  clear() {
-    this.fileSummaries.clear();
-    if (this.meta) {
-      this.meta.fileCount = 0;
-      this.meta.bm25Data = {
-        avgDocLength: 0,
-        documentFrequencies: {},
-        totalDocs: 0
-      };
+  function getFunctionName(node) {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      return node.name.text;
     }
-    this.bm25Index = new BM25Index;
-  }
-}
-var init_symbolicIndex = __esm(() => {
-  init_keywords();
-});
-
-// src/infrastructure/storage/index.ts
-var init_storage = __esm(() => {
-  init_fileIndexStorage();
-  init_symbolicIndex();
-});
-
-// src/modules/language/typescript/index.ts
-var exports_typescript = {};
-__export(exports_typescript, {
-  TypeScriptModule: () => TypeScriptModule,
-  DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
-  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
-});
-import * as path5 from "path";
-
-class TypeScriptModule {
-  id = "language/typescript";
-  name = "TypeScript Search";
-  description = "TypeScript-aware code search with AST parsing and semantic embeddings";
-  version = "1.0.0";
-  embeddingConfig = null;
-  symbolicIndex = null;
-  pendingSummaries = new Map;
-  rootDir = "";
-  async initialize(config) {
-    this.embeddingConfig = getEmbeddingConfigFromModule(config);
-    configureEmbeddings(this.embeddingConfig);
-    this.pendingSummaries.clear();
-  }
-  async indexFile(filepath, content, ctx) {
-    this.rootDir = ctx.rootDir;
-    const parsedChunks = parseCode(content, filepath);
-    if (parsedChunks.length === 0) {
-      return null;
+    if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+      return node.name.text;
     }
-    const pathContext = parsePathContext(filepath);
-    const pathPrefix = formatPathContextForEmbedding(pathContext);
-    const chunkContents = parsedChunks.map((c) => {
-      const namePrefix = c.name ? `${c.name}: ` : "";
-      return `${pathPrefix} ${namePrefix}${c.content}`;
-    });
-    const embeddings = await getEmbeddings(chunkContents);
-    const chunks = parsedChunks.map((pc) => ({
-      id: generateChunkId(filepath, pc.startLine, pc.endLine),
-      content: pc.content,
-      startLine: pc.startLine,
-      endLine: pc.endLine,
-      type: pc.type,
-      name: pc.name,
-      isExported: pc.isExported,
-      jsDoc: pc.jsDoc
-    }));
-    const references = this.extractReferences(content, filepath);
-    const stats = await ctx.getFileStats(filepath);
-    const currentConfig = getEmbeddingConfig();
-    const moduleData = {
-      embeddings,
-      embeddingModel: currentConfig.model
-    };
-    const chunkTypes = [...new Set(parsedChunks.map((pc) => pc.type))];
-    const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
-    const allKeywords = new Set;
-    for (const pc of parsedChunks) {
-      const keywords = extractKeywords(pc.content, pc.name);
-      keywords.forEach((k) => allKeywords.add(k));
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+      return node.name.text;
     }
-    pathContext.keywords.forEach((k) => allKeywords.add(k));
-    const fileSummary = {
-      filepath,
-      chunkCount: chunks.length,
-      chunkTypes,
-      keywords: Array.from(allKeywords),
-      exports,
-      lastModified: stats.lastModified,
-      pathContext: {
-        segments: pathContext.segments,
-        layer: pathContext.layer,
-        domain: pathContext.domain,
-        depth: pathContext.depth
-      }
-    };
-    this.pendingSummaries.set(filepath, fileSummary);
-    return {
-      filepath,
-      lastModified: stats.lastModified,
-      chunks,
-      moduleData,
-      references
-    };
+    return;
   }
-  async finalize(ctx) {
-    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
-    this.symbolicIndex = new SymbolicIndex(indexDir, this.id);
-    await this.symbolicIndex.initialize();
-    for (const [filepath, summary] of this.pendingSummaries) {
-      this.symbolicIndex.addFile(summary);
+  function visit(node) {
+    const { startLine, endLine } = getLineNumbers(node);
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "function",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
     }
-    this.symbolicIndex.buildBM25Index();
-    await this.symbolicIndex.save();
-    console.log(`  Symbolic index built with ${this.pendingSummaries.size} file summaries`);
-    this.pendingSummaries.clear();
-  }
-  async search(query, ctx, options = {}) {
-    const { topK = DEFAULT_TOP_K2, minScore = DEFAULT_MIN_SCORE2, filePatterns } = options;
-    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
-    const symbolicIndex = new SymbolicIndex(indexDir, this.id);
-    let candidateFiles;
-    try {
-      await symbolicIndex.initialize();
-      const maxCandidates = topK * TIER1_CANDIDATE_MULTIPLIER;
-      candidateFiles = symbolicIndex.findCandidates(query, maxCandidates);
-      if (candidateFiles.length === 0) {
-        candidateFiles = symbolicIndex.getAllFiles();
+    if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+          chunks.push({
+            content: getNodeText(node),
+            startLine,
+            endLine,
+            type: "function",
+            name,
+            isExported: isExported(node),
+            jsDoc: getJSDoc(node)
+          });
+          return;
+        }
       }
-    } catch {
-      candidateFiles = await ctx.listIndexedFiles();
     }
-    if (filePatterns && filePatterns.length > 0) {
-      candidateFiles = candidateFiles.filter((filepath) => {
-        return filePatterns.some((pattern) => {
-          if (pattern.startsWith("*.")) {
-            const ext = pattern.slice(1);
-            return filepath.endsWith(ext);
-          }
-          return filepath.includes(pattern);
-        });
+    if (ts.isClassDeclaration(node) && node.name) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "class",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
       });
+      return;
     }
-    const queryEmbedding = await getEmbedding(query);
-    const bm25Index = new BM25Index;
-    const allChunksData = [];
-    for (const filepath of candidateFiles) {
-      const fileIndex = await ctx.loadFileIndex(filepath);
-      if (!fileIndex)
-        continue;
-      const moduleData = fileIndex.moduleData;
-      if (!moduleData?.embeddings)
-        continue;
-      for (let i = 0;i < fileIndex.chunks.length; i++) {
-        const chunk = fileIndex.chunks[i];
-        const embedding = moduleData.embeddings[i];
-        if (!embedding)
-          continue;
-        allChunksData.push({
-          filepath: fileIndex.filepath,
-          chunk,
-          embedding
-        });
-        bm25Index.addDocuments([{ id: chunk.id, content: chunk.content }]);
-      }
+    if (ts.isInterfaceDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "interface",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "type",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
     }
-    const bm25Results = bm25Index.search(query, topK * 3);
-    const bm25Scores = new Map;
-    for (const result of bm25Results) {
-      bm25Scores.set(result.id, normalizeScore(result.score, 3));
+    if (ts.isEnumDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "enum",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
     }
-    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
-    const pathBoosts = new Map;
-    for (const filepath of candidateFiles) {
-      const summary = symbolicIndex.getFileSummary(filepath);
-      if (summary?.pathContext) {
-        let boost = 0;
-        const ctx2 = summary.pathContext;
-        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
-          boost += 0.1;
-        }
-        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
-          boost += 0.05;
-        }
-        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
-        if (segmentMatch) {
-          boost += 0.05;
+    if (ts.isVariableStatement(node) && isExported(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          continue;
         }
-        pathBoosts.set(filepath, boost);
+        const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+        chunks.push({
+          content: getNodeText(node),
+          startLine,
+          endLine,
+          type: "variable",
+          name,
+          isExported: true,
+          jsDoc: getJSDoc(node)
+        });
       }
+      return;
     }
-    const results = [];
-    for (const { filepath, chunk, embedding } of allChunksData) {
-      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
-      const bm25Score = bm25Scores.get(chunk.id) || 0;
-      const pathBoost = pathBoosts.get(filepath) || 0;
-      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + pathBoost;
-      if (hybridScore >= minScore || bm25Score > 0.3) {
-        results.push({
-          filepath,
-          chunk,
-          score: hybridScore,
-          moduleId: this.id,
-          context: {
-            semanticScore,
-            bm25Score,
-            pathBoost
-          }
-        });
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  if (chunks.length === 0) {
+    return parseGenericCode(content);
+  }
+  return chunks;
+}
+function parseGenericCode(content) {
+  const chunks = [];
+  const lines = content.split(`
+`);
+  const CHUNK_SIZE = 30;
+  const OVERLAP = 5;
+  if (lines.length <= CHUNK_SIZE) {
+    return [
+      {
+        content,
+        startLine: 1,
+        endLine: lines.length,
+        type: "file"
       }
+    ];
+  }
+  for (let i = 0;i < lines.length; i += CHUNK_SIZE - OVERLAP) {
+    const endIdx = Math.min(i + CHUNK_SIZE, lines.length);
+    chunks.push({
+      content: lines.slice(i, endIdx).join(`
+`),
+      startLine: i + 1,
+      endLine: endIdx,
+      type: "block"
+    });
+    if (endIdx >= lines.length)
+      break;
+  }
+  return chunks;
+}
+function generateChunkId(filepath, startLine, endLine) {
+  const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
+  return `${safePath}-${startLine}-${endLine}`;
+}
+var init_parseCode = () => {};
+
+// src/infrastructure/storage/fileIndexStorage.ts
+var init_fileIndexStorage = __esm(() => {
+  init_entities();
+});
+
+// src/domain/services/keywords.ts
+function extractKeywords(content, name, maxKeywords = 50) {
+  const keywords = new Set;
+  if (name) {
+    keywords.add(name.toLowerCase());
+    const parts = name.split(/(?=[A-Z])/).map((p) => p.toLowerCase());
+    parts.forEach((p) => p.length > 2 && keywords.add(p));
+  }
+  const identifierRegex = /\b([a-zA-Z_][a-zA-Z0-9_]{2,})\b/g;
+  let match;
+  while ((match = identifierRegex.exec(content)) !== null) {
+    const word = match[1].toLowerCase();
+    if (!COMMON_KEYWORDS.has(word) && word.length > 2) {
+      keywords.add(word);
     }
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, topK);
   }
-  extractReferences(content, filepath) {
-    const references = [];
-    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
-    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (importPath.startsWith(".")) {
-        const dir = path5.dirname(filepath);
-        const resolved = path5.normalize(path5.join(dir, importPath));
-        references.push(resolved);
+  return Array.from(keywords).slice(0, maxKeywords);
+}
+function splitIdentifier(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).map((s) => s.toLowerCase()).filter((s) => s.length > 1);
+}
+function extractPathKeywords(filepath) {
+  const keywords = new Set;
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const segments = pathWithoutExt.split(/[/\\]/);
+  for (const segment of segments) {
+    if (segment.length < 2)
+      continue;
+    const lower = segment.toLowerCase();
+    if (!COMMON_KEYWORDS.has(lower) && lower.length > 2) {
+      keywords.add(lower);
+    }
+    const parts = splitIdentifier(segment);
+    for (const part of parts) {
+      if (!COMMON_KEYWORDS.has(part) && part.length > 2) {
+        keywords.add(part);
       }
     }
-    while ((match = requireRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (importPath.startsWith(".")) {
-        const dir = path5.dirname(filepath);
-        const resolved = path5.normalize(path5.join(dir, importPath));
-        references.push(resolved);
+  }
+  return Array.from(keywords);
+}
+function parsePathContext(filepath) {
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const allSegments = pathWithoutExt.split(/[/\\]/);
+  const filename = allSegments[allSegments.length - 1];
+  const dirSegments = allSegments.slice(0, -1);
+  const keywords = extractPathKeywords(filepath);
+  let layer;
+  const allLower = [...dirSegments, filename].map((s) => s.toLowerCase()).join(" ");
+  const filenameLower = filename.toLowerCase();
+  for (const [layerName, patterns] of Object.entries(LAYER_PATTERNS2)) {
+    for (const pattern of patterns) {
+      if (filenameLower.includes(pattern)) {
+        layer = layerName;
+        break;
+      }
+      if (dirSegments.some((s) => s.toLowerCase() === pattern)) {
+        layer = layerName;
+        break;
       }
     }
-    return references;
+    if (layer)
+      break;
+  }
+  let domain;
+  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS2).flat());
+  const reversedSegments = [...dirSegments].reverse();
+  for (const segment of reversedSegments) {
+    const lower = segment.toLowerCase();
+    if (["src", "lib", "app", "packages", "modules"].includes(lower))
+      continue;
+    if (layerPatternSet.has(lower))
+      continue;
+    if (lower.length > 2) {
+      domain = lower;
+      break;
+    }
   }
+  return {
+    segments: dirSegments,
+    layer,
+    domain,
+    depth: dirSegments.length,
+    keywords
+  };
 }
-var DEFAULT_MIN_SCORE2 = 0.15, DEFAULT_TOP_K2 = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3, TIER1_CANDIDATE_MULTIPLIER = 3;
-var init_typescript = __esm(() => {
-  init_embeddings();
-  init_config2();
-  init_parseCode();
-  init_storage();
-  init_keywords();
-  init_keywords();
+function formatPathContextForEmbedding(pathContext) {
+  const parts = [];
+  if (pathContext.domain) {
+    parts.push(pathContext.domain);
+  }
+  if (pathContext.layer) {
+    parts.push(pathContext.layer);
+  }
+  const significantSegments = pathContext.segments.slice(-3).filter((s) => s.length > 2 && !["src", "lib", "app"].includes(s.toLowerCase()));
+  if (significantSegments.length > 0) {
+    parts.push(...significantSegments.map((s) => s.toLowerCase()));
+  }
+  if (parts.length === 0)
+    return "";
+  const unique = [...new Set(parts)];
+  return `[${unique.join(" ")}]`;
+}
+var COMMON_KEYWORDS, LAYER_PATTERNS2;
+var init_keywords = __esm(() => {
+  COMMON_KEYWORDS = new Set([
+    "const",
+    "let",
+    "var",
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "export",
+    "import",
+    "from",
+    "return",
+    "async",
+    "await",
+    "new",
+    "this",
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "if",
+    "else",
+    "for",
+    "while",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "typeof",
+    "instanceof",
+    "void",
+    "delete",
+    "in",
+    "of",
+    "string",
+    "number",
+    "boolean",
+    "any",
+    "unknown",
+    "never",
+    "object",
+    "public",
+    "private",
+    "protected",
+    "static",
+    "readonly",
+    "abstract",
+    "implements",
+    "extends",
+    "super",
+    "get",
+    "set",
+    "constructor",
+    "the",
+    "and",
+    "for",
+    "not",
+    "with",
+    "are",
+    "was",
+    "has",
+    "have"
+  ]);
+  LAYER_PATTERNS2 = {
+    controller: ["controller", "controllers", "handler", "handlers", "route", "routes", "api"],
+    service: ["service", "services", "usecase", "usecases", "application"],
+    repository: ["repository", "repositories", "repo", "repos", "dao", "store", "storage"],
+    model: ["model", "models", "entity", "entities", "schema", "schemas"],
+    util: ["util", "utils", "utility", "utilities", "helper", "helpers", "common", "shared"],
+    config: ["config", "configs", "configuration", "settings"],
+    middleware: ["middleware", "middlewares", "interceptor", "interceptors"],
+    domain: ["domain", "core", "business"],
+    infrastructure: ["infrastructure", "infra", "external", "adapters"],
+    presentation: ["presentation", "view", "views", "component", "components", "ui"],
+    test: ["test", "tests", "spec", "specs", "__tests__", "__test__"]
+  };
 });
 
-// src/app/indexer/index.ts
-init_config2();
-import { glob } from "glob";
-import * as fs6 from "fs/promises";
+// src/infrastructure/storage/symbolicIndex.ts
+import * as fs5 from "fs/promises";
 import * as path9 from "path";
 
-// src/modules/registry.ts
-class ModuleRegistryImpl {
-  modules = new Map;
-  register(module) {
-    if (this.modules.has(module.id)) {
-      console.warn(`Module '${module.id}' is already registered, overwriting...`);
-    }
-    this.modules.set(module.id, module);
-  }
-  get(id) {
-    return this.modules.get(id);
+class SymbolicIndex {
+  meta = null;
+  fileSummaries = new Map;
+  bm25Index = null;
+  symbolicPath;
+  moduleId;
+  constructor(indexDir, moduleId) {
+    this.symbolicPath = path9.join(indexDir, "index", moduleId, "symbolic");
+    this.moduleId = moduleId;
   }
-  list() {
-    return Array.from(this.modules.values());
+  async initialize() {
+    try {
+      await this.load();
+    } catch {
+      this.meta = {
+        version: "1.0.0",
+        lastUpdated: new Date().toISOString(),
+        moduleId: this.moduleId,
+        fileCount: 0,
+        bm25Data: {
+          avgDocLength: 0,
+          documentFrequencies: {},
+          totalDocs: 0
+        }
+      };
+      this.bm25Index = new BM25Index;
+    }
   }
-  getEnabled(config) {
-    const enabledIds = new Set(config.modules.filter((m) => m.enabled).map((m) => m.id));
-    return this.list().filter((m) => enabledIds.has(m.id));
+  addFile(summary) {
+    this.fileSummaries.set(summary.filepath, summary);
   }
-}
-var registry = new ModuleRegistryImpl;
-async function registerBuiltInModules() {
-  const { CoreModule: CoreModule2 } = await Promise.resolve().then(() => (init_core(), exports_core));
-  const { TypeScriptModule: TypeScriptModule2 } = await Promise.resolve().then(() => (init_typescript(), exports_typescript));
-  registry.register(new CoreModule2);
-  registry.register(new TypeScriptModule2);
-}
-
-// src/introspection/index.ts
-import * as path8 from "path";
-import * as fs5 from "fs/promises";
-
-// src/introspection/projectDetector.ts
-import * as path6 from "path";
-import * as fs4 from "fs/promises";
-var MAX_SCAN_DEPTH = 4;
-var SKIP_DIRS = new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  ".next",
-  ".nuxt",
-  "coverage",
-  ".raggrep"
-]);
-var PROJECT_PATTERNS = [
-  { pattern: /^apps\/([^/]+)/, type: "app", defaultScope: "unknown" },
-  { pattern: /^packages\/([^/]+)/, type: "library", defaultScope: "shared" },
-  { pattern: /^libs\/([^/]+)/, type: "library", defaultScope: "shared" },
-  { pattern: /^services\/([^/]+)/, type: "service", defaultScope: "backend" },
-  { pattern: /^scripts\/([^/]+)/, type: "script", defaultScope: "tooling" },
-  { pattern: /^tools\/([^/]+)/, type: "script", defaultScope: "tooling" }
-];
-var SCOPE_KEYWORDS = {
-  frontend: [
-    "web",
-    "webapp",
-    "frontend",
-    "client",
-    "ui",
-    "app",
-    "mobile",
-    "react",
-    "vue",
-    "angular",
-    "next",
-    "nuxt"
-  ],
-  backend: [
-    "api",
-    "server",
-    "backend",
-    "service",
-    "worker",
-    "lambda",
-    "functions"
-  ],
-  shared: ["shared", "common", "utils", "lib", "core", "types", "models"],
-  tooling: [
-    "scripts",
-    "tools",
-    "cli",
-    "devtools",
-    "build",
-    "config",
-    "infra"
-  ],
-  unknown: []
-};
-function detectScopeFromName(name) {
-  const nameLower = name.toLowerCase();
-  for (const [scope, keywords] of Object.entries(SCOPE_KEYWORDS)) {
-    if (scope === "unknown")
-      continue;
-    for (const keyword of keywords) {
-      if (nameLower.includes(keyword)) {
-        return scope;
-      }
-    }
+  removeFile(filepath) {
+    return this.fileSummaries.delete(filepath);
   }
-  return "unknown";
-}
-async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
-  if (depth > MAX_SCAN_DEPTH)
-    return [];
-  const results = [];
-  const fullDir = currentDir ? path6.join(rootDir, currentDir) : rootDir;
-  try {
-    const entries = await fs4.readdir(fullDir, { withFileTypes: true });
-    const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
-    if (hasPackageJson && currentDir) {
-      const info = await parsePackageJson(rootDir, currentDir);
-      if (info) {
-        results.push(info);
-      }
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      if (SKIP_DIRS.has(entry.name))
-        continue;
-      const subPath = currentDir ? `${currentDir}/${entry.name}` : entry.name;
-      const subResults = await scanForPackageJsons(rootDir, subPath, depth + 1);
-      results.push(...subResults);
+  buildBM25Index() {
+    this.bm25Index = new BM25Index;
+    for (const [filepath, summary] of this.fileSummaries) {
+      const content = [
+        ...summary.keywords,
+        ...summary.exports,
+        ...extractPathKeywords(filepath)
+      ].join(" ");
+      this.bm25Index.addDocuments([{ id: filepath, content }]);
     }
-  } catch {}
-  return results;
-}
-async function parsePackageJson(rootDir, relativePath) {
-  try {
-    const packageJsonPath = path6.join(rootDir, relativePath, "package.json");
-    const content = await fs4.readFile(packageJsonPath, "utf-8");
-    const pkg = JSON.parse(content);
-    const name = pkg.name || path6.basename(relativePath);
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    let type = "unknown";
-    if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
-      type = "app";
-    } else if (deps["express"] || deps["fastify"] || deps["koa"] || deps["hono"]) {
-      type = "service";
-    } else if (pkg.main || pkg.exports) {
-      type = "library";
+    if (this.meta) {
+      this.meta.fileCount = this.fileSummaries.size;
+      this.meta.bm25Data.totalDocs = this.fileSummaries.size;
     }
-    const hasWorkspaces = Boolean(pkg.workspaces);
-    return { name, relativePath, type, hasWorkspaces };
-  } catch {
-    return null;
   }
-}
-async function detectProjectStructure(rootDir) {
-  const projectMap = new Map;
-  let isMonorepo = false;
-  try {
-    const entries = await fs4.readdir(rootDir, { withFileTypes: true });
-    const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
-    const monorepoPatterns = ["apps", "packages", "libs", "services"];
-    const hasMonorepoStructure = monorepoPatterns.some((p) => dirNames.includes(p));
-    if (hasMonorepoStructure) {
-      isMonorepo = true;
-      for (const pattern of monorepoPatterns) {
-        if (!dirNames.includes(pattern))
-          continue;
-        const patternDir = path6.join(rootDir, pattern);
-        try {
-          const subDirs = await fs4.readdir(patternDir, { withFileTypes: true });
-          for (const subDir of subDirs) {
-            if (!subDir.isDirectory())
-              continue;
-            const projectRoot = `${pattern}/${subDir.name}`;
-            const type = getProjectType(pattern);
-            projectMap.set(projectRoot, {
-              name: subDir.name,
-              root: projectRoot,
-              type
-            });
-          }
-        } catch {}
-      }
+  findCandidates(query, maxCandidates = 20) {
+    if (!this.bm25Index) {
+      return Array.from(this.fileSummaries.keys());
     }
-    const packageJsons = await scanForPackageJsons(rootDir);
-    for (const pkg of packageJsons) {
-      if (pkg.hasWorkspaces) {
-        isMonorepo = true;
-      }
-      if (packageJsons.length > 1) {
-        isMonorepo = true;
-      }
-      projectMap.set(pkg.relativePath, {
-        name: pkg.name,
-        root: pkg.relativePath,
-        type: pkg.type
-      });
+    const results = this.bm25Index.search(query, maxCandidates);
+    return results.map((r) => r.id);
+  }
+  getAllFiles() {
+    return Array.from(this.fileSummaries.keys());
+  }
+  getFileSummary(filepath) {
+    return this.fileSummaries.get(filepath);
+  }
+  async save() {
+    if (!this.meta)
+      throw new Error("Index not initialized");
+    this.meta.lastUpdated = new Date().toISOString();
+    this.meta.fileCount = this.fileSummaries.size;
+    await fs5.mkdir(this.symbolicPath, { recursive: true });
+    const metaPath = path9.join(this.symbolicPath, "_meta.json");
+    await fs5.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
+    for (const [filepath, summary] of this.fileSummaries) {
+      const summaryPath = this.getFileSummaryPath(filepath);
+      await fs5.mkdir(path9.dirname(summaryPath), { recursive: true });
+      await fs5.writeFile(summaryPath, JSON.stringify(summary, null, 2));
     }
-    let rootType = "unknown";
+  }
+  async load() {
+    const metaPath = path9.join(this.symbolicPath, "_meta.json");
+    const metaContent = await fs5.readFile(metaPath, "utf-8");
+    this.meta = JSON.parse(metaContent);
+    this.fileSummaries.clear();
+    await this.loadFileSummariesRecursive(this.symbolicPath);
+    this.buildBM25Index();
+  }
+  async loadFileSummariesRecursive(dir) {
     try {
-      const rootPkgPath = path6.join(rootDir, "package.json");
-      const rootPkg = JSON.parse(await fs4.readFile(rootPkgPath, "utf-8"));
-      if (rootPkg.workspaces) {
-        isMonorepo = true;
-      }
-      const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
-      if (deps["next"] || deps["react"] || deps["vue"]) {
-        rootType = "app";
-      } else if (deps["express"] || deps["fastify"] || deps["koa"]) {
-        rootType = "service";
+      const entries = await fs5.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path9.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await this.loadFileSummariesRecursive(fullPath);
+        } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
+          try {
+            const content = await fs5.readFile(fullPath, "utf-8");
+            const summary = JSON.parse(content);
+            if (summary.filepath) {
+              this.fileSummaries.set(summary.filepath, summary);
+            }
+          } catch {}
+        }
       }
     } catch {}
-    const projects = Array.from(projectMap.values()).sort((a, b) => a.root.length - b.root.length);
-    return {
-      projects,
-      isMonorepo,
-      rootType: isMonorepo ? undefined : rootType
-    };
-  } catch {
-    return {
-      projects: [],
-      isMonorepo: false,
-      rootType: "unknown"
-    };
   }
-}
-function getProjectType(patternDir) {
-  switch (patternDir) {
-    case "apps":
-      return "app";
-    case "packages":
-    case "libs":
-      return "library";
-    case "services":
-      return "service";
-    case "scripts":
-    case "tools":
-      return "script";
-    default:
-      return "unknown";
+  getFileSummaryPath(filepath) {
+    const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
+    return path9.join(this.symbolicPath, jsonPath);
   }
-}
-function findProjectForFile(filepath, structure) {
-  const normalizedPath = filepath.replace(/\\/g, "/");
-  const matches = [];
-  for (const project of structure.projects) {
-    if (normalizedPath === project.root || normalizedPath.startsWith(project.root + "/")) {
-      matches.push(project);
+  async deleteFileSummary(filepath) {
+    try {
+      await fs5.unlink(this.getFileSummaryPath(filepath));
+    } catch {}
+    this.fileSummaries.delete(filepath);
+  }
+  async exists() {
+    try {
+      const metaPath = path9.join(this.symbolicPath, "_meta.json");
+      await fs5.access(metaPath);
+      return true;
+    } catch {
+      return false;
     }
   }
-  if (matches.length > 0) {
-    return matches.reduce((best, current) => current.root.length > best.root.length ? current : best);
+  get size() {
+    return this.fileSummaries.size;
   }
-  for (const { pattern, type } of PROJECT_PATTERNS) {
-    const match = normalizedPath.match(pattern);
-    if (match) {
-      return {
-        name: match[1],
-        root: match[0],
-        type
+  clear() {
+    this.fileSummaries.clear();
+    if (this.meta) {
+      this.meta.fileCount = 0;
+      this.meta.bm25Data = {
+        avgDocLength: 0,
+        documentFrequencies: {},
+        totalDocs: 0
       };
     }
+    this.bm25Index = new BM25Index;
   }
-  return {
-    name: "root",
-    root: "",
-    type: structure.rootType ?? "unknown"
-  };
 }
+var init_symbolicIndex = __esm(() => {
+  init_keywords();
+});
 
-// src/introspection/fileIntrospector.ts
-import * as path7 from "path";
-var LAYER_PATTERNS2 = {
-  controller: ["controller", "api", "routes", "route", "handler"],
-  service: ["service", "logic", "usecase", "usecases", "handler"],
-  repository: ["repository", "repo", "dao", "store", "persistence"],
-  model: ["model", "models", "entity", "entities", "schema", "schemas", "types", "type"],
-  util: ["util", "utils", "helper", "helpers", "common", "lib"],
-  config: ["config", "configuration", "settings"],
-  middleware: ["middleware", "middlewares"],
-  domain: ["domain"],
-  infrastructure: ["infrastructure", "infra"],
-  application: ["application", "app"],
-  presentation: ["presentation", "ui", "views", "view", "component", "components"],
-  test: ["test", "tests", "spec", "specs", "__tests__", "e2e"]
-};
-var DOMAIN_PATTERNS = [
-  "auth",
-  "authentication",
-  "user",
-  "users",
-  "account",
-  "accounts",
-  "profile",
-  "profiles",
-  "product",
-  "products",
-  "item",
-  "items",
-  "catalog",
-  "order",
-  "orders",
-  "cart",
-  "checkout",
-  "payment",
-  "payments",
-  "billing",
-  "subscription",
-  "subscriptions",
-  "notification",
-  "notifications",
-  "email",
-  "sms",
-  "report",
-  "reports",
-  "analytics",
-  "metrics",
-  "dashboard",
-  "admin",
-  "settings",
-  "search",
-  "chat",
-  "message",
-  "messages",
-  "feed",
-  "post",
-  "posts",
-  "comment",
-  "comments",
-  "media",
-  "upload",
-  "file",
-  "files",
-  "storage",
-  "cache",
-  "session",
-  "log",
-  "logs",
-  "audit"
-];
-var FRAMEWORK_INDICATORS = {
-  nextjs: ["next", "next/"],
-  express: ["express"],
-  fastify: ["fastify"],
-  react: ["react"],
-  vue: ["vue"],
-  angular: ["@angular/"],
-  nestjs: ["@nestjs/"],
-  koa: ["koa"]
-};
-var EXTENSION_TO_LANGUAGE = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".go": "go",
-  ".rs": "rust",
-  ".java": "java",
-  ".kt": "kotlin",
-  ".swift": "swift",
-  ".rb": "ruby",
-  ".php": "php",
-  ".cs": "csharp",
-  ".cpp": "cpp",
-  ".c": "c",
-  ".h": "c",
-  ".hpp": "cpp",
-  ".md": "markdown",
-  ".json": "json",
-  ".yaml": "yaml",
-  ".yml": "yaml"
-};
-function introspectFile(filepath, structure, fileContent) {
-  const normalizedPath = filepath.replace(/\\/g, "/");
-  const segments = normalizedPath.split("/").filter((s) => s.length > 0);
-  const filename = segments[segments.length - 1] || "";
-  const ext = path7.extname(filename);
-  const project = findProjectForFile(normalizedPath, structure);
-  const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
-  const layer = detectLayer(segments, filename);
-  const domain = detectDomain(segments);
-  const scope = detectScope(segments, project, layer);
-  let framework;
-  if (fileContent) {
-    framework = detectFramework(fileContent);
+// src/infrastructure/storage/index.ts
+var init_storage = __esm(() => {
+  init_fileIndexStorage();
+  init_symbolicIndex();
+});
+
+// src/modules/language/typescript/index.ts
+var exports_typescript = {};
+__export(exports_typescript, {
+  TypeScriptModule: () => TypeScriptModule,
+  DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
+  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
+});
+import * as path10 from "path";
+
+class TypeScriptModule {
+  id = "language/typescript";
+  name = "TypeScript Search";
+  description = "TypeScript-aware code search with AST parsing and semantic embeddings";
+  version = "1.0.0";
+  embeddingConfig = null;
+  symbolicIndex = null;
+  pendingSummaries = new Map;
+  rootDir = "";
+  async initialize(config) {
+    this.embeddingConfig = getEmbeddingConfigFromModule(config);
+    configureEmbeddings(this.embeddingConfig);
+    this.pendingSummaries.clear();
   }
-  return {
-    filepath: normalizedPath,
-    project,
-    scope,
-    layer,
-    domain,
-    language,
-    framework,
-    depth: segments.length - 1,
-    pathSegments: segments.slice(0, -1)
-  };
-}
-function detectLayer(segments, filename) {
-  const filenameLower = filename.toLowerCase();
-  for (const [layer, patterns] of Object.entries(LAYER_PATTERNS2)) {
-    for (const pattern of patterns) {
-      if (filenameLower.includes(pattern)) {
-        return layer;
+  async indexFile(filepath, content, ctx) {
+    this.rootDir = ctx.rootDir;
+    const parsedChunks = parseCode(content, filepath);
+    if (parsedChunks.length === 0) {
+      return null;
+    }
+    const pathContext = parsePathContext(filepath);
+    const pathPrefix = formatPathContextForEmbedding(pathContext);
+    const chunkContents = parsedChunks.map((c) => {
+      const namePrefix = c.name ? `${c.name}: ` : "";
+      return `${pathPrefix} ${namePrefix}${c.content}`;
+    });
+    const embeddings = await getEmbeddings(chunkContents);
+    const chunks = parsedChunks.map((pc) => ({
+      id: generateChunkId(filepath, pc.startLine, pc.endLine),
+      content: pc.content,
+      startLine: pc.startLine,
+      endLine: pc.endLine,
+      type: pc.type,
+      name: pc.name,
+      isExported: pc.isExported,
+      jsDoc: pc.jsDoc
+    }));
+    const references = this.extractReferences(content, filepath);
+    const stats = await ctx.getFileStats(filepath);
+    const currentConfig = getEmbeddingConfig();
+    const moduleData = {
+      embeddings,
+      embeddingModel: currentConfig.model
+    };
+    const chunkTypes = [...new Set(parsedChunks.map((pc) => pc.type))];
+    const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
+    const allKeywords = new Set;
+    for (const pc of parsedChunks) {
+      const keywords = extractKeywords(pc.content, pc.name);
+      keywords.forEach((k) => allKeywords.add(k));
+    }
+    pathContext.keywords.forEach((k) => allKeywords.add(k));
+    const fileSummary = {
+      filepath,
+      chunkCount: chunks.length,
+      chunkTypes,
+      keywords: Array.from(allKeywords),
+      exports,
+      lastModified: stats.lastModified,
+      pathContext: {
+        segments: pathContext.segments,
+        layer: pathContext.layer,
+        domain: pathContext.domain,
+        depth: pathContext.depth
       }
+    };
+    this.pendingSummaries.set(filepath, fileSummary);
+    return {
+      filepath,
+      lastModified: stats.lastModified,
+      chunks,
+      moduleData,
+      references
+    };
+  }
+  async finalize(ctx) {
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    this.symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    await this.symbolicIndex.initialize();
+    for (const [filepath, summary] of this.pendingSummaries) {
+      this.symbolicIndex.addFile(summary);
     }
+    this.symbolicIndex.buildBM25Index();
+    await this.symbolicIndex.save();
+    console.log(`  Symbolic index built with ${this.pendingSummaries.size} file summaries`);
+    this.pendingSummaries.clear();
   }
-  for (let i = segments.length - 2;i >= 0; i--) {
-    const segment = segments[i].toLowerCase();
-    for (const [layer, patterns] of Object.entries(LAYER_PATTERNS2)) {
-      if (patterns.includes(segment)) {
-        return layer;
+  async search(query, ctx, options = {}) {
+    const { topK = DEFAULT_TOP_K2, minScore = DEFAULT_MIN_SCORE2, filePatterns } = options;
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    const symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    let candidateFiles;
+    try {
+      await symbolicIndex.initialize();
+      const maxCandidates = topK * TIER1_CANDIDATE_MULTIPLIER;
+      candidateFiles = symbolicIndex.findCandidates(query, maxCandidates);
+      if (candidateFiles.length === 0) {
+        candidateFiles = symbolicIndex.getAllFiles();
+      }
+    } catch {
+      candidateFiles = await ctx.listIndexedFiles();
+    }
+    if (filePatterns && filePatterns.length > 0) {
+      candidateFiles = candidateFiles.filter((filepath) => {
+        return filePatterns.some((pattern) => {
+          if (pattern.startsWith("*.")) {
+            const ext = pattern.slice(1);
+            return filepath.endsWith(ext);
+          }
+          return filepath.includes(pattern);
+        });
+      });
+    }
+    const queryEmbedding = await getEmbedding(query);
+    const bm25Index = new BM25Index;
+    const allChunksData = [];
+    for (const filepath of candidateFiles) {
+      const fileIndex = await ctx.loadFileIndex(filepath);
+      if (!fileIndex)
+        continue;
+      const moduleData = fileIndex.moduleData;
+      if (!moduleData?.embeddings)
+        continue;
+      for (let i = 0;i < fileIndex.chunks.length; i++) {
+        const chunk = fileIndex.chunks[i];
+        const embedding = moduleData.embeddings[i];
+        if (!embedding)
+          continue;
+        allChunksData.push({
+          filepath: fileIndex.filepath,
+          chunk,
+          embedding
+        });
+        bm25Index.addDocuments([{ id: chunk.id, content: chunk.content }]);
       }
     }
-  }
-  return;
-}
-function detectDomain(segments) {
-  const skipSegments = new Set([
-    "src",
-    "lib",
-    "app",
-    "apps",
-    "packages",
-    "services",
-    "modules",
-    "features",
-    ...Object.values(LAYER_PATTERNS2).flat()
-  ]);
-  for (const segment of segments) {
-    const segmentLower = segment.toLowerCase();
-    if (skipSegments.has(segmentLower))
-      continue;
-    if (DOMAIN_PATTERNS.includes(segmentLower)) {
-      return segmentLower;
+    const bm25Results = bm25Index.search(query, topK * 3);
+    const bm25Scores = new Map;
+    for (const result of bm25Results) {
+      bm25Scores.set(result.id, normalizeScore(result.score, 3));
     }
-    for (const domain of DOMAIN_PATTERNS) {
-      if (segmentLower.startsWith(domain) || segmentLower.endsWith(domain)) {
-        return domain;
+    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+    const pathBoosts = new Map;
+    for (const filepath of candidateFiles) {
+      const summary = symbolicIndex.getFileSummary(filepath);
+      if (summary?.pathContext) {
+        let boost = 0;
+        const ctx2 = summary.pathContext;
+        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
+          boost += 0.1;
+        }
+        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
+          boost += 0.05;
+        }
+        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
+        if (segmentMatch) {
+          boost += 0.05;
+        }
+        pathBoosts.set(filepath, boost);
       }
     }
-  }
-  return;
-}
-function detectScope(segments, project, layer) {
-  const projectScope = detectScopeFromName(project.name);
-  if (projectScope !== "unknown") {
-    return projectScope;
-  }
-  if (layer) {
-    switch (layer) {
-      case "controller":
-      case "repository":
-      case "middleware":
-        return "backend";
-      case "presentation":
-        return "frontend";
-      case "util":
-      case "model":
-        return "shared";
-      case "test":
-        return "tooling";
+    const results = [];
+    for (const { filepath, chunk, embedding } of allChunksData) {
+      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
+      const bm25Score = bm25Scores.get(chunk.id) || 0;
+      const pathBoost = pathBoosts.get(filepath) || 0;
+      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + pathBoost;
+      if (hybridScore >= minScore || bm25Score > 0.3) {
+        results.push({
+          filepath,
+          chunk,
+          score: hybridScore,
+          moduleId: this.id,
+          context: {
+            semanticScore,
+            bm25Score,
+            pathBoost
+          }
+        });
+      }
     }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
   }
-  for (const segment of segments) {
-    const segmentLower = segment.toLowerCase();
-    if (["server", "api", "backend"].includes(segmentLower)) {
-      return "backend";
-    }
-    if (["client", "web", "frontend", "ui"].includes(segmentLower)) {
-      return "frontend";
-    }
-    if (["shared", "common", "lib", "libs"].includes(segmentLower)) {
-      return "shared";
+  extractReferences(content, filepath) {
+    const references = [];
+    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath.startsWith(".")) {
+        const dir = path10.dirname(filepath);
+        const resolved = path10.normalize(path10.join(dir, importPath));
+        references.push(resolved);
+      }
     }
-  }
-  return "unknown";
-}
-function detectFramework(content) {
-  for (const [framework, indicators] of Object.entries(FRAMEWORK_INDICATORS)) {
-    for (const indicator of indicators) {
-      if (content.includes(`from '${indicator}`) || content.includes(`from "${indicator}`) || content.includes(`require('${indicator}`) || content.includes(`require("${indicator}`)) {
-        return framework;
+    while ((match = requireRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath.startsWith(".")) {
+        const dir = path10.dirname(filepath);
+        const resolved = path10.normalize(path10.join(dir, importPath));
+        references.push(resolved);
       }
     }
+    return references;
   }
-  return;
 }
+var DEFAULT_MIN_SCORE2 = 0.15, DEFAULT_TOP_K2 = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3, TIER1_CANDIDATE_MULTIPLIER = 3;
+var init_typescript = __esm(() => {
+  init_embeddings();
+  init_config2();
+  init_parseCode();
+  init_storage();
+  init_keywords();
+  init_keywords();
+});
 
-// src/introspection/index.ts
+// src/app/indexer/index.ts
 init_config2();
+import { glob } from "glob";
+import * as fs6 from "fs/promises";
+import * as path11 from "path";
 
-class IntrospectionIndex {
-  rootDir;
-  structure = null;
-  files = new Map;
-  config = {};
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-  }
-  async initialize() {
-    this.structure = await detectProjectStructure(this.rootDir);
-    try {
-      const configPath = path8.join(this.rootDir, ".raggrep", "config.json");
-      const configContent = await fs5.readFile(configPath, "utf-8");
-      const config = JSON.parse(configContent);
-      this.config = config.introspection || {};
-    } catch {}
-  }
-  getStructure() {
-    return this.structure;
-  }
-  addFile(filepath, content) {
-    if (!this.structure) {
-      throw new Error("IntrospectionIndex not initialized");
-    }
-    const intro = introspectFile(filepath, this.structure, content);
-    this.applyOverrides(intro);
-    this.files.set(filepath, intro);
-    return intro;
-  }
-  getFile(filepath) {
-    return this.files.get(filepath);
-  }
-  getAllFiles() {
-    return Array.from(this.files.values());
-  }
-  applyOverrides(intro) {
-    if (!this.config.projects)
-      return;
-    for (const [projectPath, overrides] of Object.entries(this.config.projects)) {
-      if (intro.filepath.startsWith(projectPath + "/") || intro.project.root === projectPath) {
-        if (overrides.scope) {
-          intro.scope = overrides.scope;
-        }
-        if (overrides.framework) {
-          intro.framework = overrides.framework;
-        }
-        break;
-      }
-    }
-  }
-  async save(config) {
-    const introDir = path8.join(getRaggrepDir(this.rootDir, config), "introspection");
-    await fs5.mkdir(introDir, { recursive: true });
-    const projectPath = path8.join(introDir, "_project.json");
-    await fs5.writeFile(projectPath, JSON.stringify({
-      version: "1.0.0",
-      lastUpdated: new Date().toISOString(),
-      structure: this.structure
-    }, null, 2));
-    for (const [filepath, intro] of this.files) {
-      const introFilePath = path8.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
-      await fs5.mkdir(path8.dirname(introFilePath), { recursive: true });
-      await fs5.writeFile(introFilePath, JSON.stringify(intro, null, 2));
+// src/modules/registry.ts
+class ModuleRegistryImpl {
+  modules = new Map;
+  register(module) {
+    if (this.modules.has(module.id)) {
+      console.warn(`Module '${module.id}' is already registered, overwriting...`);
     }
-    console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
+    this.modules.set(module.id, module);
   }
-  async load(config) {
-    const introDir = path8.join(getRaggrepDir(this.rootDir, config), "introspection");
-    try {
-      const projectPath = path8.join(introDir, "_project.json");
-      const projectContent = await fs5.readFile(projectPath, "utf-8");
-      const projectData = JSON.parse(projectContent);
-      this.structure = projectData.structure;
-      await this.loadFilesRecursive(path8.join(introDir, "files"), "");
-    } catch {
-      this.structure = null;
-      this.files.clear();
-    }
+  get(id) {
+    return this.modules.get(id);
   }
-  async loadFilesRecursive(basePath, prefix) {
-    try {
-      const entries = await fs5.readdir(basePath, { withFileTypes: true });
-      for (const entry of entries) {
-        const entryPath = path8.join(basePath, entry.name);
-        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-          await this.loadFilesRecursive(entryPath, relativePath);
-        } else if (entry.name.endsWith(".json")) {
-          const content = await fs5.readFile(entryPath, "utf-8");
-          const intro = JSON.parse(content);
-          this.files.set(intro.filepath, intro);
-        }
-      }
-    } catch {}
+  list() {
+    return Array.from(this.modules.values());
   }
-  clear() {
-    this.files.clear();
-    this.structure = null;
+  getEnabled(config) {
+    const enabledIds = new Set(config.modules.filter((m) => m.enabled).map((m) => m.id));
+    return this.list().filter((m) => enabledIds.has(m.id));
   }
 }
+var registry = new ModuleRegistryImpl;
+async function registerBuiltInModules() {
+  const { CoreModule: CoreModule2 } = await Promise.resolve().then(() => (init_core(), exports_core));
+  const { TypeScriptModule: TypeScriptModule2 } = await Promise.resolve().then(() => (init_typescript(), exports_typescript));
+  registry.register(new CoreModule2);
+  registry.register(new TypeScriptModule2);
+}
+
+// src/app/indexer/index.ts
+init_introspection();
 
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
@@ -2182,8 +3035,10 @@ init_config2();
 // src/app/indexer/index.ts
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path9.resolve(rootDir);
+  rootDir = path11.resolve(rootDir);
+  const location = getIndexLocation(rootDir);
   console.log(`Indexing directory: ${rootDir}`);
+  console.log(`Index location: ${location.indexDir}`);
   const config = await loadConfig(rootDir);
   const introspection = new IntrospectionIndex(rootDir);
   await introspection.initialize();
@@ -2225,11 +3080,11 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+          const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
           return fs6.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+          const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
           const stats = await fs6.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
@@ -2254,18 +3109,18 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+      const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
       return fs6.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+      const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
       const stats = await fs6.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     },
     getIntrospection: (filepath) => introspection.getFile(filepath)
   };
   for (const filepath of files) {
-    const relativePath = path9.relative(rootDir, filepath);
+    const relativePath = path11.relative(rootDir, filepath);
     try {
       const stats = await fs6.stat(filepath);
       const lastModified = stats.mtime.toISOString();
@@ -2335,13 +3190,13 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs6.mkdir(path9.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path11.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
-  const indexFilePath = path9.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs6.mkdir(path9.dirname(indexFilePath), { recursive: true });
+  const indexFilePath = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs6.mkdir(path11.dirname(indexFilePath), { recursive: true });
   await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
@@ -2351,12 +3206,12 @@ async function updateGlobalManifest(rootDir, modules, config) {
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
-  await fs6.mkdir(path9.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path11.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path9.resolve(rootDir);
+  rootDir = path11.resolve(rootDir);
   console.log(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -2386,7 +3241,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path9.join(rootDir, filepath);
+    const fullPath = path11.join(rootDir, filepath);
     try {
       await fs6.access(fullPath);
       updatedFiles[filepath] = entry;
@@ -2400,7 +3255,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path9.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
       await fs6.unlink(indexFilePath);
     } catch {}
@@ -2416,7 +3271,7 @@ async function cleanupEmptyDirectories(dir) {
     const entries = await fs6.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path9.join(dir, entry.name);
+        const subDir = path11.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
@@ -2434,9 +3289,9 @@ async function cleanupEmptyDirectories(dir) {
 // src/app/search/index.ts
 init_config2();
 import * as fs7 from "fs/promises";
-import * as path10 from "path";
+import * as path12 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path10.resolve(rootDir);
+  rootDir = path12.resolve(rootDir);
   console.log(`Searching for: "${query}"`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -2477,7 +3332,7 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path10.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path10.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path12.join(indexPath, filepath + ".json");
       try {
         const content = await fs7.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
@@ -2489,7 +3344,7 @@ function createSearchContext(rootDir, moduleId, config) {
       const files = [];
       await traverseDirectory(indexPath, files, indexPath);
       return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
-        const relative3 = path10.relative(indexPath, f);
+        const relative3 = path12.relative(indexPath, f);
         return relative3.replace(/\.json$/, "");
       });
     }
@@ -2499,7 +3354,7 @@ async function traverseDirectory(dir, files, basePath) {
   try {
     const entries = await fs7.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path10.join(dir, entry.name);
+      const fullPath = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -2575,4 +3430,4 @@ export {
   cleanup
 };
 
-//# debugId=0E3E5BCA1147AB0A64756E2164756E21
+//# debugId=3C6A4139E7CDC07F64756E2164756E21