feat: implement custom dispatch command support (Issue #409)

Author: amitksingh1490

.task-409.md

@@ -52,10 +52,11 @@ I'll implement a feature that allows users to use custom commands with the forma
 
 ## Implementation Progress
 
-- [ ] Add dispatch method to API trait
-- [ ] Implement dispatch method in ForgeAPI
-- [ ] Update Command enum with Dispatch variant
-- [ ] Add command parsing for dispatch commands
-- [ ] Add event name validation
-- [ ] Update UI to handle dispatch commands
-- [ ] Add tests for dispatch command functionality
+- [x] Add dispatch method to API trait
+- [x] Implement dispatch method in ForgeAPI
+- [x] Update Command enum with Dispatch variant
+- [x] Add command parsing for dispatch commands
+- [x] Add event name validation
+- [x] Update UI to handle dispatch commands
+- [x] Add tests for dispatch command functionality
+- [x] Add CLI arguments for custom event dispatching

crates/forge_api/src/api.rs

@@ -137,6 +137,18 @@ impl<F: App + Infrastructure> API for ForgeAPI<F> {
         self.app.conversation_service().get(conversation_id).await
     }
 
+    async fn dispatch(&self, event_name: &str, event_value: &str) -> anyhow::Result<()> {
+        // Create an event with the specified name and value
+        let event = Event::new(event_name, event_value);
+        
+        // Create a new conversation with default workflow if we don't have one
+        let dummy_workflow = Workflow::default();
+        let conversation_id = self.app.conversation_service().create(dummy_workflow).await?;
+        
+        // Dispatch the event to the conversation
+        self.app.conversation_service().insert_event(&conversation_id, event).await
+    }
+
     async fn get_variable(
         &self,
         conversation_id: &ConversationId,

crates/forge_api/src/lib.rs

@@ -80,6 +80,9 @@ pub trait API: Sync + Send {
         conversation_id: &ConversationId,
     ) -> anyhow::Result<Option<Conversation>>;
 
+    /// Dispatches a custom event with the given name and value
+    async fn dispatch(&self, event_name: &str, event_value: &str) -> anyhow::Result<()>;
+
     /// Gets a variable from the conversation
     async fn get_variable(
         &self,

crates/forge_main/src/cli.rs

@@ -52,6 +52,15 @@ pub struct Cli {
     #[arg(long, short = 'd')]
     pub dispatch: Option<String>,
 
+    /// Custom dispatch event name for direct dispatch of custom events
+    /// For example: --custom-event "my-event-name" --custom-value "This is the event value"
+    #[arg(long)]
+    pub custom_event: Option<String>,
+
+    /// Custom dispatch event value to be sent with the custom event name
+    #[arg(long)]
+    pub custom_value: Option<String>,
+
     #[command(subcommand)]
     pub snapshot: Option<Snapshot>,
 }

crates/forge_main/src/model.rs

@@ -39,6 +39,9 @@ impl From<&[Model]> for Info {
 /// - File content
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Command {
+    /// Custom command dispatch that triggers event handling with a format of `/dispatch-event_name value`
+    /// The event_name must follow specific formatting rules (alphanumeric, plus hyphens and underscores)
+    Dispatch(String, String),
     /// Start a new conversation while preserving history.
     /// This can be triggered with the '/new' command.
     New,
@@ -82,6 +85,7 @@ impl Command {
             "/plan".to_string(),
             "/help".to_string(),
             "/dump".to_string(),
+            "/dispatch-event_name".to_string(),
         ]
     }
 
@@ -98,6 +102,29 @@ impl Command {
     pub fn parse(input: &str) -> Self {
         let trimmed = input.trim();
 
+        // Check if this is a dispatch command
+        if trimmed.starts_with("/dispatch-") {
+            // Get everything after "/dispatch-" until a space or end of string
+            let (event_name, value) = match trimmed[10..].find(' ') {
+                Some(space_index) => {
+                    let event_name = &trimmed[10..10 + space_index];
+                    let value = &trimmed[10 + space_index + 1..];
+                    (event_name.to_string(), value.to_string())
+                }
+                None => {
+                    // No space found, so everything after "/dispatch-" is the event name
+                    // and value is empty
+                    (trimmed[10..].to_string(), "".to_string())
+                }
+            };
+            
+            // Validate event name - only allow alphanumeric, underscores, and hyphens
+            if event_name.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-') {
+                return Command::Dispatch(event_name, value);
+            }
+            // If event name is invalid, treat as a regular message
+        }
+        
         match trimmed {
             "/new" => Command::New,
             "/info" => Command::Info,
@@ -141,3 +168,49 @@ pub trait UserInput {
     /// * `Err` - An error occurred during input processing
     async fn prompt(&self, input: Option<Self::PromptInput>) -> anyhow::Result<Command>;
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_dispatch_command() {
+        // Test valid dispatch command with value
+        let input = "/dispatch-test_event This is a test value";
+        match Command::parse(input) {
+            Command::Dispatch(event_name, value) => {
+                assert_eq!(event_name, "test_event");
+                assert_eq!(value, "This is a test value");
+            }
+            _ => panic!("Failed to parse valid dispatch command"),
+        }
+        
+        // Test valid dispatch command with no value
+        let input = "/dispatch-empty_event";
+        match Command::parse(input) {
+            Command::Dispatch(event_name, value) => {
+                assert_eq!(event_name, "empty_event");
+                assert_eq!(value, "");
+            }
+            _ => panic!("Failed to parse valid dispatch command without value"),
+        }
+        
+        // Test dispatch command with hyphens and underscores
+        let input = "/dispatch-custom-event_name Some value";
+        match Command::parse(input) {
+            Command::Dispatch(event_name, value) => {
+                assert_eq!(event_name, "custom-event_name");
+                assert_eq!(value, "Some value");
+            }
+            _ => panic!("Failed to parse valid dispatch command with hyphens and underscores"),
+        }
+        
+        // Test invalid dispatch command (contains invalid characters)
+        let input = "/dispatch-invalid!event Value";
+        match Command::parse(input) {
+            Command::Message(message) => {
+                assert_eq!(message, input);
+            }
+            _ => panic!("Invalid dispatch command should be treated as a message"),
+        }
+    }
+}

crates/forge_main/src/ui.rs

@@ -104,6 +104,12 @@ impl<F: API> UI<F> {
             return self.handle_dispatch(dispatch_json).await;
         }
 
+        // Check for custom event dispatch
+        if let Some(event_name) = self.cli.custom_event.clone() {
+            let event_value = self.cli.custom_value.clone().unwrap_or_default();
+            return self.handle_dispatch_command(&event_name, &event_value).await;
+        }
+
         if let Some(snapshot_command) = self.cli.snapshot.as_ref() {
             return match snapshot_command {
                 Snapshot::Snapshot { sub_command } => self.handle_snaps(sub_command).await,
@@ -187,7 +193,12 @@ impl<F: API> UI<F> {
                     input = self.console.prompt(prompt_input).await?;
                     continue;
                 }
-                Command::Exit => {
+                Command::Dispatch(event_name, value) => {
+                    self.handle_dispatch_command(&event_name, &value).await?;
+                    let prompt_input = Some((&self.state).into());
+                    input = self.console.prompt(prompt_input).await?;
+                    continue;
+                }                Command::Exit => {
                     break;
                 }
                 Command::Models => {
@@ -555,6 +566,27 @@ impl<F: API> UI<F> {
         }
         Ok(())
     } // Handle help chat in HELP mode
+        // Handle custom dispatch commands
+    async fn handle_dispatch_command(&mut self, event_name: &str, event_value: &str) -> Result<()> {
+        // Initialize the conversation if it doesn't exist
+        self.init_conversation().await?;
+        
+        // Log the dispatch
+        CONSOLE.writeln(
+            TitleFormat::execute(format!("Dispatching custom event: {}", event_name))
+                .sub_title(format!("value: {}", event_value))
+                .format(),
+        )?;
+        
+        // Dispatch the event using the API
+        self.api.dispatch(event_name, event_value).await?;
+        
+        CONSOLE.writeln(
+            TitleFormat::success("Event dispatched successfully").format(),
+        )?;
+        
+        Ok(())
+    }
     async fn help_chat(&mut self, content: String) -> Result<()> {
         let conversation_id = self.init_conversation().await?;