feat: engraph graph CLI — show connections and stats

'engraph graph show <file>' displays outgoing/incoming wikilinks
and mentions. Supports file path, basename, or #docid resolution.
'engraph graph stats' shows vault graph overview.
Status output now includes edge counts.

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

Author: devwhodevs

src/main.rs

@@ -81,6 +81,23 @@ enum Command {
         #[command(subcommand)]
         action: ModelsAction,
     },
+
+    /// Inspect vault graph connections.
+    Graph {
+        #[command(subcommand)]
+        action: GraphAction,
+    },
+}
+
+#[derive(Subcommand, Debug)]
+enum GraphAction {
+    /// Show connections for a note.
+    Show {
+        /// File path or #docid.
+        file: String,
+    },
+    /// Show vault graph statistics.
+    Stats,
 }
 
 #[derive(Subcommand, Debug)]
@@ -316,6 +333,133 @@ fn main() -> Result<()> {
             );
         }
 
+        Command::Graph { action } => {
+            if !index_exists(&data_dir) {
+                eprintln!("No index found. Run 'engraph index <path>' first.");
+                std::process::exit(1);
+            }
+            let db_path = data_dir.join("engraph.db");
+            let store = store::Store::open(&db_path)?;
+
+            match action {
+                GraphAction::Show { file } => {
+                    // Resolve: docid first, then exact path, then basename
+                    let record = if file.starts_with('#') && file.len() == 7 {
+                        store.get_file_by_docid(&file[1..])?
+                    } else if let Some(f) = store.get_file(&file)? {
+                        Some(f)
+                    } else {
+                        // Basename match (case-insensitive)
+                        let target = if file.ends_with(".md") {
+                            file.clone()
+                        } else {
+                            format!("{}.md", file)
+                        };
+                        let all = store.get_all_files()?;
+                        let target_lower = target.to_lowercase();
+                        all.into_iter().find(|f| {
+                            let path_lower = f.path.to_lowercase();
+                            path_lower == target_lower
+                                || path_lower.ends_with(&format!("/{}", target_lower))
+                        })
+                    };
+
+                    let record = match record {
+                        Some(r) => r,
+                        None => {
+                            eprintln!("File not found: {file}");
+                            std::process::exit(1);
+                        }
+                    };
+
+                    let docid_str = record
+                        .docid
+                        .as_deref()
+                        .map(|d| format!(" (#{d})"))
+                        .unwrap_or_default();
+                    println!("{}{}\n", record.path, docid_str);
+
+                    let outgoing_wl = store.get_outgoing(record.id, Some("wikilink"))?;
+                    println!("Outgoing wikilinks ({}):", outgoing_wl.len());
+                    for (fid, _) in &outgoing_wl {
+                        if let Some(f) = store.get_file_by_id(*fid)? {
+                            let did = f
+                                .docid
+                                .as_deref()
+                                .map(|d| format!(" (#{d})"))
+                                .unwrap_or_default();
+                            println!("  → {}{}", f.path, did);
+                        }
+                    }
+
+                    println!();
+                    let incoming_wl = store.get_incoming(record.id, Some("wikilink"))?;
+                    println!("Incoming wikilinks ({}):", incoming_wl.len());
+                    for (fid, _) in &incoming_wl {
+                        if let Some(f) = store.get_file_by_id(*fid)? {
+                            let did = f
+                                .docid
+                                .as_deref()
+                                .map(|d| format!(" (#{d})"))
+                                .unwrap_or_default();
+                            println!("  ← {}{}", f.path, did);
+                        }
+                    }
+
+                    println!();
+                    let mentions_out = store.get_outgoing(record.id, Some("mention"))?;
+                    let mentions_in = store.get_incoming(record.id, Some("mention"))?;
+                    println!("Mentions out ({}):", mentions_out.len());
+                    for (fid, _) in &mentions_out {
+                        if let Some(f) = store.get_file_by_id(*fid)? {
+                            let did = f
+                                .docid
+                                .as_deref()
+                                .map(|d| format!(" (#{d})"))
+                                .unwrap_or_default();
+                            println!("  → {}{}", f.path, did);
+                        }
+                    }
+                    if !mentions_in.is_empty() {
+                        println!("Mentioned by ({}):", mentions_in.len());
+                        for (fid, _) in &mentions_in {
+                            if let Some(f) = store.get_file_by_id(*fid)? {
+                                let did = f
+                                    .docid
+                                    .as_deref()
+                                    .map(|d| format!(" (#{d})"))
+                                    .unwrap_or_default();
+                                println!("  ← {}{}", f.path, did);
+                            }
+                        }
+                    }
+                }
+
+                GraphAction::Stats => {
+                    let stats = store.get_edge_stats()?;
+                    println!("Vault Graph:");
+                    println!(
+                        "  Wikilink edges: {} ({} bidirectional pairs)",
+                        stats.wikilink_count,
+                        stats.wikilink_count / 2
+                    );
+                    println!("  Mention edges:  {}", stats.mention_count);
+                    println!("  Total edges:    {}", stats.total_edges);
+                    let total_files = stats.connected_file_count + stats.isolated_file_count;
+                    let pct = if total_files > 0 {
+                        stats.connected_file_count as f64 / total_files as f64 * 100.0
+                    } else {
+                        0.0
+                    };
+                    println!(
+                        "  Connected files: {} / {} ({:.1}%)",
+                        stats.connected_file_count, total_files, pct
+                    );
+                    println!("  Isolated files:  {}", stats.isolated_file_count);
+                }
+            }
+        }
+
         Command::Models { action } => {
             let registry = model::ModelRegistry::default();
             match action {

src/search.rs

@@ -263,7 +263,7 @@ pub fn format_status(stats: &StoreStats, index_size: u64, model_name: &str, json
     let last_indexed = stats.last_indexed_at.as_deref().unwrap_or("never");
 
     if json {
-        let obj = json!({
+        let mut obj = json!({
             "vault": vault,
             "files": stats.file_count,
             "chunks": stats.chunk_count,
@@ -272,24 +272,40 @@ pub fn format_status(stats: &StoreStats, index_size: u64, model_name: &str, json
             "index_size": index_size,
             "model": model_name,
         });
+        if let (Some(edges), Some(wl), Some(mn)) =
+            (stats.edge_count, stats.wikilink_count, stats.mention_count)
+        {
+            obj["edges"] = json!(edges);
+            obj["wikilink_edges"] = json!(wl);
+            obj["mention_edges"] = json!(mn);
+        }
         format!("{}\n", serde_json::to_string_pretty(&obj).unwrap())
     } else {
-        format!(
+        let mut out = format!(
             "Vault:      {}\n\
              Files:      {}\n\
-             Chunks:     {}\n\
-             Tombstones: {} (pending cleanup)\n\
+             Chunks:     {}\n",
+            vault, stats.file_count, stats.chunk_count,
+        );
+        if let (Some(edges), Some(wl), Some(mn)) =
+            (stats.edge_count, stats.wikilink_count, stats.mention_count)
+        {
+            out.push_str(&format!(
+                "Edges:      {} ({} wikilinks, {} mentions)\n",
+                edges, wl, mn
+            ));
+        }
+        out.push_str(&format!(
+            "Tombstones: {} (pending cleanup)\n\
              Last index: {}\n\
              Index size: {}\n\
              Model:      {}\n",
-            vault,
-            stats.file_count,
-            stats.chunk_count,
             stats.tombstone_count,
             last_indexed,
             format_bytes(index_size),
             model_name,
-        )
+        ));
+        out
     }
 }
 
@@ -412,6 +428,9 @@ mod tests {
             tombstone_count: 3,
             last_indexed_at: Some("2026-03-19 14:30:00".to_string()),
             vault_path: Some("/path/to/vault".to_string()),
+            edge_count: None,
+            wikilink_count: None,
+            mention_count: None,
         };
         let output = format_status(&stats, 2_516_582, "all-MiniLM-L6-v2", false);
 
@@ -432,6 +451,9 @@ mod tests {
             tombstone_count: 3,
             last_indexed_at: Some("2026-03-19 14:30:00".to_string()),
             vault_path: Some("/path/to/vault".to_string()),
+            edge_count: None,
+            wikilink_count: None,
+            mention_count: None,
         };
         let output = format_status(&stats, 2_516_582, "all-MiniLM-L6-v2", true);
         let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();

src/store.rs

@@ -53,6 +53,9 @@ pub struct StoreStats {
     pub tombstone_count: usize,
     pub last_indexed_at: Option<String>,
     pub vault_path: Option<String>,
+    pub edge_count: Option<usize>,
+    pub wikilink_count: Option<usize>,
+    pub mention_count: Option<usize>,
 }
 
 const SCHEMA: &str = r#"
@@ -520,12 +523,23 @@ impl Store {
         let tombstone_count = self.tombstone_count()?;
         let last_indexed_at = self.get_meta("last_indexed_at")?;
         let vault_path = self.get_meta("vault_path")?;
+        let (edge_count, wikilink_count, mention_count) = match self.get_edge_stats() {
+            Ok(es) => (
+                Some(es.total_edges),
+                Some(es.wikilink_count),
+                Some(es.mention_count),
+            ),
+            Err(_) => (None, None, None),
+        };
         Ok(StoreStats {
             file_count: file_count as usize,
             chunk_count: chunk_count as usize,
             tombstone_count,
             last_indexed_at,
             vault_path,
+            edge_count,
+            wikilink_count,
+            mention_count,
         })
     }