raggrep 0.1.5 → 0.1.7

package/dist/index.js

@@ -76,7 +76,8 @@ var init_config = __esm(() => {
     ".go",
     ".rs",
     ".java",
-    ".md"
+    ".md",
+    ".txt"
   ];
 });
 
@@ -89,20 +90,40 @@ var init_entities = __esm(() => {
 // src/infrastructure/config/configLoader.ts
 import * as path from "path";
 import * as fs from "fs/promises";
-function getRaggrepDir(rootDir, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir);
+import * as os from "os";
+import * as crypto from "crypto";
+function hashPath(inputPath) {
+  return crypto.createHash("sha256").update(inputPath).digest("hex").slice(0, 12);
+}
+function getRaggrepDir(rootDir, _config = DEFAULT_CONFIG) {
+  const absoluteRoot = path.resolve(rootDir);
+  const projectHash = hashPath(absoluteRoot);
+  return path.join(RAGGREP_TEMP_BASE, projectHash);
+}
+function getIndexLocation(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  const projectHash = hashPath(absoluteRoot);
+  return {
+    indexDir: path.join(RAGGREP_TEMP_BASE, projectHash),
+    projectRoot: absoluteRoot,
+    projectHash
+  };
 }
 function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "index", moduleId);
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "index", moduleId);
 }
 function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "index", moduleId, "manifest.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "index", moduleId, "manifest.json");
 }
 function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "manifest.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "manifest.json");
 }
 function getConfigPath(rootDir, config = DEFAULT_CONFIG) {
-  return path.join(rootDir, config.indexDir, "config.json");
+  const indexDir = getRaggrepDir(rootDir, config);
+  return path.join(indexDir, "config.json");
 }
 async function loadConfig(rootDir) {
   const configPath = getConfigPath(rootDir, DEFAULT_CONFIG);
@@ -129,10 +150,11 @@ function getEmbeddingConfigFromModule(moduleConfig) {
     showProgress: options.showProgress !== false
   };
 }
-var DEFAULT_CONFIG, EMBEDDING_MODELS;
+var DEFAULT_CONFIG, RAGGREP_TEMP_BASE, EMBEDDING_MODELS;
 var init_configLoader = __esm(() => {
   init_entities();
   DEFAULT_CONFIG = createDefaultConfig();
+  RAGGREP_TEMP_BASE = path.join(os.tmpdir(), "raggrep-indexes");
   EMBEDDING_MODELS = {
     "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
     "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
@@ -232,21 +254,1323 @@ class BM25Index {
       totalDocs: this.totalDocs
     };
   }
-  static deserialize(data) {
-    const index = new BM25Index;
-    index.avgDocLength = data.avgDocLength;
-    index.totalDocs = data.totalDocs;
-    index.documentFrequencies = new Map(Object.entries(data.documentFrequencies));
-    for (const [id, tokens] of Object.entries(data.documents)) {
-      index.documents.set(id, { content: "", tokens });
+  static deserialize(data) {
+    const index = new BM25Index;
+    index.avgDocLength = data.avgDocLength;
+    index.totalDocs = data.totalDocs;
+    index.documentFrequencies = new Map(Object.entries(data.documentFrequencies));
+    for (const [id, tokens] of Object.entries(data.documents)) {
+      index.documents.set(id, { content: "", tokens });
+    }
+    return index;
+  }
+}
+function normalizeScore(score, midpoint = 5) {
+  return 1 / (1 + Math.exp(-score / midpoint + 1));
+}
+var BM25_K1 = 1.5, BM25_B = 0.75;
+
+// src/domain/services/conventions/entryPoints.ts
+import * as path2 from "path";
+function getParentFolder(filepath) {
+  const dir = path2.dirname(filepath);
+  return path2.basename(dir);
+}
+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"]
+    }
+  ];
+});
+
+// src/domain/services/conventions/configFiles.ts
+var configFileConventions;
+var init_configFiles = __esm(() => {
+  configFileConventions = [
+    {
+      id: "package-json",
+      name: "Package.json",
+      description: "Node.js package manifest",
+      category: "configuration",
+      match: (filepath, filename) => filename === "package.json",
+      keywords: ["package", "dependencies", "npm", "scripts", "manifest", "node"]
+    },
+    {
+      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"]
+    },
+    {
+      id: "yarn-lock",
+      name: "Yarn Lock",
+      description: "Yarn dependency lock file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "yarn.lock",
+      keywords: ["dependencies", "lock", "yarn", "versions"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"
+      ]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"
+      ]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      id: "pipfile",
+      name: "Pipfile",
+      description: "Pipenv dependency file",
+      category: "configuration",
+      match: (filepath, filename) => filename === "Pipfile" || filename === "Pipfile.lock",
+      keywords: ["python", "pipenv", "dependencies", "packages", "virtualenv"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      id: "flake8",
+      name: "Flake8 Config",
+      description: "Flake8 linter configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".flake8",
+      keywords: ["python", "flake8", "linting", "lint", "style"]
+    },
+    {
+      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"]
+    },
+    {
+      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"]
+    },
+    {
+      id: "black-toml",
+      name: "Black Config",
+      description: "Black formatter configuration",
+      category: "configuration",
+      match: (filepath, filename) => filename === ".black.toml",
+      keywords: ["python", "black", "formatting", "format", "style"]
+    },
+    {
+      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/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 [];
+      }
+    },
+    {
+      id: "next-page",
+      name: "Next.js Page",
+      description: "Next.js page component (App Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "page.tsx" || filename === "page.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "page", "route", "view", "app router"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/app\/(.+?)\/page\./);
+        if (match) {
+          const segments = match[1].split("/").filter((s) => !s.startsWith("(")).map((s) => s.replace(/^\[(.+?)\]$/, "$1"));
+          return segments.map((s) => s.toLowerCase());
+        }
+        if (filepath === "app/page.tsx" || filepath === "app/page.js") {
+          return ["home", "index", "root"];
+        }
+        return [];
+      }
+    },
+    {
+      id: "next-loading",
+      name: "Next.js Loading",
+      description: "Next.js loading UI component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "loading.tsx" || filename === "loading.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "loading", "suspense", "skeleton", "spinner"]
+    },
+    {
+      id: "next-error",
+      name: "Next.js Error",
+      description: "Next.js error boundary component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "error.tsx" || filename === "error.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "error", "boundary", "fallback", "catch"]
+    },
+    {
+      id: "next-not-found",
+      name: "Next.js Not Found",
+      description: "Next.js 404 page component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "not-found.tsx" || filename === "not-found.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "404", "not found", "missing", "error"]
+    },
+    {
+      id: "next-template",
+      name: "Next.js Template",
+      description: "Next.js template component",
+      category: "framework",
+      match: (filepath, filename) => (filename === "template.tsx" || filename === "template.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "template", "wrapper", "app router"]
+    },
+    {
+      id: "next-route-handler",
+      name: "Next.js Route Handler",
+      description: "Next.js API route handler (App Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "route.ts" || filename === "route.js") && (filepath.includes("/app/") || filepath.startsWith("app/")),
+      keywords: ["nextjs", "api", "route", "handler", "endpoint", "rest"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/app\/api\/(.+?)\/route\./);
+        if (match) {
+          const segments = match[1].split("/").filter((s) => !s.startsWith("(")).map((s) => s.replace(/^\[(.+?)\]$/, "$1"));
+          return ["api", ...segments.map((s) => s.toLowerCase())];
+        }
+        return ["api"];
+      }
+    },
+    {
+      id: "next-middleware",
+      name: "Next.js Middleware",
+      description: "Next.js edge middleware",
+      category: "framework",
+      match: (filepath, filename) => filename === "middleware.ts" || filename === "middleware.js",
+      keywords: ["nextjs", "middleware", "edge", "request", "interceptor"]
+    },
+    {
+      id: "next-global-error",
+      name: "Next.js Global Error",
+      description: "Next.js global error handler",
+      category: "framework",
+      match: (filepath, filename) => filename === "global-error.tsx" || filename === "global-error.js",
+      keywords: ["nextjs", "error", "global", "boundary", "catch"]
+    },
+    {
+      id: "next-pages-api",
+      name: "Next.js API Route (Pages)",
+      description: "Next.js API route (Pages Router)",
+      category: "framework",
+      match: (filepath) => filepath.includes("/pages/api/") || filepath.startsWith("pages/api/"),
+      keywords: ["nextjs", "api", "route", "handler", "endpoint", "pages router"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/pages\/api\/(.+?)\.(ts|js)/);
+        if (match) {
+          const segments = match[1].split("/").map((s) => s.replace(/^\[(.+?)\]$/, "$1"));
+          return ["api", ...segments.map((s) => s.toLowerCase())];
+        }
+        return ["api"];
+      }
+    },
+    {
+      id: "next-pages-document",
+      name: "Next.js Document",
+      description: "Next.js custom document (Pages Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "_document.tsx" || filename === "_document.js") && (filepath.includes("/pages/") || filepath.startsWith("pages/")),
+      keywords: ["nextjs", "document", "html", "head", "body", "pages router"]
+    },
+    {
+      id: "next-pages-app",
+      name: "Next.js App (Pages)",
+      description: "Next.js custom app (Pages Router)",
+      category: "framework",
+      match: (filepath, filename) => (filename === "_app.tsx" || filename === "_app.js") && (filepath.includes("/pages/") || filepath.startsWith("pages/")),
+      keywords: ["nextjs", "app", "wrapper", "provider", "pages router"]
+    }
+  ];
+  nextjsFramework = {
+    id: "nextjs",
+    name: "Next.js",
+    detect: (filepath) => {
+      return filepath === "next.config.js" || filepath === "next.config.mjs" || filepath === "next.config.ts" || filepath.includes("/app/page.") || filepath.includes("/pages/_app.");
+    },
+    conventions: nextjsConventions
+  };
+});
+
+// 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 [];
+      }
+    },
+    {
+      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 path3 from "path";
+function getConventions() {
+  return [
+    ...entryPointConventions,
+    ...configFileConventions,
+    ...getAllFrameworkConventions(),
+    ...typeDefinitionConventions,
+    ...testFileConventions
+  ];
+}
+function getConventionKeywords(filepath) {
+  const conventions = getConventions();
+  const filename = path3.basename(filepath);
+  const extension = path3.extname(filepath);
+  const keywords = new Set;
+  for (const convention of conventions) {
+    try {
+      if (convention.match(filepath, filename, extension)) {
+        for (const keyword of convention.keywords) {
+          keywords.add(keyword.toLowerCase());
+        }
+        if (convention.dynamicKeywords) {
+          const dynamicKws = convention.dynamicKeywords(filepath);
+          for (const kw of dynamicKws) {
+            if (kw && kw.length > 1) {
+              keywords.add(kw.toLowerCase());
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+  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"]
+    }
+  ];
+  testFileConventions = [
+    {
+      id: "test-file",
+      name: "Test File",
+      description: "Unit/integration test file",
+      category: "test",
+      match: (filepath, filename) => filename.includes(".test.") || filename.includes(".spec.") || filename.includes("_test."),
+      keywords: ["test", "spec", "unit test"],
+      dynamicKeywords: (filepath) => {
+        const match = filepath.match(/([^/]+)\.(test|spec)\./);
+        if (match)
+          return [match[1].toLowerCase()];
+        return [];
+      }
+    },
+    {
+      id: "test-folder",
+      name: "Test Folder File",
+      description: "File in a test folder",
+      category: "test",
+      match: (filepath) => filepath.includes("/__tests__/") || filepath.includes("/test/") || filepath.includes("/tests/") || filepath.startsWith("__tests__/") || filepath.startsWith("test/") || filepath.startsWith("tests/"),
+      keywords: ["test", "testing"]
+    }
+  ];
+});
+
+// src/domain/services/introspection.ts
+import * as path4 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 = path4.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 = path4.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";
     }
-    return index;
   }
+  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 normalizeScore(score, midpoint = 5) {
-  return 1 / (1 + Math.exp(-score / midpoint + 1));
+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 BM25_K1 = 1.5, BM25_B = 0.75;
+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) {
@@ -415,7 +1739,7 @@ var exports_core = {};
 __export(exports_core, {
   CoreModule: () => CoreModule
 });
-import * as path2 from "path";
+import * as path5 from "path";
 import * as fs2 from "fs/promises";
 
 class CoreModule {
@@ -432,7 +1756,11 @@ class CoreModule {
     const symbols = extractSymbols(content);
     const symbolKeywords = symbolsToKeywords(symbols);
     const contentTokens = tokenize(content);
-    const allTokens = [...new Set([...contentTokens, ...symbolKeywords])];
+    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, {
@@ -506,7 +1834,7 @@ class CoreModule {
   }
   async finalize(ctx) {
     const config = ctx.config;
-    const coreDir = path2.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
+    const coreDir = path5.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
     await fs2.mkdir(coreDir, { recursive: true });
     this.bm25Index = new BM25Index;
     for (const [filepath, entry] of this.symbolIndex) {
@@ -518,7 +1846,7 @@ class CoreModule {
       files: Object.fromEntries(this.symbolIndex),
       bm25Data: this.bm25Index.serialize()
     };
-    await fs2.writeFile(path2.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
+    await fs2.writeFile(path5.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) {
@@ -615,8 +1943,8 @@ class CoreModule {
     return bestChunk;
   }
   async loadSymbolIndex(rootDir, config) {
-    const coreDir = path2.join(getRaggrepDir(rootDir, config), "index", "core");
-    const symbolsPath = path2.join(coreDir, "symbols.json");
+    const coreDir = path5.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path5.join(coreDir, "symbols.json");
     try {
       const content = await fs2.readFile(symbolsPath, "utf-8");
       const data = JSON.parse(content);
@@ -637,13 +1965,14 @@ class CoreModule {
 var DEFAULT_MIN_SCORE = 0.1, DEFAULT_TOP_K = 20, LINES_PER_CHUNK = 50, CHUNK_OVERLAP = 10;
 var init_core = __esm(() => {
   init_config2();
+  init_introspection();
   init_symbols();
 });
 
 // src/infrastructure/embeddings/transformersEmbedding.ts
 import { pipeline, env } from "@xenova/transformers";
-import * as path3 from "path";
-import * as os from "os";
+import * as path6 from "path";
+import * as os2 from "os";
 
 class TransformersEmbeddingProvider {
   pipeline = null;
@@ -775,7 +2104,7 @@ async function getEmbeddings(texts) {
 }
 var CACHE_DIR, EMBEDDING_MODELS2, EMBEDDING_DIMENSION = 384, BATCH_SIZE = 32, globalProvider = null, globalConfig;
 var init_transformersEmbedding = __esm(() => {
-  CACHE_DIR = path3.join(os.homedir(), ".cache", "raggrep", "models");
+  CACHE_DIR = path6.join(os2.homedir(), ".cache", "raggrep", "models");
   env.cacheDir = CACHE_DIR;
   env.allowLocalModels = true;
   EMBEDDING_MODELS2 = {
@@ -1060,7 +2389,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;
@@ -1075,7 +2404,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();
@@ -1113,7 +2442,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",
@@ -1183,7 +2512,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"],
@@ -1200,7 +2529,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;
@@ -1209,7 +2538,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() {
@@ -1270,16 +2599,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();
@@ -1290,7 +2619,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") {
@@ -1307,7 +2636,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 {
@@ -1317,7 +2646,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 {
@@ -1357,7 +2686,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";
@@ -1551,16 +2880,16 @@ class TypeScriptModule {
     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));
+        const dir = path8.dirname(filepath);
+        const resolved = path8.normalize(path8.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));
+        const dir = path8.dirname(filepath);
+        const resolved = path8.normalize(path8.join(dir, importPath));
         references.push(resolved);
       }
     }
@@ -1581,7 +2910,7 @@ var init_typescript = __esm(() => {
 init_config2();
 import { glob } from "glob";
 import * as fs6 from "fs/promises";
-import * as path9 from "path";
+import * as path11 from "path";
 
 // src/modules/registry.ts
 class ModuleRegistryImpl {
@@ -1611,12 +2940,12 @@ async function registerBuiltInModules() {
   registry.register(new TypeScriptModule2);
 }
 
-// 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";
 
-// src/introspection/projectDetector.ts
-import * as path6 from "path";
+// src/infrastructure/introspection/projectDetector.ts
+import * as path9 from "path";
 import * as fs4 from "fs/promises";
 var MAX_SCAN_DEPTH = 4;
 var SKIP_DIRS = new Set([
@@ -1629,76 +2958,18 @@ var SKIP_DIRS = new Set([
   "coverage",
   ".raggrep"
 ]);
-var PROJECT_PATTERNS = [
-  { pattern: /^apps\/([^/]+)/, type: "app", defaultScope: "unknown" },
-  { pattern: /^packages\/([^/]+)/, type: "library", defaultScope: "shared" },
-  { pattern: /^libs\/([^/]+)/, type: "library", defaultScope: "shared" },
-  { pattern: /^services\/([^/]+)/, type: "service", defaultScope: "backend" },
-  { pattern: /^scripts\/([^/]+)/, type: "script", defaultScope: "tooling" },
-  { pattern: /^tools\/([^/]+)/, type: "script", defaultScope: "tooling" }
-];
-var SCOPE_KEYWORDS = {
-  frontend: [
-    "web",
-    "webapp",
-    "frontend",
-    "client",
-    "ui",
-    "app",
-    "mobile",
-    "react",
-    "vue",
-    "angular",
-    "next",
-    "nuxt"
-  ],
-  backend: [
-    "api",
-    "server",
-    "backend",
-    "service",
-    "worker",
-    "lambda",
-    "functions"
-  ],
-  shared: ["shared", "common", "utils", "lib", "core", "types", "models"],
-  tooling: [
-    "scripts",
-    "tools",
-    "cli",
-    "devtools",
-    "build",
-    "config",
-    "infra"
-  ],
-  unknown: []
-};
-function detectScopeFromName(name) {
-  const nameLower = name.toLowerCase();
-  for (const [scope, keywords] of Object.entries(SCOPE_KEYWORDS)) {
-    if (scope === "unknown")
-      continue;
-    for (const keyword of keywords) {
-      if (nameLower.includes(keyword)) {
-        return scope;
-      }
-    }
-  }
-  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;
+  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) {
+      if (info)
         results.push(info);
-      }
     }
     for (const entry of entries) {
       if (!entry.isDirectory())
@@ -1714,10 +2985,10 @@ async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
 }
 async function parsePackageJson(rootDir, relativePath) {
   try {
-    const packageJsonPath = path6.join(rootDir, relativePath, "package.json");
+    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 || path6.basename(relativePath);
+    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"]) {
@@ -1733,6 +3004,22 @@ async function parsePackageJson(rootDir, relativePath) {
     return null;
   }
 }
+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;
@@ -1746,7 +3033,7 @@ async function detectProjectStructure(rootDir) {
       for (const pattern of monorepoPatterns) {
         if (!dirNames.includes(pattern))
           continue;
-        const patternDir = path6.join(rootDir, pattern);
+        const patternDir = path9.join(rootDir, pattern);
         try {
           const subDirs = await fs4.readdir(patternDir, { withFileTypes: true });
           for (const subDir of subDirs) {
@@ -1765,12 +3052,10 @@ async function detectProjectStructure(rootDir) {
     }
     const packageJsons = await scanForPackageJsons(rootDir);
     for (const pkg of packageJsons) {
-      if (pkg.hasWorkspaces) {
+      if (pkg.hasWorkspaces)
         isMonorepo = true;
-      }
-      if (packageJsons.length > 1) {
+      if (packageJsons.length > 1)
         isMonorepo = true;
-      }
       projectMap.set(pkg.relativePath, {
         name: pkg.name,
         root: pkg.relativePath,
@@ -1779,11 +3064,10 @@ async function detectProjectStructure(rootDir) {
     }
     let rootType = "unknown";
     try {
-      const rootPkgPath = path6.join(rootDir, "package.json");
+      const rootPkgPath = path9.join(rootDir, "package.json");
       const rootPkg = JSON.parse(await fs4.readFile(rootPkgPath, "utf-8"));
-      if (rootPkg.workspaces) {
+      if (rootPkg.workspaces)
         isMonorepo = true;
-      }
       const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
       if (deps["next"] || deps["react"] || deps["vue"]) {
         rootType = "app";
@@ -1805,273 +3089,9 @@ async function detectProjectStructure(rootDir) {
     };
   }
 }
-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 {
-    name: "root",
-    root: "",
-    type: structure.rootType ?? "unknown"
-  };
-}
-
-// src/introspection/fileIntrospector.ts
-import * as path7 from "path";
-var LAYER_PATTERNS2 = {
-  controller: ["controller", "api", "routes", "route", "handler"],
-  service: ["service", "logic", "usecase", "usecases", "handler"],
-  repository: ["repository", "repo", "dao", "store", "persistence"],
-  model: ["model", "models", "entity", "entities", "schema", "schemas", "types", "type"],
-  util: ["util", "utils", "helper", "helpers", "common", "lib"],
-  config: ["config", "configuration", "settings"],
-  middleware: ["middleware", "middlewares"],
-  domain: ["domain"],
-  infrastructure: ["infrastructure", "infra"],
-  application: ["application", "app"],
-  presentation: ["presentation", "ui", "views", "view", "component", "components"],
-  test: ["test", "tests", "spec", "specs", "__tests__", "e2e"]
-};
-var DOMAIN_PATTERNS = [
-  "auth",
-  "authentication",
-  "user",
-  "users",
-  "account",
-  "accounts",
-  "profile",
-  "profiles",
-  "product",
-  "products",
-  "item",
-  "items",
-  "catalog",
-  "order",
-  "orders",
-  "cart",
-  "checkout",
-  "payment",
-  "payments",
-  "billing",
-  "subscription",
-  "subscriptions",
-  "notification",
-  "notifications",
-  "email",
-  "sms",
-  "report",
-  "reports",
-  "analytics",
-  "metrics",
-  "dashboard",
-  "admin",
-  "settings",
-  "search",
-  "chat",
-  "message",
-  "messages",
-  "feed",
-  "post",
-  "posts",
-  "comment",
-  "comments",
-  "media",
-  "upload",
-  "file",
-  "files",
-  "storage",
-  "cache",
-  "session",
-  "log",
-  "logs",
-  "audit"
-];
-var FRAMEWORK_INDICATORS = {
-  nextjs: ["next", "next/"],
-  express: ["express"],
-  fastify: ["fastify"],
-  react: ["react"],
-  vue: ["vue"],
-  angular: ["@angular/"],
-  nestjs: ["@nestjs/"],
-  koa: ["koa"]
-};
-var EXTENSION_TO_LANGUAGE = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".cjs": "javascript",
-  ".py": "python",
-  ".go": "go",
-  ".rs": "rust",
-  ".java": "java",
-  ".kt": "kotlin",
-  ".swift": "swift",
-  ".rb": "ruby",
-  ".php": "php",
-  ".cs": "csharp",
-  ".cpp": "cpp",
-  ".c": "c",
-  ".h": "c",
-  ".hpp": "cpp",
-  ".md": "markdown",
-  ".json": "json",
-  ".yaml": "yaml",
-  ".yml": "yaml"
-};
-function introspectFile(filepath, structure, fileContent) {
-  const normalizedPath = filepath.replace(/\\/g, "/");
-  const segments = normalizedPath.split("/").filter((s) => s.length > 0);
-  const filename = segments[segments.length - 1] || "";
-  const ext = path7.extname(filename);
-  const project = findProjectForFile(normalizedPath, structure);
-  const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
-  const layer = detectLayer(segments, filename);
-  const domain = detectDomain(segments);
-  const scope = detectScope(segments, project, layer);
-  let framework;
-  if (fileContent) {
-    framework = detectFramework(fileContent);
-  }
-  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;
-      }
-    }
-  }
-  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;
-      }
-    }
-  }
-  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;
-}
 
-// src/introspection/index.ts
+// src/infrastructure/introspection/IntrospectionIndex.ts
+init_introspection();
 init_config2();
 
 class IntrospectionIndex {
@@ -2085,7 +3105,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 || {};
@@ -2125,29 +3145,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();
@@ -2157,7 +3177,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);
@@ -2174,7 +3194,6 @@ class IntrospectionIndex {
     this.structure = null;
   }
 }
-
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
 init_config2();
@@ -2182,8 +3201,10 @@ init_config2();
 // src/app/indexer/index.ts
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path9.resolve(rootDir);
+  rootDir = path11.resolve(rootDir);
+  const location = getIndexLocation(rootDir);
   console.log(`Indexing directory: ${rootDir}`);
+  console.log(`Index location: ${location.indexDir}`);
   const config = await loadConfig(rootDir);
   const introspection = new IntrospectionIndex(rootDir);
   await introspection.initialize();
@@ -2225,11 +3246,11 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+          const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
           return fs6.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+          const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
           const stats = await fs6.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
@@ -2254,18 +3275,18 @@ async function indexWithModule(rootDir, files, module, config, verbose, introspe
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+      const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
       return fs6.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+      const fullPath = path11.isAbsolute(filepath) ? filepath : path11.join(rootDir, filepath);
       const stats = await fs6.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     },
     getIntrospection: (filepath) => introspection.getFile(filepath)
   };
   for (const filepath of files) {
-    const relativePath = path9.relative(rootDir, filepath);
+    const relativePath = path11.relative(rootDir, filepath);
     try {
       const stats = await fs6.stat(filepath);
       const lastModified = stats.mtime.toISOString();
@@ -2335,13 +3356,13 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs6.mkdir(path9.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path11.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
-  const indexFilePath = path9.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs6.mkdir(path9.dirname(indexFilePath), { recursive: true });
+  const indexFilePath = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs6.mkdir(path11.dirname(indexFilePath), { recursive: true });
   await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
@@ -2351,12 +3372,12 @@ async function updateGlobalManifest(rootDir, modules, config) {
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
-  await fs6.mkdir(path9.dirname(manifestPath), { recursive: true });
+  await fs6.mkdir(path11.dirname(manifestPath), { recursive: true });
   await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path9.resolve(rootDir);
+  rootDir = path11.resolve(rootDir);
   console.log(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -2386,7 +3407,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path9.join(rootDir, filepath);
+    const fullPath = path11.join(rootDir, filepath);
     try {
       await fs6.access(fullPath);
       updatedFiles[filepath] = entry;
@@ -2400,7 +3421,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path9.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
       await fs6.unlink(indexFilePath);
     } catch {}
@@ -2416,7 +3437,7 @@ async function cleanupEmptyDirectories(dir) {
     const entries = await fs6.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path9.join(dir, entry.name);
+        const subDir = path11.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
@@ -2434,9 +3455,9 @@ async function cleanupEmptyDirectories(dir) {
 // src/app/search/index.ts
 init_config2();
 import * as fs7 from "fs/promises";
-import * as path10 from "path";
+import * as path12 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path10.resolve(rootDir);
+  rootDir = path12.resolve(rootDir);
   console.log(`Searching for: "${query}"`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -2477,7 +3498,7 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path10.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path10.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path12.join(indexPath, filepath + ".json");
       try {
         const content = await fs7.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
@@ -2489,7 +3510,7 @@ function createSearchContext(rootDir, moduleId, config) {
       const files = [];
       await traverseDirectory(indexPath, files, indexPath);
       return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
-        const relative3 = path10.relative(indexPath, f);
+        const relative3 = path12.relative(indexPath, f);
         return relative3.replace(/\.json$/, "");
       });
     }
@@ -2499,7 +3520,7 @@ async function traverseDirectory(dir, files, basePath) {
   try {
     const entries = await fs7.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path10.join(dir, entry.name);
+      const fullPath = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -2517,6 +3538,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.";
@@ -2532,6 +3567,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";
     }
@@ -2575,4 +3611,4 @@ export {
   cleanup
 };
 
-//# debugId=0E3E5BCA1147AB0A64756E2164756E21
+//# debugId=B36BFBBC8240BDFB64756E2164756E21