raggrep 0.1.5 → 0.1.7

package/dist/cli/main.js

@@ -235,7 +235,8 @@ var init_config = __esm(() => {
     ".go",
     ".rs",
     ".java",
-    ".md"
+    ".md",
+    ".txt"
   ];
 });
 
@@ -248,20 +249,40 @@ var init_entities = __esm(() => {
 // src/infrastructure/config/configLoader.ts
 import * as path2 from "path";
 import * as fs from "fs/promises";
-function getRaggrepDir(rootDir, config = DEFAULT_CONFIG) {
-  return path2.join(rootDir, config.indexDir);
+import * as os2 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 = path2.resolve(rootDir);
+  const projectHash = hashPath(absoluteRoot);
+  return path2.join(RAGGREP_TEMP_BASE, projectHash);
+}
+function getIndexLocation(rootDir) {
+  const absoluteRoot = path2.resolve(rootDir);
+  const projectHash = hashPath(absoluteRoot);
+  return {
+    indexDir: path2.join(RAGGREP_TEMP_BASE, projectHash),
+    projectRoot: absoluteRoot,
+    projectHash
+  };
 }
 function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
-  return path2.join(rootDir, config.indexDir, "index", moduleId);
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path2.join(indexDir, "index", moduleId);
 }
 function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
-  return path2.join(rootDir, config.indexDir, "index", moduleId, "manifest.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path2.join(indexDir, "index", moduleId, "manifest.json");
 }
 function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG) {
-  return path2.join(rootDir, config.indexDir, "manifest.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path2.join(indexDir, "manifest.json");
 }
 function getConfigPath(rootDir, config = DEFAULT_CONFIG) {
-  return path2.join(rootDir, config.indexDir, "config.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path2.join(indexDir, "config.json");
 }
 async function loadConfig(rootDir) {
   const configPath = getConfigPath(rootDir, DEFAULT_CONFIG);
@@ -288,10 +309,11 @@ function getEmbeddingConfigFromModule(moduleConfig) {
     showProgress: options.showProgress !== false
   };
 }
-var DEFAULT_CONFIG, EMBEDDING_MODELS2;
+var DEFAULT_CONFIG, RAGGREP_TEMP_BASE, EMBEDDING_MODELS2;
 var init_configLoader = __esm(() => {
   init_entities();
   DEFAULT_CONFIG = createDefaultConfig();
+  RAGGREP_TEMP_BASE = path2.join(os2.tmpdir(), "raggrep-indexes");
   EMBEDDING_MODELS2 = {
     "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
     "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
@@ -407,405 +429,1712 @@ 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))
-        continue;
-      seenSymbols.add(symbolKey);
-      const beforeMatch = content.substring(0, match.index);
-      const line = beforeMatch.split(`
-`).length;
-      symbols.push({
-        name,
-        type,
-        line,
-        isExported: exported
-      });
-    }
-  }
-  return symbols.sort((a, b) => a.line - b.line);
+// src/domain/services/conventions/entryPoints.ts
+import * as path3 from "path";
+function getParentFolder(filepath) {
+  const dir = path3.dirname(filepath);
+  return path3.basename(dir);
 }
-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);
+var entryPointConventions;
+var init_entryPoints = __esm(() => {
+  entryPointConventions = [
+    {
+      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()];
+      }
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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()];
+      }
+    },
+    {
+      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()];
+      }
+    },
+    {
+      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"]
+    },
+    {
+      id: "go-main",
+      name: "Go Main Entry",
+      description: "Go application main entry point",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "main.go";
+      },
+      keywords: ["entry", "main", "go", "golang", "entrypoint"],
+      dynamicKeywords: (filepath) => {
+        const parent = getParentFolder(filepath);
+        if (parent && !["cmd", "src", ".", ""].includes(parent)) {
+          return [parent.toLowerCase()];
+        }
+        return [];
+      }
+    },
+    {
+      id: "python-main",
+      name: "Python Main Module",
+      description: "Python package main entry point",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "__main__.py";
+      },
+      keywords: ["entry", "main", "python", "entrypoint", "cli"],
+      dynamicKeywords: (filepath) => {
+        const parent = getParentFolder(filepath);
+        if (["src", "lib", ".", ""].includes(parent)) {
+          return [];
+        }
+        return [parent.toLowerCase()];
       }
+    },
+    {
+      id: "python-app",
+      name: "Python App Entry",
+      description: "Common Python application entry points",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "app.py" || filename === "main.py" || filename === "run.py";
+      },
+      keywords: ["entry", "main", "python", "app", "entrypoint"]
+    },
+    {
+      id: "python-manage",
+      name: "Django Manage",
+      description: "Django management script",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "manage.py";
+      },
+      keywords: ["entry", "django", "python", "manage", "cli", "admin"]
+    },
+    {
+      id: "python-wsgi",
+      name: "Python WSGI Entry",
+      description: "Python WSGI application entry point",
+      category: "entry-point",
+      match: (filepath, filename) => {
+        return filename === "wsgi.py" || filename === "asgi.py";
+      },
+      keywords: ["entry", "wsgi", "asgi", "python", "server", "web"]
     }
-  }
-  return Array.from(keywords);
-}
-var SYMBOL_PATTERNS;
-var init_symbols = __esm(() => {
-  SYMBOL_PATTERNS = [
+  ];
+});
+
+// src/domain/services/conventions/configFiles.ts
+var configFileConventions;
+var init_configFiles = __esm(() => {
+  configFileConventions = [
     {
-      type: "function",
-      pattern: /^export\s+(?:async\s+)?function\s+(\w+)/gm,
-      exported: true
+      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: "function",
-      pattern: /^export\s+(?:const|let)\s+(\w+)\s*=\s*(?:async\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: "class",
-      pattern: /^export\s+(?:abstract\s+)?class\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: "interface",
-      pattern: /^export\s+interface\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: "type",
-      pattern: /^export\s+type\s+(\w+)/gm,
-      exported: true
+      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: "enum",
-      pattern: /^export\s+(?:const\s+)?enum\s+(\w+)/gm,
-      exported: true
+      id: "go-mod",
+      name: "Go Module",
+      description: "Go module definition file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "go.mod",
+      keywords: [
+        "go",
+        "golang",
+        "module",
+        "dependencies",
+        "package",
+        "workspace"
+      ]
     },
     {
-      type: "variable",
-      pattern: /^export\s+(?:const|let|var)\s+(\w+)\s*(?::|=)/gm,
-      exported: true
+      id: "go-sum",
+      name: "Go Sum",
+      description: "Go module checksum file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "go.sum",
+      keywords: ["go", "golang", "dependencies", "checksum", "lock", "versions"]
     },
     {
-      type: "function",
-      pattern: /^export\s+default\s+(?:async\s+)?function\s+(\w+)/gm,
-      exported: true
+      id: "go-work",
+      name: "Go Workspace",
+      description: "Go workspace configuration for multi-module development",
+      category: "configuration",
+      match: (filepath, filename) => filename === "go.work" || filename === "go.work.sum",
+      keywords: ["go", "golang", "workspace", "monorepo", "modules"]
     },
     {
-      type: "class",
-      pattern: /^export\s+default\s+class\s+(\w+)/gm,
-      exported: true
+      id: "makefile",
+      name: "Makefile",
+      description: "Make build automation file",
+      category: "build",
+      match: (filepath, filename) => filename === "Makefile" || filename === "makefile" || filename === "GNUmakefile",
+      keywords: ["make", "build", "automation", "tasks", "compile"]
     },
     {
-      type: "function",
-      pattern: /^(?:async\s+)?function\s+(\w+)/gm,
-      exported: false
+      id: "requirements-txt",
+      name: "Python Requirements",
+      description: "Python pip requirements file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "requirements.txt" || filename.startsWith("requirements-") || filename.startsWith("requirements_"),
+      keywords: ["python", "pip", "dependencies", "packages", "requirements"]
     },
     {
-      type: "function",
-      pattern: /^(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/gm,
-      exported: false
+      id: "pyproject-toml",
+      name: "Python Project",
+      description: "Python project configuration (PEP 518/621)",
+      category: "configuration",
+      match: (filepath, filename) => filename === "pyproject.toml",
+      keywords: [
+        "python",
+        "project",
+        "config",
+        "poetry",
+        "build",
+        "dependencies",
+        "package"
+      ]
     },
     {
-      type: "class",
-      pattern: /^(?:abstract\s+)?class\s+(\w+)/gm,
-      exported: false
+      id: "setup-py",
+      name: "Python Setup",
+      description: "Python package setup script",
+      category: "configuration",
+      match: (filepath, filename) => filename === "setup.py",
+      keywords: ["python", "setup", "package", "install", "distribution"]
     },
     {
-      type: "interface",
-      pattern: /^interface\s+(\w+)/gm,
-      exported: false
+      id: "setup-cfg",
+      name: "Python Setup Config",
+      description: "Python setup configuration file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "setup.cfg",
+      keywords: ["python", "setup", "config", "package", "metadata"]
     },
     {
-      type: "type",
-      pattern: /^type\s+(\w+)/gm,
-      exported: false
+      id: "pipfile",
+      name: "Pipfile",
+      description: "Pipenv dependency file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "Pipfile" || filename === "Pipfile.lock",
+      keywords: ["python", "pipenv", "dependencies", "packages", "virtualenv"]
     },
     {
-      type: "enum",
-      pattern: /^(?:const\s+)?enum\s+(\w+)/gm,
-      exported: false
+      id: "poetry-lock",
+      name: "Poetry Lock",
+      description: "Poetry dependency lock file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "poetry.lock",
+      keywords: ["python", "poetry", "dependencies", "lock", "versions"]
     },
     {
-      type: "function",
-      pattern: /^def\s+(\w+)\s*\(/gm,
-      exported: false
+      id: "tox-ini",
+      name: "Tox Config",
+      description: "Tox testing automation configuration",
+      category: "test",
+      match: (filepath, filename) => filename === "tox.ini",
+      keywords: ["python", "tox", "testing", "automation", "environments"]
     },
     {
-      type: "class",
-      pattern: /^class\s+(\w+)(?:\s*\(|:)/gm,
-      exported: false
+      id: "pytest-ini",
+      name: "Pytest Config",
+      description: "Pytest configuration file",
+      category: "test",
+      match: (filepath, filename) => filename === "pytest.ini" || filename === "conftest.py",
+      keywords: ["python", "pytest", "testing", "test", "fixtures"]
     },
     {
-      type: "function",
-      pattern: /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/gm,
-      exported: false
+      id: "mypy-ini",
+      name: "Mypy Config",
+      description: "Mypy type checker configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "mypy.ini" || filename === ".mypy.ini",
+      keywords: ["python", "mypy", "types", "type checking", "static analysis"]
     },
     {
-      type: "type",
-      pattern: /^type\s+(\w+)\s+(?:struct|interface)/gm,
-      exported: false
+      id: "flake8",
+      name: "Flake8 Config",
+      description: "Flake8 linter configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".flake8",
+      keywords: ["python", "flake8", "linting", "lint", "style"]
     },
     {
-      type: "function",
-      pattern: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm,
-      exported: false
+      id: "pylintrc",
+      name: "Pylint Config",
+      description: "Pylint linter configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".pylintrc" || filename === "pylintrc" || filename === "pylint.toml",
+      keywords: ["python", "pylint", "linting", "lint", "code quality"]
     },
     {
-      type: "type",
-      pattern: /^(?:pub\s+)?struct\s+(\w+)/gm,
-      exported: false
+      id: "ruff-toml",
+      name: "Ruff Config",
+      description: "Ruff linter/formatter configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "ruff.toml" || filename === ".ruff.toml",
+      keywords: ["python", "ruff", "linting", "formatting", "fast"]
     },
     {
-      type: "enum",
-      pattern: /^(?:pub\s+)?enum\s+(\w+)/gm,
-      exported: false
+      id: "black-toml",
+      name: "Black Config",
+      description: "Black formatter configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".black.toml",
+      keywords: ["python", "black", "formatting", "format", "style"]
     },
     {
-      type: "interface",
-      pattern: /^(?:pub\s+)?trait\s+(\w+)/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"
+      ]
+    },
+    {
+      id: "jsconfig",
+      name: "JavaScript Config",
+      description: "JavaScript project configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === "jsconfig.json",
+      keywords: ["javascript", "config", "compiler", "js", "settings", "paths"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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
-});
-import * as path3 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/domain/services/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 [];
       }
-      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 = path3.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);
-    }
-    const symbolIndexData = {
-      version: this.version,
-      lastUpdated: new Date().toISOString(),
-      files: Object.fromEntries(this.symbolIndex),
-      bm25Data: this.bm25Index.serialize()
-    };
-    await fs2.writeFile(path3.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
-          }
-        });
+    },
+    {
+      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 [];
       }
-    }
-    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;
-          }
+    },
+    {
+      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"];
       }
-      if (matchScore > 0) {
-        matches.set(filepath, Math.min(1, matchScore / queryTokens.length));
+    },
+    {
+      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"]
     }
-    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;
+  ];
+  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
+  };
+});
+
+// src/domain/services/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 [];
       }
-      if (chunk.name) {
-        const nameLower = chunk.name.toLowerCase();
-        for (const token of queryTokens) {
-          if (nameLower.includes(token)) {
-            score += 2;
+    },
+    {
+      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/domain/services/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/domain/services/conventions/index.ts
+import * as path4 from "path";
+function getConventions() {
+  return [
+    ...entryPointConventions,
+    ...configFileConventions,
+    ...getAllFrameworkConventions(),
+    ...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());
+            }
           }
         }
       }
-      if (chunk.isExported) {
-        score += 0.5;
-      }
-      if (score > bestScore) {
-        bestScore = score;
-        bestChunk = chunk;
+    } catch {}
+  }
+  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"]
     }
-    return bestChunk;
-  }
-  async loadSymbolIndex(rootDir, config) {
-    const coreDir = path3.join(getRaggrepDir(rootDir, config), "index", "core");
-    const symbolsPath = path3.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);
+  ];
+  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 [];
       }
-    } catch (error) {
-      this.symbolIndex = new Map;
-      this.bm25Index = null;
+    },
+    {
+      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"]
     }
-  }
-  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_symbols();
+  ];
 });
 
-// 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}`);
-  }
-  let dotProduct = 0;
-  let normA = 0;
+// src/domain/services/introspection.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);
+  const framework = fileContent ? detectFramework(fileContent) : undefined;
+  return {
+    filepath: normalizedPath,
+    project,
+    scope,
+    layer,
+    domain,
+    language,
+    framework,
+    depth: segments.length - 1,
+    pathSegments: segments.slice(0, -1)
+  };
+}
+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());
+  }
+  if (intro.scope !== "unknown")
+    keywords.push(intro.scope);
+  if (intro.layer)
+    keywords.push(intro.layer);
+  if (intro.domain)
+    keywords.push(intro.domain);
+  if (intro.language !== "unknown")
+    keywords.push(intro.language);
+  if (intro.framework)
+    keywords.push(intro.framework);
+  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)];
+}
+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";
+}
+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);
+    }
+  }
+  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" };
+}
+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;
+    }
+  }
+  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;
+}
+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;
+      }
+    }
+  }
+  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";
+    }
+  }
+  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";
+  }
+  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;
+      }
+    }
+  }
+  return;
+}
+var LAYER_PATTERNS, DOMAIN_PATTERNS, FRAMEWORK_INDICATORS, EXTENSION_TO_LANGUAGE, SCOPE_KEYWORDS, PROJECT_PATTERNS;
+var init_introspection = __esm(() => {
+  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"]
+  };
+  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",
+    ".txt": "text"
+  };
+  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: []
+  };
+  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" }
+  ];
+});
+
+// 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 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);
+      }
+    }
+  }
+  return Array.from(keywords);
+}
+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 path6 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 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 = path6.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);
+    }
+    const symbolIndexData = {
+      version: this.version,
+      lastUpdated: new Date().toISOString(),
+      files: Object.fromEntries(this.symbolIndex),
+      bm25Data: this.bm25Index.serialize()
+    };
+    await fs2.writeFile(path6.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 = path6.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path6.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);
+      }
+    } 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/domain/services/similarity.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dotProduct = 0;
+  let normA = 0;
   let normB = 0;
   for (let i = 0;i < a.length; i++) {
     dotProduct += a[i] * b[i];
@@ -1064,7 +2393,7 @@ function parsePathContext(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 [layerName, patterns] of Object.entries(LAYER_PATTERNS2)) {
     for (const pattern of patterns) {
       if (filenameLower.includes(pattern)) {
         layer = layerName;
@@ -1079,7 +2408,7 @@ function parsePathContext(filepath) {
       break;
   }
   let domain;
-  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS).flat());
+  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS2).flat());
   const reversedSegments = [...dirSegments].reverse();
   for (const segment of reversedSegments) {
     const lower = segment.toLowerCase();
@@ -1117,7 +2446,7 @@ function formatPathContextForEmbedding(pathContext) {
   const unique = [...new Set(parts)];
   return `[${unique.join(" ")}]`;
 }
-var COMMON_KEYWORDS, LAYER_PATTERNS;
+var COMMON_KEYWORDS, LAYER_PATTERNS2;
 var init_keywords = __esm(() => {
   COMMON_KEYWORDS = new Set([
     "const",
@@ -1187,7 +2516,7 @@ var init_keywords = __esm(() => {
     "has",
     "have"
   ]);
-  LAYER_PATTERNS = {
+  LAYER_PATTERNS2 = {
     controller: ["controller", "controllers", "handler", "handlers", "route", "routes", "api"],
     service: ["service", "services", "usecase", "usecases", "application"],
     repository: ["repository", "repositories", "repo", "repos", "dao", "store", "storage"],
@@ -1204,7 +2533,7 @@ var init_keywords = __esm(() => {
 
 // src/infrastructure/storage/symbolicIndex.ts
 import * as fs3 from "fs/promises";
-import * as path4 from "path";
+import * as path7 from "path";
 
 class SymbolicIndex {
   meta = null;
@@ -1213,7 +2542,7 @@ class SymbolicIndex {
   symbolicPath;
   moduleId;
   constructor(indexDir, moduleId) {
-    this.symbolicPath = path4.join(indexDir, "index", moduleId, "symbolic");
+    this.symbolicPath = path7.join(indexDir, "index", moduleId, "symbolic");
     this.moduleId = moduleId;
   }
   async initialize() {
@@ -1274,16 +2603,16 @@ class SymbolicIndex {
     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");
+    const metaPath = path7.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.mkdir(path7.dirname(summaryPath), { recursive: true });
       await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
     }
   }
   async load() {
-    const metaPath = path4.join(this.symbolicPath, "_meta.json");
+    const metaPath = path7.join(this.symbolicPath, "_meta.json");
     const metaContent = await fs3.readFile(metaPath, "utf-8");
     this.meta = JSON.parse(metaContent);
     this.fileSummaries.clear();
@@ -1294,7 +2623,7 @@ class SymbolicIndex {
     try {
       const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path4.join(dir, entry.name);
+        const fullPath = path7.join(dir, entry.name);
         if (entry.isDirectory()) {
           await this.loadFileSummariesRecursive(fullPath);
         } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
@@ -1311,7 +2640,7 @@ class SymbolicIndex {
   }
   getFileSummaryPath(filepath) {
     const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path4.join(this.symbolicPath, jsonPath);
+    return path7.join(this.symbolicPath, jsonPath);
   }
   async deleteFileSummary(filepath) {
     try {
@@ -1321,7 +2650,7 @@ class SymbolicIndex {
   }
   async exists() {
     try {
-      const metaPath = path4.join(this.symbolicPath, "_meta.json");
+      const metaPath = path7.join(this.symbolicPath, "_meta.json");
       await fs3.access(metaPath);
       return true;
     } catch {
@@ -1361,7 +2690,7 @@ __export(exports_typescript, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
 });
-import * as path5 from "path";
+import * as path8 from "path";
 
 class TypeScriptModule {
   id = "language/typescript";
@@ -1533,549 +2862,235 @@ class TypeScriptModule {
       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);
-  }
-  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);
-      }
-    }
-    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 references;
-  }
-}
-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/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);
-  }
-  list() {
-    return Array.from(this.modules.values());
-  }
-  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));
-  }
-}
-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);
-}
-var registry;
-var init_registry = __esm(() => {
-  registry = new ModuleRegistryImpl;
-});
-
-// src/introspection/projectDetector.ts
-import * as path6 from "path";
-import * as fs4 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 ? 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);
-    }
-  } 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";
-    }
-    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
-            });
+          chunk,
+          score: hybridScore,
+          moduleId: this.id,
+          context: {
+            semanticScore,
+            bm25Score,
+            pathBoost
           }
-        } catch {}
+        });
       }
     }
-    const packageJsons = await scanForPackageJsons(rootDir);
-    for (const pkg of packageJsons) {
-      if (pkg.hasWorkspaces) {
-        isMonorepo = true;
-      }
-      if (packageJsons.length > 1) {
-        isMonorepo = true;
+    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 = path8.dirname(filepath);
+        const resolved = path8.normalize(path8.join(dir, importPath));
+        references.push(resolved);
       }
-      projectMap.set(pkg.relativePath, {
-        name: pkg.name,
-        root: pkg.relativePath,
-        type: pkg.type
-      });
     }
-    let rootType = "unknown";
-    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";
+    while ((match = requireRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath.startsWith(".")) {
+        const dir = path8.dirname(filepath);
+        const resolved = path8.normalize(path8.join(dir, importPath));
+        references.push(resolved);
       }
-    } 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);
-    }
-  }
-  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 references;
   }
-  return {
-    name: "root",
-    root: "",
-    type: structure.rootType ?? "unknown"
-  };
 }
-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: []
-  };
+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/fileIntrospector.ts
-import * as path7 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 = 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);
-  }
-  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;
-      }
-    }
-  }
-  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;
-      }
+// 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);
   }
-  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;
-    }
-    for (const domain of DOMAIN_PATTERNS) {
-      if (segmentLower.startsWith(domain) || segmentLower.endsWith(domain)) {
-        return domain;
-      }
-    }
+  get(id) {
+    return this.modules.get(id);
   }
-  return;
-}
-function detectScope(segments, project, layer) {
-  const projectScope = detectScopeFromName(project.name);
-  if (projectScope !== "unknown") {
-    return projectScope;
+  list() {
+    return Array.from(this.modules.values());
   }
-  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";
-    }
+  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));
   }
-  for (const segment of segments) {
-    const segmentLower = segment.toLowerCase();
-    if (["server", "api", "backend"].includes(segmentLower)) {
-      return "backend";
+}
+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);
+}
+var registry;
+var init_registry = __esm(() => {
+  registry = new ModuleRegistryImpl;
+});
+
+// src/infrastructure/introspection/projectDetector.ts
+import * as path9 from "path";
+import * as fs4 from "fs/promises";
+async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
+  if (depth > MAX_SCAN_DEPTH)
+    return [];
+  const results = [];
+  const fullDir = currentDir ? path9.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);
     }
-    if (["client", "web", "frontend", "ui"].includes(segmentLower)) {
-      return "frontend";
+    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);
     }
-    if (["shared", "common", "lib", "libs"].includes(segmentLower)) {
-      return "shared";
+  } catch {}
+  return results;
+}
+async function parsePackageJson(rootDir, relativePath) {
+  try {
+    const packageJsonPath = path9.join(rootDir, relativePath, "package.json");
+    const content = await fs4.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const name = pkg.name || path9.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 "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;
+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";
+  }
+}
+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 = path9.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 {}
       }
     }
+    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 = path9.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";
+      }
+    } 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"
+    };
   }
-  return;
 }
-var LAYER_PATTERNS2, DOMAIN_PATTERNS, FRAMEWORK_INDICATORS, EXTENSION_TO_LANGUAGE;
-var init_fileIntrospector = __esm(() => {
-  init_projectDetector();
-  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"]
-  };
-  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"
-  };
+var MAX_SCAN_DEPTH = 4, SKIP_DIRS;
+var init_projectDetector = __esm(() => {
+  SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    "coverage",
+    ".raggrep"
+  ]);
 });
 
-// src/introspection/index.ts
-import * as path8 from "path";
+// src/infrastructure/introspection/IntrospectionIndex.ts
+import * as path10 from "path";
 import * as fs5 from "fs/promises";
 
 class IntrospectionIndex {
@@ -2089,7 +3104,7 @@ class IntrospectionIndex {
   async initialize() {
     this.structure = await detectProjectStructure(this.rootDir);
     try {
-      const configPath = path8.join(this.rootDir, ".raggrep", "config.json");
+      const configPath = path10.join(this.rootDir, ".raggrep", "config.json");
       const configContent = await fs5.readFile(configPath, "utf-8");
       const config = JSON.parse(configContent);
       this.config = config.introspection || {};
@@ -2129,29 +3144,29 @@ class IntrospectionIndex {
     }
   }
   async save(config) {
-    const introDir = path8.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path10.join(getRaggrepDir(this.rootDir, config), "introspection");
     await fs5.mkdir(introDir, { recursive: true });
-    const projectPath = path8.join(introDir, "_project.json");
+    const projectPath = path10.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 });
+      const introFilePath = path10.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs5.mkdir(path10.dirname(introFilePath), { recursive: true });
       await fs5.writeFile(introFilePath, JSON.stringify(intro, null, 2));
     }
     console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
   }
   async load(config) {
-    const introDir = path8.join(getRaggrepDir(this.rootDir, config), "introspection");
+    const introDir = path10.join(getRaggrepDir(this.rootDir, config), "introspection");
     try {
-      const projectPath = path8.join(introDir, "_project.json");
+      const projectPath = path10.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"), "");
+      await this.loadFilesRecursive(path10.join(introDir, "files"), "");
     } catch {
       this.structure = null;
       this.files.clear();
@@ -2161,7 +3176,7 @@ class IntrospectionIndex {
     try {
       const entries = await fs5.readdir(basePath, { withFileTypes: true });
       for (const entry of entries) {
-        const entryPath = path8.join(basePath, entry.name);
+        const entryPath = path10.join(basePath, entry.name);
         const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
         if (entry.isDirectory()) {
           await this.loadFilesRecursive(entryPath, relativePath);
@@ -2178,17 +3193,21 @@ class IntrospectionIndex {
     this.structure = null;
   }
 }
-var init_introspection = __esm(() => {
+var init_IntrospectionIndex = __esm(() => {
   init_projectDetector();
-  init_fileIntrospector();
+  init_introspection();
   init_config2();
-  init_fileIntrospector();
+});
+
+// src/infrastructure/introspection/index.ts
+var init_introspection2 = __esm(() => {
+  init_IntrospectionIndex();
   init_projectDetector();
 });
 
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
-import * as path9 from "path";
+import * as path11 from "path";
 async function watchDirectory(rootDir, options = {}) {
   const {
     debounceMs = DEFAULT_DEBOUNCE_MS,
@@ -2199,13 +3218,19 @@ async function watchDirectory(rootDir, options = {}) {
     onFileChange,
     onError
   } = options;
-  rootDir = path9.resolve(rootDir);
+  rootDir = path11.resolve(rootDir);
   const config = await loadConfig(rootDir);
-  const watchPatterns = config.extensions.map((ext) => `**/*${ext}`);
+  const indexLocation = getIndexLocation(rootDir);
+  const validExtensions = new Set(config.extensions);
   const ignorePatterns = [
     ...config.ignorePaths.map((p) => `**/${p}/**`),
-    `**/${config.indexDir}/**`
+    "**/node_modules/**",
+    "**/.git/**"
   ];
+  function shouldWatchFile(filepath) {
+    const ext = path11.extname(filepath);
+    return validExtensions.has(ext);
+  }
   let isRunning = true;
   let isIndexing = false;
   let pendingChanges = new Map;
@@ -2285,7 +3310,10 @@ async function watchDirectory(rootDir, options = {}) {
   function handleFileEvent(event, filepath) {
     if (!isRunning)
       return;
-    const relativePath = path9.relative(rootDir, filepath);
+    const relativePath = path11.relative(rootDir, filepath);
+    if (!shouldWatchFile(filepath)) {
+      return;
+    }
     for (const ignorePath of config.ignorePaths) {
       if (relativePath.startsWith(ignorePath) || relativePath.includes(`/${ignorePath}/`)) {
         return;
@@ -2301,8 +3329,7 @@ async function watchDirectory(rootDir, options = {}) {
     pendingChanges.set(relativePath, event);
     scheduleProcessing();
   }
-  watcher = watch(watchPatterns, {
-    cwd: rootDir,
+  watcher = watch(rootDir, {
     ignored: ignorePatterns,
     persistent: true,
     ignoreInitial: true,
@@ -2311,11 +3338,12 @@ async function watchDirectory(rootDir, options = {}) {
       pollInterval: 50
     },
     usePolling: false,
-    atomic: true
+    atomic: true,
+    depth: 99
   });
-  watcher.on("add", (filepath) => handleFileEvent("add", path9.join(rootDir, filepath)));
-  watcher.on("change", (filepath) => handleFileEvent("change", path9.join(rootDir, filepath)));
-  watcher.on("unlink", (filepath) => handleFileEvent("unlink", path9.join(rootDir, filepath)));
+  watcher.on("add", (filepath) => handleFileEvent("add", filepath));
+  watcher.on("change", (filepath) => handleFileEvent("change", filepath));
+  watcher.on("unlink", (filepath) => handleFileEvent("unlink", filepath));
   watcher.on("error", (error) => {
     const err = error instanceof Error ? error : new Error(String(error));
     console.error("[Watch] Watcher error:", err);
@@ -2323,9 +3351,9 @@ async function watchDirectory(rootDir, options = {}) {
       onError(err);
     }
   });
-  await new Promise((resolve2) => {
+  await new Promise((resolve3) => {
     watcher.on("ready", () => {
-      resolve2();
+      resolve3();
     });
   });
   return {
@@ -2359,11 +3387,13 @@ __export(exports_indexer, {
 });
 import { glob } from "glob";
 import * as fs6 from "fs/promises";
-import * as path10 from "path";
+import * as path12 from "path";
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path10.resolve(rootDir);
+  rootDir = path12.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();
@@ -2405,11 +3435,11 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path10.isAbsolute(filepath) ? filepath : path10.join(rootDir, filepath);
+          const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
           return fs6.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path10.isAbsolute(filepath) ? filepath : path10.join(rootDir, filepath);
+          const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
           const stats = await fs6.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
@@ -2434,18 +3464,18 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path10.isAbsolute(filepath) ? filepath : path10.join(rootDir, filepath);
+      const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
       return fs6.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path10.isAbsolute(filepath) ? filepath : path10.join(rootDir, filepath);
+      const fullPath = path12.isAbsolute(filepath) ? filepath : path12.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 = path10.relative(rootDir, filepath);
+    const relativePath = path12.relative(rootDir, filepath);
     try {
       const stats = await fs6.stat(filepath);
       const lastModified = stats.mtime.toISOString();
@@ -2515,13 +3545,13 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs6.mkdir(path10.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path12.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 = path10.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs6.mkdir(path10.dirname(indexFilePath), { recursive: true });
+  const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs6.mkdir(path12.dirname(indexFilePath), { recursive: true });
   await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
@@ -2531,12 +3561,12 @@ async function updateGlobalManifest(rootDir, modules, config) {
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
-  await fs6.mkdir(path10.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path12.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path10.resolve(rootDir);
+  rootDir = path12.resolve(rootDir);
   console.log(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -2566,7 +3596,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path10.join(rootDir, filepath);
+    const fullPath = path12.join(rootDir, filepath);
     try {
       await fs6.access(fullPath);
       updatedFiles[filepath] = entry;
@@ -2580,7 +3610,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path10.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
       await fs6.unlink(indexFilePath);
     } catch {}
@@ -2596,7 +3626,7 @@ async function cleanupEmptyDirectories(dir) {
     const entries = await fs6.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path10.join(dir, entry.name);
+        const subDir = path12.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
@@ -2611,9 +3641,10 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 async function getIndexStatus(rootDir) {
-  rootDir = path10.resolve(rootDir);
+  rootDir = path12.resolve(rootDir);
   const config = await loadConfig(rootDir);
-  const indexDir = path10.join(rootDir, config.indexDir);
+  const location = getIndexLocation(rootDir);
+  const indexDir = location.indexDir;
   const status = {
     exists: false,
     rootDir,
@@ -2646,7 +3677,7 @@ async function getIndexStatus(rootDir) {
     }
   } catch {
     try {
-      const entries = await fs6.readdir(path10.join(indexDir, "index"));
+      const entries = await fs6.readdir(path12.join(indexDir, "index"));
       if (entries.length > 0) {
         status.exists = true;
         for (const entry of entries) {
@@ -2669,7 +3700,7 @@ async function getIndexStatus(rootDir) {
 var init_indexer = __esm(() => {
   init_config2();
   init_registry();
-  init_introspection();
+  init_introspection2();
   init_watcher();
 });
 
@@ -2680,9 +3711,9 @@ __export(exports_search, {
   formatSearchResults: () => formatSearchResults
 });
 import * as fs7 from "fs/promises";
-import * as path11 from "path";
+import * as path13 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path11.resolve(rootDir);
+  rootDir = path13.resolve(rootDir);
   console.log(`Searching for: "${query}"`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -2723,7 +3754,7 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path11.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path13.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path13.join(indexPath, filepath + ".json");
       try {
         const content = await fs7.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
@@ -2735,7 +3766,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 relative4 = path11.relative(indexPath, f);
+        const relative4 = path13.relative(indexPath, f);
         return relative4.replace(/\.json$/, "");
       });
     }
@@ -2745,7 +3776,7 @@ async function traverseDirectory(dir, files, basePath) {
   try {
     const entries = await fs7.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path11.join(dir, entry.name);
+      const fullPath = path13.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -2763,6 +3794,20 @@ async function loadGlobalManifest(rootDir, config) {
     return null;
   }
 }
+function formatModuleName(moduleId) {
+  switch (moduleId) {
+    case "core":
+      return "Core";
+    case "language/typescript":
+      return "TypeScript";
+    default:
+      if (moduleId.startsWith("language/")) {
+        const lang = moduleId.replace("language/", "");
+        return lang.charAt(0).toUpperCase() + lang.slice(1);
+      }
+      return moduleId;
+  }
+}
 function formatSearchResults(results) {
   if (results.length === 0) {
     return "No results found.";
@@ -2778,6 +3823,7 @@ function formatSearchResults(results) {
     output += `${i + 1}. ${location}${nameInfo}
 `;
     output += `   Score: ${(result.score * 100).toFixed(1)}% | Type: ${chunk.type}`;
+    output += ` | via ${formatModuleName(result.moduleId)}`;
     if (chunk.isExported) {
       output += " | exported";
     }
@@ -2805,7 +3851,7 @@ init_embeddings();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.1.5",
+  version: "0.1.7",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -3240,4 +4286,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=70A5CEDDD33322C164756E2164756E21
+//# debugId=C248CB1C621D0FC764756E2164756E21