raggrep 0.1.0 → 0.1.4

package/dist/cli/main.js

@@ -11,117 +11,144 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// src/utils/embeddings.ts
+// src/infrastructure/embeddings/transformersEmbedding.ts
 import { pipeline, env } from "@xenova/transformers";
 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;
+
+class TransformersEmbeddingProvider {
+  pipeline = null;
+  config;
+  isInitializing = false;
+  initPromise = null;
+  constructor(config) {
+    this.config = {
+      model: config?.model ?? "all-MiniLM-L6-v2",
+      showProgress: config?.showProgress ?? true
+    };
   }
-  if (isInitializing && initPromise) {
-    return initPromise;
+  async initialize(config) {
+    if (config) {
+      if (config.model !== this.config.model) {
+        this.pipeline = null;
+      }
+      this.config = { ...this.config, ...config };
+    }
+    await this.ensurePipeline();
   }
-  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}`);
+  async ensurePipeline() {
+    if (this.pipeline) {
+      return;
     }
-    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}              
+    if (this.isInitializing && this.initPromise) {
+      return this.initPromise;
+    }
+    this.isInitializing = true;
+    this.initPromise = (async () => {
+      const modelId = EMBEDDING_MODELS[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}              
 `);
-          } else if (progress.status === "ready") {}
-        } : undefined
-      });
-      currentModelName = currentConfig.model;
-      if (currentConfig.showProgress) {
-        console.log(`  Model ready.
+            }
+          } : 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;
       }
-    } catch (error) {
-      embeddingPipeline = null;
-      currentModelName = null;
-      throw new Error(`Failed to load embedding model: ${error}`);
-    } finally {
-      isInitializing = false;
-      initPromise = null;
+    })();
+    return this.initPromise;
+  }
+  async getEmbedding(text) {
+    await this.ensurePipeline();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
     }
-  })();
-  return initPromise;
-}
-async function getEmbedding(text) {
-  await initializePipeline();
-  if (!embeddingPipeline) {
-    throw new Error("Embedding pipeline not initialized");
+    const output = await this.pipeline(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    return Array.from(output.data);
   }
-  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");
+  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;
   }
-  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);
+  getDimension() {
+    return EMBEDDING_DIMENSION;
   }
-  return results;
-}
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
+  getModelName() {
+    return this.config.model;
   }
-  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];
+  async dispose() {
+    this.pipeline = null;
   }
-  if (normA === 0 || normB === 0)
-    return 0;
-  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-}
-function getEmbeddingConfig() {
-  return { ...currentConfig };
 }
 function getCacheDir() {
   return CACHE_DIR;
 }
-var CACHE_DIR, EMBEDDING_MODELS, embeddingPipeline = null, currentModelName = null, isInitializing = false, initPromise = null, DEFAULT_CONFIG, currentConfig, BATCH_SIZE = 32;
-var init_embeddings = __esm(() => {
+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_MODELS, EMBEDDING_DIMENSION = 384, BATCH_SIZE = 32, globalProvider = null, globalConfig;
+var init_transformersEmbedding = __esm(() => {
   CACHE_DIR = path.join(os.homedir(), ".cache", "raggrep", "models");
   env.cacheDir = CACHE_DIR;
   env.allowLocalModels = true;
@@ -131,11 +158,15 @@ var init_embeddings = __esm(() => {
     "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
     "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2"
   };
-  DEFAULT_CONFIG = {
+  globalConfig = {
     model: "all-MiniLM-L6-v2",
     showProgress: true
   };
-  currentConfig = { ...DEFAULT_CONFIG };
+});
+
+// src/infrastructure/embeddings/index.ts
+var init_embeddings = __esm(() => {
+  init_transformersEmbedding();
 });
 // src/domain/entities/searchResult.ts
 var init_searchResult = () => {};
@@ -149,7 +180,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"
@@ -209,32 +245,32 @@ var init_entities = __esm(() => {
   init_config();
 });
 
-// src/utils/config.ts
+// src/infrastructure/config/configLoader.ts
 import * as path2 from "path";
 import * as fs from "fs/promises";
-function getRaggrepDir(rootDir, config = DEFAULT_CONFIG2) {
+function getRaggrepDir(rootDir, config = DEFAULT_CONFIG) {
   return path2.join(rootDir, config.indexDir);
 }
-function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG2) {
+function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
   return path2.join(rootDir, config.indexDir, "index", moduleId);
 }
-function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG2) {
+function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG) {
   return path2.join(rootDir, config.indexDir, "index", moduleId, "manifest.json");
 }
-function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG2) {
+function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG) {
   return path2.join(rootDir, config.indexDir, "manifest.json");
 }
-function getConfigPath(rootDir, config = DEFAULT_CONFIG2) {
+function getConfigPath(rootDir, config = DEFAULT_CONFIG) {
   return path2.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) {
@@ -243,7 +279,7 @@ function getModuleConfig(config, moduleId) {
 function getEmbeddingConfigFromModule(moduleConfig) {
   const options = moduleConfig.options || {};
   const modelName = options.embeddingModel || "all-MiniLM-L6-v2";
-  if (!(modelName in EMBEDDING_MODELS)) {
+  if (!(modelName in EMBEDDING_MODELS2)) {
     console.warn(`Unknown embedding model: ${modelName}, falling back to all-MiniLM-L6-v2`);
     return { model: "all-MiniLM-L6-v2" };
   }
@@ -252,11 +288,21 @@ function getEmbeddingConfigFromModule(moduleConfig) {
     showProgress: options.showProgress !== false
   };
 }
-var DEFAULT_CONFIG2;
-var init_config2 = __esm(() => {
+var DEFAULT_CONFIG, EMBEDDING_MODELS2;
+var init_configLoader = __esm(() => {
   init_entities();
-  init_embeddings();
-  DEFAULT_CONFIG2 = createDefaultConfig();
+  DEFAULT_CONFIG = createDefaultConfig();
+  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"
+  };
+});
+
+// src/infrastructure/config/index.ts
+var init_config2 = __esm(() => {
+  init_configLoader();
 });
 
 // src/domain/services/bm25.ts
@@ -330,16 +376,449 @@ 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 path3 from "path";
+import * as fs2 from "fs/promises";
+
+class CoreModule {
+  id = "core";
+  name = "Core Search";
+  description = "Language-agnostic text search with symbol extraction";
+  version = "1.0.0";
+  symbolIndex = new Map;
+  bm25Index = null;
+  rootDir = "";
+  async initialize(_config) {}
+  async indexFile(filepath, content, ctx) {
+    this.rootDir = ctx.rootDir;
+    const symbols = extractSymbols(content);
+    const symbolKeywords = symbolsToKeywords(symbols);
+    const contentTokens = tokenize(content);
+    const allTokens = [...new Set([...contentTokens, ...symbolKeywords])];
+    const chunks = this.createChunks(filepath, content, symbols);
+    const stats = await ctx.getFileStats(filepath);
+    this.symbolIndex.set(filepath, {
+      filepath,
+      symbols,
+      tokens: allTokens
+    });
+    const moduleData = {
+      symbols,
+      tokens: allTokens
+    };
+    return {
+      filepath,
+      lastModified: stats.lastModified,
+      chunks,
+      moduleData
+    };
+  }
+  createChunks(filepath, content, symbols) {
+    const lines = content.split(`
+`);
+    const chunks = [];
+    for (let start = 0;start < lines.length; start += LINES_PER_CHUNK - CHUNK_OVERLAP) {
+      const end = Math.min(start + LINES_PER_CHUNK, lines.length);
+      const chunkLines = lines.slice(start, end);
+      const chunkContent = chunkLines.join(`
+`);
+      const chunkSymbols = symbols.filter((s) => s.line >= start + 1 && s.line <= end);
+      let chunkType = "block";
+      let chunkName;
+      let isExported = false;
+      if (chunkSymbols.length > 0) {
+        const primarySymbol = chunkSymbols[0];
+        chunkType = this.symbolTypeToChunkType(primarySymbol.type);
+        chunkName = primarySymbol.name;
+        isExported = primarySymbol.isExported;
+      }
+      const chunkId = `${filepath}:${start + 1}-${end}`;
+      chunks.push({
+        id: chunkId,
+        content: chunkContent,
+        startLine: start + 1,
+        endLine: end,
+        type: chunkType,
+        name: chunkName,
+        isExported
+      });
+      if (end >= lines.length)
+        break;
+    }
+    return chunks;
+  }
+  symbolTypeToChunkType(symbolType) {
+    switch (symbolType) {
+      case "function":
+      case "method":
+        return "function";
+      case "class":
+        return "class";
+      case "interface":
+        return "interface";
+      case "type":
+        return "type";
+      case "enum":
+        return "enum";
+      case "variable":
+        return "variable";
+      default:
+        return "block";
+    }
+  }
+  async finalize(ctx) {
+    const config = ctx.config;
+    const coreDir = path3.join(getRaggrepDir(ctx.rootDir, config), "index", "core");
+    await fs2.mkdir(coreDir, { recursive: true });
+    this.bm25Index = new BM25Index;
+    for (const [filepath, entry] of this.symbolIndex) {
+      this.bm25Index.addDocument(filepath, entry.tokens);
+    }
+    const symbolIndexData = {
+      version: this.version,
+      lastUpdated: new Date().toISOString(),
+      files: Object.fromEntries(this.symbolIndex),
+      bm25Data: this.bm25Index.serialize()
+    };
+    await fs2.writeFile(path3.join(coreDir, "symbols.json"), JSON.stringify(symbolIndexData, null, 2));
+    console.log(`  [Core] Symbol index built with ${this.symbolIndex.size} files`);
+  }
+  async search(query, ctx, options) {
+    const config = ctx.config;
+    const topK = options?.topK ?? DEFAULT_TOP_K;
+    const minScore = options?.minScore ?? DEFAULT_MIN_SCORE;
+    if (this.symbolIndex.size === 0) {
+      await this.loadSymbolIndex(ctx.rootDir, config);
+    }
+    if (!this.bm25Index || this.symbolIndex.size === 0) {
+      return [];
+    }
+    const queryTokens = tokenize(query);
+    const bm25Results = this.bm25Index.search(query, topK * 2);
+    const bm25Scores = new Map(bm25Results.map((r) => [r.id, r.score]));
+    const symbolMatches = this.findSymbolMatches(queryTokens);
+    const results = [];
+    for (const filepath of this.symbolIndex.keys()) {
+      const entry = this.symbolIndex.get(filepath);
+      const bm25Score = bm25Scores.get(filepath) ?? 0;
+      const symbolScore = symbolMatches.get(filepath) ?? 0;
+      if (bm25Score === 0 && symbolScore === 0)
+        continue;
+      const combinedScore = 0.6 * normalizeScore(bm25Score) + 0.4 * symbolScore;
+      if (combinedScore >= minScore) {
+        const fileIndex = await ctx.loadFileIndex(filepath);
+        if (!fileIndex)
+          continue;
+        const bestChunk = this.findBestChunk(fileIndex.chunks, queryTokens, entry.symbols);
+        results.push({
+          filepath,
+          chunk: bestChunk,
+          score: combinedScore,
+          moduleId: this.id,
+          context: {
+            bm25Score: normalizeScore(bm25Score),
+            symbolScore
+          }
+        });
+      }
+    }
+    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 = path3.join(getRaggrepDir(rootDir, config), "index", "core");
+    const symbolsPath = path3.join(coreDir, "symbols.json");
+    try {
+      const content = await fs2.readFile(symbolsPath, "utf-8");
+      const data = JSON.parse(content);
+      this.symbolIndex = new Map(Object.entries(data.files));
+      if (data.bm25Data) {
+        this.bm25Index = BM25Index.deserialize(data.bm25Data);
+      }
+    } 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/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/semantic/parseCode.ts
+// src/modules/language/typescript/parseCode.ts
 import * as ts from "typescript";
 function parseCode(content, filepath) {
   const ext = filepath.split(".").pop()?.toLowerCase();
@@ -530,6 +1009,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;
@@ -548,10 +1032,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);
+}
+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;
+var COMMON_KEYWORDS, LAYER_PATTERNS;
 var init_keywords = __esm(() => {
   COMMON_KEYWORDS = new Set([
     "const",
@@ -621,11 +1187,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;
@@ -634,7 +1213,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() {
@@ -694,18 +1273,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);
@@ -713,14 +1292,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);
@@ -732,18 +1311,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;
@@ -765,24 +1344,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;
@@ -799,7 +1383,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),
@@ -813,10 +1402,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);
@@ -825,13 +1414,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 {
@@ -855,7 +1451,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;
@@ -908,11 +1504,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,
@@ -921,7 +1538,8 @@ class SemanticModule {
           moduleId: this.id,
           context: {
             semanticScore,
-            bm25Score
+            bm25Score,
+            pathBoost
           }
         });
       }
@@ -937,29 +1555,30 @@ 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/modules/registry.ts
@@ -983,28 +1602,777 @@ class 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);
 }
 var registry;
 var init_registry = __esm(() => {
   registry = new ModuleRegistryImpl;
 });
 
-// src/indexer/index.ts
-var exports_indexer = {};
-__export(exports_indexer, {
-  indexDirectory: () => indexDirectory,
+// src/introspection/projectDetector.ts
+import * as path6 from "path";
+import * as fs4 from "fs/promises";
+function detectScopeFromName(name) {
+  const nameLower = name.toLowerCase();
+  for (const [scope, keywords] of Object.entries(SCOPE_KEYWORDS)) {
+    if (scope === "unknown")
+      continue;
+    for (const keyword of keywords) {
+      if (nameLower.includes(keyword)) {
+        return scope;
+      }
+    }
+  }
+  return "unknown";
+}
+async function scanForPackageJsons(rootDir, currentDir = "", depth = 0) {
+  if (depth > MAX_SCAN_DEPTH)
+    return [];
+  const results = [];
+  const fullDir = currentDir ? path6.join(rootDir, currentDir) : rootDir;
+  try {
+    const entries = await fs4.readdir(fullDir, { withFileTypes: true });
+    const hasPackageJson = entries.some((e) => e.isFile() && e.name === "package.json");
+    if (hasPackageJson && currentDir) {
+      const info = await parsePackageJson(rootDir, currentDir);
+      if (info) {
+        results.push(info);
+      }
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      if (SKIP_DIRS.has(entry.name))
+        continue;
+      const subPath = currentDir ? `${currentDir}/${entry.name}` : entry.name;
+      const subResults = await scanForPackageJsons(rootDir, subPath, depth + 1);
+      results.push(...subResults);
+    }
+  } catch {}
+  return results;
+}
+async function parsePackageJson(rootDir, relativePath) {
+  try {
+    const packageJsonPath = path6.join(rootDir, relativePath, "package.json");
+    const content = await fs4.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const name = pkg.name || path6.basename(relativePath);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    let type = "unknown";
+    if (deps["next"] || deps["react"] || deps["vue"] || deps["svelte"]) {
+      type = "app";
+    } else if (deps["express"] || deps["fastify"] || deps["koa"] || deps["hono"]) {
+      type = "service";
+    } else if (pkg.main || pkg.exports) {
+      type = "library";
+    }
+    const hasWorkspaces = Boolean(pkg.workspaces);
+    return { name, relativePath, type, hasWorkspaces };
+  } catch {
+    return null;
+  }
+}
+async function detectProjectStructure(rootDir) {
+  const projectMap = new Map;
+  let isMonorepo = false;
+  try {
+    const entries = await fs4.readdir(rootDir, { withFileTypes: true });
+    const dirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    const monorepoPatterns = ["apps", "packages", "libs", "services"];
+    const hasMonorepoStructure = monorepoPatterns.some((p) => dirNames.includes(p));
+    if (hasMonorepoStructure) {
+      isMonorepo = true;
+      for (const pattern of monorepoPatterns) {
+        if (!dirNames.includes(pattern))
+          continue;
+        const patternDir = path6.join(rootDir, pattern);
+        try {
+          const subDirs = await fs4.readdir(patternDir, { withFileTypes: true });
+          for (const subDir of subDirs) {
+            if (!subDir.isDirectory())
+              continue;
+            const projectRoot = `${pattern}/${subDir.name}`;
+            const type = getProjectType(pattern);
+            projectMap.set(projectRoot, {
+              name: subDir.name,
+              root: projectRoot,
+              type
+            });
+          }
+        } 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"
+  };
+}
+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/fileIntrospector.ts
+import * as path7 from "path";
+function introspectFile(filepath, structure, fileContent) {
+  const normalizedPath = filepath.replace(/\\/g, "/");
+  const segments = normalizedPath.split("/").filter((s) => s.length > 0);
+  const filename = segments[segments.length - 1] || "";
+  const ext = path7.extname(filename);
+  const project = findProjectForFile(normalizedPath, structure);
+  const language = EXTENSION_TO_LANGUAGE[ext] || "unknown";
+  const layer = detectLayer(segments, filename);
+  const domain = detectDomain(segments);
+  const scope = detectScope(segments, project, layer);
+  let framework;
+  if (fileContent) {
+    framework = detectFramework(fileContent);
+  }
+  return {
+    filepath: normalizedPath,
+    project,
+    scope,
+    layer,
+    domain,
+    language,
+    framework,
+    depth: segments.length - 1,
+    pathSegments: segments.slice(0, -1)
+  };
+}
+function detectLayer(segments, filename) {
+  const filenameLower = filename.toLowerCase();
+  for (const [layer, patterns] of Object.entries(LAYER_PATTERNS2)) {
+    for (const pattern of patterns) {
+      if (filenameLower.includes(pattern)) {
+        return layer;
+      }
+    }
+  }
+  for (let i = segments.length - 2;i >= 0; i--) {
+    const segment = segments[i].toLowerCase();
+    for (const [layer, patterns] of Object.entries(LAYER_PATTERNS2)) {
+      if (patterns.includes(segment)) {
+        return layer;
+      }
+    }
+  }
+  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;
+}
+var LAYER_PATTERNS2, DOMAIN_PATTERNS, FRAMEWORK_INDICATORS, EXTENSION_TO_LANGUAGE;
+var init_fileIntrospector = __esm(() => {
+  init_projectDetector();
+  LAYER_PATTERNS2 = {
+    controller: ["controller", "api", "routes", "route", "handler"],
+    service: ["service", "logic", "usecase", "usecases", "handler"],
+    repository: ["repository", "repo", "dao", "store", "persistence"],
+    model: ["model", "models", "entity", "entities", "schema", "schemas", "types", "type"],
+    util: ["util", "utils", "helper", "helpers", "common", "lib"],
+    config: ["config", "configuration", "settings"],
+    middleware: ["middleware", "middlewares"],
+    domain: ["domain"],
+    infrastructure: ["infrastructure", "infra"],
+    application: ["application", "app"],
+    presentation: ["presentation", "ui", "views", "view", "component", "components"],
+    test: ["test", "tests", "spec", "specs", "__tests__", "e2e"]
+  };
+  DOMAIN_PATTERNS = [
+    "auth",
+    "authentication",
+    "user",
+    "users",
+    "account",
+    "accounts",
+    "profile",
+    "profiles",
+    "product",
+    "products",
+    "item",
+    "items",
+    "catalog",
+    "order",
+    "orders",
+    "cart",
+    "checkout",
+    "payment",
+    "payments",
+    "billing",
+    "subscription",
+    "subscriptions",
+    "notification",
+    "notifications",
+    "email",
+    "sms",
+    "report",
+    "reports",
+    "analytics",
+    "metrics",
+    "dashboard",
+    "admin",
+    "settings",
+    "search",
+    "chat",
+    "message",
+    "messages",
+    "feed",
+    "post",
+    "posts",
+    "comment",
+    "comments",
+    "media",
+    "upload",
+    "file",
+    "files",
+    "storage",
+    "cache",
+    "session",
+    "log",
+    "logs",
+    "audit"
+  ];
+  FRAMEWORK_INDICATORS = {
+    nextjs: ["next", "next/"],
+    express: ["express"],
+    fastify: ["fastify"],
+    react: ["react"],
+    vue: ["vue"],
+    angular: ["@angular/"],
+    nestjs: ["@nestjs/"],
+    koa: ["koa"]
+  };
+  EXTENSION_TO_LANGUAGE = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".swift": "swift",
+    ".rb": "ruby",
+    ".php": "php",
+    ".cs": "csharp",
+    ".cpp": "cpp",
+    ".c": "c",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".md": "markdown",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml"
+  };
+});
+
+// src/introspection/index.ts
+import * as path8 from "path";
+import * as fs5 from "fs/promises";
+
+class IntrospectionIndex {
+  rootDir;
+  structure = null;
+  files = new Map;
+  config = {};
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  async initialize() {
+    this.structure = await detectProjectStructure(this.rootDir);
+    try {
+      const configPath = 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;
+  }
+}
+var init_introspection = __esm(() => {
+  init_projectDetector();
+  init_fileIntrospector();
+  init_config2();
+  init_fileIntrospector();
+  init_projectDetector();
+});
+
+// src/app/indexer/watcher.ts
+import { watch } from "chokidar";
+import * as path9 from "path";
+async function watchDirectory(rootDir, options = {}) {
+  const {
+    debounceMs = DEFAULT_DEBOUNCE_MS,
+    verbose = false,
+    model,
+    onIndexStart,
+    onIndexComplete,
+    onFileChange,
+    onError
+  } = options;
+  rootDir = path9.resolve(rootDir);
+  const config = await loadConfig(rootDir);
+  const watchPatterns = config.extensions.map((ext) => `**/*${ext}`);
+  const ignorePatterns = [
+    ...config.ignorePaths.map((p) => `**/${p}/**`),
+    `**/${config.indexDir}/**`
+  ];
+  let isRunning = true;
+  let isIndexing = false;
+  let pendingChanges = new Map;
+  let debounceTimer = null;
+  let watcher = null;
+  async function processPendingChanges() {
+    if (!isRunning || isIndexing || pendingChanges.size === 0) {
+      return;
+    }
+    isIndexing = true;
+    const changes = new Map(pendingChanges);
+    pendingChanges.clear();
+    try {
+      const filesToIndex = [];
+      const filesToDelete = [];
+      for (const [filepath, event] of changes) {
+        if (event === "unlink") {
+          filesToDelete.push(filepath);
+        } else {
+          filesToIndex.push(filepath);
+        }
+      }
+      if (filesToDelete.length > 0) {
+        if (verbose) {
+          console.log(`
+[Watch] Cleaning up ${filesToDelete.length} deleted file(s)...`);
+        }
+        await cleanupIndex(rootDir, { verbose: false });
+      }
+      if (filesToIndex.length > 0) {
+        if (onIndexStart) {
+          onIndexStart(filesToIndex);
+        }
+        if (verbose) {
+          console.log(`
+[Watch] Indexing ${filesToIndex.length} changed file(s)...`);
+        }
+        const results = await indexDirectory(rootDir, {
+          model,
+          verbose: false
+        });
+        if (onIndexComplete) {
+          onIndexComplete(results);
+        }
+        for (const result of results) {
+          if (result.indexed > 0 || result.errors > 0) {
+            console.log(`[Watch] ${result.moduleId}: ${result.indexed} indexed, ${result.errors} errors`);
+          }
+        }
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error("[Watch] Error during indexing:", err.message);
+      if (onError) {
+        onError(err);
+      }
+    } finally {
+      isIndexing = false;
+      if (pendingChanges.size > 0) {
+        scheduleProcessing();
+      }
+    }
+  }
+  function scheduleProcessing() {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    if (pendingChanges.size >= MAX_BATCH_SIZE) {
+      processPendingChanges();
+      return;
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      processPendingChanges();
+    }, debounceMs);
+  }
+  function handleFileEvent(event, filepath) {
+    if (!isRunning)
+      return;
+    const relativePath = path9.relative(rootDir, filepath);
+    for (const ignorePath of config.ignorePaths) {
+      if (relativePath.startsWith(ignorePath) || relativePath.includes(`/${ignorePath}/`)) {
+        return;
+      }
+    }
+    if (onFileChange) {
+      onFileChange(event, relativePath);
+    }
+    if (verbose) {
+      const symbol = event === "add" ? "+" : event === "unlink" ? "-" : "~";
+      console.log(`[Watch] ${symbol} ${relativePath}`);
+    }
+    pendingChanges.set(relativePath, event);
+    scheduleProcessing();
+  }
+  watcher = watch(watchPatterns, {
+    cwd: rootDir,
+    ignored: ignorePatterns,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50
+    },
+    usePolling: false,
+    atomic: true
+  });
+  watcher.on("add", (filepath) => handleFileEvent("add", path9.join(rootDir, filepath)));
+  watcher.on("change", (filepath) => handleFileEvent("change", path9.join(rootDir, filepath)));
+  watcher.on("unlink", (filepath) => handleFileEvent("unlink", path9.join(rootDir, filepath)));
+  watcher.on("error", (error) => {
+    const err = error instanceof Error ? error : new Error(String(error));
+    console.error("[Watch] Watcher error:", err);
+    if (onError) {
+      onError(err);
+    }
+  });
+  await new Promise((resolve2) => {
+    watcher.on("ready", () => {
+      resolve2();
+    });
+  });
+  return {
+    stop: async () => {
+      isRunning = false;
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      if (watcher) {
+        await watcher.close();
+        watcher = null;
+      }
+    },
+    isRunning: () => isRunning
+  };
+}
+var DEFAULT_DEBOUNCE_MS = 300, MAX_BATCH_SIZE = 100;
+var init_watcher = __esm(() => {
+  init_config2();
+  init_indexer();
+});
+
+// src/app/indexer/index.ts
+var exports_indexer = {};
+__export(exports_indexer, {
+  watchDirectory: () => watchDirectory,
+  indexDirectory: () => indexDirectory,
+  getIndexStatus: () => getIndexStatus,
   cleanupIndex: () => cleanupIndex
 });
 import { glob } from "glob";
-import * as fs3 from "fs/promises";
-import * as path5 from "path";
+import * as fs6 from "fs/promises";
+import * as path10 from "path";
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path5.resolve(rootDir);
+  rootDir = path10.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) {
@@ -1021,7 +2389,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
@@ -1029,7 +2397,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...`);
@@ -1037,12 +2405,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 = path10.isAbsolute(filepath) ? filepath : path10.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 = path10.isAbsolute(filepath) ? filepath : path10.join(rootDir, filepath);
+          const stats = await fs6.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
       };
@@ -1050,10 +2418,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,
@@ -1065,19 +2434,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 = path10.isAbsolute(filepath) ? filepath : path10.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 = path10.isAbsolute(filepath) ? filepath : path10.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 = path10.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) {
@@ -1087,7 +2457,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}...`);
       }
@@ -1131,7 +2502,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 {
@@ -1144,14 +2515,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(path10.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 = path10.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs6.mkdir(path10.dirname(indexFilePath), { recursive: true });
+  await fs6.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
   const manifestPath = getGlobalManifestPath(rootDir, config);
@@ -1160,12 +2531,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(path10.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 = path10.resolve(rootDir);
   console.log(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -1195,9 +2566,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 = path10.join(rootDir, filepath);
     try {
-      await fs3.access(fullPath);
+      await fs6.access(fullPath);
       updatedFiles[filepath] = entry;
       result.kept++;
     } catch {
@@ -1209,9 +2580,9 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path5.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path10.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
-      await fs3.unlink(indexFilePath);
+      await fs6.unlink(indexFilePath);
     } catch {}
   }
   manifest.files = updatedFiles;
@@ -1222,16 +2593,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 = path10.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;
@@ -1239,21 +2610,79 @@ async function cleanupEmptyDirectories(dir) {
     return false;
   }
 }
+async function getIndexStatus(rootDir) {
+  rootDir = path10.resolve(rootDir);
+  const config = await loadConfig(rootDir);
+  const indexDir = path10.join(rootDir, config.indexDir);
+  const status = {
+    exists: false,
+    rootDir,
+    indexDir,
+    modules: [],
+    totalFiles: 0
+  };
+  try {
+    await fs6.access(indexDir);
+  } catch {
+    return status;
+  }
+  try {
+    const globalManifestPath = getGlobalManifestPath(rootDir, config);
+    const content = await fs6.readFile(globalManifestPath, "utf-8");
+    const globalManifest = JSON.parse(content);
+    status.exists = true;
+    status.lastUpdated = globalManifest.lastUpdated;
+    for (const moduleId of globalManifest.modules) {
+      try {
+        const manifest = await loadModuleManifest(rootDir, moduleId, config);
+        const fileCount = Object.keys(manifest.files).length;
+        status.modules.push({
+          id: moduleId,
+          fileCount,
+          lastUpdated: manifest.lastUpdated
+        });
+        status.totalFiles += fileCount;
+      } catch {}
+    }
+  } catch {
+    try {
+      const entries = await fs6.readdir(path10.join(indexDir, "index"));
+      if (entries.length > 0) {
+        status.exists = true;
+        for (const entry of entries) {
+          try {
+            const manifest = await loadModuleManifest(rootDir, entry, config);
+            const fileCount = Object.keys(manifest.files).length;
+            status.modules.push({
+              id: entry,
+              fileCount,
+              lastUpdated: manifest.lastUpdated
+            });
+            status.totalFiles += fileCount;
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  return status;
+}
 var init_indexer = __esm(() => {
   init_config2();
   init_registry();
+  init_introspection();
+  init_watcher();
 });
 
-// src/search/index.ts
+// src/app/search/index.ts
 var exports_search = {};
 __export(exports_search, {
   search: () => search,
   formatSearchResults: () => formatSearchResults
 });
-import * as fs4 from "fs/promises";
-import * as path6 from "path";
+import * as fs7 from "fs/promises";
+import * as path11 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path6.resolve(rootDir);
+  rootDir = path11.resolve(rootDir);
   console.log(`Searching for: "${query}"`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -1294,9 +2723,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 ? path11.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path11.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;
@@ -1306,17 +2735,17 @@ 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);
-        return relative3.replace(/\.json$/, "");
+        const relative4 = path11.relative(indexPath, f);
+        return relative4.replace(/\.json$/, "");
       });
     }
   };
 }
 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 = path11.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -1328,7 +2757,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;
@@ -1371,14 +2800,40 @@ var init_search = __esm(() => {
   init_registry();
 });
 
-// src/cli/main.ts
+// src/app/cli/main.ts
 init_embeddings();
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../../../package.json");
+var VERSION = pkg.version;
 var args = process.argv.slice(2);
 var command = args[0];
+if (command === "--version" || command === "-v") {
+  console.log(`raggrep v${VERSION}`);
+  process.exit(0);
+}
+function formatTimeAgo(date) {
+  const now = new Date;
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1000);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffSecs < 60)
+    return "just now";
+  if (diffMins < 60)
+    return `${diffMins}m ago`;
+  if (diffHours < 24)
+    return `${diffHours}h ago`;
+  if (diffDays < 7)
+    return `${diffDays}d ago`;
+  return date.toLocaleDateString();
+}
 function parseFlags(args2) {
   const flags = {
     help: false,
     verbose: false,
+    watch: false,
     remaining: []
   };
   for (let i = 0;i < args2.length; i++) {
@@ -1387,6 +2842,8 @@ function parseFlags(args2) {
       flags.help = true;
     } else if (arg === "--verbose" || arg === "-v") {
       flags.verbose = true;
+    } else if (arg === "--watch" || arg === "-w") {
+      flags.watch = true;
     } else if (arg === "--model" || arg === "-m") {
       const modelName = args2[++i];
       if (modelName && modelName in EMBEDDING_MODELS) {
@@ -1436,6 +2893,7 @@ Usage:
   raggrep index [options]
 
 Options:
+  -w, --watch          Watch for file changes and re-index automatically
   -m, --model <name>   Embedding model to use (default: all-MiniLM-L6-v2)
   -v, --verbose        Show detailed progress
   -h, --help           Show this help message
@@ -1447,12 +2905,13 @@ Model Cache: ${getCacheDir()}
 
 Examples:
   raggrep index
+  raggrep index --watch
   raggrep index --model bge-small-en-v1.5
   raggrep index --verbose
 `);
         process.exit(0);
       }
-      const { indexDirectory: indexDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      const { indexDirectory: indexDirectory2, watchDirectory: watchDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       console.log("RAGgrep Indexer");
       console.log(`================
 `);
@@ -1471,6 +2930,39 @@ Examples:
         console.error("Error during indexing:", error);
         process.exit(1);
       }
+      if (flags.watch) {
+        console.log(`
+┌─────────────────────────────────────────┐`);
+        console.log("│  Watching for changes... (Ctrl+C to stop) │");
+        console.log(`└─────────────────────────────────────────┘
+`);
+        try {
+          const watcher = await watchDirectory2(process.cwd(), {
+            model: flags.model,
+            verbose: flags.verbose,
+            onFileChange: (event, filepath) => {
+              if (flags.verbose) {
+                const symbol = event === "add" ? "＋" : event === "unlink" ? "－" : "～";
+                console.log(`  ${symbol} ${filepath}`);
+              }
+            }
+          });
+          const shutdown = async () => {
+            console.log(`
+
+Stopping watcher...`);
+            await watcher.stop();
+            console.log("Done.");
+            process.exit(0);
+          };
+          process.on("SIGINT", shutdown);
+          process.on("SIGTERM", shutdown);
+          await new Promise(() => {});
+        } catch (error) {
+          console.error("Error starting watcher:", error);
+          process.exit(1);
+        }
+      }
       break;
     }
     case "query": {
@@ -1487,6 +2979,10 @@ Options:
   -t, --type <ext>     Filter by file extension (e.g., ts, tsx, js)
   -h, --help           Show this help message
 
+Note:
+  If the current directory has not been indexed, raggrep will
+  automatically index it before searching.
+
 Examples:
   raggrep query "user authentication"
   raggrep query "handle errors" --top 5
@@ -1496,16 +2992,36 @@ Examples:
         process.exit(0);
       }
       const { search: search2, formatSearchResults: formatSearchResults2 } = await Promise.resolve().then(() => (init_search(), exports_search));
+      const { getIndexStatus: getIndexStatus2, indexDirectory: indexDirectory2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
       const query = flags.remaining[0];
       if (!query) {
         console.error("Usage: raggrep query <search query>");
         console.error('Run "raggrep query --help" for more information.');
         process.exit(1);
       }
-      console.log("RAGgrep Search");
-      console.log(`==============
-`);
       try {
+        const status = await getIndexStatus2(process.cwd());
+        if (!status.exists) {
+          console.log(`No index found. Indexing directory first...
+`);
+          console.log("RAGgrep Indexer");
+          console.log(`================
+`);
+          const indexResults = await indexDirectory2(process.cwd(), {
+            model: flags.model,
+            verbose: false
+          });
+          console.log(`
+================`);
+          console.log("Summary:");
+          for (const result of indexResults) {
+            console.log(`  ${result.moduleId}: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
+          }
+          console.log("");
+        }
+        console.log("RAGgrep Search");
+        console.log(`==============
+`);
         const filePatterns = flags.fileType ? [`*.${flags.fileType}`] : undefined;
         const results = await search2(process.cwd(), query, {
           topK: flags.topK ?? 10,
@@ -1561,9 +3077,72 @@ Examples:
       }
       break;
     }
+    case "status": {
+      if (flags.help) {
+        console.log(`
+raggrep status - Show the current state of the index
+
+Usage:
+  raggrep status [options]
+
+Options:
+  -h, --help           Show this help message
+
+Description:
+  Displays information about the index in the current directory,
+  including whether it exists, how many files are indexed, and
+  when it was last updated.
+
+Examples:
+  raggrep status
+`);
+        process.exit(0);
+      }
+      const { getIndexStatus: getIndexStatus2 } = await Promise.resolve().then(() => (init_indexer(), exports_indexer));
+      try {
+        const status = await getIndexStatus2(process.cwd());
+        if (!status.exists) {
+          console.log(`
+┌─────────────────────────────────────────┐
+│  RAGgrep Status                         │
+├─────────────────────────────────────────┤
+│  ○ Not indexed                          │
+└─────────────────────────────────────────┘
+
+  Directory: ${status.rootDir}
+
+  Run "raggrep index" to create an index.
+`);
+        } else {
+          const date = status.lastUpdated ? new Date(status.lastUpdated) : null;
+          const timeAgo = date ? formatTimeAgo(date) : "unknown";
+          console.log(`
+┌─────────────────────────────────────────┐
+│  RAGgrep Status                         │
+├─────────────────────────────────────────┤
+│  ● Indexed                              │
+└─────────────────────────────────────────┘
+
+  Files:    ${status.totalFiles.toString().padEnd(10)} Updated: ${timeAgo}
+  Location: ${status.indexDir}
+`);
+          if (status.modules.length > 0) {
+            console.log("  Modules:");
+            for (const mod of status.modules) {
+              console.log(`    └─ ${mod.id} (${mod.fileCount} files)`);
+            }
+            console.log("");
+          }
+        }
+      } catch (error) {
+        console.error("Error getting status:", error);
+        process.exit(1);
+      }
+      break;
+    }
     default:
       console.log(`
-raggrep - Local filesystem-based RAG system for codebases
+raggrep v${VERSION} - Local filesystem-based RAG system for codebases
 
 Usage:
   raggrep <command> [options]
@@ -1571,16 +3150,17 @@ Usage:
 Commands:
   index    Index the current directory
   query    Search the indexed codebase
+  status   Show the current state of the index
   cleanup  Remove stale index entries for deleted files
 
 Options:
-  -h, --help   Show help for a command
+  -h, --help     Show help for a command
+  -v, --version  Show version number
 
 Examples:
   raggrep index
-  raggrep index --model bge-small-en-v1.5
   raggrep query "user login"
-  raggrep query "handle errors" --top 5
+  raggrep status
   raggrep cleanup
 
 Run 'raggrep <command> --help' for more information.
@@ -1593,4 +3173,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=8E6C629D8A1BA14F64756E2164756E21
+//# debugId=9D236CA9876AFE5464756E2164756E21