commit a84c484fad4fe6606a8d6a227da976330b8f3797 · anil.recoil.org/slop

+91 -28

stack/zulip/examples/README_ECHO_BOT.md

···

       1
       1
       -
       # Zulip Echo Bot

     

       1
       1
       +
       # Zulip Echo Bot with Verbose Logging

     

       2
       2
        
       

     

       3
       3
       -
       A simple echo bot that demonstrates the basic functionality of the Zulip bot framework. The bot responds to direct messages and mentions by echoing back the message content.

     

       3
       3
       +
       An enhanced echo bot that demonstrates the Zulip bot framework with comprehensive logging and CLI configuration. The bot responds to direct messages and mentions by echoing back the message content, with detailed logging at every step.

     

       4
       4
        
       

     

       5
       5
        
       ## Features

     

       6
       6
        
       

     

       7
       7
       -
       - Responds to direct messages

     

       8
       8
       -
       - Responds to @mentions in channels

     

       9
       9
       -
       - Avoids infinite loops by ignoring its own messages

     

       10
       10
       -
       - Simple help command

     

       7
       7
       +
       - **Responds to direct messages and @mentions in channels**

     

       8
       8
       +
       - **Comprehensive logging** with multiple verbosity levels

     

       9
       9
       +
       - **Command-line interface** with help and configuration options

     

       10
       10
       +
       - **Detailed message tracing** for debugging

     

       11
       11
       +
       - **Structured logging** using the OCaml logs library

     

       12
       12
       +
       - **Built-in commands**: help, ping, and echo

     

       13
       13
       +
       - **Avoids infinite loops** by ignoring its own messages

     

       11
       14
        
       

     

       12
       15
        
       ## Prerequisites

     

       13
       16
        
       

     
···

       51
       54
        
       

     

       52
       55
        
       ## Running the Bot

     

       53
       56
        
       

     

       57
       57
       +
       ### Basic Usage

     

       58
       58
       +
       

     

       54
       59
        
       ```bash

     

       55
       55
       -
       # Run from the project root

     

       60
       60
       +
       # Show help and available options

     

       61
       61
       +
       dune exec echo_bot -- --help

     

       62
       62
       +
       

     

       63
       63
       +
       # Run with default settings (info level logging)

     

       56
       64
        
       dune exec echo_bot

     

       57
       65
        
       

     

       58
       58
       -
       # Or run the built executable directly

     

       59
       59
       -
       ./_build/default/zulip/examples/echo_bot.exe

     

       66
       66
       +
       # Run with verbose logging (shows all info messages)

     

       67
       67
       +
       dune exec echo_bot -- -v

     

       68
       68
       +
       

     

       69
       69
       +
       # Run with debug logging (shows everything)

     

       70
       70
       +
       dune exec echo_bot -- -vv

     

       71
       71
       +
       

     

       72
       72
       +
       # Use custom config file

     

       73
       73
       +
       dune exec echo_bot -- -c /path/to/bot.zuliprc

     

       74
       74
       +
       

     

       75
       75
       +
       # Combine options

     

       76
       76
       +
       dune exec echo_bot -- -vv -c ~/my-bot.zuliprc

     

       60
       77
        
       ```

     

       61
       78
        
       

     

       62
       62
       -
       You should see output like:

     

       79
       79
       +
       ### Example Output with Different Verbosity Levels

     

       80
       80
       +
       

     

       81
       81
       +
       **Default (no flags) - Info level:**

     

       63
       82
        
       ```

     

       64
       64
       -
       Starting Zulip Echo Bot...

     

       65
       65
       -
       =============================

     

       83
       83
       +
       echo_bot: [INFO] Starting Zulip Echo Bot

     

       84
       84
       +
       echo_bot: [INFO] Log level: Info

     

       85
       85
       +
       echo_bot: [INFO] =============================

     

       66
       86
        
       

     

       67
       67
       -
       Loaded authentication for: echo-bot@your-domain.zulipchat.com

     

       68
       68
       -
       Server: https://your-domain.zulipchat.com

     

       87
       87
       +
       echo_bot: [INFO] Echo bot is running!

     

       88
       88
       +
       echo_bot: [INFO] Send a direct message or mention @echobot in a channel.

     

       89
       89
       +
       echo_bot: [INFO] Commands: 'help', 'ping', or any message to echo

     

       90
       90
       +
       echo_bot: [INFO] Press Ctrl+C to stop.

     

       91
       91
       +
       ```

     

       92
       92
       +
       

     

       93
       93
       +
       **Verbose (-v) - Info level with more details:**

     

       94
       94
       +
       ```

     

       95
       95
       +
       echo_bot: [INFO] Starting Zulip Echo Bot

     

       96
       96
       +
       echo_bot: [INFO] Log level: Info

     

       97
       97
       +
       echo_bot: [INFO] =============================

     

       98
       98
       +
       

     

       99
       99
       +
       echo_bot: [INFO] Loaded authentication for: echo-bot@your-domain.zulipchat.com

     

       100
       100
       +
       echo_bot: [INFO] Server: https://your-domain.zulipchat.com

     

       101
       101
       +
       echo_bot: [INFO] Bot identity created: Echo Bot (echo-bot@your-domain.zulipchat.com)

     

       102
       102
       +
       echo_bot: [INFO] Echo bot is running!

     

       103
       103
       +
       echo_bot: [INFO] Processing message with 12 fields

     

       104
       104
       +
       echo_bot: [INFO] Message metadata: type=private, sender=John Doe (john@example.com), id=12345

     

       105
       105
       +
       echo_bot: [INFO] Processing message from John Doe (ID: 123): Hello bot!

     

       106
       106
       +
       echo_bot: [INFO] Sending private reply: Echo from John Doe: Hello bot!

     

       107
       107
       +
       ```

     

       69
       108
        
       

     

       70
       70
       -
       Echo bot is running!

     

       71
       71
       -
       Send a direct message or mention @echobot in a channel.

     

       72
       72
       -
       Press Ctrl+C to stop.

     

       109
       109
       +
       **Debug (-vv) - Full debug output:**

     

       110
       110
       +
       ```

     

       111
       111
       +
       echo_bot: [INFO] Starting Zulip Echo Bot

     

       112
       112
       +
       echo_bot: [DEBUG] Creating Zulip client

     

       113
       113
       +
       echo_bot: [DEBUG] Creating bot storage for echo-bot@your-domain.zulipchat.com

     

       114
       114
       +
       echo_bot: [DEBUG] Creating bot handler

     

       115
       115
       +
       echo_bot: [DEBUG] Creating bot runner

     

       116
       116
       +
       echo_bot: [DEBUG] Received message for processing

     

       117
       117
       +
       echo_bot: [DEBUG] Extracted field content: Hello bot!

     

       118
       118
       +
       echo_bot: [DEBUG] Extracted field sender_email: john@example.com

     

       119
       119
       +
       echo_bot: [DEBUG] Extracted field sender_full_name: John Doe

     

       120
       120
       +
       echo_bot: [DEBUG] Extracted field type: private

     

       121
       121
       +
       echo_bot: [DEBUG] Extracted field sender_id: 123

     

       122
       122
       +
       echo_bot: [DEBUG] Extracted field id: 12345

     

       123
       123
       +
       echo_bot: [DEBUG] No bot mention to remove

     

       124
       124
       +
       echo_bot: [DEBUG] Generated response: Echo from John Doe: Hello bot!

     

       73
       125
        
       ```

     

       74
       126
        
       

     

       75
       127
        
       ## Testing the Bot

     
···

       84
       136
        
       1. In any channel, type: `@echobot Hello everyone!`

     

       85
       137
        
       2. The bot should respond: `Echo from [Your Name]: Hello everyone!`

     

       86
       138
        
       

     

       87
       87
       -
       ### Help Command

     

       88
       88
       -
       Send `help` to the bot to get usage information.

     

       139
       139
       +
       ### Special Commands

     

       140
       140
       +
       

     

       141
       141
       +
       - **`help`** - Get usage information

     

       142
       142
       +
       - **`ping`** - Bot responds with "Pong! 🏓"

     

       143
       143
       +
       - Any other text - Bot echoes it back

     

       89
       144
        
       

     

       90
       145
        
       ## How It Works

     

       91
       146
        
       

     

       92
       147
        
       The echo bot:

     

       93
       93
       -
       1. Connects to Zulip using the real-time events API

     

       94
       94
       -
       2. Listens for messages where it's mentioned or direct messaged

     

       95
       95
       -
       3. Extracts the message content and sender information

     

       96
       96
       -
       4. Sends back an echo of the message

     

       97
       97
       -
       5. Ignores its own messages to prevent loops

     

       148
       148
       +
       1. **Initializes logging** based on CLI verbosity flags

     

       149
       149
       +
       2. **Connects to Zulip** using the real-time events API

     

       150
       150
       +
       3. **Listens for messages** where it's mentioned or direct messaged

     

       151
       151
       +
       4. **Logs message details** at various verbosity levels

     

       152
       152
       +
       5. **Extracts fields** with debug logging for each field

     

       153
       153
       +
       6. **Processes content** and removes bot mentions

     

       154
       154
       +
       7. **Generates responses** with appropriate logging

     

       155
       155
       +
       8. **Sends back echo** with type-appropriate reply

     

       156
       156
       +
       9. **Ignores own messages** to prevent loops

     

       98
       157
        
       

     

       99
       158
        
       ## Code Structure

     

       100
       159
        
       

     

       101
       101
       -
       - **Bot Handler Module**: Implements the `Bot_handler.S` signature with message processing logic

     

       102
       102
       -
       - **Message Processing**: Extracts fields from incoming JSON messages

     

       103
       103
       -
       - **Response Generation**: Creates appropriate responses based on message type

     

       104
       104
       -
       - **Identity Management**: Uses bot identity to avoid self-responses

     

       160
       160
       +
       - **Logging Setup**: Creates a custom log source `echo_bot` for structured logging

     

       161
       161
       +
       - **Bot Handler Module**: Implements the `Bot_handler.S` signature with comprehensive logging

     

       162
       162
       +
       - **Field Extraction**: Helper functions with debug logging for each field

     

       163
       163
       +
       - **Message Processing**: Detailed logging of message metadata and content

     

       164
       164
       +
       - **Response Generation**: Logs response creation and type determination

     

       165
       165
       +
       - **CLI Interface**: Cmdliner-based argument parsing with help text

     

       166
       166
       +
       - **Verbosity Control**: Maps CLI flags to log levels (Info/Debug)

     

       167
       167
       +
       - **Error Handling**: Catches and logs exceptions with backtraces

     

       105
       168
        
       

     

       106
       169
        
       ## Customization

     

       107
       170

+1 -1

stack/zulip/examples/dune

···

       8
       8
        
        (public_name echo_bot)

     

       9
       9
        
        (name echo_bot)

     

       10
       10
        
        (package zulip_bot)

     

       11
       11
       -
        (libraries zulip zulip_bot eio_main))

     

       11
       11
       +
        (libraries zulip zulip_bot eio_main cmdliner logs logs.fmt))

     

       12
       12
        
       

     

       13
       13
        
       (executable

     

       14
       14
        
        (public_name atom_feed_bot)

+215 -50

stack/zulip/examples/echo_bot.ml

···

       1
       1
       -
       (* Simple Echo Bot for Zulip

     

       2
       2
       -
          Responds to direct messages and mentions by echoing back the message *)

     

       1
       1
       +
       (* Enhanced Echo Bot for Zulip with Logging and CLI

     

       2
       2
       +
          Responds to direct messages and mentions by echoing back the message

     

       3
       3
       +
          Features verbose logging and command-line configuration *)

     

       3
       4
        
       

     

       4
       5
        
       open Zulip_bot

     

       6
       6
       +
       

     

       7
       7
       +
       (* Set up logging *)

     

       8
       8
       +
       let src = Logs.Src.create "echo_bot" ~doc:"Zulip Echo Bot"

     

       9
       9
       +
       module Log = (val Logs.src_log src : Logs.LOG)

     

       5
       10
        
       

     

       6
       11
        
       module Echo_bot_handler : Bot_handler.S = struct

     

       7
       7
       -
         let initialize _ = Ok ()

     

       12
       12
       +
         let initialize _config =

     

       13
       13
       +
           Log.info (fun m -> m "Initializing echo bot handler");

     

       14
       14
       +
           Log.debug (fun m -> m "Bot handler initialized");

     

       15
       15
       +
           Ok ()

     

       8
       16
        
       

     

       9
       17
        
         let usage () =

     

       10
       18
        
           "Echo Bot - I repeat everything you say to me!"

     
···

       14
       22
        
            Send me a direct message or mention me in a channel."

     

       15
       23
        
       

     

       16
       24
        
         let handle_message ~config:_ ~storage:_ ~identity ~message ~env:_ =

     

       25
       25
       +
           Log.debug (fun m -> m "Received message for processing");

     

       26
       26
       +
       

     

       17
       27
        
           (* Parse the incoming message *)

     

       18
       28
        
           let extract_field fields name =

     

       19
       29
        
             match List.assoc_opt name fields with

     

       20
       20
       -
             | Some (`String s) -> Some s

     

       21
       21
       -
             | _ -> None

     

       30
       30
       +
             | Some (`String s) ->

     

       31
       31
       +
                 Log.debug (fun m -> m "Extracted field %s: %s" name s);

     

       32
       32
       +
                 Some s

     

       33
       33
       +
             | _ ->

     

       34
       34
       +
                 Log.debug (fun m -> m "Field %s not found or not a string" name);

     

       35
       35
       +
                 None

     

       22
       36
        
           in

     

       23
       37
        
       

     

       24
       38
        
           let extract_int_field fields name =

     

       25
       39
        
             match List.assoc_opt name fields with

     

       26
       26
       -
             | Some (`Float f) -> Some (int_of_float f)

     

       27
       27
       -
             | _ -> None

     

       40
       40
       +
             | Some (`Float f) ->

     

       41
       41
       +
                 let i = int_of_float f in

     

       42
       42
       +
                 Log.debug (fun m -> m "Extracted field %s: %d" name i);

     

       43
       43
       +
                 Some i

     

       44
       44
       +
             | _ ->

     

       45
       45
       +
                 Log.debug (fun m -> m "Field %s not found or not a number" name);

     

       46
       46
       +
                 None

     

       28
       47
        
           in

     

       29
       48
        
       

     

       30
       49
        
           match message with

     

       31
       50
        
           | `O fields ->

     

       51
       51
       +
               Log.info (fun m -> m "Processing message with %d fields" (List.length fields));

     

       52
       52
       +
       

     

       32
       53
        
               (* Extract message details *)

     

       33
       54
        
               let content = extract_field fields "content" in

     

       34
       55
        
               let sender_email = extract_field fields "sender_email" in

     

       35
       56
        
               let sender_full_name = extract_field fields "sender_full_name" in

     

       36
       57
        
               let message_type = extract_field fields "type" in

     

       37
       37
       -
               let _sender_id = extract_int_field fields "sender_id" in

     

       58
       58
       +
               let sender_id = extract_int_field fields "sender_id" in

     

       59
       59
       +
               let message_id = extract_int_field fields "id" in

     

       60
       60
       +
       

     

       61
       61
       +
               (* Log message metadata *)

     

       62
       62
       +
               Log.info (fun m ->

     

       63
       63
       +
                 m "Message metadata: type=%s, sender=%s (%s), id=%s"

     

       64
       64
       +
                   (Option.value message_type ~default:"unknown")

     

       65
       65
       +
                   (Option.value sender_full_name ~default:"unknown")

     

       66
       66
       +
                   (Option.value sender_email ~default:"unknown")

     

       67
       67
       +
                   (Option.fold ~none:"none" ~some:string_of_int message_id));

     

       38
       68
        
       

     

       39
       69
        
               (* Check if this is our own message to avoid loops *)

     

       70
       70
       +
               let bot_email = Bot_handler.Identity.email identity in

     

       40
       71
        
               let is_own_message = match sender_email with

     

       41
       41
       -
                 | Some email -> email = (Bot_handler.Identity.email identity)

     

       72
       72
       +
                 | Some email ->

     

       73
       73
       +
                     let is_own = email = bot_email in

     

       74
       74
       +
                     if is_own then

     

       75
       75
       +
                       Log.debug (fun m -> m "Ignoring own message from %s" email);

     

       76
       76
       +
                     is_own

     

       42
       77
        
                 | None -> false

     

       43
       78
        
               in

     

       44
       79
        
       

     

       45
       45
       -
               if is_own_message then

     

       80
       80
       +
               if is_own_message then (

     

       81
       81
       +
                 Log.debug (fun m -> m "Skipping response to own message");

     

       46
       82
        
                 Ok Bot_handler.Response.None

     

       47
       47
       -
               else

     

       83
       83
       +
               ) else

     

       48
       84
        
                 (* Process the message content *)

     

       49
       49
       -
                 let response_content = match content, sender_full_name with

     

       50
       50
       -
                   | Some msg, Some name ->

     

       85
       85
       +
                 let response_content = match content, sender_full_name, sender_id with

     

       86
       86
       +
                   | Some msg, Some name, Some id ->

     

       87
       87
       +
                       Log.info (fun m -> m "Processing message from %s (ID: %d): %s" name id msg);

     

       88
       88
       +
       

     

       51
       89
        
                       (* Remove bot mention if present *)

     

       90
       90
       +
                       let mention = "@**" ^ Bot_handler.Identity.mention_name identity ^ "**" in

     

       52
       91
        
                       let cleaned_msg =

     

       53
       53
       -
                         let mention = "@**" ^ Bot_handler.Identity.mention_name identity ^ "**" in

     

       54
       54
       -
                         let msg =

     

       55
       55
       -
                           if String.starts_with ~prefix:mention msg then

     

       56
       56
       -
                             String.sub msg (String.length mention) (String.length msg - String.length mention)

     

       57
       57
       -
                           else msg

     

       58
       58
       -
                         in

     

       59
       59
       -
                         String.trim msg

     

       92
       92
       +
                         if String.starts_with ~prefix:mention msg then (

     

       93
       93
       +
                           let cleaned = String.sub msg

     

       94
       94
       +
                             (String.length mention)

     

       95
       95
       +
                             (String.length msg - String.length mention) in

     

       96
       96
       +
                           Log.debug (fun m -> m "Removed bot mention, cleaned message: %s" cleaned);

     

       97
       97
       +
                           String.trim cleaned

     

       98
       98
       +
                         ) else (

     

       99
       99
       +
                           Log.debug (fun m -> m "No bot mention to remove");

     

       100
       100
       +
                           String.trim msg

     

       101
       101
       +
                         )

     

       60
       102
        
                       in

     

       61
       103
        
       

     

       62
       104
        
                       (* Create echo response *)

     

       63
       63
       -
                       if cleaned_msg = "" then

     

       64
       64
       -
                         Printf.sprintf "Hello %s! Send me a message and I'll echo it back!" name

     

       65
       65
       -
                       else if String.lowercase_ascii cleaned_msg = "help" then

     

       66
       66
       -
                         Printf.sprintf "Hi %s! I'm an echo bot. Whatever you say to me, I'll repeat back. \

     

       67
       67
       -
                                         Try sending me any message!" name

     

       68
       68
       -
                       else

     

       69
       69
       -
                         Printf.sprintf "Echo from %s: %s" name cleaned_msg

     

       70
       70
       -
                   | Some msg, None ->

     

       105
       105
       +
                       let response =

     

       106
       106
       +
                         if cleaned_msg = "" then

     

       107
       107
       +
                           Printf.sprintf "Hello %s! Send me a message and I'll echo it back!" name

     

       108
       108
       +
                         else if String.lowercase_ascii cleaned_msg = "help" then

     

       109
       109
       +
                           Printf.sprintf "Hi %s! I'm an echo bot. Whatever you say to me, I'll repeat back. \

     

       110
       110
       +
                                           Try sending me any message!" name

     

       111
       111
       +
                         else if String.lowercase_ascii cleaned_msg = "ping" then (

     

       112
       112
       +
                           Log.info (fun m -> m "Responding to ping from %s" name);

     

       113
       113
       +
                           Printf.sprintf "Pong! 🏓 (from %s)" name

     

       114
       114
       +
                         )

     

       115
       115
       +
                         else

     

       116
       116
       +
                           Printf.sprintf "Echo from %s: %s" name cleaned_msg

     

       117
       117
       +
                       in

     

       118
       118
       +
       

     

       119
       119
       +
                       Log.debug (fun m -> m "Generated response: %s" response);

     

       120
       120
       +
                       response

     

       121
       121
       +
       

     

       122
       122
       +
                   | Some msg, None, _ ->

     

       123
       123
       +
                       Log.warn (fun m -> m "Message without sender name: %s" msg);

     

       71
       124
        
                       Printf.sprintf "Echo: %s" msg

     

       72
       72
       -
                   | _ ->

     

       125
       125
       +
       

     

       126
       126
       +
                   | None, _, _ ->

     

       127
       127
       +
                       Log.warn (fun m -> m "Received message without content");

     

       73
       128
        
                       "I couldn't understand that message."

     

       129
       129
       +
       

     

       130
       130
       +
                   | _ ->

     

       131
       131
       +
                       Log.warn (fun m -> m "Incomplete message data");

     

       132
       132
       +
                       "I couldn't process that message properly."

     

       74
       133
        
                 in

     

       75
       134
        
       

     

       76
       135
        
                 (* Determine response type based on original message type *)

     

       77
       136
        
                 let response = match message_type with

     

       78
       137
        
                   | Some "private" ->

     

       79
       79
       -
                       (* For private messages, reply directly *)

     

       138
       138
       +
                       Log.info (fun m -> m "Sending private reply: %s" response_content);

     

       80
       139
        
                       Bot_handler.Response.Reply response_content

     

       81
       140
        
                   | Some "stream" ->

     

       82
       82
       -
                       (* For stream messages, reply in the same topic *)

     

       141
       141
       +
                       Log.info (fun m -> m "Sending stream reply: %s" response_content);

     

       83
       142
        
                       Bot_handler.Response.Reply response_content

     

       84
       84
       -
                   | _ ->

     

       143
       143
       +
                   | Some other ->

     

       144
       144
       +
                       Log.warn (fun m -> m "Unknown message type: %s" other);

     

       145
       145
       +
                       Bot_handler.Response.None

     

       146
       146
       +
                   | None ->

     

       147
       147
       +
                       Log.warn (fun m -> m "No message type specified");

     

       85
       148
        
                       Bot_handler.Response.None

     

       86
       149
        
                 in

     

       87
       150
        
       

     

       88
       151
        
                 Ok response

     

       89
       89
       -
           | _ ->

     

       152
       152
       +
       

     

       153
       153
       +
           | other ->

     

       154
       154
       +
               Log.err (fun m -> m "Received non-object message: %s"

     

       155
       155
       +
                 (match other with

     

       156
       156
       +
                  | `A _ -> "array"

     

       157
       157
       +
                  | `Bool _ -> "bool"

     

       158
       158
       +
                  | `Float _ -> "float"

     

       159
       159
       +
                  | `String _ -> "string"

     

       160
       160
       +
                  | `Null -> "null"

     

       161
       161
       +
                  | _ -> "unknown"));

     

       90
       162
        
               Ok Bot_handler.Response.None

     

       91
       163
        
       end

     

       92
       164
        
       

     

       93
       93
       -
       let run_echo_bot env =

     

       94
       94
       -
         Printf.printf "Starting Zulip Echo Bot...\n";

     

       95
       95
       -
         Printf.printf "=============================\n\n";

     

       165
       165
       +
       let run_echo_bot config_file verbosity env =

     

       166
       166
       +
         (* Set up logging based on verbosity *)

     

       167
       167
       +
         Logs.set_reporter (Logs_fmt.reporter ());

     

       168
       168
       +
         let log_level = match verbosity with

     

       169
       169
       +
           | 0 -> Logs.Info

     

       170
       170
       +
           | 1 -> Logs.Debug

     

       171
       171
       +
           | _ -> Logs.Debug  (* Cap at debug level *)

     

       172
       172
       +
         in

     

       173
       173
       +
         Logs.set_level (Some log_level);

     

       174
       174
       +
       

     

       175
       175
       +
         (* Also set levels for related modules if they exist *)

     

       176
       176
       +
         Logs.Src.set_level src (Some log_level);

     

       177
       177
       +
       

     

       178
       178
       +
         Log.app (fun m -> m "Starting Zulip Echo Bot");

     

       179
       179
       +
         Log.app (fun m -> m "Log level: %s" (Logs.level_to_string (Some log_level)));

     

       180
       180
       +
         Log.app (fun m -> m "=============================\n");

     

       96
       181
        
       

     

       97
       182
        
         (* Load authentication from .zuliprc file *)

     

       98
       98
       -
         let auth = match Zulip.Auth.from_zuliprc () with

     

       183
       183
       +
         let auth = match Zulip.Auth.from_zuliprc ?path:config_file () with

     

       99
       184
        
           | Ok a ->

     

       100
       100
       -
               Printf.printf "Loaded authentication for: %s\n" (Zulip.Auth.email a);

     

       101
       101
       -
               Printf.printf "Server: %s\n\n" (Zulip.Auth.server_url a);

     

       185
       185
       +
               Log.info (fun m -> m "Loaded authentication for: %s" (Zulip.Auth.email a));

     

       186
       186
       +
               Log.info (fun m -> m "Server: %s" (Zulip.Auth.server_url a));

     

       102
       187
        
               a

     

       103
       188
        
           | Error e ->

     

       104
       104
       -
               Printf.eprintf "Failed to load .zuliprc: %s\n" (Zulip.Error.message e);

     

       105
       105
       -
               Printf.eprintf "\nPlease create a ~/.zuliprc file with:\n";

     

       106
       106
       -
               Printf.eprintf "[api]\n";

     

       107
       107
       -
               Printf.eprintf "email=bot@example.com\n";

     

       108
       108
       -
               Printf.eprintf "key=your-api-key\n";

     

       109
       109
       -
               Printf.eprintf "site=https://your-domain.zulipchat.com\n";

     

       189
       189
       +
               Log.err (fun m -> m "Failed to load .zuliprc: %s" (Zulip.Error.message e));

     

       190
       190
       +
               Log.app (fun m -> m "\nPlease create a ~/.zuliprc file with:");

     

       191
       191
       +
               Log.app (fun m -> m "[api]");

     

       192
       192
       +
               Log.app (fun m -> m "email=bot@example.com");

     

       193
       193
       +
               Log.app (fun m -> m "key=your-api-key");

     

       194
       194
       +
               Log.app (fun m -> m "site=https://your-domain.zulipchat.com");

     

       110
       195
        
               exit 1

     

       111
       196
        
         in

     

       112
       197
        
       

     

       113
       198
        
         Eio.Switch.run @@ fun sw ->

     

       199
       199
       +
         Log.debug (fun m -> m "Creating Zulip client");

     

       114
       200
        
         let client = Zulip.Client.create ~sw env auth in

     

       115
       201
        
       

     

       116
       202
        
         (* Create bot configuration *)

     

       117
       203
        
         let config = Bot_config.create [] in

     

       118
       204
        
         let bot_email = Zulip.Auth.email auth in

     

       205
       205
       +
       

     

       206
       206
       +
         Log.debug (fun m -> m "Creating bot storage for %s" bot_email);

     

       119
       207
        
         let storage = Bot_storage.create client ~bot_email in

     

       208
       208
       +
       

     

       120
       209
        
         let identity = Bot_handler.Identity.create

     

       121
       210
        
           ~full_name:"Echo Bot"

     

       122
       211
        
           ~email:bot_email

     

       123
       212
        
           ~mention_name:"echobot"

     

       124
       213
        
         in

     

       214
       214
       +
         Log.info (fun m -> m "Bot identity created: %s (%s)"

     

       215
       215
       +
           (Bot_handler.Identity.full_name identity)

     

       216
       216
       +
           (Bot_handler.Identity.email identity));

     

       125
       217
        
       

     

       126
       218
        
         (* Create and run the bot *)

     

       219
       219
       +
         Log.debug (fun m -> m "Creating bot handler");

     

       127
       220
        
         let handler = Bot_handler.create

     

       128
       221
        
           (module Echo_bot_handler)

     

       129
       222
        
           ~config ~storage ~identity

     

       130
       223
        
         in

     

       131
       224
        
       

     

       225
       225
       +
         Log.debug (fun m -> m "Creating bot runner");

     

       132
       226
        
         let runner = Bot_runner.create ~env ~client ~handler in

     

       133
       227
        
       

     

       134
       134
       -
         Printf.printf "Echo bot is running!\n";

     

       135
       135
       -
         Printf.printf "Send a direct message or mention @echobot in a channel.\n";

     

       136
       136
       -
         Printf.printf "Press Ctrl+C to stop.\n\n";

     

       228
       228
       +
         Log.app (fun m -> m "Echo bot is running!");

     

       229
       229
       +
         Log.app (fun m -> m "Send a direct message or mention @echobot in a channel.");

     

       230
       230
       +
         Log.app (fun m -> m "Commands: 'help', 'ping', or any message to echo");

     

       231
       231
       +
         Log.app (fun m -> m "Press Ctrl+C to stop.\n");

     

       137
       232
        
       

     

       138
       233
        
         (* Run in real-time mode *)

     

       139
       139
       -
         Bot_runner.run_realtime runner

     

       234
       234
       +
         Log.info (fun m -> m "Starting real-time event loop");

     

       235
       235
       +
         try

     

       236
       236
       +
           Bot_runner.run_realtime runner;

     

       237
       237
       +
           Log.info (fun m -> m "Bot runner exited normally")

     

       238
       238
       +
         with

     

       239
       239
       +
         | Sys.Break ->

     

       240
       240
       +
             Log.info (fun m -> m "Received interrupt signal, shutting down");

     

       241
       241
       +
             Bot_runner.shutdown runner

     

       242
       242
       +
         | exn ->

     

       243
       243
       +
             Log.err (fun m -> m "Bot crashed with exception: %s" (Printexc.to_string exn));

     

       244
       244
       +
             Log.debug (fun m -> m "Backtrace: %s" (Printexc.get_backtrace ()));

     

       245
       245
       +
             raise exn

     

       246
       246
       +
       

     

       247
       247
       +
       (* Command-line interface *)

     

       248
       248
       +
       open Cmdliner

     

       249
       249
       +
       

     

       250
       250
       +
       let config_file =

     

       251
       251
       +
         let doc = "Path to .zuliprc configuration file" in

     

       252
       252
       +
         Arg.(value & opt (some string) None & info ["c"; "config"] ~docv:"FILE" ~doc)

     

       253
       253
       +
       

     

       254
       254
       +
       let verbosity =

     

       255
       255
       +
         let doc = "Increase verbosity. Use multiple times for more verbose output." in

     

       256
       256
       +
         Arg.(value & flag_all & info ["v"; "verbose"] ~doc)

     

       257
       257
       +
       

     

       258
       258
       +
       let verbosity_term =

     

       259
       259
       +
         Term.(const List.length $ verbosity)

     

       260
       260
       +
       

     

       261
       261
       +
       let bot_cmd env =

     

       262
       262
       +
         let doc = "Zulip Echo Bot with verbose logging" in

     

       263
       263
       +
         let man = [

     

       264
       264
       +
           `S Manpage.s_description;

     

       265
       265
       +
           `P "A simple echo bot for Zulip that responds to messages by echoing them back. \

     

       266
       266
       +
               Features verbose logging for debugging and development.";

     

       267
       267
       +
           `S "CONFIGURATION";

     

       268
       268
       +
           `P "The bot reads configuration from a .zuliprc file (default: ~/.zuliprc).";

     

       269
       269
       +
           `P "The file should contain:";

     

       270
       270
       +
           `Pre "[api]\n\

     

       271
       271
       +
                 email=bot@example.com\n\

     

       272
       272
       +
                 key=your-api-key\n\

     

       273
       273
       +
                 site=https://your-domain.zulipchat.com";

     

       274
       274
       +
           `S "LOGGING";

     

       275
       275
       +
           `P "Use -v for info level logging, -vv for debug level logging.";

     

       276
       276
       +
           `P "Log messages include:";

     

       277
       277
       +
           `P "- Message metadata (sender, type, ID)";

     

       278
       278
       +
           `P "- Message processing steps";

     

       279
       279
       +
           `P "- Bot responses";

     

       280
       280
       +
           `P "- Error conditions";

     

       281
       281
       +
           `S "COMMANDS";

     

       282
       282
       +
           `P "The bot responds to:";

     

       283
       283
       +
           `P "- 'help' - Show usage information";

     

       284
       284
       +
           `P "- 'ping' - Respond with 'Pong!'";

     

       285
       285
       +
           `P "- Any other message - Echo it back";

     

       286
       286
       +
           `S Manpage.s_examples;

     

       287
       287
       +
           `P "Run with default configuration:";

     

       288
       288
       +
           `Pre "  echo_bot";

     

       289
       289
       +
           `P "Run with verbose logging:";

     

       290
       290
       +
           `Pre "  echo_bot -v";

     

       291
       291
       +
           `P "Run with debug logging:";

     

       292
       292
       +
           `Pre "  echo_bot -vv";

     

       293
       293
       +
           `P "Run with custom config file:";

     

       294
       294
       +
           `Pre "  echo_bot -c /path/to/.zuliprc";

     

       295
       295
       +
           `P "Run with maximum verbosity and custom config:";

     

       296
       296
       +
           `Pre "  echo_bot -vv -c ~/my-bot.zuliprc";

     

       297
       297
       +
           `S Manpage.s_bugs;

     

       298
       298
       +
           `P "Report bugs at https://github.com/your-org/zulip-ocaml/issues";

     

       299
       299
       +
           `S Manpage.s_see_also;

     

       300
       300
       +
           `P "zulip(1), zulip-bot(1)";

     

       301
       301
       +
         ] in

     

       302
       302
       +
         let info = Cmd.info "echo_bot" ~version:"1.0.0" ~doc ~man in

     

       303
       303
       +
         Cmd.v info Term.(const (run_echo_bot) $ config_file $ verbosity_term $ const env)

     

       140
       304
        
       

     

       141
       305
        
       let () =

     

       142
       142
       -
         Eio_main.run run_echo_bot
     

       306
       306
       +
         Eio_main.run @@ fun env ->

     

       307
       307
       +
         exit (Cmd.eval (bot_cmd env))