feat: implement agent-scoped knowledge base and context-specific search (#2647)

Author: kensave

crates/chat-cli/src/cli/chat/cli/knowledge.rs

@@ -8,7 +8,6 @@ use crossterm::style::{
 };
 use eyre::Result;
 use semantic_search_client::{
-    KnowledgeContext,
     OperationStatus,
     SystemStatus,
 };
@@ -103,6 +102,11 @@ impl KnowledgeSubcommand {
         }
     }
 
+    /// Get the current agent from the session
+    fn get_agent(session: &ChatSession) -> Option<&crate::cli::Agent> {
+        session.conversation.agents.get_active()
+    }
+
     async fn execute_operation(&self, os: &Os, session: &mut ChatSession) -> OperationResult {
         match self {
             KnowledgeSubcommand::Show => {
@@ -116,127 +120,105 @@ impl KnowledgeSubcommand {
                 include,
                 exclude,
                 index_type,
-            } => Self::handle_add(os, path, include, exclude, index_type).await,
-            KnowledgeSubcommand::Remove { path } => Self::handle_remove(os, path).await,
-            KnowledgeSubcommand::Update { path } => Self::handle_update(os, path).await,
+            } => Self::handle_add(os, session, path, include, exclude, index_type).await,
+            KnowledgeSubcommand::Remove { path } => Self::handle_remove(os, session, path).await,
+            KnowledgeSubcommand::Update { path } => Self::handle_update(os, session, path).await,
             KnowledgeSubcommand::Clear => Self::handle_clear(os, session).await,
-            KnowledgeSubcommand::Status => Self::handle_status(os).await,
-            KnowledgeSubcommand::Cancel { operation_id } => Self::handle_cancel(os, operation_id.as_deref()).await,
+            KnowledgeSubcommand::Status => Self::handle_status(os, session).await,
+            KnowledgeSubcommand::Cancel { operation_id } => {
+                Self::handle_cancel(os, session, operation_id.as_deref()).await
+            },
         }
     }
 
     async fn handle_show(os: &Os, session: &mut ChatSession) -> Result<(), std::io::Error> {
-        match KnowledgeStore::get_async_instance_with_os(os).await {
-            Ok(store) => {
-                let store = store.lock().await;
-                let entries = store.get_all().await.unwrap_or_else(|e| {
-                    let _ = queue!(
-                        session.stderr,
-                        style::SetForegroundColor(Color::Red),
-                        style::Print(&format!("Error getting knowledge base entries: {}\n", e)),
-                        style::ResetColor
-                    );
-                    Vec::new()
-                });
-                let _ = Self::format_knowledge_entries(session, &entries);
-            },
-            Err(e) => {
-                queue!(
-                    session.stderr,
-                    style::SetForegroundColor(Color::Red),
-                    style::Print(&format!("Error accessing knowledge base: {}\n", e)),
-                    style::SetForegroundColor(Color::Reset)
-                )?;
-            },
-        }
-        Ok(())
-    }
+        let agent_name = Self::get_agent(session).map(|a| a.name.clone());
 
-    fn format_knowledge_entries(
-        session: &mut ChatSession,
-        knowledge_entries: &[KnowledgeContext],
-    ) -> Result<(), std::io::Error> {
-        if knowledge_entries.is_empty() {
-            queue!(
-                session.stderr,
-                style::Print("\nNo knowledge base entries found.\n"),
-                style::Print("💡 Tip: If indexing is in progress, entries may not appear until indexing completes.\n"),
-                style::Print("   Use 'knowledge status' to check active operations.\n\n")
-            )?;
-        } else {
+        // Show agent-specific knowledge
+        if let Some(agent) = agent_name {
             queue!(
                 session.stderr,
-                style::Print("\n📚 Knowledge Base Entries:\n"),
-                style::Print(format!("{}\n", "━".repeat(80)))
+                style::SetAttribute(crossterm::style::Attribute::Bold),
+                style::SetForegroundColor(Color::Magenta),
+                style::Print(format!("👤 Agent ({}):\n", agent)),
+                style::SetAttribute(crossterm::style::Attribute::Reset),
             )?;
 
-            for entry in knowledge_entries {
-                Self::format_single_entry(session, &entry)?;
-                queue!(session.stderr, style::Print(format!("{}\n", "━".repeat(80))))?;
+            match KnowledgeStore::get_async_instance(os, Self::get_agent(session)).await {
+                Ok(store) => {
+                    let store = store.lock().await;
+                    let contexts = store.get_all().await.unwrap_or_default();
+
+                    if contexts.is_empty() {
+                        queue!(
+                            session.stderr,
+                            style::SetForegroundColor(Color::DarkGrey),
+                            style::Print("    <none>\n\n"),
+                            style::SetForegroundColor(Color::Reset)
+                        )?;
+                    } else {
+                        Self::format_knowledge_entries_with_indent(session, &contexts, "    ")?;
+                    }
+                },
+                Err(_) => {
+                    queue!(
+                        session.stderr,
+                        style::SetForegroundColor(Color::DarkGrey),
+                        style::Print("    <none>\n\n"),
+                        style::SetForegroundColor(Color::Reset)
+                    )?;
+                },
             }
-            // Add final newline to match original formatting exactly
-            queue!(session.stderr, style::Print("\n"))?;
         }
+
         Ok(())
     }
 
-    fn format_single_entry(session: &mut ChatSession, entry: &&KnowledgeContext) -> Result<(), std::io::Error> {
-        queue!(
-            session.stderr,
-            style::SetAttribute(style::Attribute::Bold),
-            style::SetForegroundColor(Color::Cyan),
-            style::Print(format!("📂 {}: ", entry.id)),
-            style::SetForegroundColor(Color::Green),
-            style::Print(&entry.name),
-            style::SetAttribute(style::Attribute::Reset),
-            style::Print("\n")
-        )?;
-
-        queue!(
-            session.stderr,
-            style::Print(format!("   Description: {}\n", entry.description)),
-            style::Print(format!(
-                "   Created: {}\n",
-                entry.created_at.format("%Y-%m-%d %H:%M:%S")
-            )),
-            style::Print(format!(
-                "   Updated: {}\n",
-                entry.updated_at.format("%Y-%m-%d %H:%M:%S")
-            ))
-        )?;
-
-        if let Some(path) = &entry.source_path {
-            queue!(session.stderr, style::Print(format!("   Source: {}\n", path)))?;
-        }
-
-        queue!(
-            session.stderr,
-            style::Print("   Items: "),
-            style::SetForegroundColor(Color::Yellow),
-            style::Print(entry.item_count.to_string()),
-            style::SetForegroundColor(Color::Reset),
-            style::Print(" | Index Type: "),
-            style::SetForegroundColor(Color::Magenta),
-            style::Print(entry.embedding_type.description().to_string()),
-            style::SetForegroundColor(Color::Reset),
-            style::Print(" | Persistent: ")
-        )?;
-
-        if entry.persistent {
+    fn format_knowledge_entries_with_indent(
+        session: &mut ChatSession,
+        contexts: &[semantic_search_client::KnowledgeContext],
+        indent: &str,
+    ) -> Result<(), std::io::Error> {
+        for ctx in contexts {
+            // Main entry line with name and ID
             queue!(
                 session.stderr,
+                style::Print(format!("{}📂 ", indent)),
+                style::SetAttribute(style::Attribute::Bold),
+                style::SetForegroundColor(Color::Grey),
+                style::Print(&ctx.name),
                 style::SetForegroundColor(Color::Green),
-                style::Print("Yes"),
+                style::Print(format!(" ({})", &ctx.id[..8])),
+                style::SetAttribute(style::Attribute::Reset),
                 style::SetForegroundColor(Color::Reset),
                 style::Print("\n")
             )?;
-        } else {
+
+            // Description line with original description
             queue!(
                 session.stderr,
-                style::SetForegroundColor(Color::Yellow),
-                style::Print("No"),
+                style::Print(format!("{}   ", indent)),
+                style::SetForegroundColor(Color::Grey),
+                style::Print(format!("{}\n", ctx.description)),
+                style::SetForegroundColor(Color::Reset)
+            )?;
+
+            // Stats line with improved colors
+            queue!(
+                session.stderr,
+                style::Print(format!("{}   ", indent)),
+                style::SetForegroundColor(Color::Green),
+                style::Print(format!("{} items", ctx.item_count)),
+                style::SetForegroundColor(Color::DarkGrey),
+                style::Print(" • "),
+                style::SetForegroundColor(Color::Blue),
+                style::Print(ctx.embedding_type.description()),
+                style::SetForegroundColor(Color::DarkGrey),
+                style::Print(" • "),
+                style::SetForegroundColor(Color::DarkGrey),
+                style::Print(format!("{}", ctx.updated_at.format("%m/%d %H:%M"))),
                 style::SetForegroundColor(Color::Reset),
-                style::Print("\n")
+                style::Print("\n\n")
             )?;
         }
         Ok(())
@@ -254,14 +236,17 @@ impl KnowledgeSubcommand {
 
     async fn handle_add(
         os: &Os,
+        session: &mut ChatSession,
         path: &str,
         include_patterns: &[String],
         exclude_patterns: &[String],
         index_type: &Option<String>,
     ) -> OperationResult {
         match Self::validate_and_sanitize_path(os, path) {
             Ok(sanitized_path) => {
-                let async_knowledge_store = match KnowledgeStore::get_async_instance_with_os(os).await {
+                let agent = Self::get_agent(session);
+
+                let async_knowledge_store = match KnowledgeStore::get_async_instance(os, agent).await {
                     Ok(store) => store,
                     Err(e) => return OperationResult::Error(format!("Error accessing knowledge base: {}", e)),
                 };
@@ -307,30 +292,40 @@ impl KnowledgeSubcommand {
     }
 
     /// Handle remove operation
-    async fn handle_remove(os: &Os, path: &str) -> OperationResult {
+    async fn handle_remove(os: &Os, session: &ChatSession, path: &str) -> OperationResult {
         let sanitized_path = sanitize_path_tool_arg(os, path);
+        let agent = Self::get_agent(session);
 
-        let async_knowledge_store = match KnowledgeStore::get_async_instance_with_os(os).await {
+        let async_knowledge_store = match KnowledgeStore::get_async_instance(os, agent).await {
             Ok(store) => store,
             Err(e) => return OperationResult::Error(format!("Error accessing knowledge base: {}", e)),
         };
         let mut store = async_knowledge_store.lock().await;
 
+        let scope_desc = "agent";
+
         // Try path first, then name
         if store.remove_by_path(&sanitized_path.to_string_lossy()).await.is_ok() {
-            OperationResult::Success(format!("Removed knowledge base entry with path '{}'", path))
+            OperationResult::Success(format!(
+                "Removed {} knowledge base entry with path '{}'",
+                scope_desc, path
+            ))
         } else if store.remove_by_name(path).await.is_ok() {
-            OperationResult::Success(format!("Removed knowledge base entry with name '{}'", path))
+            OperationResult::Success(format!(
+                "Removed {} knowledge base entry with name '{}'",
+                scope_desc, path
+            ))
         } else {
-            OperationResult::Warning(format!("Entry not found in knowledge base: {}", path))
+            OperationResult::Warning(format!("Entry not found in {} knowledge base: {}", scope_desc, path))
         }
     }
 
     /// Handle update operation
-    async fn handle_update(os: &Os, path: &str) -> OperationResult {
+    async fn handle_update(os: &Os, session: &ChatSession, path: &str) -> OperationResult {
         match Self::validate_and_sanitize_path(os, path) {
             Ok(sanitized_path) => {
-                let async_knowledge_store = match KnowledgeStore::get_async_instance_with_os(os).await {
+                let agent = Self::get_agent(session);
+                let async_knowledge_store = match KnowledgeStore::get_async_instance(os, agent).await {
                     Ok(store) => store,
                     Err(e) => {
                         return OperationResult::Error(format!("Error accessing knowledge base directory: {}", e));
@@ -368,7 +363,8 @@ impl KnowledgeSubcommand {
             return OperationResult::Info("Clear operation cancelled".to_string());
         }
 
-        let async_knowledge_store = match KnowledgeStore::get_async_instance_with_os(os).await {
+        let agent = Self::get_agent(session);
+        let async_knowledge_store = match KnowledgeStore::get_async_instance(os, agent).await {
             Ok(store) => store,
             Err(e) => return OperationResult::Error(format!("Error accessing knowledge base directory: {}", e)),
         };
@@ -401,8 +397,9 @@ impl KnowledgeSubcommand {
     }
 
     /// Handle status operation
-    async fn handle_status(os: &Os) -> OperationResult {
-        let async_knowledge_store = match KnowledgeStore::get_async_instance_with_os(os).await {
+    async fn handle_status(os: &Os, session: &ChatSession) -> OperationResult {
+        let agent = Self::get_agent(session);
+        let async_knowledge_store = match KnowledgeStore::get_async_instance(os, agent).await {
             Ok(store) => store,
             Err(e) => return OperationResult::Error(format!("Error accessing knowledge base directory: {}", e)),
         };
@@ -512,8 +509,9 @@ impl KnowledgeSubcommand {
     }
 
     /// Handle cancel operation
-    async fn handle_cancel(os: &Os, operation_id: Option<&str>) -> OperationResult {
-        let async_knowledge_store = match KnowledgeStore::get_async_instance_with_os(os).await {
+    async fn handle_cancel(os: &Os, session: &ChatSession, operation_id: Option<&str>) -> OperationResult {
+        let agent = Self::get_agent(session);
+        let async_knowledge_store = match KnowledgeStore::get_async_instance(os, agent).await {
             Ok(store) => store,
             Err(e) => return OperationResult::Error(format!("Error accessing knowledge base directory: {}", e)),
         };

crates/chat-cli/src/cli/chat/mod.rs

@@ -1950,7 +1950,12 @@ impl ChatSession {
 
             let invoke_result = tool
                 .tool
-                .invoke(os, &mut self.stdout, &mut self.conversation.file_line_tracker)
+                .invoke(
+                    os,
+                    &mut self.stdout,
+                    &mut self.conversation.file_line_tracker,
+                    self.conversation.agents.get_active(),
+                )
                 .await;
 
             if self.spinner.is_some() {

crates/chat-cli/src/cli/chat/tools/knowledge.rs

@@ -312,9 +312,13 @@ impl Knowledge {
         Ok(())
     }
 
-    pub async fn invoke(&self, os: &Os, _updates: &mut impl Write) -> Result<InvokeOutput> {
-        // Get the async knowledge store singleton with OS-aware directory
-        let async_knowledge_store = KnowledgeStore::get_async_instance_with_os(os)
+    pub async fn invoke(
+        &self,
+        os: &Os,
+        _updates: &mut impl Write,
+        agent: Option<&crate::cli::Agent>,
+    ) -> Result<InvokeOutput> {
+        let async_knowledge_store = KnowledgeStore::get_async_instance(os, agent)
             .await
             .map_err(|e| eyre::eyre!("Failed to access knowledge base: {}", e))?;
         let mut store = async_knowledge_store.lock().await;

crates/chat-cli/src/cli/chat/tools/mod.rs

@@ -120,6 +120,7 @@ impl Tool {
         os: &Os,
         stdout: &mut impl Write,
         line_tracker: &mut HashMap<String, FileLineTracker>,
+        agent: Option<&crate::cli::agent::Agent>,
     ) -> Result<InvokeOutput> {
         match self {
             Tool::FsRead(fs_read) => fs_read.invoke(os, stdout).await,
@@ -128,7 +129,7 @@ impl Tool {
             Tool::UseAws(use_aws) => use_aws.invoke(os, stdout).await,
             Tool::Custom(custom_tool) => custom_tool.invoke(os, stdout).await,
             Tool::GhIssue(gh_issue) => gh_issue.invoke(os, stdout).await,
-            Tool::Knowledge(knowledge) => knowledge.invoke(os, stdout).await,
+            Tool::Knowledge(knowledge) => knowledge.invoke(os, stdout, agent).await,
             Tool::Thinking(think) => think.invoke(stdout).await,
         }
     }

crates/chat-cli/src/cli/mod.rs

@@ -16,6 +16,10 @@ use std::io::{
 use std::process::ExitCode;
 
 use agent::AgentArgs;
+pub use agent::{
+    Agent,
+    DEFAULT_AGENT_NAME,
+};
 use anstream::println;
 pub use chat::ConversationState;
 use clap::{