raggrep 0.1.6 → 0.2.0

package/dist/index.js

@@ -270,247 +270,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 path2 from "path";
-import * as fs2 from "fs/promises";
-function detectScopeFromName(name) {
-  const nameLower = name.toLowerCase();
-  for (const [scope, keywords] of Object.entries(SCOPE_KEYWORDS)) {
-    if (scope === "unknown")
-      continue;
-    for (const keyword of keywords) {
-      if (nameLower.includes(keyword)) {
-        return scope;
-      }
-    }
-  }
-  return "unknown";
-}
-async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
-  if (depth > MAX_SCAN_DEPTH)
-    return [];
-  const results = [];
-  const fullDir = currentDir ? path2.join(rootDir, currentDir) : rootDir;
-  try {
-    const entries = await fs2.readdir(fullDir, { withFileTypes: true });
-    const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
-    if (hasPackageJson && currentDir) {
-      const info = await parsePackageJson(rootDir, currentDir);
-      if (info) {
-        results.push(info);
-      }
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory())
-        continue;
-      if (SKIP_DIRS.has(entry.name))
-        continue;
-      const subPath = currentDir ? `${currentDir}/${entry.name}` : entry.name;
-      const subResults = await scanForPackageJsons(rootDir, subPath, depth + 1);
-      results.push(...subResults);
-    }
-  } catch {}
-  return results;
-}
-async function parsePackageJson(rootDir, relativePath) {
-  try {
-    const packageJsonPath = path2.join(rootDir, relativePath, "package.json");
-    const content = await fs2.readFile(packageJsonPath, "utf-8");
-    const pkg = JSON.parse(content);
-    const name = pkg.name || path2.basename(relativePath);
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    let type = "unknown";
-    if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
-      type = "app";
-    } else if (deps["express"] || deps["fastify"] || deps["koa"] || deps["hono"]) {
-      type = "service";
-    } else if (pkg.main || pkg.exports) {
-      type = "library";
-    }
-    const hasWorkspaces = Boolean(pkg.workspaces);
-    return { name, relativePath, type, hasWorkspaces };
-  } catch {
-    return null;
-  }
-}
-async function detectProjectStructure(rootDir) {
-  const projectMap = new Map;
-  let isMonorepo = false;
-  try {
-    const entries = await fs2.readdir(rootDir, { withFileTypes: true });
-    const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
-    const monorepoPatterns = ["apps", "packages", "libs", "services"];
-    const hasMonorepoStructure = monorepoPatterns.some((p) => dirNames.includes(p));
-    if (hasMonorepoStructure) {
-      isMonorepo = true;
-      for (const pattern of monorepoPatterns) {
-        if (!dirNames.includes(pattern))
-          continue;
-        const patternDir = path2.join(rootDir, pattern);
-        try {
-          const subDirs = await fs2.readdir(patternDir, { withFileTypes: true });
-          for (const subDir of subDirs) {
-            if (!subDir.isDirectory())
-              continue;
-            const projectRoot = `${pattern}/${subDir.name}`;
-            const type = getProjectType(pattern);
-            projectMap.set(projectRoot, {
-              name: subDir.name,
-              root: projectRoot,
-              type
-            });
-          }
-        } catch {}
-      }
-    }
-    const packageJsons = await scanForPackageJsons(rootDir);
-    for (const pkg of packageJsons) {
-      if (pkg.hasWorkspaces) {
-        isMonorepo = true;
-      }
-      if (packageJsons.length > 1) {
-        isMonorepo = true;
-      }
-      projectMap.set(pkg.relativePath, {
-        name: pkg.name,
-        root: pkg.relativePath,
-        type: pkg.type
-      });
-    }
-    let rootType = "unknown";
-    try {
-      const rootPkgPath = path2.join(rootDir, "package.json");
-      const rootPkg = JSON.parse(await fs2.readFile(rootPkgPath, "utf-8"));
-      if (rootPkg.workspaces) {
-        isMonorepo = true;
-      }
-      const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
-      if (deps["next"] || deps["react"] || deps["vue"]) {
-        rootType = "app";
-      } else if (deps["express"] || deps["fastify"] || deps["koa"]) {
-        rootType = "service";
-      }
-    } catch {}
-    const projects = Array.from(projectMap.values()).sort((a, b) => a.root.length - b.root.length);
-    return {
-      projects,
-      isMonorepo,
-      rootType: isMonorepo ? undefined : rootType
-    };
-  } catch {
-    return {
-      projects: [],
-      isMonorepo: false,
-      rootType: "unknown"
-    };
-  }
-}
-function getProjectType(patternDir) {
-  switch (patternDir) {
-    case "apps":
-      return "app";
-    case "packages":
-    case "libs":
-      return "library";
-    case "services":
-      return "service";
-    case "scripts":
-    case "tools":
-      return "script";
-    default:
-      return "unknown";
-  }
-}
-function findProjectForFile(filepath, structure) {
-  const normalizedPath = filepath.replace(/\\/g, "/");
-  const matches = [];
-  for (const project of structure.projects) {
-    if (normalizedPath === project.root || normalizedPath.startsWith(project.root + "/")) {
-      matches.push(project);
-    }
-  }
-  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 path3 from "path";
 function getParentFolder(filepath) {
-  const dir = path3.dirname(filepath);
-  return path3.basename(dir);
+  const dir = path2.dirname(filepath);
+  return path2.basename(dir);
 }
 var entryPointConventions;
 var init_entryPoints = __esm(() => {
@@ -595,11 +359,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 = [
@@ -643,6 +471,157 @@ var init_configFiles = __esm(() => {
       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",
@@ -884,7 +863,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 = [
@@ -1049,7 +1028,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 = [
@@ -1145,7 +1124,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);
 }
@@ -1161,26 +1140,21 @@ var init_frameworks = __esm(() => {
   ];
 });
 
-// src/introspection/conventions/index.ts
-import * as path4 from "path";
-function getAllConventions() {
+// src/domain/services/conventions/index.ts
+import * as path3 from "path";
+function getConventions() {
   return [
     ...entryPointConventions,
     ...configFileConventions,
-    ...getAllFrameworkConventions()
-  ];
-}
-function getConventions() {
-  return [
-    ...getAllConventions(),
+    ...getAllFrameworkConventions(),
     ...typeDefinitionConventions,
     ...testFileConventions
   ];
 }
 function getConventionKeywords(filepath) {
   const conventions = getConventions();
-  const filename = path4.basename(filepath);
-  const extension = path4.extname(filepath);
+  const filename = path3.basename(filepath);
+  const extension = path3.extname(filepath);
   const keywords = new Set;
   for (const convention of conventions) {
     try {
@@ -1227,9 +1201,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 [];
       }
     },
@@ -1252,9 +1225,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 [];
       }
     },
@@ -1269,22 +1241,19 @@ var init_conventions = __esm(() => {
   ];
 });
 
-// src/introspection/fileIntrospector.ts
-import * as path5 from "path";
+// 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 = path5.extname(filename);
+  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);
-  let framework;
-  if (fileContent) {
-    framework = detectFramework(fileContent);
-  }
+  const framework = fileContent ? detectFramework(fileContent) : undefined;
   return {
     filepath: normalizedPath,
     project,
@@ -1297,21 +1266,81 @@ function introspectFile(filepath, structure, fileContent) {
     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)) {
+      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;
@@ -1332,9 +1361,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;
@@ -1345,9 +1373,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":
@@ -1365,15 +1392,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";
 }
@@ -1387,44 +1411,8 @@ function detectFramework(content) {
   }
   return;
 }
-function introspectionToKeywords(intro) {
-  const keywords = [];
-  const filename = path5.basename(intro.filepath);
-  const filenameWithoutExt = filename.replace(/\.[^.]+$/, "");
-  const filenameParts = filenameWithoutExt.split(/[-_.]/).flatMap((part) => part.split(/(?=[A-Z])/)).map((part) => part.toLowerCase()).filter((part) => part.length > 1);
-  keywords.push(...filenameParts);
-  keywords.push(filenameWithoutExt.toLowerCase());
-  if (intro.project.name && intro.project.name !== "root") {
-    keywords.push(intro.project.name.toLowerCase());
-  }
-  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"],
@@ -1543,120 +1531,45 @@ var init_fileIntrospector = __esm(() => {
     ".md": "markdown",
     ".json": "json",
     ".yaml": "yaml",
-    ".yml": "yaml"
+    ".yml": "yaml",
+    ".txt": "text"
   };
-});
-
-// src/introspection/index.ts
-import * as path6 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 = path6.join(this.rootDir, ".raggrep", "config.json");
-      const configContent = await fs3.readFile(configPath, "utf-8");
-      const config = JSON.parse(configContent);
-      this.config = config.introspection || {};
-    } catch {}
-  }
-  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 = path6.join(getRaggrepDir(this.rootDir, config), "introspection");
-    await fs3.mkdir(introDir, { recursive: true });
-    const projectPath = path6.join(introDir, "_project.json");
-    await fs3.writeFile(projectPath, JSON.stringify({
-      version: "1.0.0",
-      lastUpdated: new Date().toISOString(),
-      structure: this.structure
-    }, null, 2));
-    for (const [filepath, intro] of this.files) {
-      const introFilePath = path6.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
-      await fs3.mkdir(path6.dirname(introFilePath), { recursive: true });
-      await fs3.writeFile(introFilePath, JSON.stringify(intro, null, 2));
-    }
-    console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
-  }
-  async load(config) {
-    const introDir = path6.join(getRaggrepDir(this.rootDir, config), "introspection");
-    try {
-      const projectPath = path6.join(introDir, "_project.json");
-      const projectContent = await fs3.readFile(projectPath, "utf-8");
-      const projectData = JSON.parse(projectContent);
-      this.structure = projectData.structure;
-      await this.loadFilesRecursive(path6.join(introDir, "files"), "");
-    } catch {
-      this.structure = null;
-      this.files.clear();
-    }
-  }
-  async loadFilesRecursive(basePath, prefix) {
-    try {
-      const entries = await fs3.readdir(basePath, { withFileTypes: true });
-      for (const entry of entries) {
-        const entryPath = path6.join(basePath, entry.name);
-        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-          await this.loadFilesRecursive(entryPath, relativePath);
-        } else if (entry.name.endsWith(".json")) {
-          const content = await fs3.readFile(entryPath, "utf-8");
-          const intro = JSON.parse(content);
-          this.files.set(intro.filepath, intro);
-        }
-      }
-    } 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
@@ -1826,8 +1739,8 @@ var exports_core = {};
 __export(exports_core, {
   CoreModule: () => CoreModule
 });
-import * as path7 from "path";
-import * as fs4 from "fs/promises";
+import * as path5 from "path";
+import * as fs2 from "fs/promises";
 
 class CoreModule {
   id = "core";
@@ -1845,7 +1758,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, {
@@ -1919,8 +1834,8 @@ class CoreModule {
   }
   async finalize(ctx) {
     const config = ctx.config;
-    const coreDir = path7.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
-    await fs4.mkdir(coreDir, { recursive: true });
+    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) {
       this.bm25Index.addDocument(filepath, entry.tokens);
@@ -1931,7 +1846,7 @@ class CoreModule {
       files: Object.fromEntries(this.symbolIndex),
       bm25Data: this.bm25Index.serialize()
     };
-    await fs4.writeFile(path7.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) {
@@ -2028,10 +1943,10 @@ class CoreModule {
     return bestChunk;
   }
   async loadSymbolIndex(rootDir, config) {
-    const coreDir = path7.join(getRaggrepDir(rootDir, config), "index", "core");
-    const symbolsPath = path7.join(coreDir, "symbols.json");
+    const coreDir = path5.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path5.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) {
@@ -2056,7 +1971,7 @@ var init_core = __esm(() => {
 
 // src/infrastructure/embeddings/transformersEmbedding.ts
 import { pipeline, env } from "@xenova/transformers";
-import * as path8 from "path";
+import * as path6 from "path";
 import * as os2 from "os";
 
 class TransformersEmbeddingProvider {
@@ -2189,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 = path8.join(os2.homedir(), ".cache", "raggrep", "models");
+  CACHE_DIR = path6.join(os2.homedir(), ".cache", "raggrep", "models");
   env.cacheDir = CACHE_DIR;
   env.allowLocalModels = true;
   EMBEDDING_MODELS2 = {
@@ -2613,8 +2528,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;
@@ -2623,7 +2538,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() {
@@ -2683,18 +2598,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);
@@ -2702,14 +2617,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);
@@ -2721,18 +2636,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;
@@ -2771,7 +2686,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";
@@ -2965,16 +2880,16 @@ class TypeScriptModule {
     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));
+        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 = path10.dirname(filepath);
-        const resolved = path10.normalize(path10.join(dir, importPath));
+        const dir = path8.dirname(filepath);
+        const resolved = path8.normalize(path8.join(dir, importPath));
         references.push(resolved);
       }
     }
@@ -3025,20 +2940,275 @@ async function registerBuiltInModules() {
   registry.register(new TypeScriptModule2);
 }
 
-// src/app/indexer/index.ts
+// src/infrastructure/introspection/IntrospectionIndex.ts
+import * as path10 from "path";
+import * as fs5 from "fs/promises";
+
+// 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([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".raggrep"
+]);
+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"
+    };
+  }
+}
+
+// src/infrastructure/introspection/IntrospectionIndex.ts
 init_introspection();
+init_config2();
 
+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;
+        }
+        if (overrides.framework) {
+          intro.framework = overrides.framework;
+        }
+        break;
+      }
+    }
+  }
+  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));
+    }
+    console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
+  }
+  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();
+    }
+  }
+  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);
+        }
+      }
+    } catch {}
+  }
+  clear() {
+    this.files.clear();
+    this.structure = null;
+  }
+}
 // src/app/indexer/watcher.ts
 import { watch } from "chokidar";
 init_config2();
 
 // src/app/indexer/index.ts
+var INDEX_SCHEMA_VERSION = "1.0.0";
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
+  const quiet = options.quiet ?? false;
   rootDir = path11.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();
@@ -3051,16 +3221,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 };
@@ -3075,7 +3253,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,
@@ -3091,7 +3271,9 @@ 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);
@@ -3202,7 +3384,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)
   };
@@ -3372,6 +3554,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.";
@@ -3387,6 +3583,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";
     }
@@ -3430,4 +3627,4 @@ export {
   cleanup
 };
 
-//# debugId=3C6A4139E7CDC07F64756E2164756E21
+//# debugId=DEB2F8AAF72AF0A164756E2164756E21