raggrep 0.1.6 → 0.2.0

package/dist/cli/main.js

@@ -429,247 +429,11 @@ function normalizeScore(score, midpoint = 5) {
 }
 var BM25_K1 = 1.5, BM25_B = 0.75;
 
-// src/introspection/projectDetector.ts
+// src/domain/services/conventions/entryPoints.ts
 import * as path3 from "path";
-import * as fs2 from "fs/promises";
-function detectScopeFromName(name) {
-  const nameLower = name.toLowerCase();
-  for (const [scope, keywords] of Object.entries(SCOPE_KEYWORDS)) {
-    if (scope === "unknown")
-      continue;
-    for (const keyword of keywords) {
-      if (nameLower.includes(keyword)) {
-        return scope;
-      }
-    }
-  }
-  return "unknown";
-}
-async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
-  if (depth > MAX_SCAN_DEPTH)
-    return [];
-  const results = [];
-  const fullDir = currentDir ? path3.join(rootDir, currentDir) : rootDir;
-  try {
-    const entries = await fs2.readdir(fullDir, { withFileTypes: true });
-    const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
-    if (hasPackageJson && currentDir) {
-      const info = await parsePackageJson(rootDir, currentDir);
-      if (info) {
-        results.push(info);
-      }
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      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 = path3.join(rootDir, relativePath, "package.json");
-    const content = await fs2.readFile(packageJsonPath, "utf-8");
-    const pkg = JSON.parse(content);
-    const name = pkg.name || path3.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 fs2.readdir(rootDir, { withFileTypes: true });
-    const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
-    const monorepoPatterns = ["apps", "packages", "libs", "services"];
-    const hasMonorepoStructure = monorepoPatterns.some((p) => dirNames.includes(p));
-    if (hasMonorepoStructure) {
-      isMonorepo = true;
-      for (const pattern of monorepoPatterns) {
-        if (!dirNames.includes(pattern))
-          continue;
-        const patternDir = path3.join(rootDir, pattern);
-        try {
-          const subDirs = await fs2.readdir(patternDir, { withFileTypes: true });
-          for (const subDir of subDirs) {
-            if (!subDir.isDirectory())
-              continue;
-            const projectRoot = `${pattern}/${subDir.name}`;
-            const type = getProjectType(pattern);
-            projectMap.set(projectRoot, {
-              name: subDir.name,
-              root: projectRoot,
-              type
-            });
-          }
-        } catch {}
-      }
-    }
-    const packageJsons = await scanForPackageJsons(rootDir);
-    for (const pkg of packageJsons) {
-      if (pkg.hasWorkspaces) {
-        isMonorepo = true;
-      }
-      if (packageJsons.length > 1) {
-        isMonorepo = true;
-      }
-      projectMap.set(pkg.relativePath, {
-        name: pkg.name,
-        root: pkg.relativePath,
-        type: pkg.type
-      });
-    }
-    let rootType = "unknown";
-    try {
-      const rootPkgPath = path3.join(rootDir, "package.json");
-      const rootPkg = JSON.parse(await fs2.readFile(rootPkgPath, "utf-8"));
-      if (rootPkg.workspaces) {
-        isMonorepo = true;
-      }
-      const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
-      if (deps["next"] || deps["react"] || deps["vue"]) {
-        rootType = "app";
-      } else if (deps["express"] || deps["fastify"] || deps["koa"]) {
-        rootType = "service";
-      }
-    } catch {}
-    const projects = Array.from(projectMap.values()).sort((a, b) => a.root.length - b.root.length);
-    return {
-      projects,
-      isMonorepo,
-      rootType: isMonorepo ? undefined : rootType
-    };
-  } catch {
-    return {
-      projects: [],
-      isMonorepo: false,
-      rootType: "unknown"
-    };
-  }
-}
-function getProjectType(patternDir) {
-  switch (patternDir) {
-    case "apps":
-      return "app";
-    case "packages":
-    case "libs":
-      return "library";
-    case "services":
-      return "service";
-    case "scripts":
-    case "tools":
-      return "script";
-    default:
-      return "unknown";
-  }
-}
-function findProjectForFile(filepath, structure) {
-  const normalizedPath = filepath.replace(/\\/g, "/");
-  const matches = [];
-  for (const project of structure.projects) {
-    if (normalizedPath === project.root || normalizedPath.startsWith(project.root + "/")) {
-      matches.push(project);
-    }
-  }
-  if (matches.length > 0) {
-    return matches.reduce((best, current) => current.root.length > best.root.length ? current : best);
-  }
-  for (const { pattern, type } of PROJECT_PATTERNS) {
-    const match = normalizedPath.match(pattern);
-    if (match) {
-      return {
-        name: match[1],
-        root: match[0],
-        type
-      };
-    }
-  }
-  return {
-    name: "root",
-    root: "",
-    type: structure.rootType ?? "unknown"
-  };
-}
-var MAX_SCAN_DEPTH = 4, SKIP_DIRS, PROJECT_PATTERNS, SCOPE_KEYWORDS;
-var init_projectDetector = __esm(() => {
-  SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    ".next",
-    ".nuxt",
-    "coverage",
-    ".raggrep"
-  ]);
-  PROJECT_PATTERNS = [
-    { pattern: /^apps\/([^/]+)/, type: "app", defaultScope: "unknown" },
-    { pattern: /^packages\/([^/]+)/, type: "library", defaultScope: "shared" },
-    { pattern: /^libs\/([^/]+)/, type: "library", defaultScope: "shared" },
-    { pattern: /^services\/([^/]+)/, type: "service", defaultScope: "backend" },
-    { pattern: /^scripts\/([^/]+)/, type: "script", defaultScope: "tooling" },
-    { pattern: /^tools\/([^/]+)/, type: "script", defaultScope: "tooling" }
-  ];
-  SCOPE_KEYWORDS = {
-    frontend: [
-      "web",
-      "webapp",
-      "frontend",
-      "client",
-      "ui",
-      "app",
-      "mobile",
-      "react",
-      "vue",
-      "angular",
-      "next",
-      "nuxt"
-    ],
-    backend: [
-      "api",
-      "server",
-      "backend",
-      "service",
-      "worker",
-      "lambda",
-      "functions"
-    ],
-    shared: ["shared", "common", "utils", "lib", "core", "types", "models"],
-    tooling: [
-      "scripts",
-      "tools",
-      "cli",
-      "devtools",
-      "build",
-      "config",
-      "infra"
-    ],
-    unknown: []
-  };
-});
-
-// src/introspection/conventions/entryPoints.ts
-import * as path4 from "path";
 function getParentFolder(filepath) {
-  const dir = path4.dirname(filepath);
-  return path4.basename(dir);
+  const dir = path3.dirname(filepath);
+  return path3.basename(dir);
 }
 var entryPointConventions;
 var init_entryPoints = __esm(() => {
@@ -754,11 +518,75 @@ var init_entryPoints = __esm(() => {
         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/introspection/conventions/configFiles.ts
+// src/domain/services/conventions/configFiles.ts
 var configFileConventions;
 var init_configFiles = __esm(() => {
   configFileConventions = [
@@ -767,40 +595,191 @@ var init_configFiles = __esm(() => {
       name: "Package.json",
       description: "Node.js package manifest",
       category: "configuration",
-      match: (filepath, filename) => filename === "package.json",
-      keywords: ["package", "dependencies", "npm", "scripts", "manifest", "node"]
+      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: "pnpm-workspace",
-      name: "PNPM Workspace",
-      description: "PNPM monorepo workspace configuration",
+      id: "flake8",
+      name: "Flake8 Config",
+      description: "Flake8 linter configuration",
       category: "configuration",
-      match: (filepath, filename) => filename === "pnpm-workspace.yaml" || filename === "pnpm-workspace.yml",
-      keywords: ["workspace", "monorepo", "pnpm", "packages"]
+      match: (filepath, filename) => filename === ".flake8",
+      keywords: ["python", "flake8", "linting", "lint", "style"]
     },
     {
-      id: "yarn-lock",
-      name: "Yarn Lock",
-      description: "Yarn dependency lock file",
+      id: "pylintrc",
+      name: "Pylint Config",
+      description: "Pylint linter configuration",
       category: "configuration",
-      match: (filepath, filename) => filename === "yarn.lock",
-      keywords: ["dependencies", "lock", "yarn", "versions"]
+      match: (filepath, filename) => filename === ".pylintrc" || filename === "pylintrc" || filename === "pylint.toml",
+      keywords: ["python", "pylint", "linting", "lint", "code quality"]
     },
     {
-      id: "package-lock",
-      name: "Package Lock",
-      description: "NPM dependency lock file",
+      id: "ruff-toml",
+      name: "Ruff Config",
+      description: "Ruff linter/formatter configuration",
       category: "configuration",
-      match: (filepath, filename) => filename === "package-lock.json",
-      keywords: ["dependencies", "lock", "npm", "versions"]
+      match: (filepath, filename) => filename === "ruff.toml" || filename === ".ruff.toml",
+      keywords: ["python", "ruff", "linting", "formatting", "fast"]
     },
     {
-      id: "bun-lockb",
-      name: "Bun Lock",
-      description: "Bun dependency lock file",
+      id: "black-toml",
+      name: "Black Config",
+      description: "Black formatter configuration",
       category: "configuration",
-      match: (filepath, filename) => filename === "bun.lockb" || filename === "bun.lock",
-      keywords: ["dependencies", "lock", "bun", "versions"]
+      match: (filepath, filename) => filename === ".black.toml",
+      keywords: ["python", "black", "formatting", "format", "style"]
     },
     {
       id: "tsconfig",
@@ -1043,7 +1022,7 @@ var init_configFiles = __esm(() => {
   ];
 });
 
-// src/introspection/conventions/frameworks/nextjs.ts
+// src/domain/services/conventions/frameworks/nextjs.ts
 var nextjsConventions, nextjsFramework;
 var init_nextjs = __esm(() => {
   nextjsConventions = [
@@ -1208,7 +1187,7 @@ var init_nextjs = __esm(() => {
   };
 });
 
-// src/introspection/conventions/frameworks/convex.ts
+// src/domain/services/conventions/frameworks/convex.ts
 var convexConventions, convexFramework;
 var init_convex = __esm(() => {
   convexConventions = [
@@ -1304,7 +1283,7 @@ var init_convex = __esm(() => {
   };
 });
 
-// src/introspection/conventions/frameworks/index.ts
+// src/domain/services/conventions/frameworks/index.ts
 function getAllFrameworkConventions() {
   return frameworkProviders.flatMap((f) => f.conventions);
 }
@@ -1320,26 +1299,21 @@ var init_frameworks = __esm(() => {
   ];
 });
 
-// src/introspection/conventions/index.ts
-import * as path5 from "path";
-function getAllConventions() {
+// src/domain/services/conventions/index.ts
+import * as path4 from "path";
+function getConventions() {
   return [
     ...entryPointConventions,
     ...configFileConventions,
-    ...getAllFrameworkConventions()
-  ];
-}
-function getConventions() {
-  return [
-    ...getAllConventions(),
+    ...getAllFrameworkConventions(),
     ...typeDefinitionConventions,
     ...testFileConventions
   ];
 }
 function getConventionKeywords(filepath) {
   const conventions = getConventions();
-  const filename = path5.basename(filepath);
-  const extension = path5.extname(filepath);
+  const filename = path4.basename(filepath);
+  const extension = path4.extname(filepath);
   const keywords = new Set;
   for (const convention of conventions) {
     try {
@@ -1386,9 +1360,8 @@ var init_conventions = __esm(() => {
       keywords: ["types", "definitions", "typescript", "interfaces"],
       dynamicKeywords: (filepath) => {
         const match = filepath.match(/([^/]+)\.types\.ts$/);
-        if (match) {
+        if (match)
           return [match[1].toLowerCase()];
-        }
         return [];
       }
     },
@@ -1411,9 +1384,8 @@ var init_conventions = __esm(() => {
       keywords: ["test", "spec", "unit test"],
       dynamicKeywords: (filepath) => {
         const match = filepath.match(/([^/]+)\.(test|spec)\./);
-        if (match) {
+        if (match)
           return [match[1].toLowerCase()];
-        }
         return [];
       }
     },
@@ -1428,22 +1400,19 @@ var init_conventions = __esm(() => {
   ];
 });
 
-// src/introspection/fileIntrospector.ts
-import * as path6 from "path";
+// 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 = path6.extname(filename);
+  const ext = path5.extname(filename);
   const project = findProjectForFile(normalizedPath, structure);
   const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
   const layer = detectLayer(segments, filename);
   const domain = detectDomain(segments);
   const scope = detectScope(segments, project, layer);
-  let framework;
-  if (fileContent) {
-    framework = detectFramework(fileContent);
-  }
+  const framework = fileContent ? detectFramework(fileContent) : undefined;
   return {
     filepath: normalizedPath,
     project,
@@ -1456,21 +1425,81 @@ function introspectFile(filepath, structure, fileContent) {
     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)) {
+      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)) {
+      if (patterns.includes(segment))
         return layer;
-      }
     }
   }
   return;
@@ -1491,9 +1520,8 @@ function detectDomain(segments) {
     const segmentLower = segment.toLowerCase();
     if (skipSegments.has(segmentLower))
       continue;
-    if (DOMAIN_PATTERNS.includes(segmentLower)) {
+    if (DOMAIN_PATTERNS.includes(segmentLower))
       return segmentLower;
-    }
     for (const domain of DOMAIN_PATTERNS) {
       if (segmentLower.startsWith(domain) || segmentLower.endsWith(domain)) {
         return domain;
@@ -1504,9 +1532,8 @@ function detectDomain(segments) {
 }
 function detectScope(segments, project, layer) {
   const projectScope = detectScopeFromName(project.name);
-  if (projectScope !== "unknown") {
+  if (projectScope !== "unknown")
     return projectScope;
-  }
   if (layer) {
     switch (layer) {
       case "controller":
@@ -1524,15 +1551,12 @@ function detectScope(segments, project, layer) {
   }
   for (const segment of segments) {
     const segmentLower = segment.toLowerCase();
-    if (["server", "api", "backend"].includes(segmentLower)) {
+    if (["server", "api", "backend"].includes(segmentLower))
       return "backend";
-    }
-    if (["client", "web", "frontend", "ui"].includes(segmentLower)) {
+    if (["client", "web", "frontend", "ui"].includes(segmentLower))
       return "frontend";
-    }
-    if (["shared", "common", "lib", "libs"].includes(segmentLower)) {
+    if (["shared", "common", "lib", "libs"].includes(segmentLower))
       return "shared";
-    }
   }
   return "unknown";
 }
@@ -1546,44 +1570,8 @@ function detectFramework(content) {
   }
   return;
 }
-function introspectionToKeywords(intro) {
-  const keywords = [];
-  const filename = path6.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)];
-}
-var LAYER_PATTERNS, DOMAIN_PATTERNS, FRAMEWORK_INDICATORS, EXTENSION_TO_LANGUAGE;
-var init_fileIntrospector = __esm(() => {
-  init_projectDetector();
+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"],
@@ -1702,120 +1690,45 @@ var init_fileIntrospector = __esm(() => {
     ".md": "markdown",
     ".json": "json",
     ".yaml": "yaml",
-    ".yml": "yaml"
+    ".yml": "yaml",
+    ".txt": "text"
   };
-});
-
-// src/introspection/index.ts
-import * as path7 from "path";
-import * as fs3 from "fs/promises";
-
-class IntrospectionIndex {
-  rootDir;
-  structure = null;
-  files = new Map;
-  config = {};
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-  }
-  async initialize() {
-    this.structure = await detectProjectStructure(this.rootDir);
-    try {
-      const configPath = path7.join(this.rootDir, ".raggrep", "config.json");
-      const configContent = await fs3.readFile(configPath, "utf-8");
-      const config = JSON.parse(configContent);
-      this.config = config.introspection || {};
-    } catch {}
-  }
-  getStructure() {
-    return this.structure;
-  }
-  addFile(filepath, content) {
-    if (!this.structure) {
-      throw new Error("IntrospectionIndex not initialized");
-    }
-    const intro = introspectFile(filepath, this.structure, content);
-    this.applyOverrides(intro);
-    this.files.set(filepath, intro);
-    return intro;
-  }
-  getFile(filepath) {
-    return this.files.get(filepath);
-  }
-  getAllFiles() {
-    return Array.from(this.files.values());
-  }
-  applyOverrides(intro) {
-    if (!this.config.projects)
-      return;
-    for (const [projectPath, overrides] of Object.entries(this.config.projects)) {
-      if (intro.filepath.startsWith(projectPath + "/") || intro.project.root === projectPath) {
-        if (overrides.scope) {
-          intro.scope = overrides.scope;
-        }
-        if (overrides.framework) {
-          intro.framework = overrides.framework;
-        }
-        break;
-      }
-    }
-  }
-  async save(config) {
-    const introDir = path7.join(getRaggrepDir(this.rootDir, config), "introspection");
-    await fs3.mkdir(introDir, { recursive: true });
-    const projectPath = path7.join(introDir, "_project.json");
-    await fs3.writeFile(projectPath, JSON.stringify({
-      version: "1.0.0",
-      lastUpdated: new Date().toISOString(),
-      structure: this.structure
-    }, null, 2));
-    for (const [filepath, intro] of this.files) {
-      const introFilePath = path7.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
-      await fs3.mkdir(path7.dirname(introFilePath), { recursive: true });
-      await fs3.writeFile(introFilePath, JSON.stringify(intro, null, 2));
-    }
-    console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
-  }
-  async load(config) {
-    const introDir = path7.join(getRaggrepDir(this.rootDir, config), "introspection");
-    try {
-      const projectPath = path7.join(introDir, "_project.json");
-      const projectContent = await fs3.readFile(projectPath, "utf-8");
-      const projectData = JSON.parse(projectContent);
-      this.structure = projectData.structure;
-      await this.loadFilesRecursive(path7.join(introDir, "files"), "");
-    } catch {
-      this.structure = null;
-      this.files.clear();
-    }
-  }
-  async loadFilesRecursive(basePath, prefix) {
-    try {
-      const entries = await fs3.readdir(basePath, { withFileTypes: true });
-      for (const entry of entries) {
-        const entryPath = path7.join(basePath, entry.name);
-        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-          await this.loadFilesRecursive(entryPath, relativePath);
-        } else if (entry.name.endsWith(".json")) {
-          const content = await fs3.readFile(entryPath, "utf-8");
-          const intro = JSON.parse(content);
-          this.files.set(intro.filepath, intro);
-        }
-      }
-    } catch {}
-  }
-  clear() {
-    this.files.clear();
-    this.structure = null;
-  }
-}
-var init_introspection = __esm(() => {
-  init_projectDetector();
-  init_fileIntrospector();
-  init_config2();
-  init_fileIntrospector();
-  init_projectDetector();
+  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
@@ -1985,8 +1898,8 @@ var exports_core = {};
 __export(exports_core, {
   CoreModule: () => CoreModule
 });
-import * as path8 from "path";
-import * as fs4 from "fs/promises";
+import * as path6 from "path";
+import * as fs2 from "fs/promises";
 
 class CoreModule {
   id = "core";
@@ -2004,7 +1917,9 @@ class CoreModule {
     const contentTokens = tokenize(content);
     const intro = ctx.getIntrospection?.(filepath);
     const introKeywords = intro ? introspectionToKeywords(intro) : [];
-    const allTokens = [...new Set([...contentTokens, ...symbolKeywords, ...introKeywords])];
+    const allTokens = [
+      ...new Set([...contentTokens, ...symbolKeywords, ...introKeywords])
+    ];
     const chunks = this.createChunks(filepath, content, symbols);
     const stats = await ctx.getFileStats(filepath);
     this.symbolIndex.set(filepath, {
@@ -2078,8 +1993,8 @@ class CoreModule {
   }
   async finalize(ctx) {
     const config = ctx.config;
-    const coreDir = path8.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
-    await fs4.mkdir(coreDir, { recursive: true });
+    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);
@@ -2090,7 +2005,7 @@ class CoreModule {
       files: Object.fromEntries(this.symbolIndex),
       bm25Data: this.bm25Index.serialize()
     };
-    await fs4.writeFile(path8.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
+    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) {
@@ -2187,10 +2102,10 @@ class CoreModule {
     return bestChunk;
   }
   async loadSymbolIndex(rootDir, config) {
-    const coreDir = path8.join(getRaggrepDir(rootDir, config), "index", "core");
-    const symbolsPath = path8.join(coreDir, "symbols.json");
+    const coreDir = path6.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path6.join(coreDir, "symbols.json");
     try {
-      const content = await fs4.readFile(symbolsPath, "utf-8");
+      const content = await fs2.readFile(symbolsPath, "utf-8");
       const data = JSON.parse(content);
       this.symbolIndex = new Map(Object.entries(data.files));
       if (data.bm25Data) {
@@ -2617,8 +2532,8 @@ var init_keywords = __esm(() => {
 });
 
 // src/infrastructure/storage/symbolicIndex.ts
-import * as fs5 from "fs/promises";
-import * as path9 from "path";
+import * as fs3 from "fs/promises";
+import * as path7 from "path";
 
 class SymbolicIndex {
   meta = null;
@@ -2627,7 +2542,7 @@ class SymbolicIndex {
   symbolicPath;
   moduleId;
   constructor(indexDir, moduleId) {
-    this.symbolicPath = path9.join(indexDir, "index", moduleId, "symbolic");
+    this.symbolicPath = path7.join(indexDir, "index", moduleId, "symbolic");
     this.moduleId = moduleId;
   }
   async initialize() {
@@ -2687,18 +2602,18 @@ class SymbolicIndex {
       throw new Error("Index not initialized");
     this.meta.lastUpdated = new Date().toISOString();
     this.meta.fileCount = this.fileSummaries.size;
-    await fs5.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path9.join(this.symbolicPath, "_meta.json");
-    await fs5.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
+    await fs3.mkdir(this.symbolicPath, { recursive: true });
+    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 fs5.mkdir(path9.dirname(summaryPath), { recursive: true });
-      await fs5.writeFile(summaryPath, JSON.stringify(summary, null, 2));
+      await fs3.mkdir(path7.dirname(summaryPath), { recursive: true });
+      await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
     }
   }
   async load() {
-    const metaPath = path9.join(this.symbolicPath, "_meta.json");
-    const metaContent = await fs5.readFile(metaPath, "utf-8");
+    const metaPath = path7.join(this.symbolicPath, "_meta.json");
+    const metaContent = await fs3.readFile(metaPath, "utf-8");
     this.meta = JSON.parse(metaContent);
     this.fileSummaries.clear();
     await this.loadFileSummariesRecursive(this.symbolicPath);
@@ -2706,14 +2621,14 @@ class SymbolicIndex {
   }
   async loadFileSummariesRecursive(dir) {
     try {
-      const entries = await fs5.readdir(dir, { withFileTypes: true });
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path9.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") {
           try {
-            const content = await fs5.readFile(fullPath, "utf-8");
+            const content = await fs3.readFile(fullPath, "utf-8");
             const summary = JSON.parse(content);
             if (summary.filepath) {
               this.fileSummaries.set(summary.filepath, summary);
@@ -2725,18 +2640,18 @@ class SymbolicIndex {
   }
   getFileSummaryPath(filepath) {
     const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path9.join(this.symbolicPath, jsonPath);
+    return path7.join(this.symbolicPath, jsonPath);
   }
   async deleteFileSummary(filepath) {
     try {
-      await fs5.unlink(this.getFileSummaryPath(filepath));
+      await fs3.unlink(this.getFileSummaryPath(filepath));
     } catch {}
     this.fileSummaries.delete(filepath);
   }
   async exists() {
     try {
-      const metaPath = path9.join(this.symbolicPath, "_meta.json");
-      await fs5.access(metaPath);
+      const metaPath = path7.join(this.symbolicPath, "_meta.json");
+      await fs3.access(metaPath);
       return true;
     } catch {
       return false;
@@ -2775,7 +2690,7 @@ __export(exports_typescript, {
   DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
   DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
 });
-import * as path10 from "path";
+import * as path8 from "path";
 
 class TypeScriptModule {
   id = "language/typescript";
@@ -2918,112 +2833,376 @@ class TypeScriptModule {
     for (const result of bm25Results) {
       bm25Scores.set(result.id, normalizeScore(result.score, 3));
     }
-    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
-    const pathBoosts = new Map;
-    for (const filepath of candidateFiles) {
-      const summary = symbolicIndex.getFileSummary(filepath);
-      if (summary?.pathContext) {
-        let boost = 0;
-        const ctx2 = summary.pathContext;
-        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
-          boost += 0.1;
-        }
-        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
-          boost += 0.05;
+    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+    const pathBoosts = new Map;
+    for (const filepath of candidateFiles) {
+      const summary = symbolicIndex.getFileSummary(filepath);
+      if (summary?.pathContext) {
+        let boost = 0;
+        const ctx2 = summary.pathContext;
+        if (ctx2.domain && queryTerms.some((t) => ctx2.domain.includes(t) || t.includes(ctx2.domain))) {
+          boost += 0.1;
+        }
+        if (ctx2.layer && queryTerms.some((t) => ctx2.layer.includes(t) || t.includes(ctx2.layer))) {
+          boost += 0.05;
+        }
+        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
+        if (segmentMatch) {
+          boost += 0.05;
+        }
+        pathBoosts.set(filepath, boost);
+      }
+    }
+    const results = [];
+    for (const { filepath, chunk, embedding } of allChunksData) {
+      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
+      const bm25Score = bm25Scores.get(chunk.id) || 0;
+      const pathBoost = pathBoosts.get(filepath) || 0;
+      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + pathBoost;
+      if (hybridScore >= minScore || bm25Score > 0.3) {
+        results.push({
+          filepath,
+          chunk,
+          score: hybridScore,
+          moduleId: this.id,
+          context: {
+            semanticScore,
+            bm25Score,
+            pathBoost
+          }
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  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);
+      }
+    }
+    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);
+      }
+    }
+    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/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);
+    }
+    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 = 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;
+  }
+}
+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"
+    };
+  }
+}
+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/infrastructure/introspection/IntrospectionIndex.ts
+import * as path10 from "path";
+import * as fs5 from "fs/promises";
+
+class IntrospectionIndex {
+  rootDir;
+  structure = null;
+  files = new Map;
+  config = {};
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  async initialize() {
+    this.structure = await detectProjectStructure(this.rootDir);
+    try {
+      const configPath = path10.join(this.rootDir, ".raggrep", "config.json");
+      const configContent = await fs5.readFile(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      this.config = config.introspection || {};
+    } catch {}
+  }
+  getStructure() {
+    return this.structure;
+  }
+  addFile(filepath, content) {
+    if (!this.structure) {
+      throw new Error("IntrospectionIndex not initialized");
+    }
+    const intro = introspectFile(filepath, this.structure, content);
+    this.applyOverrides(intro);
+    this.files.set(filepath, intro);
+    return intro;
+  }
+  getFile(filepath) {
+    return this.files.get(filepath);
+  }
+  getAllFiles() {
+    return Array.from(this.files.values());
+  }
+  applyOverrides(intro) {
+    if (!this.config.projects)
+      return;
+    for (const [projectPath, overrides] of Object.entries(this.config.projects)) {
+      if (intro.filepath.startsWith(projectPath + "/") || intro.project.root === projectPath) {
+        if (overrides.scope) {
+          intro.scope = overrides.scope;
         }
-        const segmentMatch = ctx2.segments.some((seg) => queryTerms.some((t) => seg.toLowerCase().includes(t) || t.includes(seg.toLowerCase())));
-        if (segmentMatch) {
-          boost += 0.05;
+        if (overrides.framework) {
+          intro.framework = overrides.framework;
         }
-        pathBoosts.set(filepath, boost);
+        break;
       }
     }
-    const results = [];
-    for (const { filepath, chunk, embedding } of allChunksData) {
-      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
-      const bm25Score = bm25Scores.get(chunk.id) || 0;
-      const pathBoost = pathBoosts.get(filepath) || 0;
-      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + pathBoost;
-      if (hybridScore >= minScore || bm25Score > 0.3) {
-        results.push({
-          filepath,
-          chunk,
-          score: hybridScore,
-          moduleId: this.id,
-          context: {
-            semanticScore,
-            bm25Score,
-            pathBoost
-          }
-        });
-      }
+  }
+  async save(config) {
+    const introDir = path10.join(getRaggrepDir(this.rootDir, config), "introspection");
+    await fs5.mkdir(introDir, { recursive: true });
+    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 = path10.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs5.mkdir(path10.dirname(introFilePath), { recursive: true });
+      await fs5.writeFile(introFilePath, JSON.stringify(intro, null, 2));
     }
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, topK);
+    console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
   }
-  extractReferences(content, filepath) {
-    const references = [];
-    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
-    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    let match;
-    while ((match = importRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (importPath.startsWith(".")) {
-        const dir = path10.dirname(filepath);
-        const resolved = path10.normalize(path10.join(dir, importPath));
-        references.push(resolved);
-      }
+  async load(config) {
+    const introDir = path10.join(getRaggrepDir(this.rootDir, config), "introspection");
+    try {
+      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(path10.join(introDir, "files"), "");
+    } catch {
+      this.structure = null;
+      this.files.clear();
     }
-    while ((match = requireRegex.exec(content)) !== null) {
-      const importPath = match[1];
-      if (importPath.startsWith(".")) {
-        const dir = path10.dirname(filepath);
-        const resolved = path10.normalize(path10.join(dir, importPath));
-        references.push(resolved);
+  }
+  async loadFilesRecursive(basePath, prefix) {
+    try {
+      const entries = await fs5.readdir(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path10.join(basePath, entry.name);
+        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          await this.loadFilesRecursive(entryPath, relativePath);
+        } else if (entry.name.endsWith(".json")) {
+          const content = await fs5.readFile(entryPath, "utf-8");
+          const intro = JSON.parse(content);
+          this.files.set(intro.filepath, intro);
+        }
       }
-    }
-    return references;
+    } catch {}
+  }
+  clear() {
+    this.files.clear();
+    this.structure = null;
   }
 }
-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();
+var init_IntrospectionIndex = __esm(() => {
+  init_projectDetector();
+  init_introspection();
   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/infrastructure/introspection/index.ts
+var init_introspection2 = __esm(() => {
+  init_IntrospectionIndex();
+  init_projectDetector();
 });
 
 // src/app/indexer/watcher.ts
@@ -3204,6 +3383,7 @@ __export(exports_indexer, {
   watchDirectory: () => watchDirectory,
   indexDirectory: () => indexDirectory,
   getIndexStatus: () => getIndexStatus,
+  ensureIndexFresh: () => ensureIndexFresh,
   cleanupIndex: () => cleanupIndex
 });
 import { glob } from "glob";
@@ -3211,10 +3391,13 @@ import * as fs6 from "fs/promises";
 import * as path12 from "path";
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
+  const quiet = options.quiet ?? false;
   rootDir = path12.resolve(rootDir);
   const location = getIndexLocation(rootDir);
-  console.log(`Indexing directory: ${rootDir}`);
-  console.log(`Index location: ${location.indexDir}`);
+  if (!quiet) {
+    console.log(`Indexing directory: ${rootDir}`);
+    console.log(`Index location: ${location.indexDir}`);
+  }
   const config = await loadConfig(rootDir);
   const introspection = new IntrospectionIndex(rootDir);
   await introspection.initialize();
@@ -3227,16 +3410,24 @@ async function indexDirectory(rootDir, options = {}) {
   await registerBuiltInModules();
   const enabledModules = registry.getEnabled(config);
   if (enabledModules.length === 0) {
-    console.log("No modules enabled. Check your configuration.");
+    if (!quiet) {
+      console.log("No modules enabled. Check your configuration.");
+    }
     return [];
   }
-  console.log(`Enabled modules: ${enabledModules.map((m) => m.id).join(", ")}`);
+  if (!quiet) {
+    console.log(`Enabled modules: ${enabledModules.map((m) => m.id).join(", ")}`);
+  }
   const files = await findFiles(rootDir, config);
-  console.log(`Found ${files.length} files to index`);
+  if (!quiet) {
+    console.log(`Found ${files.length} files to index`);
+  }
   const results = [];
   for (const module of enabledModules) {
-    console.log(`
+    if (!quiet) {
+      console.log(`
 [${module.name}] Starting indexing...`);
+    }
     const moduleConfig = getModuleConfig(config, module.id);
     if (module.initialize && moduleConfig) {
       const configWithOverrides = { ...moduleConfig };
@@ -3251,7 +3442,9 @@ async function indexDirectory(rootDir, options = {}) {
     const result = await indexWithModule(rootDir, files, module, config, verbose, introspection);
     results.push(result);
     if (module.finalize) {
-      console.log(`[${module.name}] Building secondary indexes...`);
+      if (!quiet) {
+        console.log(`[${module.name}] Building secondary indexes...`);
+      }
       const ctx = {
         rootDir,
         config,
@@ -3267,12 +3460,167 @@ async function indexDirectory(rootDir, options = {}) {
       };
       await module.finalize(ctx);
     }
-    console.log(`[${module.name}] Complete: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
+    if (!quiet) {
+      console.log(`[${module.name}] Complete: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
+    }
   }
   await introspection.save(config);
   await updateGlobalManifest(rootDir, enabledModules, config);
   return results;
 }
+async function isIndexVersionCompatible(rootDir) {
+  const config = await loadConfig(rootDir);
+  const globalManifestPath = getGlobalManifestPath(rootDir, config);
+  try {
+    const content = await fs6.readFile(globalManifestPath, "utf-8");
+    const manifest = JSON.parse(content);
+    return manifest.version === INDEX_SCHEMA_VERSION;
+  } catch {
+    return false;
+  }
+}
+async function deleteIndex(rootDir) {
+  const indexDir = getRaggrepDir(rootDir);
+  try {
+    await fs6.rm(indexDir, { recursive: true, force: true });
+  } catch {}
+}
+async function ensureIndexFresh(rootDir, options = {}) {
+  const verbose = options.verbose ?? false;
+  const quiet = options.quiet ?? false;
+  rootDir = path12.resolve(rootDir);
+  const status = await getIndexStatus(rootDir);
+  if (!status.exists) {
+    if (!quiet) {
+      console.log(`No index found. Creating index...
+`);
+    }
+    const results = await indexDirectory(rootDir, { ...options, quiet });
+    const totalIndexed2 = results.reduce((sum, r) => sum + r.indexed, 0);
+    return { indexed: totalIndexed2, removed: 0, unchanged: 0 };
+  }
+  const versionCompatible = await isIndexVersionCompatible(rootDir);
+  if (!versionCompatible) {
+    if (!quiet) {
+      console.log(`Index version incompatible. Rebuilding...
+`);
+    }
+    await deleteIndex(rootDir);
+    const results = await indexDirectory(rootDir, { ...options, quiet });
+    const totalIndexed2 = results.reduce((sum, r) => sum + r.indexed, 0);
+    return { indexed: totalIndexed2, removed: 0, unchanged: 0 };
+  }
+  const config = await loadConfig(rootDir);
+  await registerBuiltInModules();
+  const enabledModules = registry.getEnabled(config);
+  if (enabledModules.length === 0) {
+    return { indexed: 0, removed: 0, unchanged: 0 };
+  }
+  const introspection = new IntrospectionIndex(rootDir);
+  await introspection.initialize();
+  const currentFiles = await findFiles(rootDir, config);
+  const currentFileSet = new Set(currentFiles.map((f) => path12.relative(rootDir, f)));
+  let totalIndexed = 0;
+  let totalRemoved = 0;
+  let totalUnchanged = 0;
+  for (const module of enabledModules) {
+    const moduleConfig = getModuleConfig(config, module.id);
+    if (module.initialize && moduleConfig) {
+      const configWithOverrides = { ...moduleConfig };
+      if (options.model && module.id === "language/typescript") {
+        configWithOverrides.options = {
+          ...configWithOverrides.options,
+          embeddingModel: options.model
+        };
+      }
+      await module.initialize(configWithOverrides);
+    }
+    const manifest = await loadModuleManifest(rootDir, module.id, config);
+    const indexPath = getModuleIndexPath(rootDir, module.id, config);
+    const filesToRemove = [];
+    for (const filepath of Object.keys(manifest.files)) {
+      if (!currentFileSet.has(filepath)) {
+        filesToRemove.push(filepath);
+      }
+    }
+    for (const filepath of filesToRemove) {
+      if (verbose) {
+        console.log(`  Removing stale: ${filepath}`);
+      }
+      const indexFilePath = path12.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+      try {
+        await fs6.unlink(indexFilePath);
+      } catch {}
+      delete manifest.files[filepath];
+      totalRemoved++;
+    }
+    const ctx = {
+      rootDir,
+      config,
+      readFile: async (filepath) => {
+        const fullPath = path12.isAbsolute(filepath) ? filepath : path12.join(rootDir, filepath);
+        return fs6.readFile(fullPath, "utf-8");
+      },
+      getFileStats: async (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 currentFiles) {
+      const relativePath = path12.relative(rootDir, filepath);
+      try {
+        const stats = await fs6.stat(filepath);
+        const lastModified = stats.mtime.toISOString();
+        const existingEntry = manifest.files[relativePath];
+        if (existingEntry && existingEntry.lastModified === lastModified) {
+          totalUnchanged++;
+          continue;
+        }
+        if (verbose) {
+          console.log(`  Indexing: ${relativePath}`);
+        }
+        const content = await fs6.readFile(filepath, "utf-8");
+        introspection.addFile(relativePath, content);
+        const fileIndex = await module.indexFile(relativePath, content, ctx);
+        if (fileIndex) {
+          await writeFileIndex(rootDir, module.id, relativePath, fileIndex, config);
+          manifest.files[relativePath] = {
+            lastModified,
+            chunkCount: fileIndex.chunks.length
+          };
+          totalIndexed++;
+        }
+      } catch (error) {
+        if (verbose) {
+          console.error(`  Error indexing ${relativePath}:`, error);
+        }
+      }
+    }
+    if (totalIndexed > 0 || totalRemoved > 0) {
+      manifest.lastUpdated = new Date().toISOString();
+      await writeModuleManifest(rootDir, module.id, manifest, config);
+      if (module.finalize) {
+        await module.finalize(ctx);
+      }
+    }
+    if (totalRemoved > 0) {
+      await cleanupEmptyDirectories(indexPath);
+    }
+  }
+  if (totalIndexed > 0) {
+    await introspection.save(config);
+  }
+  if (totalIndexed > 0 || totalRemoved > 0) {
+    await updateGlobalManifest(rootDir, enabledModules, config);
+  }
+  return {
+    indexed: totalIndexed,
+    removed: totalRemoved,
+    unchanged: totalUnchanged
+  };
+}
 async function indexWithModule(rootDir, files, module, config, verbose, introspection) {
   const result = {
     moduleId: module.id,
@@ -3378,7 +3726,7 @@ async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
 async function updateGlobalManifest(rootDir, modules, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
   const manifest = {
-    version: config.version,
+    version: INDEX_SCHEMA_VERSION,
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
@@ -3518,10 +3866,11 @@ async function getIndexStatus(rootDir) {
   }
   return status;
 }
+var INDEX_SCHEMA_VERSION = "1.0.0";
 var init_indexer = __esm(() => {
   init_config2();
   init_registry();
-  init_introspection();
+  init_introspection2();
   init_watcher();
 });
 
@@ -3615,6 +3964,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.";
@@ -3630,6 +3993,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";
     }
@@ -3657,7 +4021,7 @@ init_embeddings();
 // package.json
 var package_default = {
   name: "raggrep",
-  version: "0.1.6",
+  version: "0.2.0",
   description: "Local filesystem-based RAG system for codebases - semantic search using local embeddings",
   type: "module",
   main: "./dist/index.js",
@@ -3899,8 +4263,11 @@ Options:
   -h, --help           Show this help message
 
 Note:
-  If the current directory has not been indexed, raggrep will
-  automatically index it before searching.
+  The index is managed automatically like a cache:
+  - First query creates the index
+  - Changed files are re-indexed automatically
+  - Deleted files are cleaned up automatically
+  - Unchanged files use the cached index (instant)
 
 Examples:
   raggrep query "user authentication"
@@ -3911,7 +4278,7 @@ Examples:
         process.exit(0);
       }
       const { search: search2, formatSearchResults: formatSearchResults2 } = await Promise.resolve().then(() => (init_search(), exports_search));
-      const { getIndexStatus: getIndexStatus2, indexDirectory: indexDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const { ensureIndexFresh: ensureIndexFresh2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       const query = flags.remaining[0];
       if (!query) {
         console.error("Usage: raggrep query <search query>");
@@ -3919,24 +4286,20 @@ Examples:
         process.exit(1);
       }
       try {
-        const status = await getIndexStatus2(process.cwd());
-        if (!status.exists) {
-          console.log(`No index found. Indexing directory first...
-`);
-          console.log("RAGgrep Indexer");
-          console.log(`================
-`);
-          const indexResults = await indexDirectory2(process.cwd(), {
-            model: flags.model,
-            verbose: false
-          });
-          console.log(`
-================`);
-          console.log("Summary:");
-          for (const result of indexResults) {
-            console.log(`  ${result.moduleId}: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
+        const freshStats = await ensureIndexFresh2(process.cwd(), {
+          model: flags.model,
+          quiet: true
+        });
+        if (freshStats.indexed > 0 || freshStats.removed > 0) {
+          const parts = [];
+          if (freshStats.indexed > 0) {
+            parts.push(`${freshStats.indexed} indexed`);
           }
-          console.log("");
+          if (freshStats.removed > 0) {
+            parts.push(`${freshStats.removed} removed`);
+          }
+          console.log(`Index updated: ${parts.join(", ")}
+`);
         }
         console.log("RAGgrep Search");
         console.log(`==============
@@ -4092,4 +4455,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=03A02811A6080C5964756E2164756E21
+//# debugId=4B6F0EA9EEB7164864756E2164756E21