raggrep 0.1.0 → 0.1.3

package/dist/cli/main.js

@@ -548,10 +548,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,6 +703,19 @@ 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
@@ -799,7 +894,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),
@@ -825,13 +925,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 {
@@ -908,11 +1015,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 +1049,8 @@ class SemanticModule {
           moduleId: this.id,
           context: {
             semanticScore,
-            bm25Score
+            bm25Score,
+            pathBoost
           }
         });
       }
@@ -960,6 +1089,7 @@ var init_semantic = __esm(() => {
   init_config2();
   init_parseCode();
   init_tieredIndex();
+  init_keywords();
 });
 
 // src/modules/registry.ts
@@ -991,18 +1121,183 @@ var init_registry = __esm(() => {
   registry = new ModuleRegistryImpl;
 });
 
+// src/indexer/watcher.ts
+import { watch } from "chokidar";
+import * as path5 from "path";
+async function watchDirectory(rootDir, options = {}) {
+  const {
+    debounceMs = DEFAULT_DEBOUNCE_MS,
+    verbose = false,
+    model,
+    onIndexStart,
+    onIndexComplete,
+    onFileChange,
+    onError
+  } = options;
+  rootDir = path5.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 = path5.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", path5.join(rootDir, filepath)));
+  watcher.on("change", (filepath) => handleFileEvent("change", path5.join(rootDir, filepath)));
+  watcher.on("unlink", (filepath) => handleFileEvent("unlink", path5.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/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 path6 from "path";
 async function indexDirectory(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path5.resolve(rootDir);
+  rootDir = path6.resolve(rootDir);
   console.log(`Indexing directory: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -1037,11 +1332,11 @@ async function indexDirectory(rootDir, options = {}) {
         rootDir,
         config,
         readFile: async (filepath) => {
-          const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+          const fullPath = path6.isAbsolute(filepath) ? filepath : path6.join(rootDir, filepath);
           return fs3.readFile(fullPath, "utf-8");
         },
         getFileStats: async (filepath) => {
-          const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+          const fullPath = path6.isAbsolute(filepath) ? filepath : path6.join(rootDir, filepath);
           const stats = await fs3.stat(fullPath);
           return { lastModified: stats.mtime.toISOString() };
         }
@@ -1065,17 +1360,17 @@ async function indexWithModule(rootDir, files, module, config, verbose) {
     rootDir,
     config,
     readFile: async (filepath) => {
-      const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+      const fullPath = path6.isAbsolute(filepath) ? filepath : path6.join(rootDir, filepath);
       return fs3.readFile(fullPath, "utf-8");
     },
     getFileStats: async (filepath) => {
-      const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+      const fullPath = path6.isAbsolute(filepath) ? filepath : path6.join(rootDir, filepath);
       const stats = await fs3.stat(fullPath);
       return { lastModified: stats.mtime.toISOString() };
     }
   };
   for (const filepath of files) {
-    const relativePath = path5.relative(rootDir, filepath);
+    const relativePath = path6.relative(rootDir, filepath);
     try {
       const stats = await fs3.stat(filepath);
       const lastModified = stats.mtime.toISOString();
@@ -1144,13 +1439,13 @@ 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.mkdir(path6.dirname(manifestPath), { recursive: true });
   await fs3.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 });
+  const indexFilePath = path6.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs3.mkdir(path6.dirname(indexFilePath), { recursive: true });
   await fs3.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
 }
 async function updateGlobalManifest(rootDir, modules, config) {
@@ -1160,12 +1455,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.mkdir(path6.dirname(manifestPath), { recursive: true });
   await fs3.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
 }
 async function cleanupIndex(rootDir, options = {}) {
   const verbose = options.verbose ?? false;
-  rootDir = path5.resolve(rootDir);
+  rootDir = path6.resolve(rootDir);
   console.log(`Cleaning up index in: ${rootDir}`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -1195,7 +1490,7 @@ 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 = path6.join(rootDir, filepath);
     try {
       await fs3.access(fullPath);
       updatedFiles[filepath] = entry;
@@ -1209,7 +1504,7 @@ async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
     }
   }
   for (const filepath of filesToRemove) {
-    const indexFilePath = path5.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    const indexFilePath = path6.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
     try {
       await fs3.unlink(indexFilePath);
     } catch {}
@@ -1225,7 +1520,7 @@ async function cleanupEmptyDirectories(dir) {
     const entries = await fs3.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = path5.join(dir, entry.name);
+        const subDir = path6.join(dir, entry.name);
         await cleanupEmptyDirectories(subDir);
       }
     }
@@ -1239,9 +1534,66 @@ async function cleanupEmptyDirectories(dir) {
     return false;
   }
 }
+async function getIndexStatus(rootDir) {
+  rootDir = path6.resolve(rootDir);
+  const config = await loadConfig(rootDir);
+  const indexDir = path6.join(rootDir, config.indexDir);
+  const status = {
+    exists: false,
+    rootDir,
+    indexDir,
+    modules: [],
+    totalFiles: 0
+  };
+  try {
+    await fs3.access(indexDir);
+  } catch {
+    return status;
+  }
+  try {
+    const globalManifestPath = getGlobalManifestPath(rootDir, config);
+    const content = await fs3.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 fs3.readdir(path6.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_watcher();
 });
 
 // src/search/index.ts
@@ -1251,9 +1603,9 @@ __export(exports_search, {
   formatSearchResults: () => formatSearchResults
 });
 import * as fs4 from "fs/promises";
-import * as path6 from "path";
+import * as path7 from "path";
 async function search(rootDir, query, options = {}) {
-  rootDir = path6.resolve(rootDir);
+  rootDir = path7.resolve(rootDir);
   console.log(`Searching for: "${query}"`);
   const config = await loadConfig(rootDir);
   await registerBuiltInModules();
@@ -1294,7 +1646,7 @@ 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 ? path7.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path7.join(indexPath, filepath + ".json");
       try {
         const content = await fs4.readFile(indexFilePath, "utf-8");
         return JSON.parse(content);
@@ -1306,8 +1658,8 @@ 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 = path7.relative(indexPath, f);
+        return relative4.replace(/\.json$/, "");
       });
     }
   };
@@ -1316,7 +1668,7 @@ async function traverseDirectory(dir, files, basePath) {
   try {
     const entries = await fs4.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path6.join(dir, entry.name);
+      const fullPath = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         await traverseDirectory(fullPath, files, basePath);
       } else if (entry.isFile()) {
@@ -1373,12 +1725,38 @@ var init_search = __esm(() => {
 
 // src/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 +1765,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 +1816,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 +1828,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 +1853,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 +1902,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 +1915,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 +2000,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 +2073,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 +2096,4 @@ Run 'raggrep <command> --help' for more information.
 }
 main();
 
-//# debugId=8E6C629D8A1BA14F64756E2164756E21
+//# debugId=0D3D8495D3A140B664756E2164756E21