feat: wire all modules to CLI subcommands

Connect index, search, status, and clear commands to real module calls.
Fix db filename mismatch between indexer (engraph.db) and search (store.db).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: devwhodevs

src/main.rs

@@ -8,6 +8,7 @@ mod store;
 
 use anyhow::Result;
 use clap::{Parser, Subcommand};
+use std::io::{self, BufRead, Write};
 use std::path::PathBuf;
 use tracing::info;
 
@@ -61,6 +62,29 @@ enum Command {
     },
 }
 
+/// Check whether an index has been built by looking for engraph.db in data_dir.
+fn index_exists(data_dir: &std::path::Path) -> bool {
+    data_dir.join("engraph.db").exists()
+}
+
+/// Remove a file, ignoring NotFound errors.
+fn remove_if_exists(path: &std::path::Path) -> Result<bool> {
+    match std::fs::remove_file(path) {
+        Ok(()) => Ok(true),
+        Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(false),
+        Err(e) => Err(e.into()),
+    }
+}
+
+/// Remove a directory recursively, ignoring NotFound errors.
+fn remove_dir_if_exists(path: &std::path::Path) -> Result<bool> {
+    match std::fs::remove_dir_all(path) {
+        Ok(()) => Ok(true),
+        Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(false),
+        Err(e) => Err(e.into()),
+    }
+}
+
 fn main() -> Result<()> {
     let cli = Cli::parse();
 
@@ -74,28 +98,112 @@ fn main() -> Result<()> {
         .init();
 
     let mut cfg = Config::load()?;
-    info!(data_dir = %Config::data_dir()?.display(), "loaded config");
+    let data_dir = Config::data_dir()?;
+    info!(data_dir = %data_dir.display(), "loaded config");
 
     match cli.command {
         Command::Index { path, rebuild } => {
+            // Merge CLI vault path over config.
             cfg.merge_vault_path(path);
-            let vault = cfg
-                .vault_path
-                .as_deref()
-                .map(|p| p.display().to_string())
-                .unwrap_or_else(|| "<not set>".into());
-            println!("Would index: {vault} (rebuild={rebuild})");
+
+            // Fall back to current directory if neither CLI nor config provides a vault path.
+            let vault_path = match &cfg.vault_path {
+                Some(p) => p.clone(),
+                None => {
+                    let cwd = std::env::current_dir()?;
+                    cfg.vault_path = Some(cwd.clone());
+                    cwd
+                }
+            };
+
+            // Canonicalize to resolve symlinks and relative paths.
+            let vault_path = vault_path.canonicalize().unwrap_or(vault_path);
+
+            // Ensure data directory exists.
+            std::fs::create_dir_all(&data_dir)?;
+
+            // Check for vault mismatch: if store has a different vault path, warn.
+            let db_path = data_dir.join("engraph.db");
+            if db_path.exists() && !rebuild {
+                let store = store::Store::open(&db_path)?;
+                if let Some(stored_vault) = store.get_meta("vault_path")? {
+                    let stored = PathBuf::from(&stored_vault);
+                    if stored != vault_path {
+                        eprint!(
+                            "Warning: Index was built for '{}'. Re-indexing will replace it. Continue? [y/N] ",
+                            stored.display()
+                        );
+                        io::stderr().flush()?;
+                        let mut answer = String::new();
+                        io::stdin().lock().read_line(&mut answer)?;
+                        if !answer.trim().eq_ignore_ascii_case("y") {
+                            println!("Aborted.");
+                            return Ok(());
+                        }
+                    }
+                }
+            }
+
+            let result = indexer::run_index(&vault_path, &cfg, rebuild)?;
+
+            println!(
+                "Indexed {} new, {} updated, {} deleted files ({} chunks) in {:.1}s",
+                result.new_files,
+                result.updated_files,
+                result.deleted_files,
+                result.total_chunks,
+                result.duration.as_secs_f64(),
+            );
         }
+
         Command::Search { query, top_n } => {
             cfg.merge_top_n(top_n);
-            println!("Would search: \"{query}\" (top_n={})", cfg.top_n);
+
+            if !index_exists(&data_dir) {
+                eprintln!("No index found. Run 'engraph index <path>' first.");
+                std::process::exit(1);
+            }
+
+            search::run_search(&query, cfg.top_n, cli.json, &data_dir)?;
         }
+
         Command::Status => {
-            let json_flag = cli.json;
-            println!("Would show status (json={json_flag})");
+            if !index_exists(&data_dir) {
+                eprintln!("No index found. Run 'engraph index <path>' first.");
+                std::process::exit(1);
+            }
+
+            search::run_status(cli.json, &data_dir)?;
         }
+
         Command::Clear { all } => {
-            println!("Would clear cache (all={all})");
+            if all {
+                // Delete entire ~/.engraph/ directory.
+                if remove_dir_if_exists(&data_dir)? {
+                    println!("Removed {}", data_dir.display());
+                } else {
+                    println!("Nothing to clear (data directory does not exist).");
+                }
+            } else {
+                // Delete only index files: engraph.db and hnsw directory.
+                let mut deleted_any = false;
+
+                let db_path = data_dir.join("engraph.db");
+                if remove_if_exists(&db_path)? {
+                    println!("Removed {}", db_path.display());
+                    deleted_any = true;
+                }
+
+                let hnsw_dir = data_dir.join("hnsw");
+                if remove_dir_if_exists(&hnsw_dir)? {
+                    println!("Removed {}", hnsw_dir.display());
+                    deleted_any = true;
+                }
+
+                if !deleted_any {
+                    println!("Nothing to clear (no index files found).");
+                }
+            }
         }
     }
 

src/search.rs

@@ -23,7 +23,7 @@ pub fn run_search(query: &str, top_n: usize, json: bool, data_dir: &Path) -> Res
     let hnsw_dir = data_dir.join("hnsw");
     let index = HnswIndex::load(&hnsw_dir).context("loading HNSW index")?;
 
-    let db_path = data_dir.join("store.db");
+    let db_path = data_dir.join("engraph.db");
     let store = Store::open(&db_path).context("opening store")?;
 
     let query_vec = embedder.embed_one(query).context("embedding query")?;
@@ -64,7 +64,7 @@ pub fn run_search(query: &str, top_n: usize, json: bool, data_dir: &Path) -> Res
 
 /// Run the status command and print index information.
 pub fn run_status(json: bool, data_dir: &Path) -> Result<()> {
-    let db_path = data_dir.join("store.db");
+    let db_path = data_dir.join("engraph.db");
     let store = Store::open(&db_path).context("opening store")?;
     let stats = store.stats()?;