✨ feat(cli): search + system subcommands

Author: chaizhenhua

crates/oversight-cli/src/cli.rs

@@ -60,6 +60,10 @@ pub enum Command {
     Run(run::RunArgs),
     /// Manage scheduled agent runs
     Schedules(commands::schedules::SchedulesArgs),
+    /// Search across tasks, documents, and projects
+    Search(commands::search::SearchArgs),
+    /// System status, stats, and activity log
+    System(commands::system::SystemArgs),
     /// Manage tasks
     Tasks(commands::tasks::TasksArgs),
     /// Manage workflows

crates/oversight-cli/src/commands/mod.rs

@@ -9,5 +9,7 @@ pub mod inbox;
 pub mod milestones;
 pub mod projects;
 pub mod schedules;
+pub mod search;
+pub mod system;
 pub mod tasks;
 pub mod workflows;

crates/oversight-cli/src/commands/search.rs

@@ -0,0 +1,98 @@
+use anyhow::{Context, Result};
+use clap::Args;
+
+use crate::cli::{self, GlobalArgs};
+use crate::config::Config;
+use crate::output::{render_list, resolve_format, TableView};
+
+#[derive(Debug, Args)]
+pub struct SearchArgs {
+    /// Search query
+    pub query: String,
+    /// lexical | semantic | hybrid (default hybrid)
+    #[arg(long)]
+    pub mode: Option<String>,
+    /// Comma-separated entity types (task, document, project)
+    #[arg(long)]
+    pub types: Option<String>,
+    /// Max results (1-100, default 20)
+    #[arg(long)]
+    pub limit: Option<u32>,
+}
+
+pub async fn execute(args: SearchArgs, globals: &GlobalArgs) -> Result<()> {
+    let config_path = Config::default_path()?;
+    let mut config = Config::load(&config_path)?;
+    config.apply_profile_override(globals.profile.as_deref())?;
+    let client = cli::client_from_globals(&config, globals).await?;
+
+    let resp = client
+        .search(
+            &args.query,
+            args.mode.as_deref(),
+            args.types.as_deref(),
+            args.limit,
+        )
+        .await
+        .context("search")?;
+
+    if let Some(reason) = &resp.degraded_reason {
+        eprintln!("note: {reason}");
+    }
+
+    let view = TableView {
+        headers: vec!["TYPE", "ID", "TITLE", "SCORE"],
+        rows: resp
+            .results
+            .iter()
+            .map(|r| {
+                vec![
+                    r.entity_type.clone(),
+                    short_id(&r.id),
+                    r.title.clone(),
+                    format!("{:.3}", r.score),
+                ]
+            })
+            .collect(),
+    };
+    let fmt = resolve_format(globals.format.unwrap_or_default());
+    let out = render_list(&resp.results, view, fmt)?;
+    println!("{out}");
+    Ok(())
+}
+
+fn short_id(id: &str) -> String {
+    if id.len() <= 8 {
+        id.to_string()
+    } else {
+        format!("{}…", &id[..8])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::Parser;
+
+    #[derive(Parser)]
+    struct Wrapper {
+        #[command(flatten)]
+        args: SearchArgs,
+    }
+
+    #[test]
+    fn parses_query_with_mode_and_limit() {
+        let w = Wrapper::try_parse_from(["test", "needle", "--mode", "lexical", "--limit", "5"])
+            .unwrap();
+        assert_eq!(w.args.query, "needle");
+        assert_eq!(w.args.mode.as_deref(), Some("lexical"));
+        assert_eq!(w.args.limit, Some(5));
+    }
+
+    #[test]
+    fn parses_query_only() {
+        let w = Wrapper::try_parse_from(["test", "auth"]).unwrap();
+        assert_eq!(w.args.query, "auth");
+        assert!(w.args.mode.is_none());
+    }
+}

crates/oversight-cli/src/commands/system.rs

@@ -0,0 +1,136 @@
+use anyhow::{Context, Result};
+use clap::{Args, Subcommand};
+
+use crate::cli::{self, GlobalArgs};
+use crate::client::ApiClient;
+use crate::config::Config;
+use crate::output::{render_describe, render_list, resolve_format, TableView};
+
+#[derive(Debug, Args)]
+pub struct SystemArgs {
+    #[command(subcommand)]
+    pub command: SystemCommand,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum SystemCommand {
+    /// Health check (status, version, uptime)
+    Status,
+    /// Global statistics (documents, edges, top labels)
+    Stats,
+    /// Recent agent activities
+    Activities {
+        #[arg(long)]
+        agent: Option<String>,
+        #[arg(long)]
+        task: Option<String>,
+        #[arg(long, default_value_t = 50)]
+        limit: u32,
+    },
+}
+
+pub async fn execute(args: SystemArgs, globals: &GlobalArgs) -> Result<()> {
+    let config_path = Config::default_path()?;
+    let mut config = Config::load(&config_path)?;
+    config.apply_profile_override(globals.profile.as_deref())?;
+    let client = cli::client_from_globals(&config, globals).await?;
+
+    match args.command {
+        SystemCommand::Status => status(&client, globals).await,
+        SystemCommand::Stats => stats(&client, globals).await,
+        SystemCommand::Activities { agent, task, limit } => {
+            activities(&client, agent.as_deref(), task.as_deref(), limit, globals).await
+        }
+    }
+}
+
+async fn status(client: &ApiClient, globals: &GlobalArgs) -> Result<()> {
+    let h = client.health().await.context("get health")?;
+    let fmt = resolve_format(globals.format.unwrap_or_default());
+    println!("{}", render_describe(&h, fmt)?);
+    Ok(())
+}
+
+async fn stats(client: &ApiClient, globals: &GlobalArgs) -> Result<()> {
+    let s = client.stats().await.context("get stats")?;
+    let fmt = resolve_format(globals.format.unwrap_or_default());
+    println!("{}", render_describe(&s, fmt)?);
+    Ok(())
+}
+
+async fn activities(
+    client: &ApiClient,
+    agent_id: Option<&str>,
+    task_id: Option<&str>,
+    limit: u32,
+    globals: &GlobalArgs,
+) -> Result<()> {
+    let acts = client
+        .list_activities(agent_id, task_id, Some(limit))
+        .await
+        .context("list activities")?;
+    let view = TableView {
+        headers: vec!["WHEN", "AGENT", "TYPE", "STATUS", "TASK", "COST"],
+        rows: acts
+            .iter()
+            .map(|a| {
+                vec![
+                    a.created_at.clone(),
+                    a.agent_id.clone(),
+                    a.activity_type.clone(),
+                    a.status.clone(),
+                    a.task_id
+                        .as_deref()
+                        .map(short_id)
+                        .unwrap_or_else(|| "-".into()),
+                    format!("{:.4}", a.cost_usd),
+                ]
+            })
+            .collect(),
+    };
+    let fmt = resolve_format(globals.format.unwrap_or_default());
+    let out = render_list(&acts, view, fmt)?;
+    println!("{out}");
+    Ok(())
+}
+
+fn short_id(id: &str) -> String {
+    if id.len() <= 8 {
+        id.to_string()
+    } else {
+        format!("{}…", &id[..8])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::Parser;
+
+    #[derive(Parser)]
+    struct Wrapper {
+        #[command(subcommand)]
+        cmd: SystemCommand,
+    }
+
+    #[test]
+    fn parses_status() {
+        let w = Wrapper::try_parse_from(["test", "status"]).unwrap();
+        assert!(matches!(w.cmd, SystemCommand::Status));
+    }
+
+    #[test]
+    fn parses_activities_with_filters() {
+        let w =
+            Wrapper::try_parse_from(["test", "activities", "--agent", "coder", "--limit", "10"])
+                .unwrap();
+        match w.cmd {
+            SystemCommand::Activities { agent, task, limit } => {
+                assert_eq!(agent.as_deref(), Some("coder"));
+                assert!(task.is_none());
+                assert_eq!(limit, 10);
+            }
+            _ => panic!("expected Activities"),
+        }
+    }
+}

crates/oversight-cli/src/main.rs

@@ -36,6 +36,8 @@ async fn main() -> anyhow::Result<()> {
         cli::Command::Projects(args) => commands::projects::execute(args, &globals).await,
         cli::Command::Run(args) => run::execute(args).await,
         cli::Command::Schedules(args) => commands::schedules::execute(args, &globals).await,
+        cli::Command::Search(args) => commands::search::execute(args, &globals).await,
+        cli::Command::System(args) => commands::system::execute(args, &globals).await,
         cli::Command::Tasks(args) => commands::tasks::execute(args, &globals).await,
         cli::Command::Workflows(args) => commands::workflows::execute(args, &globals).await,
         cli::Command::Worker(args) => worker::execute(args).await,