raggrep 0.1.0 → 0.1.4

package/dist/index.js

@@ -21,7 +21,12 @@ function createDefaultConfig() {
     ignorePaths: DEFAULT_IGNORE_PATHS,
     modules: [
       {
-        id: "semantic",
+        id: "core",
+        enabled: true,
+        options: {}
+      },
+      {
+        id: "language/typescript",
         enabled: true,
         options: {
           embeddingModel: "all-MiniLM-L6-v2"
@@ -81,156 +86,32 @@ var init_entities = __esm(() => {
   init_config();
 });
 
-// src/utils/embeddings.ts
-import { pipeline, env } from "@xenova/transformers";
+// src/infrastructure/config/configLoader.ts
 import * as path from "path";
-import * as os from "os";
-function configureEmbeddings(config) {
-  const newConfig = { ...currentConfig, ...config };
-  if (newConfig.model !== currentConfig.model) {
-    embeddingPipeline = null;
-    currentModelName = null;
-  }
-  currentConfig = newConfig;
-}
-async function initializePipeline() {
-  if (embeddingPipeline && currentModelName === currentConfig.model) {
-    return;
-  }
-  if (isInitializing && initPromise) {
-    return initPromise;
-  }
-  isInitializing = true;
-  initPromise = (async () => {
-    const modelId = EMBEDDING_MODELS[currentConfig.model];
-    if (currentConfig.showProgress) {
-      console.log(`
-  Loading embedding model: ${currentConfig.model}`);
-      console.log(`  Cache: ${CACHE_DIR}`);
-    }
-    try {
-      embeddingPipeline = await pipeline("feature-extraction", modelId, {
-        progress_callback: currentConfig.showProgress ? (progress) => {
-          if (progress.status === "progress" && progress.file) {
-            const pct = progress.progress ? Math.round(progress.progress) : 0;
-            process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
-          } else if (progress.status === "done" && progress.file) {
-            process.stdout.write(`\r  Downloaded ${progress.file}              
-`);
-          } else if (progress.status === "ready") {}
-        } : undefined
-      });
-      currentModelName = currentConfig.model;
-      if (currentConfig.showProgress) {
-        console.log(`  Model ready.
-`);
-      }
-    } catch (error) {
-      embeddingPipeline = null;
-      currentModelName = null;
-      throw new Error(`Failed to load embedding model: ${error}`);
-    } finally {
-      isInitializing = false;
-      initPromise = null;
-    }
-  })();
-  return initPromise;
-}
-async function getEmbedding(text) {
-  await initializePipeline();
-  if (!embeddingPipeline) {
-    throw new Error("Embedding pipeline not initialized");
-  }
-  const output = await embeddingPipeline(text, {
-    pooling: "mean",
-    normalize: true
-  });
-  return Array.from(output.data);
-}
-async function getEmbeddings(texts) {
-  if (texts.length === 0)
-    return [];
-  await initializePipeline();
-  if (!embeddingPipeline) {
-    throw new Error("Embedding pipeline not initialized");
-  }
-  const results = [];
-  for (let i = 0;i < texts.length; i += BATCH_SIZE) {
-    const batch = texts.slice(i, i + BATCH_SIZE);
-    const outputs = await Promise.all(batch.map(async (text) => {
-      const output = await embeddingPipeline(text, {
-        pooling: "mean",
-        normalize: true
-      });
-      return Array.from(output.data);
-    }));
-    results.push(...outputs);
-  }
-  return results;
-}
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0;i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  if (normA === 0 || normB === 0)
-    return 0;
-  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-function getEmbeddingConfig() {
-  return { ...currentConfig };
-}
-var CACHE_DIR, EMBEDDING_MODELS, embeddingPipeline = null, currentModelName = null, isInitializing = false, initPromise = null, DEFAULT_CONFIG, currentConfig, BATCH_SIZE = 32;
-var init_embeddings = __esm(() => {
-  CACHE_DIR = path.join(os.homedir(), ".cache", "raggrep", "models");
-  env.cacheDir = CACHE_DIR;
-  env.allowLocalModels = true;
-  EMBEDDING_MODELS = {
-    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
-    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
-    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
-    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2"
-  };
-  DEFAULT_CONFIG = {
-    model: "all-MiniLM-L6-v2",
-    showProgress: true
-  };
-  currentConfig = { ...DEFAULT_CONFIG };
-});
-
-// src/utils/config.ts
-import * as path2 from "path";
 import * as fs from "fs/promises";
-function getRaggrepDir(rootDir, config = DEFAULT_CONFIG2) {
-  return path2.join(rootDir, config.indexDir);
+function getRaggrepDir(rootDir, config = DEFAULT_CONFIG) {
+  return path.join(rootDir, config.indexDir);
 }
-function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG2) {
-  return path2.join(rootDir, config.indexDir, "index", moduleId);
+function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
+  return path.join(rootDir, config.indexDir, "index", moduleId);
 }
-function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG2) {
-  return path2.join(rootDir, config.indexDir, "index", moduleId, "manifest.json");
+function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
+  return path.join(rootDir, config.indexDir, "index", moduleId, "manifest.json");
 }
-function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG2) {
-  return path2.join(rootDir, config.indexDir, "manifest.json");
+function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG) {
+  return path.join(rootDir, config.indexDir, "manifest.json");
 }
-function getConfigPath(rootDir, config = DEFAULT_CONFIG2) {
-  return path2.join(rootDir, config.indexDir, "config.json");
+function getConfigPath(rootDir, config = DEFAULT_CONFIG) {
+  return path.join(rootDir, config.indexDir, "config.json");
 }
 async function loadConfig(rootDir) {
-  const configPath = getConfigPath(rootDir, DEFAULT_CONFIG2);
+  const configPath = getConfigPath(rootDir, DEFAULT_CONFIG);
   try {
     const content = await fs.readFile(configPath, "utf-8");
     const savedConfig = JSON.parse(content);
-    return { ...DEFAULT_CONFIG2, ...savedConfig };
+    return { ...DEFAULT_CONFIG, ...savedConfig };
   } catch {
-    return DEFAULT_CONFIG2;
+    return DEFAULT_CONFIG;
   }
 }
 function getModuleConfig(config, moduleId) {
@@ -248,11 +129,21 @@ function getEmbeddingConfigFromModule(moduleConfig) {
     showProgress: options.showProgress !== false
   };
 }
-var DEFAULT_CONFIG2;
-var init_config2 = __esm(() => {
+var DEFAULT_CONFIG, EMBEDDING_MODELS;
+var init_configLoader = __esm(() => {
   init_entities();
-  init_embeddings();
-  DEFAULT_CONFIG2 = createDefaultConfig();
+  DEFAULT_CONFIG = createDefaultConfig();
+  EMBEDDING_MODELS = {
+    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
+    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
+    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
+    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2"
+  };
+});
+
+// src/infrastructure/config/index.ts
+var init_config2 = __esm(() => {
+  init_configLoader();
 });
 
 // src/domain/services/bm25.ts
@@ -326,16 +217,604 @@ class BM25Index {
     this.avgDocLength = 0;
     this.totalDocs = 0;
   }
+  addDocument(id, tokens) {
+    this.addDocuments([{ id, content: "", tokens }]);
+  }
+  serialize() {
+    const documents = {};
+    for (const [id, { tokens }] of this.documents) {
+      documents[id] = tokens;
+    }
+    return {
+      documents,
+      avgDocLength: this.avgDocLength,
+      documentFrequencies: Object.fromEntries(this.documentFrequencies),
+      totalDocs: this.totalDocs
+    };
+  }
+  static deserialize(data) {
+    const index = new BM25Index;
+    index.avgDocLength = data.avgDocLength;
+    index.totalDocs = data.totalDocs;
+    index.documentFrequencies = new Map(Object.entries(data.documentFrequencies));
+    for (const [id, tokens] of Object.entries(data.documents)) {
+      index.documents.set(id, { content: "", tokens });
+    }
+    return index;
+  }
 }
 function normalizeScore(score, midpoint = 5) {
   return 1 / (1 + Math.exp(-score / midpoint + 1));
 }
 var BM25_K1 = 1.5, BM25_B = 0.75;
 
-// src/utils/bm25.ts
-var init_bm25 = () => {};
+// src/modules/core/symbols.ts
+function extractSymbols(content) {
+  const symbols = [];
+  const seenSymbols = new Set;
+  const lines = content.split(`
+`);
+  for (const { type, pattern, exported } of SYMBOL_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const name = match[1];
+      const symbolKey = `${name}:${type}`;
+      if (seenSymbols.has(symbolKey))
+        continue;
+      seenSymbols.add(symbolKey);
+      const beforeMatch = content.substring(0, match.index);
+      const line = beforeMatch.split(`
+`).length;
+      symbols.push({
+        name,
+        type,
+        line,
+        isExported: exported
+      });
+    }
+  }
+  return symbols.sort((a, b) => a.line - b.line);
+}
+function symbolsToKeywords(symbols) {
+  const keywords = new Set;
+  for (const symbol of symbols) {
+    keywords.add(symbol.name.toLowerCase());
+    const parts = symbol.name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/\s+/);
+    for (const part of parts) {
+      if (part.length > 2) {
+        keywords.add(part);
+      }
+    }
+  }
+  return Array.from(keywords);
+}
+var SYMBOL_PATTERNS;
+var init_symbols = __esm(() => {
+  SYMBOL_PATTERNS = [
+    {
+      type: "function",
+      pattern: /^export\s+(?:async\s+)?function\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "function",
+      pattern: /^export\s+(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/gm,
+      exported: true
+    },
+    {
+      type: "class",
+      pattern: /^export\s+(?:abstract\s+)?class\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "interface",
+      pattern: /^export\s+interface\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "type",
+      pattern: /^export\s+type\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "enum",
+      pattern: /^export\s+(?:const\s+)?enum\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "variable",
+      pattern: /^export\s+(?:const|let|var)\s+(\w+)\s*(?::|=)/gm,
+      exported: true
+    },
+    {
+      type: "function",
+      pattern: /^export\s+default\s+(?:async\s+)?function\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "class",
+      pattern: /^export\s+default\s+class\s+(\w+)/gm,
+      exported: true
+    },
+    {
+      type: "function",
+      pattern: /^(?:async\s+)?function\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/gm,
+      exported: false
+    },
+    {
+      type: "class",
+      pattern: /^(?:abstract\s+)?class\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "interface",
+      pattern: /^interface\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "type",
+      pattern: /^type\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "enum",
+      pattern: /^(?:const\s+)?enum\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^def\s+(\w+)\s*\(/gm,
+      exported: false
+    },
+    {
+      type: "class",
+      pattern: /^class\s+(\w+)(?:\s*\(|:)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/gm,
+      exported: false
+    },
+    {
+      type: "type",
+      pattern: /^type\s+(\w+)\s+(?:struct|interface)/gm,
+      exported: false
+    },
+    {
+      type: "function",
+      pattern: /^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "type",
+      pattern: /^(?:pub\s+)?struct\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "enum",
+      pattern: /^(?:pub\s+)?enum\s+(\w+)/gm,
+      exported: false
+    },
+    {
+      type: "interface",
+      pattern: /^(?:pub\s+)?trait\s+(\w+)/gm,
+      exported: false
+    }
+  ];
+});
+
+// src/modules/core/index.ts
+var exports_core = {};
+__export(exports_core, {
+  CoreModule: () => CoreModule
+});
+import * as path2 from "path";
+import * as fs2 from "fs/promises";
 
-// src/modules/semantic/parseCode.ts
+class CoreModule {
+  id = "core";
+  name = "Core Search";
+  description = "Language-agnostic text search with symbol extraction";
+  version = "1.0.0";
+  symbolIndex = new Map;
+  bm25Index = null;
+  rootDir = "";
+  async initialize(_config) {}
+  async indexFile(filepath, content, ctx) {
+    this.rootDir = ctx.rootDir;
+    const symbols = extractSymbols(content);
+    const symbolKeywords = symbolsToKeywords(symbols);
+    const contentTokens = tokenize(content);
+    const allTokens = [...new Set([...contentTokens, ...symbolKeywords])];
+    const chunks = this.createChunks(filepath, content, symbols);
+    const stats = await ctx.getFileStats(filepath);
+    this.symbolIndex.set(filepath, {
+      filepath,
+      symbols,
+      tokens: allTokens
+    });
+    const moduleData = {
+      symbols,
+      tokens: allTokens
+    };
+    return {
+      filepath,
+      lastModified: stats.lastModified,
+      chunks,
+      moduleData
+    };
+  }
+  createChunks(filepath, content, symbols) {
+    const lines = content.split(`
+`);
+    const chunks = [];
+    for (let start = 0;start < lines.length; start += LINES_PER_CHUNK - CHUNK_OVERLAP) {
+      const end = Math.min(start + LINES_PER_CHUNK, lines.length);
+      const chunkLines = lines.slice(start, end);
+      const chunkContent = chunkLines.join(`
+`);
+      const chunkSymbols = symbols.filter((s) => s.line >= start + 1 && s.line <= end);
+      let chunkType = "block";
+      let chunkName;
+      let isExported = false;
+      if (chunkSymbols.length > 0) {
+        const primarySymbol = chunkSymbols[0];
+        chunkType = this.symbolTypeToChunkType(primarySymbol.type);
+        chunkName = primarySymbol.name;
+        isExported = primarySymbol.isExported;
+      }
+      const chunkId = `${filepath}:${start + 1}-${end}`;
+      chunks.push({
+        id: chunkId,
+        content: chunkContent,
+        startLine: start + 1,
+        endLine: end,
+        type: chunkType,
+        name: chunkName,
+        isExported
+      });
+      if (end >= lines.length)
+        break;
+    }
+    return chunks;
+  }
+  symbolTypeToChunkType(symbolType) {
+    switch (symbolType) {
+      case "function":
+      case "method":
+        return "function";
+      case "class":
+        return "class";
+      case "interface":
+        return "interface";
+      case "type":
+        return "type";
+      case "enum":
+        return "enum";
+      case "variable":
+        return "variable";
+      default:
+        return "block";
+    }
+  }
+  async finalize(ctx) {
+    const config = ctx.config;
+    const coreDir = path2.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
+    await fs2.mkdir(coreDir, { recursive: true });
+    this.bm25Index = new BM25Index;
+    for (const [filepath, entry] of this.symbolIndex) {
+      this.bm25Index.addDocument(filepath, entry.tokens);
+    }
+    const symbolIndexData = {
+      version: this.version,
+      lastUpdated: new Date().toISOString(),
+      files: Object.fromEntries(this.symbolIndex),
+      bm25Data: this.bm25Index.serialize()
+    };
+    await fs2.writeFile(path2.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
+    console.log(`  [Core] Symbol index built with ${this.symbolIndex.size} files`);
+  }
+  async search(query, ctx, options) {
+    const config = ctx.config;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    if (this.symbolIndex.size === 0) {
+      await this.loadSymbolIndex(ctx.rootDir, config);
+    }
+    if (!this.bm25Index || this.symbolIndex.size === 0) {
+      return [];
+    }
+    const queryTokens = tokenize(query);
+    const bm25Results = this.bm25Index.search(query, topK * 2);
+    const bm25Scores = new Map(bm25Results.map((r) => [r.id, r.score]));
+    const symbolMatches = this.findSymbolMatches(queryTokens);
+    const results = [];
+    for (const filepath of this.symbolIndex.keys()) {
+      const entry = this.symbolIndex.get(filepath);
+      const bm25Score = bm25Scores.get(filepath) ?? 0;
+      const symbolScore = symbolMatches.get(filepath) ?? 0;
+      if (bm25Score === 0 && symbolScore === 0)
+        continue;
+      const combinedScore = 0.6 * normalizeScore(bm25Score) + 0.4 * symbolScore;
+      if (combinedScore >= minScore) {
+        const fileIndex = await ctx.loadFileIndex(filepath);
+        if (!fileIndex)
+          continue;
+        const bestChunk = this.findBestChunk(fileIndex.chunks, queryTokens, entry.symbols);
+        results.push({
+          filepath,
+          chunk: bestChunk,
+          score: combinedScore,
+          moduleId: this.id,
+          context: {
+            bm25Score: normalizeScore(bm25Score),
+            symbolScore
+          }
+        });
+      }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  findSymbolMatches(queryTokens) {
+    const matches = new Map;
+    for (const [filepath, entry] of this.symbolIndex) {
+      let matchScore = 0;
+      for (const symbol of entry.symbols) {
+        const symbolName = symbol.name.toLowerCase();
+        const symbolParts = symbolsToKeywords([symbol]);
+        for (const token of queryTokens) {
+          if (symbolName === token) {
+            matchScore += symbol.isExported ? 1 : 0.8;
+          } else if (symbolName.includes(token) || token.includes(symbolName)) {
+            matchScore += symbol.isExported ? 0.5 : 0.4;
+          } else if (symbolParts.some((p) => p === token)) {
+            matchScore += symbol.isExported ? 0.3 : 0.2;
+          }
+        }
+      }
+      if (matchScore > 0) {
+        matches.set(filepath, Math.min(1, matchScore / queryTokens.length));
+      }
+    }
+    return matches;
+  }
+  findBestChunk(chunks, queryTokens, symbols) {
+    let bestChunk = chunks[0];
+    let bestScore = 0;
+    for (const chunk of chunks) {
+      let score = 0;
+      const chunkContent = chunk.content.toLowerCase();
+      for (const token of queryTokens) {
+        if (chunkContent.includes(token)) {
+          score += 1;
+        }
+      }
+      if (chunk.name) {
+        const nameLower = chunk.name.toLowerCase();
+        for (const token of queryTokens) {
+          if (nameLower.includes(token)) {
+            score += 2;
+          }
+        }
+      }
+      if (chunk.isExported) {
+        score += 0.5;
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestChunk = chunk;
+      }
+    }
+    return bestChunk;
+  }
+  async loadSymbolIndex(rootDir, config) {
+    const coreDir = path2.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path2.join(coreDir, "symbols.json");
+    try {
+      const content = await fs2.readFile(symbolsPath, "utf-8");
+      const data = JSON.parse(content);
+      this.symbolIndex = new Map(Object.entries(data.files));
+      if (data.bm25Data) {
+        this.bm25Index = BM25Index.deserialize(data.bm25Data);
+      }
+    } catch (error) {
+      this.symbolIndex = new Map;
+      this.bm25Index = null;
+    }
+  }
+  async dispose() {
+    this.symbolIndex.clear();
+    this.bm25Index = null;
+  }
+}
+var DEFAULT_MIN_SCORE = 0.1, DEFAULT_TOP_K = 20, LINES_PER_CHUNK = 50, CHUNK_OVERLAP = 10;
+var init_core = __esm(() => {
+  init_config2();
+  init_symbols();
+});
+
+// src/infrastructure/embeddings/transformersEmbedding.ts
+import { pipeline, env } from "@xenova/transformers";
+import * as path3 from "path";
+import * as os from "os";
+
+class TransformersEmbeddingProvider {
+  pipeline = null;
+  config;
+  isInitializing = false;
+  initPromise = null;
+  constructor(config) {
+    this.config = {
+      model: config?.model ?? "all-MiniLM-L6-v2",
+      showProgress: config?.showProgress ?? true
+    };
+  }
+  async initialize(config) {
+    if (config) {
+      if (config.model !== this.config.model) {
+        this.pipeline = null;
+      }
+      this.config = { ...this.config, ...config };
+    }
+    await this.ensurePipeline();
+  }
+  async ensurePipeline() {
+    if (this.pipeline) {
+      return;
+    }
+    if (this.isInitializing && this.initPromise) {
+      return this.initPromise;
+    }
+    this.isInitializing = true;
+    this.initPromise = (async () => {
+      const modelId = EMBEDDING_MODELS2[this.config.model];
+      if (this.config.showProgress) {
+        console.log(`
+  Loading embedding model: ${this.config.model}`);
+        console.log(`  Cache: ${CACHE_DIR}`);
+      }
+      try {
+        this.pipeline = await pipeline("feature-extraction", modelId, {
+          progress_callback: this.config.showProgress ? (progress) => {
+            if (progress.status === "progress" && progress.file) {
+              const pct = progress.progress ? Math.round(progress.progress) : 0;
+              process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
+            } else if (progress.status === "done" && progress.file) {
+              process.stdout.write(`\r  Downloaded ${progress.file}              
+`);
+            }
+          } : undefined
+        });
+        if (this.config.showProgress) {
+          console.log(`  Model ready.
+`);
+        }
+      } catch (error) {
+        this.pipeline = null;
+        throw new Error(`Failed to load embedding model: ${error}`);
+      } finally {
+        this.isInitializing = false;
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  async getEmbedding(text) {
+    await this.ensurePipeline();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const output = await this.pipeline(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    return Array.from(output.data);
+  }
+  async getEmbeddings(texts) {
+    if (texts.length === 0)
+      return [];
+    await this.ensurePipeline();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const results = [];
+    for (let i = 0;i < texts.length; i += BATCH_SIZE) {
+      const batch = texts.slice(i, i + BATCH_SIZE);
+      const outputs = await Promise.all(batch.map(async (text) => {
+        const output = await this.pipeline(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        return Array.from(output.data);
+      }));
+      results.push(...outputs);
+    }
+    return results;
+  }
+  getDimension() {
+    return EMBEDDING_DIMENSION;
+  }
+  getModelName() {
+    return this.config.model;
+  }
+  async dispose() {
+    this.pipeline = null;
+  }
+}
+function configureEmbeddings(config) {
+  const newConfig = { ...globalConfig, ...config };
+  if (newConfig.model !== globalConfig.model) {
+    globalProvider = null;
+  }
+  globalConfig = newConfig;
+}
+function getEmbeddingConfig() {
+  return { ...globalConfig };
+}
+async function ensureGlobalProvider() {
+  if (!globalProvider) {
+    globalProvider = new TransformersEmbeddingProvider(globalConfig);
+    await globalProvider.initialize();
+  }
+  return globalProvider;
+}
+async function getEmbedding(text) {
+  const provider = await ensureGlobalProvider();
+  return provider.getEmbedding(text);
+}
+async function getEmbeddings(texts) {
+  const provider = await ensureGlobalProvider();
+  return provider.getEmbeddings(texts);
+}
+var CACHE_DIR, EMBEDDING_MODELS2, EMBEDDING_DIMENSION = 384, BATCH_SIZE = 32, globalProvider = null, globalConfig;
+var init_transformersEmbedding = __esm(() => {
+  CACHE_DIR = path3.join(os.homedir(), ".cache", "raggrep", "models");
+  env.cacheDir = CACHE_DIR;
+  env.allowLocalModels = true;
+  EMBEDDING_MODELS2 = {
+    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
+    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
+    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
+    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2"
+  };
+  globalConfig = {
+    model: "all-MiniLM-L6-v2",
+    showProgress: true
+  };
+});
+
+// src/infrastructure/embeddings/index.ts
+var init_embeddings = __esm(() => {
+  init_transformersEmbedding();
+});
+
+// src/domain/services/similarity.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0)
+    return 0;
+  return dotProduct / magnitude;
+}
+
+// src/modules/language/typescript/parseCode.ts
 import * as ts from "typescript";
 function parseCode(content, filepath) {
   const ext = filepath.split(".").pop()?.toLowerCase();
@@ -526,6 +1005,11 @@ function generateChunkId(filepath, startLine, endLine) {
 }
 var init_parseCode = () => {};
 
+// src/infrastructure/storage/fileIndexStorage.ts
+var init_fileIndexStorage = __esm(() => {
+  init_entities();
+});
+
 // src/domain/services/keywords.ts
 function extractKeywords(content, name, maxKeywords = 50) {
   const keywords = new Set;
@@ -544,10 +1028,92 @@ function extractKeywords(content, name, maxKeywords = 50) {
   }
   return Array.from(keywords).slice(0, maxKeywords);
 }
+function splitIdentifier(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).map((s) => s.toLowerCase()).filter((s) => s.length > 1);
+}
 function extractPathKeywords(filepath) {
-  return filepath.split(/[/\\.]/).filter((p) => p.length > 2 && !COMMON_KEYWORDS.has(p.toLowerCase())).map((p) => p.toLowerCase());
+  const keywords = new Set;
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const segments = pathWithoutExt.split(/[/\\]/);
+  for (const segment of segments) {
+    if (segment.length < 2)
+      continue;
+    const lower = segment.toLowerCase();
+    if (!COMMON_KEYWORDS.has(lower) && lower.length > 2) {
+      keywords.add(lower);
+    }
+    const parts = splitIdentifier(segment);
+    for (const part of parts) {
+      if (!COMMON_KEYWORDS.has(part) && part.length > 2) {
+        keywords.add(part);
+      }
+    }
+  }
+  return Array.from(keywords);
 }
-var COMMON_KEYWORDS;
+function parsePathContext(filepath) {
+  const pathWithoutExt = filepath.replace(/\.[^.]+$/, "");
+  const allSegments = pathWithoutExt.split(/[/\\]/);
+  const filename = allSegments[allSegments.length - 1];
+  const dirSegments = allSegments.slice(0, -1);
+  const keywords = extractPathKeywords(filepath);
+  let layer;
+  const allLower = [...dirSegments, filename].map((s) => s.toLowerCase()).join(" ");
+  const filenameLower = filename.toLowerCase();
+  for (const [layerName, patterns] of Object.entries(LAYER_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (filenameLower.includes(pattern)) {
+        layer = layerName;
+        break;
+      }
+      if (dirSegments.some((s) => s.toLowerCase() === pattern)) {
+        layer = layerName;
+        break;
+      }
+    }
+    if (layer)
+      break;
+  }
+  let domain;
+  const layerPatternSet = new Set(Object.values(LAYER_PATTERNS).flat());
+  const reversedSegments = [...dirSegments].reverse();
+  for (const segment of reversedSegments) {
+    const lower = segment.toLowerCase();
+    if (["src", "lib", "app", "packages", "modules"].includes(lower))
+      continue;
+    if (layerPatternSet.has(lower))
+      continue;
+    if (lower.length > 2) {
+      domain = lower;
+      break;
+    }
+  }
+  return {
+    segments: dirSegments,
+    layer,
+    domain,
+    depth: dirSegments.length,
+    keywords
+  };
+}
+function formatPathContextForEmbedding(pathContext) {
+  const parts = [];
+  if (pathContext.domain) {
+    parts.push(pathContext.domain);
+  }
+  if (pathContext.layer) {
+    parts.push(pathContext.layer);
+  }
+  const significantSegments = pathContext.segments.slice(-3).filter((s) => s.length > 2 && !["src", "lib", "app"].includes(s.toLowerCase()));
+  if (significantSegments.length > 0) {
+    parts.push(...significantSegments.map((s) => s.toLowerCase()));
+  }
+  if (parts.length === 0)
+    return "";
+  const unique = [...new Set(parts)];
+  return `[${unique.join(" ")}]`;
+}
+var COMMON_KEYWORDS, LAYER_PATTERNS;
 var init_keywords = __esm(() => {
   COMMON_KEYWORDS = new Set([
     "const",
@@ -617,11 +1183,24 @@ var init_keywords = __esm(() => {
     "has",
     "have"
   ]);
+  LAYER_PATTERNS = {
+    controller: ["controller", "controllers", "handler", "handlers", "route", "routes", "api"],
+    service: ["service", "services", "usecase", "usecases", "application"],
+    repository: ["repository", "repositories", "repo", "repos", "dao", "store", "storage"],
+    model: ["model", "models", "entity", "entities", "schema", "schemas"],
+    util: ["util", "utils", "utility", "utilities", "helper", "helpers", "common", "shared"],
+    config: ["config", "configs", "configuration", "settings"],
+    middleware: ["middleware", "middlewares", "interceptor", "interceptors"],
+    domain: ["domain", "core", "business"],
+    infrastructure: ["infrastructure", "infra", "external", "adapters"],
+    presentation: ["presentation", "view", "views", "component", "components", "ui"],
+    test: ["test", "tests", "spec", "specs", "__tests__", "__test__"]
+  };
 });
 
-// src/utils/tieredIndex.ts
-import * as fs2 from "fs/promises";
-import * as path3 from "path";
+// src/infrastructure/storage/symbolicIndex.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
 
 class SymbolicIndex {
   meta = null;
@@ -630,7 +1209,7 @@ class SymbolicIndex {
   symbolicPath;
   moduleId;
   constructor(indexDir, moduleId) {
-    this.symbolicPath = path3.join(indexDir, "index", moduleId, "symbolic");
+    this.symbolicPath = path4.join(indexDir, "index", moduleId, "symbolic");
     this.moduleId = moduleId;
   }
   async initialize() {
@@ -690,18 +1269,18 @@ class SymbolicIndex {
       throw new Error("Index not initialized");
     this.meta.lastUpdated = new Date().toISOString();
     this.meta.fileCount = this.fileSummaries.size;
-    await fs2.mkdir(this.symbolicPath, { recursive: true });
-    const metaPath = path3.join(this.symbolicPath, "_meta.json");
-    await fs2.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
+    await fs3.mkdir(this.symbolicPath, { recursive: true });
+    const metaPath = path4.join(this.symbolicPath, "_meta.json");
+    await fs3.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
     for (const [filepath, summary] of this.fileSummaries) {
       const summaryPath = this.getFileSummaryPath(filepath);
-      await fs2.mkdir(path3.dirname(summaryPath), { recursive: true });
-      await fs2.writeFile(summaryPath, JSON.stringify(summary, null, 2));
+      await fs3.mkdir(path4.dirname(summaryPath), { recursive: true });
+      await fs3.writeFile(summaryPath, JSON.stringify(summary, null, 2));
     }
   }
   async load() {
-    const metaPath = path3.join(this.symbolicPath, "_meta.json");
-    const metaContent = await fs2.readFile(metaPath, "utf-8");
+    const metaPath = path4.join(this.symbolicPath, "_meta.json");
+    const metaContent = await fs3.readFile(metaPath, "utf-8");
     this.meta = JSON.parse(metaContent);
     this.fileSummaries.clear();
     await this.loadFileSummariesRecursive(this.symbolicPath);
@@ -709,14 +1288,14 @@ class SymbolicIndex {
   }
   async loadFileSummariesRecursive(dir) {
     try {
-      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path3.join(dir, entry.name);
+        const fullPath = path4.join(dir, entry.name);
         if (entry.isDirectory()) {
           await this.loadFileSummariesRecursive(fullPath);
         } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
           try {
-            const content = await fs2.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);
@@ -728,18 +1307,18 @@ class SymbolicIndex {
   }
   getFileSummaryPath(filepath) {
     const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
-    return path3.join(this.symbolicPath, jsonPath);
+    return path4.join(this.symbolicPath, jsonPath);
   }
   async deleteFileSummary(filepath) {
     try {
-      await fs2.unlink(this.getFileSummaryPath(filepath));
+      await fs3.unlink(this.getFileSummaryPath(filepath));
     } catch {}
     this.fileSummaries.delete(filepath);
   }
   async exists() {
     try {
-      const metaPath = path3.join(this.symbolicPath, "_meta.json");
-      await fs2.access(metaPath);
+      const metaPath = path4.join(this.symbolicPath, "_meta.json");
+      await fs3.access(metaPath);
       return true;
     } catch {
       return false;
@@ -761,24 +1340,29 @@ class SymbolicIndex {
     this.bm25Index = new BM25Index;
   }
 }
-var init_tieredIndex = __esm(() => {
-  init_keywords();
+var init_symbolicIndex = __esm(() => {
   init_keywords();
 });
 
-// src/modules/semantic/index.ts
-var exports_semantic = {};
-__export(exports_semantic, {
-  SemanticModule: () => SemanticModule,
-  DEFAULT_TOP_K: () => DEFAULT_TOP_K,
-  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE
+// src/infrastructure/storage/index.ts
+var init_storage = __esm(() => {
+  init_fileIndexStorage();
+  init_symbolicIndex();
 });
-import * as path4 from "path";
 
-class SemanticModule {
-  id = "semantic";
-  name = "Semantic Search";
-  description = "Natural language code search using local text embeddings";
+// src/modules/language/typescript/index.ts
+var exports_typescript = {};
+__export(exports_typescript, {
+  TypeScriptModule: () => TypeScriptModule,
+  DEFAULT_TOP_K: () => DEFAULT_TOP_K2,
+  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE2
+});
+import * as path5 from "path";
+
+class TypeScriptModule {
+  id = "language/typescript";
+  name = "TypeScript Search";
+  description = "TypeScript-aware code search with AST parsing and semantic embeddings";
   version = "1.0.0";
   embeddingConfig = null;
   symbolicIndex = null;
@@ -795,7 +1379,12 @@ class SemanticModule {
     if (parsedChunks.length === 0) {
       return null;
     }
-    const chunkContents = parsedChunks.map((c) => c.content);
+    const pathContext = parsePathContext(filepath);
+    const pathPrefix = formatPathContextForEmbedding(pathContext);
+    const chunkContents = parsedChunks.map((c) => {
+      const namePrefix = c.name ? `${c.name}: ` : "";
+      return `${pathPrefix} ${namePrefix}${c.content}`;
+    });
     const embeddings = await getEmbeddings(chunkContents);
     const chunks = parsedChunks.map((pc) => ({
       id: generateChunkId(filepath, pc.startLine, pc.endLine),
@@ -809,10 +1398,10 @@ class SemanticModule {
     }));
     const references = this.extractReferences(content, filepath);
     const stats = await ctx.getFileStats(filepath);
-    const currentConfig2 = getEmbeddingConfig();
+    const currentConfig = getEmbeddingConfig();
     const moduleData = {
       embeddings,
-      embeddingModel: currentConfig2.model
+      embeddingModel: currentConfig.model
     };
     const chunkTypes = [...new Set(parsedChunks.map((pc) => pc.type))];
     const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
@@ -821,13 +1410,20 @@ class SemanticModule {
       const keywords = extractKeywords(pc.content, pc.name);
       keywords.forEach((k) => allKeywords.add(k));
     }
+    pathContext.keywords.forEach((k) => allKeywords.add(k));
     const fileSummary = {
       filepath,
       chunkCount: chunks.length,
       chunkTypes,
       keywords: Array.from(allKeywords),
       exports,
-      lastModified: stats.lastModified
+      lastModified: stats.lastModified,
+      pathContext: {
+        segments: pathContext.segments,
+        layer: pathContext.layer,
+        domain: pathContext.domain,
+        depth: pathContext.depth
+      }
     };
     this.pendingSummaries.set(filepath, fileSummary);
     return {
@@ -851,7 +1447,7 @@ class SemanticModule {
     this.pendingSummaries.clear();
   }
   async search(query, ctx, options = {}) {
-    const { topK = DEFAULT_TOP_K, minScore = DEFAULT_MIN_SCORE, filePatterns } = options;
+    const { topK = DEFAULT_TOP_K2, minScore = DEFAULT_MIN_SCORE2, filePatterns } = options;
     const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
     const symbolicIndex = new SymbolicIndex(indexDir, this.id);
     let candidateFiles;
@@ -904,11 +1500,32 @@ class SemanticModule {
     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 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 hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score;
+      const pathBoost = pathBoosts.get(filepath) || 0;
+      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score + pathBoost;
       if (hybridScore >= minScore || bm25Score > 0.3) {
         results.push({
           filepath,
@@ -917,7 +1534,8 @@ class SemanticModule {
           moduleId: this.id,
           context: {
             semanticScore,
-            bm25Score
+            bm25Score,
+            pathBoost
           }
         });
       }
@@ -933,36 +1551,37 @@ class SemanticModule {
     while ((match = importRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (importPath.startsWith(".")) {
-        const dir = path4.dirname(filepath);
-        const resolved = path4.normalize(path4.join(dir, importPath));
+        const dir = path5.dirname(filepath);
+        const resolved = path5.normalize(path5.join(dir, importPath));
         references.push(resolved);
       }
     }
     while ((match = requireRegex.exec(content)) !== null) {
       const importPath = match[1];
       if (importPath.startsWith(".")) {
-        const dir = path4.dirname(filepath);
-        const resolved = path4.normalize(path4.join(dir, importPath));
+        const dir = path5.dirname(filepath);
+        const resolved = path5.normalize(path5.join(dir, importPath));
         references.push(resolved);
       }
     }
     return references;
   }
 }
-var DEFAULT_MIN_SCORE = 0.15, DEFAULT_TOP_K = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3, TIER1_CANDIDATE_MULTIPLIER = 3;
-var init_semantic = __esm(() => {
+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_bm25();
   init_config2();
   init_parseCode();
-  init_tieredIndex();
+  init_storage();
+  init_keywords();
+  init_keywords();
 });
 
-// src/indexer/index.ts
+// src/app/indexer/index.ts
 init_config2();
 import { glob } from "glob";
-import * as fs3 from "fs/promises";
-import * as path5 from "path";
+import * as fs6 from "fs/promises";
+import * as path9 from "path";
 
 // src/modules/registry.ts
 class ModuleRegistryImpl {
@@ -986,16 +1605,594 @@ class ModuleRegistryImpl {
 }
 var registry = new ModuleRegistryImpl;
 async function registerBuiltInModules() {
-  const { SemanticModule: SemanticModule2 } = await Promise.resolve().then(() => (init_semantic(), exports_semantic));
-  registry.register(new SemanticModule2);
+  const { CoreModule: CoreModule2 } = await Promise.resolve().then(() => (init_core(), exports_core));
+  const { TypeScriptModule: TypeScriptModule2 } = await Promise.resolve().then(() => (init_typescript(), exports_typescript));
+  registry.register(new CoreModule2);
+  registry.register(new TypeScriptModule2);
+}
+
+// src/introspection/index.ts
+import * as path8 from "path";
+import * as fs5 from "fs/promises";
+
+// src/introspection/projectDetector.ts
+import * as path6 from "path";
+import * as fs4 from "fs/promises";
+var MAX_SCAN_DEPTH = 4;
+var SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".raggrep"
+]);
+var PROJECT_PATTERNS = [
+  { pattern: /^apps\/([^/]+)/, type: "app", defaultScope: "unknown" },
+  { pattern: /^packages\/([^/]+)/, type: "library", defaultScope: "shared" },
+  { pattern: /^libs\/([^/]+)/, type: "library", defaultScope: "shared" },
+  { pattern: /^services\/([^/]+)/, type: "service", defaultScope: "backend" },
+  { pattern: /^scripts\/([^/]+)/, type: "script", defaultScope: "tooling" },
+  { pattern: /^tools\/([^/]+)/, type: "script", defaultScope: "tooling" }
+];
+var SCOPE_KEYWORDS = {
+  frontend: [
+    "web",
+    "webapp",
+    "frontend",
+    "client",
+    "ui",
+    "app",
+    "mobile",
+    "react",
+    "vue",
+    "angular",
+    "next",
+    "nuxt"
+  ],
+  backend: [
+    "api",
+    "server",
+    "backend",
+    "service",
+    "worker",
+    "lambda",
+    "functions"
+  ],
+  shared: ["shared", "common", "utils", "lib", "core", "types", "models"],
+  tooling: [
+    "scripts",
+    "tools",
+    "cli",
+    "devtools",
+    "build",
+    "config",
+    "infra"
+  ],
+  unknown: []
+};
+function detectScopeFromName(name) {
+  const nameLower = name.toLowerCase();
+  for (const [scope, keywords] of Object.entries(SCOPE_KEYWORDS)) {
+    if (scope === "unknown")
+      continue;
+    for (const keyword of keywords) {
+      if (nameLower.includes(keyword)) {
+        return scope;
+      }
+    }
+  }
+  return "unknown";
+}
+async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
+  if (depth > MAX_SCAN_DEPTH)
+    return [];
+  const results = [];
+  const fullDir = currentDir ? path6.join(rootDir, currentDir) : rootDir;
+  try {
+    const entries = await fs4.readdir(fullDir, { withFileTypes: true });
+    const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
+    if (hasPackageJson && currentDir) {
+      const info = await parsePackageJson(rootDir, currentDir);
+      if (info) {
+        results.push(info);
+      }
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      if (SKIP_DIRS.has(entry.name))
+        continue;
+      const subPath = currentDir ? `${currentDir}/${entry.name}` : entry.name;
+      const subResults = await scanForPackageJsons(rootDir, subPath, depth + 1);
+      results.push(...subResults);
+    }
+  } catch {}
+  return results;
+}
+async function parsePackageJson(rootDir, relativePath) {
+  try {
+    const packageJsonPath = path6.join(rootDir, relativePath, "package.json");
+    const content = await fs4.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const name = pkg.name || path6.basename(relativePath);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    let type = "unknown";
+    if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
+      type = "app";
+    } else if (deps["express"] || deps["fastify"] || deps["koa"] || deps["hono"]) {
+      type = "service";
+    } else if (pkg.main || pkg.exports) {
+      type = "library";
+    }
+    const hasWorkspaces = Boolean(pkg.workspaces);
+    return { name, relativePath, type, hasWorkspaces };
+  } catch {
+    return null;
+  }
+}
+async function detectProjectStructure(rootDir) {
+  const projectMap = new Map;
+  let isMonorepo = false;
+  try {
+    const entries = await fs4.readdir(rootDir, { withFileTypes: true });
+    const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    const monorepoPatterns = ["apps", "packages", "libs", "services"];
+    const hasMonorepoStructure = monorepoPatterns.some((p) => dirNames.includes(p));
+    if (hasMonorepoStructure) {
+      isMonorepo = true;
+      for (const pattern of monorepoPatterns) {
+        if (!dirNames.includes(pattern))
+          continue;
+        const patternDir = path6.join(rootDir, pattern);
+        try {
+          const subDirs = await fs4.readdir(patternDir, { withFileTypes: true });
+          for (const subDir of subDirs) {
+            if (!subDir.isDirectory())
+              continue;
+            const projectRoot = `${pattern}/${subDir.name}`;
+            const type = getProjectType(pattern);
+            projectMap.set(projectRoot, {
+              name: subDir.name,
+              root: projectRoot,
+              type
+            });
+          }
+        } 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 = path6.join(rootDir, "package.json");
+      const rootPkg = JSON.parse(await fs4.readFile(rootPkgPath, "utf-8"));
+      if (rootPkg.workspaces) {
+        isMonorepo = true;
+      }
+      const deps = { ...rootPkg.dependencies, ...rootPkg.devDependencies };
+      if (deps["next"] || deps["react"] || deps["vue"]) {
+        rootType = "app";
+      } else if (deps["express"] || deps["fastify"] || deps["koa"]) {
+        rootType = "service";
+      }
+    } 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"
+  };
 }
 
-// src/indexer/index.ts
+// src/introspection/fileIntrospector.ts
+import * as path7 from "path";
+var LAYER_PATTERNS2 = {
+  controller: ["controller", "api", "routes", "route", "handler"],
+  service: ["service", "logic", "usecase", "usecases", "handler"],
+  repository: ["repository", "repo", "dao", "store", "persistence"],
+  model: ["model", "models", "entity", "entities", "schema", "schemas", "types", "type"],
+  util: ["util", "utils", "helper", "helpers", "common", "lib"],
+  config: ["config", "configuration", "settings"],
+  middleware: ["middleware", "middlewares"],
+  domain: ["domain"],
+  infrastructure: ["infrastructure", "infra"],
+  application: ["application", "app"],
+  presentation: ["presentation", "ui", "views", "view", "component", "components"],
+  test: ["test", "tests", "spec", "specs", "__tests__", "e2e"]
+};
+var DOMAIN_PATTERNS = [
+  "auth",
+  "authentication",
+  "user",
+  "users",
+  "account",
+  "accounts",
+  "profile",
+  "profiles",
+  "product",
+  "products",
+  "item",
+  "items",
+  "catalog",
+  "order",
+  "orders",
+  "cart",
+  "checkout",
+  "payment",
+  "payments",
+  "billing",
+  "subscription",
+  "subscriptions",
+  "notification",
+  "notifications",
+  "email",
+  "sms",
+  "report",
+  "reports",
+  "analytics",
+  "metrics",
+  "dashboard",
+  "admin",
+  "settings",
+  "search",
+  "chat",
+  "message",
+  "messages",
+  "feed",
+  "post",
+  "posts",
+  "comment",
+  "comments",
+  "media",
+  "upload",
+  "file",
+  "files",
+  "storage",
+  "cache",
+  "session",
+  "log",
+  "logs",
+  "audit"
+];
+var FRAMEWORK_INDICATORS = {
+  nextjs: ["next", "next/"],
+  express: ["express"],
+  fastify: ["fastify"],
+  react: ["react"],
+  vue: ["vue"],
+  angular: ["@angular/"],
+  nestjs: ["@nestjs/"],
+  koa: ["koa"]
+};
+var EXTENSION_TO_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".rb": "ruby",
+  ".php": "php",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".md": "markdown",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml"
+};
+function introspectFile(filepath, structure, fileContent) {
+  const normalizedPath = filepath.replace(/\\/g, "/");
+  const segments = normalizedPath.split("/").filter((s) => s.length > 0);
+  const filename = segments[segments.length - 1] || "";
+  const ext = path7.extname(filename);
+  const project = findProjectForFile(normalizedPath, structure);
+  const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
+  const layer = detectLayer(segments, filename);
+  const domain = detectDomain(segments);
+  const scope = detectScope(segments, project, layer);
+  let framework;
+  if (fileContent) {
+    framework = detectFramework(fileContent);
+  }
+  return {
+    filepath: normalizedPath,
+    project,
+    scope,
+    layer,
+    domain,
+    language,
+    framework,
+    depth: segments.length - 1,
+    pathSegments: segments.slice(0, -1)
+  };
+}
+function detectLayer(segments, filename) {
+  const filenameLower = filename.toLowerCase();
+  for (const [layer, patterns] of Object.entries(LAYER_PATTERNS2)) {
+    for (const pattern of patterns) {
+      if (filenameLower.includes(pattern)) {
+        return layer;
+      }
+    }
+  }
+  for (let i = segments.length - 2;i >= 0; i--) {
+    const segment = segments[i].toLowerCase();
+    for (const [layer, patterns] of Object.entries(LAYER_PATTERNS2)) {
+      if (patterns.includes(segment)) {
+        return layer;
+      }
+    }
+  }
+  return;
+}
+function detectDomain(segments) {
+  const skipSegments = new Set([
+    "src",
+    "lib",
+    "app",
+    "apps",
+    "packages",
+    "services",
+    "modules",
+    "features",
+    ...Object.values(LAYER_PATTERNS2).flat()
+  ]);
+  for (const segment of segments) {
+    const segmentLower = segment.toLowerCase();
+    if (skipSegments.has(segmentLower))
+      continue;
+    if (DOMAIN_PATTERNS.includes(segmentLower)) {
+      return segmentLower;
+    }
+    for (const domain of DOMAIN_PATTERNS) {
+      if (segmentLower.startsWith(domain) || segmentLower.endsWith(domain)) {
+        return domain;
+      }
+    }
+  }
+  return;
+}
+function detectScope(segments, project, layer) {
+  const projectScope = detectScopeFromName(project.name);
+  if (projectScope !== "unknown") {
+    return projectScope;
+  }
+  if (layer) {
+    switch (layer) {
+      case "controller":
+      case "repository":
+      case "middleware":
+        return "backend";
+      case "presentation":
+        return "frontend";
+      case "util":
+      case "model":
+        return "shared";
+      case "test":
+        return "tooling";
+    }
+  }
+  for (const segment of segments) {
+    const segmentLower = segment.toLowerCase();
+    if (["server", "api", "backend"].includes(segmentLower)) {
+      return "backend";
+    }
+    if (["client", "web", "frontend", "ui"].includes(segmentLower)) {
+      return "frontend";
+    }
+    if (["shared", "common", "lib", "libs"].includes(segmentLower)) {
+      return "shared";
+    }
+  }
+  return "unknown";
+}
+function detectFramework(content) {
+  for (const [framework, indicators] of Object.entries(FRAMEWORK_INDICATORS)) {
+    for (const indicator of indicators) {
+      if (content.includes(`from '${indicator}`) || content.includes(`from "${indicator}`) || content.includes(`require('${indicator}`) || content.includes(`require("${indicator}`)) {
+        return framework;
+      }
+    }
+  }
+  return;
+}
+
+// src/introspection/index.ts
+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 = path8.join(this.rootDir, ".raggrep", "config.json");
+      const configContent = await fs5.readFile(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      this.config = config.introspection || {};
+    } catch {}
+  }
+  getStructure() {
+    return this.structure;
+  }
+  addFile(filepath, content) {
+    if (!this.structure) {
+      throw new Error("IntrospectionIndex not initialized");
+    }
+    const intro = introspectFile(filepath, this.structure, content);
+    this.applyOverrides(intro);
+    this.files.set(filepath, intro);
+    return intro;
+  }
+  getFile(filepath) {
+    return this.files.get(filepath);
+  }
+  getAllFiles() {
+    return Array.from(this.files.values());
+  }
+  applyOverrides(intro) {
+    if (!this.config.projects)
+      return;
+    for (const [projectPath, overrides] of Object.entries(this.config.projects)) {
+      if (intro.filepath.startsWith(projectPath + "/") || intro.project.root === projectPath) {
+        if (overrides.scope) {
+          intro.scope = overrides.scope;
+        }
+        if (overrides.framework) {
+          intro.framework = overrides.framework;
+        }
+        break;
+      }
+    }
+  }
+  async save(config) {
+    const introDir = path8.join(getRaggrepDir(this.rootDir, config), "introspection");
+    await fs5.mkdir(introDir, { recursive: true });
+    const projectPath = path8.join(introDir, "_project.json");
+    await fs5.writeFile(projectPath, JSON.stringify({
+      version: "1.0.0",
+      lastUpdated: new Date().toISOString(),
+      structure: this.structure
+    }, null, 2));
+    for (const [filepath, intro] of this.files) {
+      const introFilePath = path8.join(introDir, "files", filepath.replace(/\.[^.]+$/, ".json"));
+      await fs5.mkdir(path8.dirname(introFilePath), { recursive: true });
+      await fs5.writeFile(introFilePath, JSON.stringify(intro, null, 2));
+    }
+    console.log(`  [Introspection] Saved metadata for ${this.files.size} files`);
+  }
+  async load(config) {
+    const introDir = path8.join(getRaggrepDir(this.rootDir, config), "introspection");
+    try {
+      const projectPath = path8.join(introDir, "_project.json");
+      const projectContent = await fs5.readFile(projectPath, "utf-8");
+      const projectData = JSON.parse(projectContent);
+      this.structure = projectData.structure;
+      await this.loadFilesRecursive(path8.join(introDir, "files"), "");
+    } catch {
+      this.structure = null;
+      this.files.clear();
+    }
+  }
+  async loadFilesRecursive(basePath, prefix) {
+    try {
+      const entries = await fs5.readdir(basePath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path8.join(basePath, entry.name);
+        const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          await this.loadFilesRecursive(entryPath, relativePath);
+        } else if (entry.name.endsWith(".json")) {
+          const content = await fs5.readFile(entryPath, "utf-8");
+          const intro = JSON.parse(content);
+          this.files.set(intro.filepath, intro);
+        }
+      }
+    } catch {}
+  }
+  clear() {
+    this.files.clear();
+    this.structure = null;
+  }
+}
+
+// src/app/indexer/watcher.ts
+import { watch } from "chokidar";
+init_config2();
+
+// src/app/indexer/index.ts
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path5.resolve(rootDir);
+  rootDir = path9.resolve(rootDir);
   console.log(`Indexing directory: ${rootDir}`);
   const config = await loadConfig(rootDir);
+  const introspection = new IntrospectionIndex(rootDir);
+  await introspection.initialize();
+  if (verbose) {
+    const structure = introspection.getStructure();
+    if (structure?.isMonorepo) {
+      console.log(`Detected monorepo with ${structure.projects.length} projects`);
+    }
+  }
   await registerBuiltInModules();
   const enabledModules = registry.getEnabled(config);
   if (enabledModules.length === 0) {
@@ -1012,7 +2209,7 @@ async function indexDirectory(rootDir, options = {}) {
     const moduleConfig = getModuleConfig(config, module.id);
     if (module.initialize && moduleConfig) {
       const configWithOverrides = { ...moduleConfig };
-      if (options.model && module.id === "semantic") {
+      if (options.model && module.id === "language/typescript") {
         configWithOverrides.options = {
           ...configWithOverrides.options,
           embeddingModel: options.model
@@ -1020,7 +2217,7 @@ async function indexDirectory(rootDir, options = {}) {
       }
       await module.initialize(configWithOverrides);
     }
-    const result = await indexWithModule(rootDir, files, module, config, verbose);
+    const result = await indexWithModule(rootDir, files, module, config, verbose, introspection);
     results.push(result);
     if (module.finalize) {
       console.log(`[${module.name}] Building secondary indexes...`);
@@ -1028,12 +2225,12 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
-          return fs3.readFile(fullPath, "utf-8");
+          const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+          return fs6.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
-          const stats = await fs3.stat(fullPath);
+          const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+          const stats = await fs6.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
       };
@@ -1041,10 +2238,11 @@ async function indexDirectory(rootDir, options = {}) {
     }
     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 indexWithModule(rootDir, files, module, config, verbose) {
+async function indexWithModule(rootDir, files, module, config, verbose, introspection) {
   const result = {
     moduleId: module.id,
     indexed: 0,
@@ -1056,19 +2254,20 @@ async function indexWithModule(rootDir, files, module, config, verbose) {
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
-      return fs3.readFile(fullPath, "utf-8");
+      const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+      return fs6.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
-      const stats = await fs3.stat(fullPath);
+      const fullPath = path9.isAbsolute(filepath) ? filepath : path9.join(rootDir, filepath);
+      const stats = await fs6.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
-    }
+    },
+    getIntrospection: (filepath) => introspection.getFile(filepath)
   };
   for (const filepath of files) {
-    const relativePath = path5.relative(rootDir, filepath);
+    const relativePath = path9.relative(rootDir, filepath);
     try {
-      const stats = await fs3.stat(filepath);
+      const stats = await fs6.stat(filepath);
       const lastModified = stats.mtime.toISOString();
       const existingEntry = manifest.files[relativePath];
       if (existingEntry && existingEntry.lastModified === lastModified) {
@@ -1078,7 +2277,8 @@ async function indexWithModule(rootDir, files, module, config, verbose) {
         result.skipped++;
         continue;
       }
-      const content = await fs3.readFile(filepath, "utf-8");
+      const content = await fs6.readFile(filepath, "utf-8");
+      introspection.addFile(relativePath, content);
       if (verbose) {
         console.log(`  Processing ${relativePath}...`);
       }
@@ -1122,7 +2322,7 @@ async function findFiles(rootDir, config) {
 async function loadModuleManifest(rootDir, moduleId, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
   try {
-    const content = await fs3.readFile(manifestPath, "utf-8");
+    const content = await fs6.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {
@@ -1135,14 +2335,14 @@ async function loadModuleManifest(rootDir, moduleId, config) {
 }
 async function writeModuleManifest(rootDir, moduleId, manifest, config) {
   const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
-  await fs3.mkdir(path5.dirname(manifestPath), { recursive: true });
-  await fs3.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs6.mkdir(path9.dirname(manifestPath), { recursive: true });
+  await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
   const indexPath = getModuleIndexPath(rootDir, moduleId, config);
-  const indexFilePath = path5.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
-  await fs3.mkdir(path5.dirname(indexFilePath), { recursive: true });
-  await fs3.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
+  const indexFilePath = path9.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs6.mkdir(path9.dirname(indexFilePath), { recursive: true });
+  await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
@@ -1151,12 +2351,12 @@ async function updateGlobalManifest(rootDir, modules, config) {
     lastUpdated: new Date().toISOString(),
     modules: modules.map((m) => m.id)
   };
-  await fs3.mkdir(path5.dirname(manifestPath), { recursive: true });
-  await fs3.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  await fs6.mkdir(path9.dirname(manifestPath), { recursive: true });
+  await fs6.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path5.resolve(rootDir);
+  rootDir = path9.resolve(rootDir);
   console.log(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -1186,9 +2386,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
   const filesToRemove = [];
   const updatedFiles = {};
   for (const [filepath, entry] of Object.entries(manifest.files)) {
-    const fullPath = path5.join(rootDir, filepath);
+    const fullPath = path9.join(rootDir, filepath);
     try {
-      await fs3.access(fullPath);
+      await fs6.access(fullPath);
       updatedFiles[filepath] = entry;
       result.kept++;
     } catch {
@@ -1200,9 +2400,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path5.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path9.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
-      await fs3.unlink(indexFilePath);
+      await fs6.unlink(indexFilePath);
     } catch {}
   }
   manifest.files = updatedFiles;
@@ -1213,16 +2413,16 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
 }
 async function cleanupEmptyDirectories(dir) {
   try {
-    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    const entries = await fs6.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path5.join(dir, entry.name);
+        const subDir = path9.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
-    const remainingEntries = await fs3.readdir(dir);
+    const remainingEntries = await fs6.readdir(dir);
     if (remainingEntries.length === 0) {
-      await fs3.rmdir(dir);
+      await fs6.rmdir(dir);
       return true;
     }
     return false;
@@ -1231,12 +2431,12 @@ async function cleanupEmptyDirectories(dir) {
   }
 }
 
-// src/search/index.ts
+// src/app/search/index.ts
 init_config2();
-import * as fs4 from "fs/promises";
-import * as path6 from "path";
+import * as fs7 from "fs/promises";
+import * as path10 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path6.resolve(rootDir);
+  rootDir = path10.resolve(rootDir);
   console.log(`Searching for: "${query}"`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -1277,9 +2477,9 @@ function createSearchContext(rootDir, moduleId, config) {
     config,
     loadFileIndex: async (filepath) => {
       const hasExtension = /\.[^./]+$/.test(filepath);
-      const indexFilePath = hasExtension ? path6.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path6.join(indexPath, filepath + ".json");
+      const indexFilePath = hasExtension ? path10.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path10.join(indexPath, filepath + ".json");
       try {
-        const content = await fs4.readFile(indexFilePath, "utf-8");
+        const content = await fs7.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -1289,7 +2489,7 @@ function createSearchContext(rootDir, moduleId, config) {
       const files = [];
       await traverseDirectory(indexPath, files, indexPath);
       return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
-        const relative3 = path6.relative(indexPath, f);
+        const relative3 = path10.relative(indexPath, f);
         return relative3.replace(/\.json$/, "");
       });
     }
@@ -1297,9 +2497,9 @@ function createSearchContext(rootDir, moduleId, config) {
 }
 async function traverseDirectory(dir, files, basePath) {
   try {
-    const entries = await fs4.readdir(dir, { withFileTypes: true });
+    const entries = await fs7.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path6.join(dir, entry.name);
+      const fullPath = path10.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -1311,7 +2511,7 @@ async function traverseDirectory(dir, files, basePath) {
 async function loadGlobalManifest(rootDir, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
   try {
-    const content = await fs4.readFile(manifestPath, "utf-8");
+    const content = await fs7.readFile(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -1375,4 +2575,4 @@ export {
   cleanup
 };
 
-//# debugId=3A2C4D6166478FB764756E2164756E21
+//# debugId=0E3E5BCA1147AB0A64756E2164756E21