Merge pull request #9416 from gitbutlerapp/but-cli-posthog

but-cli-posthog

Author: krlvi

Cargo.lock

@@ -27,6 +27,8 @@ bstr.workspace = true
 anyhow.workspace = true
 # rmcp = { git = "https://github.com/modelcontextprotocol/rust-sdk", branch = "main" }
 rmcp = "0.1.5"
+command-group = { version = "5.0.1", features = ["with-tokio"] }
+sysinfo = "0.36.0"
 gitbutler-project.workspace = true
 gix.workspace = true
 but-core.workspace = true

crates/but/Cargo.toml

@@ -50,6 +50,47 @@ For examples `but rub --help`.")]
     // Claude hooks
     #[clap(hide = true)]
     Claude(claude::Platform),
+    /// If metrics are permitted, this subcommand handles posthog event creation.
+    #[clap(hide = true)]
+    Metrics {
+        #[clap(long, value_enum)]
+        command_name: CommandName,
+        #[clap(long)]
+        props: String,
+    },
+}
+
+#[derive(Debug, Clone, Copy, clap::ValueEnum, Default)]
+pub enum CommandName {
+    #[clap(alias = "log")]
+    Log,
+    #[clap(alias = "status")]
+    Status,
+    #[clap(alias = "rub")]
+    Rub,
+    #[clap(
+        alias = "claude-pre-tool",
+        alias = "claudepretool",
+        alias = "claudePreTool",
+        alias = "ClaudePreTool"
+    )]
+    ClaudePreTool,
+    #[clap(
+        alias = "claude-post-tool",
+        alias = "claudeposttool",
+        alias = "claudePostTool",
+        alias = "ClaudePostTool"
+    )]
+    ClaudePostTool,
+    #[clap(
+        alias = "claude-stop",
+        alias = "claudestop",
+        alias = "claudeStop",
+        alias = "ClaudeStop"
+    )]
+    ClaudeStop,
+    #[default]
+    Unknown,
 }
 
 pub mod actions {

crates/but/src/args.rs

@@ -1,8 +1,9 @@
-use anyhow::{Context, Ok, Result};
+use anyhow::{Context, Result};
 
 mod args;
-use args::{Args, Subcommands, actions, claude};
+use args::{Args, CommandName, Subcommands, actions, claude};
 use but_settings::AppSettings;
+use metrics::{Event, Metrics, Props, metrics_if_configured};
 mod command;
 mod id;
 mod log;
@@ -19,6 +20,7 @@ async fn main() -> Result<()> {
 
     let namespace = option_env!("IDENTIFIER").unwrap_or("com.gitbutler.app");
     gitbutler_secret::secret::set_application_namespace(namespace);
+    let start = std::time::Instant::now();
 
     match &args.cmd {
         Subcommands::Mcp { internal } => {
@@ -38,32 +40,70 @@ async fn main() -> Result<()> {
             }
             None => command::list_actions(&args.current_dir, args.json, 0, 10),
         },
+        Subcommands::Metrics {
+            command_name,
+            props,
+        } => {
+            let event = &mut Event::new((*command_name).into());
+            if let Ok(props) = Props::from_json_string(props) {
+                props.update_event(event);
+            }
+            Metrics::capture_blocking(&app_settings, event.clone()).await;
+            Ok(())
+        }
         Subcommands::Claude(claude::Platform { cmd }) => match cmd {
             claude::Subcommands::PreTool => {
-                let out = command::claude::handle_pre_tool_call()?;
-                println!("{}", serde_json::to_string(&out)?);
+                let result = command::claude::handle_pre_tool_call();
+                let p = props(start, &result);
+                println!("{}", serde_json::to_string(&result?)?);
+                metrics_if_configured(app_settings, CommandName::ClaudePreTool, p).ok();
                 Ok(())
             }
             claude::Subcommands::PostTool => {
-                let out = command::claude::handle_post_tool_call()?;
-                println!("{}", serde_json::to_string(&out)?);
+                let result = command::claude::handle_post_tool_call();
+                let p = props(start, &result);
+                println!("{}", serde_json::to_string(&result?)?);
+                metrics_if_configured(app_settings, CommandName::ClaudePostTool, p).ok();
                 Ok(())
             }
             claude::Subcommands::Stop => {
-                let out = command::claude::handle_stop().await?;
-                println!("{}", serde_json::to_string(&out)?);
+                let result = command::claude::handle_stop().await;
+                let p = props(start, &result);
+                println!("{}", serde_json::to_string(&result?)?);
+                metrics_if_configured(app_settings, CommandName::ClaudeStop, p).ok();
                 Ok(())
             }
         },
-        Subcommands::Log => log::commit_graph(&args.current_dir, args.json),
-        Subcommands::Status => status::worktree(&args.current_dir, args.json),
+        Subcommands::Log => {
+            let result = log::commit_graph(&args.current_dir, args.json);
+            metrics_if_configured(app_settings, CommandName::Log, props(start, &result)).ok();
+            Ok(())
+        }
+        Subcommands::Status => {
+            let result = status::worktree(&args.current_dir, args.json);
+            metrics_if_configured(app_settings, CommandName::Status, props(start, &result)).ok();
+            Ok(())
+        }
         Subcommands::Rub { source, target } => {
             let result = rub::handle(&args.current_dir, args.json, source, target)
                 .context("Rubbed the wrong way.");
             if let Err(e) = &result {
                 eprintln!("{} {}", e, e.root_cause());
             }
+            metrics_if_configured(app_settings, CommandName::Rub, props(start, &result)).ok();
             Ok(())
         }
     }
 }
+
+fn props<E, T, R>(start: std::time::Instant, result: R) -> Props
+where
+    R: std::ops::Deref<Target = Result<T, E>>,
+    E: std::fmt::Display,
+{
+    let error = result.as_ref().err().map(|e| e.to_string());
+    let mut props = Props::new();
+    props.insert("durationMs", start.elapsed().as_millis());
+    props.insert("error", error);
+    props
+}