Add thread reply support with optional thread-ts parameter (#10)

* Initial plan

* Add reply-message functionality for threading support

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Fix code formatting for consistency

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Refactor to use optional timestamp parameter on send-message

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Rename parameter to [thread-ts] and clarify it's for replying to threads

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Print thread-ts after sending messages for thread continuity

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

* Only print thread-ts for new messages, not thread replies

Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: alexec <1142830+alexec@users.noreply.github.com>

Author: Copilot

README.md

@@ -36,6 +36,7 @@ Add this to your prompt (e.g. `AGENTS.md`):
 
 ```markdown
 - You can send messages to a Slack user by using the `slack send-message <channel|email> "<message>"` command.
+- You can reply to a message in a thread by adding the thread timestamp as a third parameter: `slack send-message <channel|email> "<message>" <thread-ts>`.
 - The message supports Markdown formatting which will be automatically converted to Slack's Mrkdwn format.
 - For AI assistants supporting MCP (Model Context Protocol), you can use `slack mcp-server` to enable tool-based Slack integration.
 ```
@@ -46,16 +47,27 @@ Add this to your prompt (e.g. `AGENTS.md`):
 
 ```bash
 Usage:
-  slack configure                                   - configure Slack token (reads from stdin)
-  slack send-message <channel|email> <message>      - send a message to a user
-  slack mcp-server                                  - start MCP server (Model Context Protocol)
+  slack configure                                            - configure Slack token (reads from stdin)
+  slack send-message <channel|email> <message> [thread-ts]   - send a message (optionally reply to a thread)
+  slack mcp-server                                           - start MCP server (Model Context Protocol)
 ```
 
-**Example:**
+**Examples:**
 ```bash
+# Send a message (prints thread-ts for starting a thread)
 slack send-message alex_collins@intuit.com "I love this tool! It makes Slack integration so easy."
+# Output:
+# Message sent to alex_collins@intuit.com (U12345678)
+# thread-ts: 1234567890.123456
+
+# Reply to a message in a thread (use the thread-ts from the previous message)
+slack send-message alex_collins@intuit.com "Thanks for the feedback!" "1234567890.123456"
+# Output:
+# Reply sent to alex_collins@intuit.com (U12345678) in thread 1234567890.123456
 ```
 
+The `thread-ts` is only printed when sending a new message (not when replying to a thread), allowing you to use it to start a threaded conversation.
+
 ### MCP Server Mode
 
 The MCP (Model Context Protocol) server allows AI assistants and other tools to interact with Slack through a standardized JSON-RPC protocol over stdio. This enables seamless integration with AI coding assistants and other automation tools.
@@ -79,9 +91,11 @@ The MCP (Model Context Protocol) server allows AI assistants and other tools to
    }
    ```
 
-The server exposes a `send_message` tool that accepts:
+The server exposes the `send_message` tool with the following parameters:
 - `identifier` - Slack channel ID (e.g., 'C1234567890') or user email address (e.g., 'user@example.com')
 - `message` - The message to send (supports Markdown formatting)
+- `thread_ts` - Optional: The thread timestamp of the parent message to reply to (e.g., '1234567890.123456'). When provided, the message will be sent as a threaded reply.
 
 **Example usage from an AI assistant:**
 > "Slack alex_collins@intuit.com to say how much you like this tool."
+> "Reply to that Slack message with a thumbs up emoji."

main.go

@@ -28,9 +28,9 @@ func main() {
 		w := flag.CommandLine.Output()
 		fmt.Fprintf(w, "Usage:")
 		fmt.Fprintln(w)
-		fmt.Fprintln(w, "  slack configure                                   - configure Slack token (reads from stdin)")
-		fmt.Fprintln(w, "  slack send-message <channel|email> <message>      - send a message to a user")
-		fmt.Fprintln(w, "  slack mcp-server                                  - start MCP server (Model Context Protocol)")
+		fmt.Fprintln(w, "  slack configure                                            - configure Slack token (reads from stdin)")
+		fmt.Fprintln(w, "  slack send-message <channel|email> <message> [thread-ts]   - send a message (optionally reply to a thread)")
+		fmt.Fprintln(w, "  slack mcp-server                                           - start MCP server (Model Context Protocol)")
 		fmt.Fprintln(w)
 	}
 	flag.Parse()
@@ -54,7 +54,7 @@ func run(ctx context.Context, args []string) error {
 		return runMCPServer(ctx)
 	case "send-message":
 		if len(args) < 3 {
-			return fmt.Errorf("usage: slack send-message <channel|email> <message>")
+			return fmt.Errorf("usage: slack send-message <channel|email> <message> [thread-ts]")
 		}
 
 		token := getToken()
@@ -66,7 +66,14 @@ func run(ctx context.Context, args []string) error {
 		http.DefaultTransport.(*http.Transport).ForceAttemptHTTP2 = false
 		api := slack.New(token)
 
-		return sendMessage(ctx, api, args[1], args[2])
+		// Check if optional thread-ts parameter is provided for replying to a thread
+		var timestamp string
+		if len(args) >= 4 {
+			timestamp = args[3]
+		}
+		
+		_, err := sendMessage(ctx, api, args[1], args[2], timestamp)
+		return err
 	default:
 		return fmt.Errorf("unknown sub-command: %s", args[0])
 	}
@@ -86,12 +93,12 @@ func getToken() string {
 	return ""
 }
 
-func sendMessage(ctx context.Context, api *slack.Client, identifier, body string) error {
+func sendMessage(ctx context.Context, api *slack.Client, identifier, body, timestamp string) (string, error) {
 	var channel string
 	if strings.Contains(identifier, "@") {
 		user, err := api.GetUserByEmailContext(ctx, identifier)
 		if err != nil {
-			return fmt.Errorf("failed to lookup user: %w", err)
+			return "", fmt.Errorf("failed to lookup user: %w", err)
 		}
 		channel = user.ID
 	} else {
@@ -101,12 +108,27 @@ func sendMessage(ctx context.Context, api *slack.Client, identifier, body string
 	// Convert Markdown to Mrkdwn format
 	mrkdwnBody := convertMarkdownToMrkdwn(body)
 
-	if _, _, err := api.PostMessageContext(ctx, channel, slack.MsgOptionText(mrkdwnBody, false)); err != nil {
-		return fmt.Errorf("failed to send message: %w", err)
+	// Build message options
+	options := []slack.MsgOption{slack.MsgOptionText(mrkdwnBody, false)}
+	
+	// If timestamp is provided, add it to create a threaded reply
+	if timestamp != "" {
+		options = append(options, slack.MsgOptionTS(timestamp))
 	}
 
-	fmt.Printf("Message sent to %s (%s)\n", identifier, channel)
-	return nil
+	_, respTimestamp, err := api.PostMessageContext(ctx, channel, options...)
+	if err != nil {
+		return "", fmt.Errorf("failed to send message: %w", err)
+	}
+
+	if timestamp != "" {
+		fmt.Printf("Reply sent to %s (%s) in thread %s\n", identifier, channel, timestamp)
+	} else {
+		fmt.Printf("Message sent to %s (%s)\n", identifier, channel)
+		fmt.Printf("thread-ts: %s\n", respTimestamp)
+	}
+	
+	return respTimestamp, nil
 }
 
 func configureToken(ctx context.Context) error {

main_test.go

@@ -69,3 +69,58 @@ func TestConvertMarkdownToMrkdwn_Integration(t *testing.T) {
 		t.Errorf("Expected '*bold*', got '%s'", result)
 	}
 }
+
+func TestRun_SendMessageMissingArgs(t *testing.T) {
+	// Set SLACK_TOKEN env var to get past token check
+	oldToken := os.Getenv("SLACK_TOKEN")
+	os.Setenv("SLACK_TOKEN", "test-token")
+	defer func() {
+		if oldToken == "" {
+			os.Unsetenv("SLACK_TOKEN")
+		} else {
+			os.Setenv("SLACK_TOKEN", oldToken)
+		}
+	}()
+
+	ctx := context.Background()
+	
+	// Test with no arguments
+	err := run(ctx, []string{"send-message"})
+	if err == nil {
+		t.Error("Expected error for missing arguments, got nil")
+	}
+	if !strings.Contains(err.Error(), "usage:") {
+		t.Errorf("Expected usage error, got: %v", err)
+	}
+	
+	// Test with only channel
+	err = run(ctx, []string{"send-message", "C1234567890"})
+	if err == nil {
+		t.Error("Expected error for missing arguments, got nil")
+	}
+	if !strings.Contains(err.Error(), "usage:") {
+		t.Errorf("Expected usage error, got: %v", err)
+	}
+}
+
+func TestRun_SendMessageMissingToken(t *testing.T) {
+	// Ensure SLACK_TOKEN env var is not set
+	oldToken := os.Getenv("SLACK_TOKEN")
+	os.Unsetenv("SLACK_TOKEN")
+	defer func() {
+		if oldToken != "" {
+			os.Setenv("SLACK_TOKEN", oldToken)
+		}
+	}()
+
+	ctx := context.Background()
+	err := run(ctx, []string{"send-message", "C1234567890", "test message"})
+	
+	if err == nil {
+		t.Error("Expected error for missing token, got nil")
+	}
+	
+	if !strings.Contains(err.Error(), "Slack token must be set") {
+		t.Errorf("Expected 'Slack token must be set' error, got: %v", err)
+	}
+}

mcp.go

@@ -30,7 +30,7 @@ func runMCPServer(ctx context.Context) error {
 
 	// Define the send_message tool
 	sendMessageTool := mcp.NewTool("send_message",
-		mcp.WithDescription("Send a message to a Slack channel or user. You can specify either a channel ID or a user's email address. The message supports Markdown formatting which will be automatically converted to Slack's Mrkdwn format."),
+		mcp.WithDescription("Send a message to a Slack channel or user. You can specify either a channel ID or a user's email address. The message supports Markdown formatting which will be automatically converted to Slack's Mrkdwn format. Optionally provide a thread_ts to reply to a message in a thread."),
 		mcp.WithString("identifier",
 			mcp.Required(),
 			mcp.Description("The Slack channel ID (e.g., 'C1234567890') or user email address (e.g., 'user@example.com')"),
@@ -39,6 +39,9 @@ func runMCPServer(ctx context.Context) error {
 			mcp.Required(),
 			mcp.Description("The message to send. Supports Markdown formatting."),
 		),
+		mcp.WithString("thread_ts",
+			mcp.Description("Optional: The thread timestamp of the parent message to reply to (e.g., '1234567890.123456'). When provided, the message will be sent as a threaded reply."),
+		),
 	)
 
 	// Add the tool handler
@@ -53,13 +56,19 @@ func runMCPServer(ctx context.Context) error {
 			return mcp.NewToolResultError(fmt.Sprintf("Missing or invalid 'message' argument: %v", err)), nil
 		}
 
-		// Send the message using the existing sendMessage function
-		err = sendMessage(ctx, api, identifier, message)
+		// Get optional thread_ts parameter for replying to a thread
+		timestamp := request.GetString("thread_ts", "")
+
+		// Send the message using the sendMessage function
+		respTimestamp, err := sendMessage(ctx, api, identifier, message, timestamp)
 		if err != nil {
 			return mcp.NewToolResultError(fmt.Sprintf("Error: %v", err)), nil
 		}
 
-		return mcp.NewToolResultText(fmt.Sprintf("Message sent successfully to %s", identifier)), nil
+		if timestamp != "" {
+			return mcp.NewToolResultText(fmt.Sprintf("Reply sent successfully to %s in thread %s", identifier, timestamp)), nil
+		}
+		return mcp.NewToolResultText(fmt.Sprintf("Message sent successfully to %s\nthread-ts: %s", identifier, respTimestamp)), nil
 	})
 
 	// Start the stdio server