wme-cli 0.1.3

//! Wikimedia Enterprise CLI
//!
//! A command-line interface for interacting with the Wikimedia Enterprise API.
//!
//! # Overview
//!
//! This CLI provides access to:
//! - **Authentication**: Login, token refresh, and password management
//! - **Metadata**: Browse project codes, languages, projects, and namespaces
//! - **Articles**: Fetch individual articles and structured data
//! - **Snapshots**: List, inspect, and download snapshot files
//! - **Realtime**: Stream live updates and manage realtime batches
//!
//! # Architecture
//!
//! The CLI is organized into modules:
//! - `client`: HTTP client builder and error mapping
//! - `commands`: CLI command implementations (auth, meta, article, snapshot, realtime)
//! - `config`: Configuration management (tokens stored in ~/.wme/config.json)
//! - `output`: Output formatting (JSON, NDJSON, table, quiet)
//! - `util`: Utility functions (formatting, prompts, parameter building)
//!
//! # Usage
//!
//! ```bash
//! # Authenticate
//! wme auth login
//!
//! # List project codes
//! wme meta project-codes
//!
//! # Get an article
//! wme article get "Main_Page"
//!
//! # List snapshots
//! wme snapshot list
//! ```

use anyhow::Result;
use clap::{Parser, Subcommand};
use std::path::PathBuf;
use tracing::info;

mod client;
mod commands;
mod config;
mod output;
mod util;

use commands::{article, auth, meta, realtime, snapshot};
use config::Config;
use output::OutputFormat;

/// Wikimedia Enterprise CLI
///
/// Command-line interface for the Wikimedia Enterprise API.
/// Run `wme --help` to see available commands.
#[derive(Parser)]
#[command(name = "wme")]
#[command(about = "CLI for Wikimedia Enterprise API")]
#[command(version)]
#[command(propagate_version = true)]
struct Cli {
    /// Bearer access token (overrides stored token)
    #[arg(long, global = true, env = "WME_TOKEN")]
    token: Option<String>,

    /// Output format
    #[arg(short, long, global = true, default_value = "json")]
    output: OutputFormat,

    /// Comma-separated fields to include in response
    #[arg(long, global = true)]
    fields: Option<String>,

    /// Field filter as field=value (repeatable)
    #[arg(long, global = true)]
    filter: Vec<String>,

    /// Max results to return
    #[arg(long, global = true)]
    limit: Option<usize>,

    /// Path to config file
    #[arg(long, global = true, env = "WME_CONFIG")]
    config: Option<PathBuf>,

    /// Enable verbose logging
    #[arg(short, long, global = true)]
    verbose: bool,

    /// Subcommand to run
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Authentication commands
    Auth {
        #[command(subcommand)]
        command: AuthCommands,
    },

    /// Metadata commands
    Meta {
        #[command(subcommand)]
        command: MetaCommands,
    },

    /// Article on-demand API commands
    Article {
        #[command(subcommand)]
        command: ArticleCommands,
    },

    /// Snapshot API commands
    Snapshot {
        #[command(subcommand)]
        command: SnapshotCommands,
    },

    /// Realtime API commands
    Realtime {
        #[command(subcommand)]
        command: RealtimeCommands,
    },
}

#[derive(Subcommand)]
enum AuthCommands {
    /// Login and store tokens
    Login {
        /// API username
        #[arg(short, long, env = "WME_USERNAME")]
        username: Option<String>,

        /// API password
        #[arg(short, long, env = "WME_PASSWORD")]
        password: Option<String>,
    },

    /// Refresh access token
    Refresh {
        /// API username
        #[arg(short, long, env = "WME_USERNAME")]
        username: Option<String>,

        /// Refresh token
        #[arg(long)]
        refresh_token: Option<String>,
    },

    /// Revoke the refresh token
    Revoke {
        /// Refresh token to revoke
        #[arg(long)]
        refresh_token: Option<String>,
    },

    /// Trigger forgot password email
    ForgotPassword {
        /// Username
        #[arg(long)]
        username: String,
    },

    /// Confirm forgot password with code
    ForgotPasswordConfirm {
        /// Username
        #[arg(long)]
        username: String,

        /// New password
        #[arg(long)]
        password: String,

        /// Confirmation code from email
        #[arg(long)]
        code: String,
    },

    /// Change password (requires authentication)
    ChangePassword {
        /// Previous password
        #[arg(long)]
        previous_password: String,

        /// Proposed new password
        #[arg(long)]
        proposed_password: String,
    },

    /// Set new password for NEW_PASSWORD_REQUIRED challenge
    SetNewPassword {
        /// Username
        #[arg(long)]
        username: String,

        /// Session string
        #[arg(long)]
        session: String,

        /// New password
        #[arg(long)]
        new_password: String,
    },
}

#[derive(Subcommand)]
enum MetaCommands {
    /// List all project codes
    ProjectCodes,

    /// Get specific project code info
    #[command(name = "project-codes-get")]
    ProjectCodesGet {
        /// Project code
        #[arg(value_name = "CODE")]
        code: String,
    },

    /// List all languages
    Languages,

    /// Get specific language info
    #[command(name = "languages-get")]
    LanguagesGet {
        /// Language identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,
    },

    /// List all projects
    Projects,

    /// Get specific project info
    #[command(name = "projects-get")]
    ProjectsGet {
        /// Project identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,
    },

    /// List all namespaces
    Namespaces,

    /// Get specific namespace info
    #[command(name = "namespaces-get")]
    NamespacesGet {
        /// Namespace ID
        #[arg(value_name = "ID")]
        id: u32,
    },
}

#[derive(Subcommand)]
enum ArticleCommands {
    /// Get a single article
    Get {
        /// Article name
        #[arg(value_name = "NAME")]
        name: String,
    },

    /// Get structured article data (BETA)
    Structured {
        /// Article name
        #[arg(value_name = "NAME")]
        name: String,
    },
}

#[derive(Subcommand)]
enum SnapshotCommands {
    /// List available snapshots
    List,

    /// Get snapshot metadata
    Info {
        /// Snapshot identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,
    },

    /// Download a snapshot
    Download {
        /// Snapshot identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,

        /// Output file path
        #[arg(short = 'f', long = "output-file")]
        output_file: Option<PathBuf>,

        /// HTTP Range header for resumable download
        #[arg(long)]
        range: Option<String>,
    },

    /// Chunk commands
    Chunks {
        #[command(subcommand)]
        command: SnapshotChunkCommands,
    },

    /// Structured snapshot commands (BETA)
    Structured {
        #[command(subcommand)]
        command: StructuredSnapshotCommands,
    },
}

#[derive(Subcommand)]
enum SnapshotChunkCommands {
    /// List chunks for a snapshot
    List {
        /// Snapshot identifier
        #[arg(value_name = "SNAPSHOT_ID")]
        snapshot_id: String,
    },

    /// Get chunk metadata
    Info {
        /// Snapshot identifier
        #[arg(value_name = "SNAPSHOT_ID")]
        snapshot_id: String,

        /// Chunk identifier
        #[arg(value_name = "CHUNK_ID")]
        chunk_id: String,
    },

    /// Download a chunk
    Download {
        /// Snapshot identifier
        #[arg(value_name = "SNAPSHOT_ID")]
        snapshot_id: String,

        /// Chunk identifier
        #[arg(value_name = "CHUNK_ID")]
        chunk_id: String,

        /// Output file path
        #[arg(short = 'f', long = "output-file")]
        output_file: Option<PathBuf>,

        /// HTTP Range header for resumable download
        #[arg(long)]
        range: Option<String>,
    },
}

#[derive(Subcommand)]
enum StructuredSnapshotCommands {
    /// List structured snapshots
    List,

    /// Get structured snapshot metadata
    Info {
        /// Snapshot identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,
    },

    /// Download structured snapshot
    Download {
        /// Snapshot identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,

        /// Output file path
        #[arg(short = 'f', long = "output-file")]
        output_file: Option<PathBuf>,

        /// HTTP Range header for resumable download
        #[arg(long)]
        range: Option<String>,
    },
}

#[derive(Subcommand)]
enum RealtimeCommands {
    /// Connect to realtime SSE stream
    Stream {
        /// Resume from timestamp (RFC3339)
        #[arg(long)]
        since: Option<String>,

        /// Partition numbers (repeatable)
        #[arg(long)]
        parts: Vec<u32>,

        /// Partition:offset map as JSON
        #[arg(long)]
        offsets: Option<String>,

        /// Partition:timestamp map as JSON
        #[arg(long = "since-per-partition")]
        since_per_partition: Option<String>,

        /// Request NDJSON instead of SSE
        #[arg(long)]
        ndjson: bool,
    },

    /// Batch commands
    Batches {
        #[command(subcommand)]
        command: RealtimeBatchCommands,
    },
}

#[derive(Subcommand)]
enum RealtimeBatchCommands {
    /// List batches for a date/hour
    List {
        /// Date (YYYY-MM-DD)
        #[arg(value_name = "DATE")]
        date: String,

        /// Hour (00-23)
        #[arg(value_name = "HOUR")]
        hour: String,
    },

    /// Get batch metadata
    Info {
        /// Date (YYYY-MM-DD)
        #[arg(value_name = "DATE")]
        date: String,

        /// Hour (00-23)
        #[arg(value_name = "HOUR")]
        hour: String,

        /// Batch identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,
    },

    /// Download a batch
    Download {
        /// Date (YYYY-MM-DD)
        #[arg(value_name = "DATE")]
        date: String,

        /// Hour (00-23)
        #[arg(value_name = "HOUR")]
        hour: String,

        /// Batch identifier
        #[arg(value_name = "IDENTIFIER")]
        identifier: String,

        /// Output file path
        #[arg(short = 'f', long = "output-file")]
        output_file: Option<PathBuf>,

        /// HTTP Range header for resumable download
        #[arg(long)]
        range: Option<String>,
    },
}

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    // Setup logging
    let level = if cli.verbose { "debug" } else { "warn" };
    tracing_subscriber::fmt()
        .with_env_filter(format!("wme_cli={level},warn"))
        .init();

    // Load config
    let config = Config::load(cli.config.as_deref())?;

    // Parse global options
    let global_opts = commands::GlobalOpts {
        token: cli.token,
        output: cli.output,
        fields: cli.fields,
        filter: cli.filter,
        limit: cli.limit,
        config,
    };

    info!("Starting wme CLI");

    match cli.command {
        Commands::Auth { command } => match command {
            AuthCommands::Login { username, password } => {
                auth::login(username, password, &global_opts).await?;
            }
            AuthCommands::Refresh {
                username,
                refresh_token,
            } => {
                auth::refresh(username, refresh_token, &global_opts).await?;
            }
            AuthCommands::Revoke { refresh_token } => {
                auth::revoke(refresh_token, &global_opts).await?;
            }
            AuthCommands::ForgotPassword { username } => {
                auth::forgot_password(&username, &global_opts).await?;
            }
            AuthCommands::ForgotPasswordConfirm {
                username,
                password,
                code,
            } => {
                auth::forgot_password_confirm(&username, &password, &code, &global_opts).await?;
            }
            AuthCommands::ChangePassword {
                previous_password,
                proposed_password,
            } => {
                auth::change_password(&previous_password, &proposed_password, &global_opts).await?;
            }
            AuthCommands::SetNewPassword {
                username,
                session,
                new_password,
            } => {
                auth::set_new_password(&username, &session, &new_password, &global_opts).await?;
            }
        },
        Commands::Meta { command } => match command {
            MetaCommands::ProjectCodes => {
                meta::project_codes(&global_opts).await?;
            }
            MetaCommands::ProjectCodesGet { code } => {
                meta::project_codes_get(&code, &global_opts).await?;
            }
            MetaCommands::Languages => {
                meta::languages(&global_opts).await?;
            }
            MetaCommands::LanguagesGet { identifier } => {
                meta::languages_get(&identifier, &global_opts).await?;
            }
            MetaCommands::Projects => {
                meta::projects(&global_opts).await?;
            }
            MetaCommands::ProjectsGet { identifier } => {
                meta::projects_get(&identifier, &global_opts).await?;
            }
            MetaCommands::Namespaces => {
                meta::namespaces(&global_opts).await?;
            }
            MetaCommands::NamespacesGet { id } => {
                meta::namespaces_get(id, &global_opts).await?;
            }
        },
        Commands::Article { command } => match command {
            ArticleCommands::Get { name } => {
                article::get(&name, &global_opts).await?;
            }
            ArticleCommands::Structured { name } => {
                article::structured(&name, &global_opts).await?;
            }
        },
        Commands::Snapshot { command } => match command {
            SnapshotCommands::List => {
                snapshot::list(&global_opts).await?;
            }
            SnapshotCommands::Info { identifier } => {
                snapshot::info(&identifier, &global_opts).await?;
            }
            SnapshotCommands::Download {
                identifier,
                output_file,
                range,
            } => {
                snapshot::download(&identifier, output_file, range, &global_opts).await?;
            }
            SnapshotCommands::Chunks { command } => match command {
                SnapshotChunkCommands::List { snapshot_id } => {
                    snapshot::chunks_list(&snapshot_id, &global_opts).await?;
                }
                SnapshotChunkCommands::Info {
                    snapshot_id,
                    chunk_id,
                } => {
                    snapshot::chunks_info(&snapshot_id, &chunk_id, &global_opts).await?;
                }
                SnapshotChunkCommands::Download {
                    snapshot_id,
                    chunk_id,
                    output_file,
                    range,
                } => {
                    snapshot::chunks_download(
                        &snapshot_id,
                        &chunk_id,
                        output_file,
                        range,
                        &global_opts,
                    )
                    .await?;
                }
            },
            SnapshotCommands::Structured { command } => match command {
                StructuredSnapshotCommands::List => {
                    snapshot::structured_list(&global_opts).await?;
                }
                StructuredSnapshotCommands::Info { identifier } => {
                    snapshot::structured_info(&identifier, &global_opts).await?;
                }
                StructuredSnapshotCommands::Download {
                    identifier,
                    output_file,
                    range,
                } => {
                    snapshot::structured_download(&identifier, output_file, range, &global_opts)
                        .await?;
                }
            },
        },
        Commands::Realtime { command } => match command {
            RealtimeCommands::Stream {
                since,
                parts,
                offsets,
                since_per_partition,
                ndjson,
            } => {
                realtime::stream(
                    since,
                    parts,
                    offsets,
                    since_per_partition,
                    ndjson,
                    &global_opts,
                )
                .await?;
            }
            RealtimeCommands::Batches { command } => match command {
                RealtimeBatchCommands::List { date, hour } => {
                    realtime::batches_list(&date, &hour, &global_opts).await?;
                }
                RealtimeBatchCommands::Info {
                    date,
                    hour,
                    identifier,
                } => {
                    realtime::batches_info(&date, &hour, &identifier, &global_opts).await?;
                }
                RealtimeBatchCommands::Download {
                    date,
                    hour,
                    identifier,
                    output_file,
                    range,
                } => {
                    realtime::batches_download(
                        &date,
                        &hour,
                        &identifier,
                        output_file,
                        range,
                        &global_opts,
                    )
                    .await?;
                }
            },
        },
    }

    Ok(())
}