Add /resource command with indexed/pinned storage types

- Create new ResourceSubcommand with --type flag (indexed/pinned)
- Default to pinned storage for backward compatibility
- Preserve /context command unchanged for existing workflows
- Support show/add/remove/clear/status operations
- Case insensitive storage type values

Author: kennvene-aws

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

@@ -9,6 +9,7 @@ pub mod model;
 pub mod persist;
 pub mod profile;
 pub mod prompts;
+pub mod resource;
 pub mod subscribe;
 pub mod tools;
 pub mod unified_context;

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

@@ -0,0 +1,104 @@
+use clap::{Subcommand, ValueEnum};
+use eyre::Result;
+
+use crate::cli::chat::{ChatError, ChatSession, ChatState};
+use crate::os::Os;
+
+use super::context::ContextSubcommand as OriginalContextSubcommand;
+use super::knowledge::KnowledgeSubcommand;
+
+#[derive(Clone, Debug, PartialEq, Eq, ValueEnum)]
+pub enum StorageType {
+    Indexed,
+    Pinned,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Subcommand)]
+pub enum ResourceSubcommand {
+    Show {
+        #[arg(long)]
+        expand: bool,
+        #[arg(long, value_enum, ignore_case = true)]
+        r#type: Option<StorageType>,
+    },
+    Add {
+        #[arg(short, long)]
+        force: bool,
+        #[arg(long, value_enum, ignore_case = true)]
+        r#type: Option<StorageType>,
+        #[arg(required = true)]
+        paths: Vec<String>,
+    },
+    #[command(alias = "rm")]
+    Remove {
+        #[arg(required = true)]
+        paths: Vec<String>,
+    },
+    Clear {
+        #[arg(long, value_enum, ignore_case = true)]
+        r#type: Option<StorageType>,
+    },
+    Status,
+}
+
+impl ResourceSubcommand {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Self::Show { .. } => "show",
+            Self::Add { .. } => "add",
+            Self::Remove { .. } => "remove",
+            Self::Clear { .. } => "clear",
+            Self::Status => "status",
+        }
+    }
+
+    pub async fn execute(self, os: &Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
+        match self {
+            Self::Show { expand, r#type } => {
+                match r#type {
+                    Some(StorageType::Indexed) => KnowledgeSubcommand::Show.execute(os, session).await,
+                    Some(StorageType::Pinned) => OriginalContextSubcommand::Show { expand }.execute(os, session).await,
+                    None => {
+                        OriginalContextSubcommand::Show { expand }.execute(os, session).await?;
+                        KnowledgeSubcommand::Show.execute(os, session).await
+                    }
+                }
+            },
+            Self::Add { force, r#type, paths } => {
+                match r#type.unwrap_or(StorageType::Pinned) {
+                    StorageType::Indexed => {
+                        KnowledgeSubcommand::Add { 
+                            path: paths.join(" "), 
+                            include: vec![], 
+                            exclude: vec![], 
+                            index_type: None 
+                        }.execute(os, session).await
+                    },
+                    StorageType::Pinned => {
+                        OriginalContextSubcommand::Add { paths, force }.execute(os, session).await
+                    },
+                }
+            },
+            Self::Remove { paths } => {
+                let _ = OriginalContextSubcommand::Remove { paths: paths.clone() }.execute(os, session).await;
+                // Remove first path from knowledge (knowledge only supports single path)
+                if let Some(first_path) = paths.first() {
+                    KnowledgeSubcommand::Remove { path: first_path.clone() }.execute(os, session).await
+                } else {
+                    Ok(ChatState::PromptUser { skip_printing_tools: true })
+                }
+            },
+            Self::Clear { r#type } => {
+                match r#type {
+                    Some(StorageType::Indexed) => KnowledgeSubcommand::Clear.execute(os, session).await,
+                    Some(StorageType::Pinned) => OriginalContextSubcommand::Clear.execute(os, session).await,
+                    None => {
+                        OriginalContextSubcommand::Clear.execute(os, session).await?;
+                        KnowledgeSubcommand::Clear.execute(os, session).await
+                    }
+                }
+            },
+            Self::Status => KnowledgeSubcommand::Status.execute(os, session).await,
+        }
+    }
+}

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

@@ -20,6 +20,7 @@ use super::model::ModelArgs;
 use super::persist::PersistSubcommand;
 use super::prompts::PromptsArgs;
 use super::subscribe::SubscribeArgs;
+use super::resource::ResourceSubcommand;
 use super::tools::ToolsArgs;
 use super::unified_context::UnifiedContextSubcommand;
 use super::usage::UsageArgs;
@@ -44,6 +45,9 @@ pub enum UnifiedSlashCommand {
     /// Manage context files and knowledge base (unified interface)
     #[command(subcommand)]
     Context(UnifiedContextSubcommand),
+    /// Manage resources (pinned and indexed)
+    #[command(subcommand)]
+    Resource(ResourceSubcommand),
     /// (Deprecated) Use /context instead - Legacy knowledge base management
     #[command(subcommand, hide = true)]
     Knowledge(KnowledgeSubcommand),
@@ -102,6 +106,10 @@ impl UnifiedSlashCommand {
                 // Use the new unified context system
                 subcommand.execute(os, session).await
             },
+            Self::Resource(subcommand) => {
+                // Use the new resource system
+                subcommand.execute(os, session).await
+            },
             Self::Knowledge(subcommand) => {
                 // Show deprecation warning and redirect to unified context
                 use crossterm::{queue, style};
@@ -141,6 +149,7 @@ impl UnifiedSlashCommand {
             Self::Agent(_) => "agent",
             Self::Profile => "profile",
             Self::Context(_) => "context",
+            Self::Resource(_) => "resource",
             Self::Knowledge(_) => "knowledge",
             Self::PromptEditor(_) => "editor",
             Self::Compact(_) => "compact",
@@ -159,6 +168,7 @@ impl UnifiedSlashCommand {
     pub fn subcommand_name(&self) -> Option<&'static str> {
         match self {
             Self::Context(subcommand) => Some(subcommand.name()),
+            Self::Resource(subcommand) => Some(subcommand.name()),
             Self::Knowledge(subcommand) => Some(subcommand.name()),
             Self::Agent(subcommand) => Some(subcommand.name()),
             Self::Persist(subcommand) => Some(subcommand.name()),