Add chat history search + vault sync

Author: Snehal-Reddy

src/lib.rs

@@ -7,6 +7,7 @@ pub mod heartbeat;
 pub mod llm;
 pub mod memory;
 pub mod skills;
+pub mod sync;
 pub mod telegram;
 pub mod tools;
 pub mod workspace;

src/main.rs

@@ -16,7 +16,8 @@ use icrab::heartbeat;
 use icrab::llm::HttpProvider;
 use icrab::memory::db::BrainDb;
 use icrab::memory::indexer::VaultIndexer;
-use icrab::tools::SearchVaultTool;
+use icrab::sync;
+use icrab::tools::{GitSyncTool, GrepDirTool, SearchChatTool, SearchVaultTool};
 use icrab::telegram::{self, OutboundMsg};
 use icrab::tools;
 use icrab::tools::cron::{CronStore, CronTool};
@@ -84,10 +85,23 @@ async fn main() {
         });
     }
 
-    // Build subagent registry (core + search — no spawn, no cron).
+    // Background git pull + re-index loop (every 15 min).
+    sync::spawn_git_pull_loop(
+        workspace.clone(),
+        Arc::clone(&db),
+        sync::DEFAULT_PULL_INTERVAL_SECS,
+    );
+    eprintln!(
+        "background git pull loop started (interval: {}h)",
+        sync::DEFAULT_PULL_INTERVAL_SECS / 3600
+    );
+
+    // Build subagent registry (core + search tools — no spawn, no cron).
     let subagent_registry = Arc::new({
         let reg = tools::build_core_registry(&cfg);
         reg.register(SearchVaultTool::new(Arc::clone(&db)));
+        reg.register(SearchChatTool::new(Arc::clone(&db)));
+        reg.register(GrepDirTool);
         reg
     });
 
@@ -101,9 +115,12 @@ async fn main() {
         SUBAGENT_MAX_ITERATIONS,
     ));
 
-    // Main registry: core + search + spawn + cron (cron is main-agent-only).
+    // Main registry: core + search + git + grep + spawn + cron.
     let registry = tools::build_core_registry(&cfg);
     registry.register(SearchVaultTool::new(Arc::clone(&db)));
+    registry.register(SearchChatTool::new(Arc::clone(&db)));
+    registry.register(GrepDirTool);
+    registry.register(GitSyncTool);
     registry.register(SpawnTool::new(Arc::clone(&manager)));
     registry.register(SubagentTool::new(Arc::clone(&manager)));
 

src/memory/db.rs

@@ -111,6 +111,32 @@ impl BrainDb {
                 summary TEXT NOT NULL DEFAULT ''
             );
 
+            -- ── Chat FTS5 ──────────────────────────────────────────────────────────
+            CREATE VIRTUAL TABLE IF NOT EXISTS chat_fts USING fts5(
+                content,
+                content=chat_history,
+                content_rowid=id
+            );
+
+            -- Triggers: keep chat_fts in sync with chat_history
+            CREATE TRIGGER IF NOT EXISTS chat_history_ai
+                AFTER INSERT ON chat_history BEGIN
+                    INSERT INTO chat_fts(rowid, content)
+                    VALUES (new.id, new.content);
+                END;
+            CREATE TRIGGER IF NOT EXISTS chat_history_ad
+                AFTER DELETE ON chat_history BEGIN
+                    INSERT INTO chat_fts(chat_fts, rowid, content)
+                    VALUES ('delete', old.id, old.content);
+                END;
+            CREATE TRIGGER IF NOT EXISTS chat_history_au
+                AFTER UPDATE ON chat_history BEGIN
+                    INSERT INTO chat_fts(chat_fts, rowid, content)
+                    VALUES ('delete', old.id, old.content);
+                    INSERT INTO chat_fts(rowid, content)
+                    VALUES (new.id, new.content);
+                END;
+
             -- ── Vault index  ──────────────────────────────────────────────────────
             CREATE TABLE IF NOT EXISTS vault_index (
                 filepath      TEXT    PRIMARY KEY,
@@ -410,6 +436,47 @@ impl BrainDb {
         let results: Vec<(String, String)> = rows.collect::<Result<_, _>>()?;
         Ok(results)
     }
+
+    /// BM25-ranked keyword search over `chat_fts`.
+    ///
+    /// Returns at most `limit` triples of `(chat_id, role, snippet)`.
+    pub fn chat_fts_search(
+        &self,
+        fts_query: &str,
+        limit: usize,
+    ) -> Result<Vec<(String, String, String)>, DbError> {
+        if fts_query.trim().is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let conn = self
+            .conn
+            .lock()
+            .map_err(|e| DbError(format!("lock: {e}")))?;
+
+        #[allow(clippy::cast_possible_wrap)]
+        let limit_i64 = limit as i64;
+
+        let mut stmt = conn.prepare(
+            "SELECT h.chat_id, h.role,
+                    snippet(chat_fts, 0, '**', '**', '...', 10) AS snip
+             FROM chat_fts
+             JOIN chat_history h ON h.id = chat_fts.rowid
+             WHERE chat_fts MATCH ?1
+             ORDER BY bm25(chat_fts)
+             LIMIT ?2",
+        )?;
+
+        let rows = stmt.query_map(params![fts_query, limit_i64], |row| {
+            Ok((
+                row.get::<_, String>(0)?,
+                row.get::<_, String>(1)?,
+                row.get::<_, String>(2)?,
+            ))
+        })?;
+
+        rows.collect::<Result<_, _>>().map_err(DbError::from)
+    }
 }
 
 // ---------------------------------------------------------------------------
@@ -854,6 +921,71 @@ mod tests {
         assert_eq!(summary, "日本語サマリー");
     }
 
+    // ── chat_fts: search ─────────────────────────────────────────────────────
+
+    #[test]
+    fn chat_fts_search_finds_saved_message() {
+        let (_tmp, db) = temp_db();
+        db.save_session(
+            "chat1",
+            &[StoredMessage {
+                role: "user".into(),
+                content: "I want to do squats tomorrow".into(),
+                tool_call_id: None,
+                tool_calls: None,
+            }],
+            "",
+        )
+        .unwrap();
+
+        let rows = db.chat_fts_search("squats", 5).unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0].0, "chat1");
+        assert_eq!(rows[0].1, "user");
+        assert!(rows[0].2.contains("squats") || rows[0].2.contains("**"));
+    }
+
+    #[test]
+    fn chat_fts_search_empty_query_returns_empty() {
+        let (_tmp, db) = temp_db();
+        let rows = db.chat_fts_search("   ", 5).unwrap();
+        assert!(rows.is_empty());
+    }
+
+    #[test]
+    fn chat_fts_search_no_match_returns_empty() {
+        let (_tmp, db) = temp_db();
+        db.save_session(
+            "c",
+            &[StoredMessage {
+                role: "user".into(),
+                content: "hello world".into(),
+                tool_call_id: None,
+                tool_calls: None,
+            }],
+            "",
+        )
+        .unwrap();
+        let rows = db.chat_fts_search("squats", 5).unwrap();
+        assert!(rows.is_empty());
+    }
+
+    #[test]
+    fn chat_fts_search_respects_limit() {
+        let (_tmp, db) = temp_db();
+        let messages: Vec<StoredMessage> = (0..10)
+            .map(|i| StoredMessage {
+                role: "user".into(),
+                content: format!("workout session {i} squats reps"),
+                tool_call_id: None,
+                tool_calls: None,
+            })
+            .collect();
+        db.save_session("bulk", &messages, "").unwrap();
+        let rows = db.chat_fts_search("squats", 3).unwrap();
+        assert!(rows.len() <= 3);
+    }
+
     #[test]
     fn message_ordering_preserved() {
         let (_tmp, db) = temp_db();

src/sync.rs

@@ -0,0 +1,61 @@
+//! Background git pull loop: keeps the local Obsidian vault clone in sync
+//! with GitHub and triggers vault re-indexing after each successful pull.
+//!
+//! Chat history (`brain.db`) is strictly local and is never pushed to Git.
+
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+
+use crate::memory::db::BrainDb;
+use crate::memory::indexer::VaultIndexer;
+
+/// Default interval between background pulls (3 hours).
+pub const DEFAULT_PULL_INTERVAL_SECS: u64 = 3 * 60 * 60;
+
+/// Spawn a background task that periodically runs `git pull --rebase origin
+/// main` in `workspace`, then re-scans the vault FTS5 index.
+///
+/// Errors are logged but never fatal — the app keeps running regardless.
+pub fn spawn_git_pull_loop(workspace: PathBuf, db: Arc<BrainDb>, interval_secs: u64) {
+    tokio::spawn(pull_loop(workspace, db, interval_secs));
+}
+
+async fn pull_loop(workspace: PathBuf, db: Arc<BrainDb>, interval_secs: u64) {
+    let indexer = VaultIndexer::new(db);
+    let interval = Duration::from_secs(interval_secs);
+
+    loop {
+        tokio::time::sleep(interval).await;
+
+        let ws = workspace.clone();
+        match tokio::process::Command::new("git")
+            .args(["pull", "--rebase", "origin", "main"])
+            .current_dir(&ws)
+            .output()
+            .await
+        {
+            Ok(out) if out.status.success() => {
+                let stdout = String::from_utf8_lossy(&out.stdout);
+                eprintln!("git pull: ok — {}", stdout.trim());
+
+                // Re-index vault so FTS5 reflects any new notes from PC.
+                let idx = indexer.clone();
+                match tokio::task::spawn_blocking(move || idx.scan(&ws)).await {
+                    Ok(Ok(stats)) => eprintln!("vault re-index: {stats}"),
+                    Ok(Err(e)) => eprintln!("vault re-index warning: {e}"),
+                    Err(e) => eprintln!("vault re-index task error: {e}"),
+                }
+            }
+            Ok(out) => {
+                let stderr = String::from_utf8_lossy(&out.stderr);
+                eprintln!(
+                    "git pull: non-zero exit ({}): {}",
+                    out.status,
+                    stderr.trim()
+                );
+            }
+            Err(e) => eprintln!("git pull: failed to spawn: {e}"),
+        }
+    }
+}

src/tools.rs

@@ -3,15 +3,21 @@
 pub mod context;
 pub mod cron;
 pub mod file;
+pub mod git;
+pub mod grep_dir;
 pub mod message;
 pub mod registry;
 pub mod result;
 pub mod search;
+pub mod search_chat;
 pub mod spawn;
 pub mod subagent;
 pub mod web;
 
 pub use context::ToolCtx;
+pub use git::GitSyncTool;
+pub use grep_dir::GrepDirTool;
 pub use registry::{Tool, ToolRegistry, build_core_registry, build_default_registry, tool_to_def};
 pub use result::ToolResult;
 pub use search::SearchVaultTool;
+pub use search_chat::SearchChatTool;