void-cli 0.0.3

use clap::{Parser, Subcommand};
use std::path::PathBuf;

mod commands;
mod context;
mod daemon;
mod ipfs_utils;
mod keyring;
mod observer;
mod output;
mod registry;
mod repo_init;

use output::CliOptions;

#[derive(Parser)]
#[command(name = "void", version, about = "Anonymous encrypted source control")]
pub struct Cli {
    /// Output JSON (auto-detected if not TTY)
    #[arg(long, global = true)]
    json: bool,

    /// Force human-readable output even when piped
    #[arg(long, global = true)]
    human: bool,

    /// Suppress all non-JSON output
    #[arg(short, long, global = true)]
    quiet: bool,

    /// Show debug information
    #[arg(long, global = true)]
    debug: bool,

    /// Working directory
    #[arg(long, global = true, default_value = ".")]
    cwd: PathBuf,

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

    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Initialize a new void repository
    Init,

    /// Show working tree status
    Status {
        /// Paths to check status for (empty means all)
        #[arg()]
        paths: Vec<String>,
    },

    /// Stage files for commit
    Add {
        /// Paths to stage
        paths: Vec<String>,
    },

    /// Unstage files
    Reset {
        /// Paths to unstage
        paths: Vec<String>,
    },

    /// Restore files from a commit to the working tree
    #[command(alias = "checkout")]
    Restore {
        /// Paths to restore (empty means all)
        #[arg()]
        paths: Vec<String>,

        /// Commit to restore from (default: HEAD)
        #[arg(long)]
        source: Option<String>,

        /// Unstage files only (don't touch working tree)
        #[arg(long)]
        staged: bool,

        /// Overwrite local changes
        #[arg(short, long)]
        force: bool,
    },

    /// Create a new commit
    Commit {
        /// Commit message
        #[arg(short, long, default_value = "commit")]
        message: String,

        /// Sign commit with configured identity (default when identity exists)
        #[arg(short = 'S', long)]
        sign: bool,

        /// Do not sign commit (overrides auto-signing)
        #[arg(long = "no-sign")]
        no_sign: bool,

        /// Target compressed shard size (bytes)
        #[arg(long)]
        target_shard_size: Option<u64>,

        /// Maximum compressed shard size before splitting (bytes)
        #[arg(long)]
        max_shard_size: Option<u64>,

        /// Mmap file read threshold (bytes)
        #[arg(long)]
        mmap_threshold: Option<u64>,

        /// Shard padding strategy: none, power2, buckets, or fixed bytes
        #[arg(long)]
        padding: Option<String>,

        /// Allow commits that delete >50% of files
        #[arg(long)]
        allow_data_loss: bool,
    },

    /// Show commit history
    Log {
        /// Number of commits to show
        #[arg(short, long, default_value = "10")]
        number: usize,

        /// Skip signature verification
        #[arg(long = "no-verify", default_value = "false")]
        no_verify: bool,
    },

    /// Show changes between commits or working tree
    Diff {
        /// Commits to diff (0, 1, or 2)
        commits: Vec<String>,

        /// Show staged changes (index vs HEAD)
        #[arg(long)]
        staged: bool,

        /// Alias for --staged
        #[arg(long)]
        cached: bool,

        /// Show only file-level summary (no content diff)
        #[arg(long)]
        stat: bool,

        /// Disable colored output
        #[arg(long = "no-color")]
        no_color: bool,
    },

    /// Move/rename a file
    Mv {
        /// Source path
        source: String,

        /// Destination path
        dest: String,
    },

    /// Remove files from the index and working tree
    Rm {
        /// Paths to remove
        paths: Vec<String>,

        /// Remove from index only (keep on disk)
        #[arg(long)]
        cached: bool,

        /// Remove even with local changes
        #[arg(short, long)]
        force: bool,

        /// Allow directory removal
        #[arg(short, long)]
        recursive: bool,
    },

    /// Verify a commit signature
    Verify {
        /// Commit reference (CID, branch, tag, or HEAD)
        #[arg(default_value = "HEAD")]
        commit: String,
    },

    /// List contents of a tree at a given commit
    LsTree {
        /// Commit reference (HEAD, branch, tag, or CID)
        commit: String,

        /// Optional path prefix to filter
        path: Option<String>,

        /// Show only filenames (no mode/type/size)
        #[arg(long)]
        name_only: bool,

        /// Recurse into subdirectories
        #[arg(short, long)]
        recursive: bool,
    },

    /// Show commit details or file contents
    Show {
        /// Target: commit ref, commit:path, HEAD, or branch name
        target: String,

        /// Skip signature verification
        #[arg(long = "no-verify")]
        no_verify: bool,
    },

    /// Seal workspace into encrypted shards without creating a commit
    Seal {
        /// Target compressed shard size (bytes)
        #[arg(long)]
        target_shard_size: Option<u64>,

        /// Maximum compressed shard size before splitting (bytes)
        #[arg(long)]
        max_shard_size: Option<u64>,

        /// Shard padding strategy: none, power2, buckets, or fixed bytes
        #[arg(long)]
        padding: Option<String>,
    },

    /// Restore files from sealed shards (low-level)
    Unseal {
        /// Output directory (default: current working directory)
        #[arg(short, long)]
        output: Option<String>,

        /// Specific commit CID (default: HEAD)
        #[arg(long)]
        commit: Option<String>,

        /// List files only, don't extract
        #[arg(long)]
        list: bool,

        /// Don't fetch missing shards from IPFS
        #[arg(long)]
        offline: bool,

        /// Skip hash verification
        #[arg(long = "no-verify")]
        no_verify: bool,

        /// Backend type for fetching remote shards: kubo or gateway
        #[arg(long)]
        backend: Option<String>,

        /// Kubo API URL (default: http://127.0.0.1:5001)
        #[arg(long)]
        kubo: Option<String>,

        /// Gateway URL (required if backend is gateway)
        #[arg(long)]
        gateway: Option<String>,

        /// Request timeout in milliseconds (default: 30000)
        #[arg(long)]
        timeout: Option<u64>,
    },

    /// Repository information and statistics
    #[command(subcommand)]
    Repo(RepoCommands),

    /// Generate shell completion scripts
    Completion {
        /// Shell to generate completions for (bash, zsh, fish, powershell)
        #[arg(value_parser = ["bash", "zsh", "fish", "powershell"])]
        shell: String,
    },

    /// Get, set, list, or unset configuration values
    Config {
        /// List all configuration values
        #[arg(long, short)]
        list: bool,

        /// Unset a configuration value
        #[arg(long)]
        unset: Option<String>,

        /// Configuration key to get or set
        #[arg()]
        key: Option<String>,

        /// Value to set (with key)
        #[arg()]
        value: Option<String>,
    },

    /// Manage user identity for P2P sharing
    #[command(subcommand)]
    Identity(IdentityCommands),

    /// Manage repository contributors
    #[command(subcommand)]
    Contributors(ContributorsCommands),

    /// Manage remote pinning targets
    #[command(subcommand)]
    Remote(RemoteCommands),

    /// Manage linked worktrees
    #[command(subcommand)]
    Workspace(WorkspaceCommands),

    /// Publish repository as a browsable static website
    Publish {
        /// Commit reference (default: HEAD)
        #[arg(long)]
        commit: Option<String>,
        /// Output directory (default: _publish/)
        #[arg(short, long)]
        output: Option<String>,
        /// Pin to IPFS via local Kubo
        #[arg(long)]
        push: bool,
        /// Omit identity URI from published metadata
        #[arg(long)]
        no_identity: bool,
        /// Include contributor list in published metadata
        #[arg(long)]
        contributors: bool,
        /// Show verbose output
        #[arg(long)]
        verbose: bool,
        /// Publish workspace crates to crates.io in dependency order (dry-run by default)
        #[arg(long)]
        crates_io: bool,
        /// Actually publish to crates.io (without this, --crates-io is a dry-run)
        #[arg(long, requires = "crates_io")]
        execute: bool,
        /// Skip cargo verify during crates.io publish
        #[arg(long, requires = "crates_io")]
        no_verify: bool,
    },

    /// Export a commit and its objects to a CAR file
    ExportCar {
        /// Commit reference (default: HEAD)
        #[arg(long)]
        commit: Option<String>,
        /// Output file path (default: export.car)
        #[arg(short, long)]
        output: Option<String>,
    },

    /// Pin a commit to a remote IPFS node via SSH
    PinRemote {
        /// Remote name (from `void remote list`)
        remote: String,
        /// Commit CID to pin (default: HEAD)
        #[arg(long)]
        commit: Option<String>,
    },

    /// List conflicted files during a merge
    Conflicts,

    /// Interactive commit graph visualization
    Graph {
        /// Maximum commits to show
        #[arg(short, long, default_value = "100")]
        max_count: usize,

        /// Sort order: chrono or topo
        #[arg(long, default_value = "chrono")]
        order: String,
    },

    // ========== Branch Commands ==========
    /// Manage branches
    Branch {
        /// Branch name (list all if omitted)
        name: Option<String>,
        /// Delete the branch
        #[arg(short, long)]
        delete: bool,
        /// Overwrite existing branch when creating
        #[arg(short, long)]
        force: bool,
        /// Target commit CID (default: HEAD)
        #[arg(long)]
        target: Option<String>,
    },

    /// Switch branches or restore working tree files
    Switch {
        /// Branch name to switch to
        target: Option<String>,
        /// Create and switch to a new branch
        #[arg(short, long)]
        create: bool,
        /// Detach HEAD at the given commit CID
        #[arg(short, long)]
        detach: Option<String>,
        /// Force switch even with uncommitted changes
        #[arg(short, long)]
        force: bool,
    },

    /// Join two development histories together
    Merge {
        /// Branch or commit to merge (required unless --continue/--abort)
        target: Option<String>,
        /// Force overwrite of local changes
        #[arg(short, long)]
        force: bool,
        /// Continue after resolving conflicts
        #[arg(long = "continue")]
        continue_merge: bool,
        /// Abort in-progress merge
        #[arg(long)]
        abort: bool,
    },

    /// Mark conflicts as resolved
    Resolve {
        /// Paths to resolve
        paths: Vec<String>,
        /// Use our version (HEAD)
        #[arg(long)]
        ours: bool,
        /// Use their version (merge head)
        #[arg(long)]
        theirs: bool,
        /// Resolve all conflicts
        #[arg(long)]
        all: bool,
    },

    /// Stash changes in a dirty working directory
    Stash {
        /// Optional stash message (implies save)
        #[arg(short, long)]
        message: Option<String>,
        /// Stash subcommand
        #[command(subcommand)]
        action: Option<StashCommands>,
    },

    /// Create, list, or delete tags
    Tag {
        /// Tag name (list all if omitted)
        name: Option<String>,
        /// List all tags
        #[arg(short, long)]
        list: bool,
        /// Delete the tag
        #[arg(short, long)]
        delete: bool,
        /// Overwrite existing tag
        #[arg(short, long)]
        force: bool,
        /// Target commit (default: HEAD)
        #[arg(long)]
        target: Option<String>,
    },

    // ========== Network Commands ==========
    /// Push commits to IPFS
    Push {
        /// Commit to push (default: HEAD)
        commit: Option<String>,
        /// Backend type: daemon (default), kubo, or gateway
        #[arg(long, default_value = "daemon")]
        backend: String,
        /// Kubo API URL
        #[arg(long, default_value = "http://127.0.0.1:5001")]
        kubo: String,
        /// Gateway URL (required if backend is gateway)
        #[arg(long)]
        gateway: Option<String>,
        /// Request timeout in milliseconds
        #[arg(long, default_value = "30000")]
        timeout: u64,
        /// Pin objects after pushing (use --no-pin to skip)
        #[arg(long, default_value = "true", action = clap::ArgAction::Set)]
        pin: bool,
        /// Also replicate to SSH remotes (optionally specify a remote name)
        #[arg(long, num_args = 0..=1, default_missing_value = "*")]
        remote: Option<String>,
        /// Push all objects (ignore push markers)
        #[arg(long)]
        full: bool,
        /// Force push: skip missing objects instead of failing
        #[arg(long)]
        force: bool,
    },

    /// Pull commits from IPFS
    Pull {
        /// Commit CID or inbox reference (contact/project) to pull
        commit: Option<String>,
        /// Backend type: daemon (default), kubo, or gateway
        #[arg(long)]
        backend: Option<String>,
        /// Kubo API URL
        #[arg(long, default_value = "http://127.0.0.1:5001")]
        kubo: String,
        /// Gateway URL (required if backend is gateway)
        #[arg(long)]
        gateway: Option<String>,
        /// Request timeout in milliseconds
        #[arg(long, default_value = "30000")]
        timeout: u64,
        /// Pull mode: depth1, full, or lazy
        #[arg(long, default_value = "depth1")]
        mode: String,
    },

    /// Clone a repository from IPFS
    Clone {
        /// Source: commit CID or inbox reference (user/repo/branch)
        source: String,
        /// Target directory to clone into
        #[arg()]
        path: Option<PathBuf>,
        /// Repository encryption key (64 hex chars, required for CID sources)
        #[arg(long)]
        key: Option<String>,
        /// Scoped content key for single-commit clone (64 hex chars).
        /// Used with published repos — decrypts only the target commit.
        #[arg(long)]
        content_key: Option<String>,
        /// Backend type: kubo or gateway
        #[arg(long)]
        backend: Option<String>,
        /// Kubo API URL
        #[arg(long, default_value = "http://127.0.0.1:5001")]
        kubo: String,
        /// Gateway URL (required if backend is gateway)
        #[arg(long)]
        gateway: Option<String>,
        /// Request timeout in milliseconds
        #[arg(long, default_value = "30000")]
        timeout: u64,
        /// Clone mode: depth1, full, or lazy
        #[arg(long, default_value = "depth1")]
        mode: String,
        /// Clone with full history (shorthand for --mode full)
        #[arg(long, conflicts_with = "lazy")]
        full: bool,
        /// Clone metadata only, no files (shorthand for --mode lazy)
        #[arg(long, conflicts_with = "full")]
        lazy: bool,
        /// Skip interactive prompts (use defaults)
        #[arg(long, short = 'y')]
        yes: bool,
    },

    /// Fork a published repository (creates independent repo from snapshot)
    Fork {
        /// Source: commit CID
        source: String,
        /// Target directory
        #[arg()]
        path: Option<PathBuf>,
        /// Scoped content key (64 hex chars)
        #[arg(long)]
        content_key: Option<String>,
        /// Backend type: daemon (default), kubo, or gateway
        #[arg(long, default_value = "daemon")]
        backend: String,
        /// Kubo API URL
        #[arg(long, default_value = "http://127.0.0.1:5001")]
        kubo: String,
        /// Gateway URL (required if backend is gateway)
        #[arg(long)]
        gateway: Option<String>,
        /// Request timeout in milliseconds
        #[arg(long, default_value = "30000")]
        timeout: u64,
    },

    /// Import a published commit as a branch for review and merge
    PullRequest {
        /// Commit CID from contributor's publish output
        source: String,
        /// Branch name (created as pr/<name>)
        #[arg(long)]
        name: String,
        /// Content key (64 hex chars)
        #[arg(long)]
        content_key: String,
        /// Backend type: kubo or gateway
        #[arg(long, default_value = "gateway")]
        backend: String,
        /// Gateway URL
        #[arg(long, default_value = "https://ipfs.io")]
        gateway: Option<String>,
        /// Kubo API URL
        #[arg(long, default_value = "http://127.0.0.1:5001")]
        kubo: String,
        /// Request timeout in milliseconds
        #[arg(long, default_value = "30000")]
        timeout: u64,
    },

    /// Tor and onion daemon integration helpers
    #[command(subcommand)]
    Tor(TorCommands),

    // ========== Daemon Commands ==========
    /// Manage the embedded IPFS daemon
    #[command(subcommand)]
    Daemon(DaemonCommands),

    // ========== Debug Commands ==========
    /// Debug and maintenance commands
    #[command(subcommand)]
    Debug(DebugCommands),
}

/// Subcommands for the daemon command.
#[derive(Subcommand)]
enum DaemonCommands {
    /// Start the daemon (foreground, with logging)
    Start {
        /// Listen address (default: /ip4/0.0.0.0/tcp/0, OS assigns port)
        #[arg(long)]
        listen: Option<String>,
        /// Log level: error, warn, info, debug, trace
        #[arg(long, default_value = "info")]
        log_level: String,
    },
    /// Stop a running daemon
    Stop,
    /// Show daemon status (peer count, uptime, addresses)
    Status,
    /// Show detailed daemon stats (bitswap counters, bytes transferred)
    Stats,
    /// List connected peers
    Peers,
    /// List stored blocks
    Files,
    /// Check a specific block by CID
    Block {
        /// CID to check
        cid: String,
    },
    /// Add a file or directory to IPFS (UnixFS)
    Add {
        /// Path to file or directory
        path: String,
    },
    /// Read a UnixFS file from IPFS
    Cat {
        /// CID of the file
        cid: String,
    },
    /// Tail the daemon log file
    Logs {
        /// Number of lines to show (default: 50)
        #[arg(short, long, default_value = "50")]
        lines: usize,
        /// Follow the log (like tail -f)
        #[arg(short, long)]
        follow: bool,
    },
    /// Generate a systemd service file for the daemon
    Install {
        /// Target init system
        #[arg(long, default_value = "systemd")]
        target: String,
    },
}

/// Subcommands for the identity command.
#[derive(Subcommand)]
enum IdentityCommands {
    /// Generate new identity with seed phrase
    Init {
        /// Force overwrite if identity already exists
        #[arg(long)]
        force: bool,
        /// Username for the identity (defaults to system username)
        #[arg(long)]
        username: Option<String>,
    },
    /// Show identity string (public keys). No PIN needed.
    Show,
    /// Export identity string for sharing. No PIN needed.
    Export,
    /// Recover identity from a mnemonic seed phrase
    Recover {
        /// Force overwrite if identity already exists
        #[arg(long)]
        force: bool,
        /// Username for the recovered identity (defaults to system username)
        #[arg(long)]
        username: Option<String>,
    },
    /// Clear cached identity keys from OS keyring
    Lock,
    /// Pre-cache identity keys in OS keyring (prompts for PIN)
    Unlock,
}


/// Subcommands for the contributors command.
#[derive(Subcommand)]
enum ContributorsCommands {
    /// List all contributors
    List,
    /// Add a contributor
    Add {
        /// Identity string (void://[username@]ed25519:.../x25519:...)
        identity: String,
        /// Optional display name
        #[arg(long)]
        name: Option<String>,
    },
    /// Remove a contributor by name or signing pubkey prefix
    Remove {
        /// Name or signing pubkey prefix
        target: String,
    },
    /// Rename a contributor
    Rename {
        /// Current name or signing pubkey prefix
        target: String,
        /// New display name
        new_name: String,
    },
    /// Create an invite JSON for a contributor
    Invite {
        /// Contributor name or signing pubkey prefix
        target: String,
    },
}

/// Subcommands for the stash command.
#[derive(Subcommand)]
enum StashCommands {
    /// Save current changes to stash
    #[command(alias = "push")]
    Save {
        /// Optional stash message
        #[arg(short, long)]
        message: Option<String>,
    },
    /// List stash entries
    List,
    /// Apply and remove a stash entry
    Pop {
        /// Stash index (default: 0)
        index: Option<u32>,
    },
    /// Remove a stash entry without applying
    Drop {
        /// Stash index (default: 0)
        index: Option<u32>,
    },
    /// Clear all stash entries
    Clear,
}

/// Subcommands for the workspace command.
#[derive(Subcommand)]
enum WorkspaceCommands {
    /// List all workspaces
    List,
    /// Create a new linked workspace
    Create {
        /// Workspace name
        name: String,
        /// Branch to check out (default: same as workspace name)
        #[arg(short, long)]
        branch: Option<String>,
        /// Working tree path (default: ../<name> relative to repo root)
        #[arg(short, long)]
        path: Option<PathBuf>,
    },
    /// Remove a linked workspace
    Remove {
        /// Workspace name
        name: String,
    },
    /// Remove stale workspace entries
    Prune,
}

/// Subcommands for the remote command.
#[derive(Subcommand)]
enum RemoteCommands {
    /// List configured remotes
    List,
    /// Add a new remote
    Add {
        /// Remote name
        name: String,
        /// Host (supports user@host format)
        #[arg(long)]
        host: Option<String>,
        /// SSH key path
        #[arg(long)]
        key: Option<String>,
        /// P2P peer multiaddr
        #[arg(long)]
        peer: Option<String>,
    },
    /// Remove a remote
    Remove {
        /// Remote name
        name: String,
    },
    /// Show remote details
    Show {
        /// Remote name
        name: String,
    },
}

/// Subcommands for the debug command.
#[derive(Subcommand)]
enum DebugCommands {
    /// Audit all objects in the repository (machine-readable)
    Audit {
        /// Maximum commits to traverse (default: 10000)
        #[arg(long, default_value = "10000")]
        max_commits: usize,
    },
    /// Interactive audit viewer (TUI)
    AuditTui,
    /// Check repository integrity
    Fsck {
        /// Run full verification (verify content hashes)
        #[arg(long)]
        full: bool,
        /// Find unreferenced objects (gc candidates)
        #[arg(long)]
        unreferenced: bool,
    },
    /// Show contents of an object by CID
    CatFile {
        /// CID of the object
        cid: String,
    },
    /// Garbage collection - quarantine unreferenced objects
    Gc {
        /// List unreferenced objects without quarantining
        #[arg(long)]
        dry_run: bool,
    },
    /// Read and display shard contents
    ReadShard {
        /// CID of the shard
        cid: String,
    },
    /// Create a new shard from files
    CreateShard {
        /// Files to include in the shard
        files: Vec<String>,
    },
    /// Encrypt data using a provided key
    Encrypt {
        /// 32-byte key as hex (64 chars)
        key: String,
        /// Plaintext data to encrypt
        plaintext: String,
    },
    /// Decrypt data using a provided key
    Decrypt {
        /// 32-byte key as hex (64 chars)
        key: String,
        /// Ciphertext to decrypt (hex-encoded)
        ciphertext: String,
    },
    /// Create a CID from data (stdin)
    CreateCid,
    /// Show shard information for a commit
    DebugShards {
        /// Commit reference (default: HEAD)
        commit: Option<String>,
    },
    /// Generate a random 32-byte encryption key
    GenerateKey,
    /// Print the repo's encryption key (hex-encoded, from identity ECIES unwrap)
    RepoKey,
    /// Rebuild the index from HEAD and working tree
    RebuildIndex,
    /// Read a single file from an encrypted shard
    ReadShardFile {
        /// CID of the shard
        shard_cid: String,
        /// File path within the shard
        path: String,
    },
    /// Repair a corrupted repository
    Repair {
        /// Repair mode: truncate (default), best-effort, rewrite-history
        #[arg(long, default_value = "truncate")]
        mode: String,
        /// Target branch for rewrite-history mode
        #[arg(long)]
        target_branch: Option<String>,
        /// Show what would happen without making changes
        #[arg(long)]
        dry_run: bool,
    },
    /// Reparent a commit (change its parent pointers)
    Reparent {
        /// CID of the commit to reparent
        commit_cid: String,
        /// New parent CID(s)
        new_parent_cids: Vec<String>,
    },
    /// Inspect an encrypted object with decrypt diagnostics
    InspectObject {
        /// CID of the object to inspect
        cid: String,
    },
}

/// Subcommands for the repo command.
#[derive(Subcommand)]
enum RepoCommands {
    /// Show file statistics by extension
    Stat {
        /// Show all file types (not just code files)
        #[arg(long)]
        all: bool,

        /// Show top N file types (default: 10)
        #[arg(long, default_value = "10")]
        top: usize,

        /// Sort by: lines, files, bytes (default: lines)
        #[arg(long, default_value = "lines")]
        sort: String,

        /// Limit to specific directory
        #[arg(long)]
        path: Option<String>,

        /// Exclude file extensions (repeatable, e.g. --exclude lock --exclude json; also supports comma-separated)
        #[arg(long)]
        exclude: Vec<String>,
    },

    /// Show repository size breakdown
    Size {
        /// Show top N largest files (default: 10)
        #[arg(long, default_value = "10")]
        top: usize,
    },

    /// Show repository information
    Info,

    /// List all known repositories in the local registry
    List {
        /// Show full details (paths, keys, branches)
        #[arg(long)]
        verbose: bool,
    },
    /// Show detailed registry info for a repo
    Registry {
        /// Repo name or UUID
        target: String,
    },
    /// Remove a repository from the registry
    Unregister {
        /// Repo name or UUID
        target: String,
    },
}

/// Subcommands for the tor command.
#[derive(Subcommand)]
enum TorCommands {
    /// Generate Tor and Kubo service config templates
    Setup {
        /// Output directory for generated files
        #[arg(short, long)]
        output: Option<PathBuf>,
        /// Service platform override (systemd or launchd)
        #[arg(long)]
        platform: Option<String>,
        /// Tor SOCKS port
        #[arg(long, default_value = "9050")]
        socks_port: u16,
        /// Tor control port
        #[arg(long, default_value = "9051")]
        control_port: u16,
        /// Local void P2P listener port
        #[arg(long, default_value = "4001")]
        p2p_port: u16,
        /// Local Kubo API endpoint
        #[arg(long, default_value = "http://127.0.0.1:5001")]
        kubo_api: String,
    },
}


fn main() {
    let cli = Cli::parse();

    // Build CliOptions from parsed arguments
    let opts = CliOptions {
        json: cli.json,
        human: cli.human,
        quiet: cli.quiet,
        debug: cli.debug,
        verbose: cli.verbose,
    };

    let result = match cli.command {
        Commands::Init => commands::init::run(&cli.cwd, &opts),
        Commands::Status { paths } => commands::status::run(&cli.cwd, paths, &opts),
        Commands::Add { paths } => commands::add::run(&cli.cwd, paths, &opts),
        Commands::Reset { paths } => commands::reset::run(&cli.cwd, paths, &opts),
        Commands::Restore {
            paths,
            source,
            staged,
            force,
        } => commands::restore::run(
            &cli.cwd,
            commands::restore::RestoreArgs {
                paths,
                source,
                staged,
                force,
            },
            &opts,
        ),
        Commands::Commit {
            message,
            sign,
            no_sign,
            target_shard_size,
            max_shard_size,
            mmap_threshold,
            padding,
            allow_data_loss,
        } => commands::commit::run(
            &cli.cwd,
            commands::commit::CommitArgs {
                message,
                sign,
                no_sign,
                target_shard_size,
                max_shard_size,
                mmap_threshold,
                padding,
                allow_data_loss,
            },
            &opts,
        ),
        Commands::Log { number, no_verify } => {
            commands::log::run(&cli.cwd, number, &opts, !no_verify)
        }
        Commands::Diff {
            commits,
            staged,
            cached,
            stat,
            no_color,
        } => commands::diff::run(&cli.cwd, commits, staged || cached, stat, no_color, &opts),
        Commands::Mv { source, dest } => commands::mv::run(&cli.cwd, source, dest, &opts),
        Commands::Rm {
            paths,
            cached,
            force,
            recursive,
        } => commands::rm::run(&cli.cwd, paths, cached, force, recursive, &opts),
        Commands::Verify { commit } => commands::verify::run(&cli.cwd, &commit, &opts),
        Commands::LsTree {
            commit,
            path,
            name_only,
            recursive,
        } => commands::ls_tree::run(
            &cli.cwd,
            &commit,
            path.as_deref(),
            name_only,
            recursive,
            &opts,
        ),
        Commands::Show { target, no_verify } => {
            commands::show::run(&cli.cwd, &target, !no_verify, &opts)
        }
        Commands::Seal {
            target_shard_size,
            max_shard_size,
            padding,
        } => commands::seal::run(
            &cli.cwd,
            commands::seal::SealArgs {
                target_shard_size,
                max_shard_size,
                padding,
            },
            &opts,
        ),
        Commands::Unseal {
            output,
            commit,
            list,
            offline,
            no_verify,
            backend,
            kubo,
            gateway,
            timeout,
        } => commands::unseal::run(
            &cli.cwd,
            commands::unseal::UnsealArgs {
                output,
                commit,
                list,
                offline,
                no_verify,
                backend,
                kubo,
                gateway,
                timeout,
            },
            &opts,
        ),
        Commands::Repo(subcmd) => match subcmd {
            RepoCommands::Stat {
                all,
                top,
                sort,
                path,
                exclude,
            } => commands::repo::run_stat(
                &cli.cwd,
                commands::repo::StatArgs {
                    all,
                    top,
                    sort,
                    path,
                    exclude,
                },
                &opts,
            ),
            RepoCommands::Size { top } => {
                commands::repo::run_size(&cli.cwd, commands::repo::SizeArgs { top }, &opts)
            }
            RepoCommands::Info => commands::repo::run_info(&cli.cwd, &opts),
            RepoCommands::List { verbose } => commands::repo::run_list(verbose, &opts),
            RepoCommands::Registry { target } => commands::repo::run_registry(&target, &opts),
            RepoCommands::Unregister { target } => commands::repo::run_unregister(&target, &opts),
        },
        Commands::Completion { shell } => commands::completion::run(&shell, &opts),
        Commands::Config {
            list,
            unset,
            key,
            value,
        } => commands::config::run(
            &cli.cwd,
            commands::config::ConfigArgs {
                list,
                unset,
                key,
                value,
            },
            &opts,
        ),
        Commands::Identity(subcmd) => {
            let subcommand = match subcmd {
                IdentityCommands::Init {
                    force,
                    username,
                } => commands::collab::identity::IdentitySubcommand::Init {
                    force,
                    username,
                },
                IdentityCommands::Show => commands::collab::identity::IdentitySubcommand::Show,
                IdentityCommands::Export => commands::collab::identity::IdentitySubcommand::Export,
                IdentityCommands::Recover { force, username } => {
                    commands::collab::identity::IdentitySubcommand::Recover { force, username }
                }
                IdentityCommands::Lock => commands::collab::identity::IdentitySubcommand::Lock,
                IdentityCommands::Unlock => commands::collab::identity::IdentitySubcommand::Unlock,
            };
            commands::collab::identity::run(
                commands::collab::identity::IdentityArgs { subcommand },
                &opts,
            )
        }
        Commands::Contributors(subcmd) => match subcmd {
            ContributorsCommands::Invite { target } => commands::collab::invite::run(
                &cli.cwd,
                commands::collab::invite::InviteArgs { target },
                &opts,
            ),
            other => {
                let subcommand = match other {
                    ContributorsCommands::List => {
                        commands::collab::contributors::ContributorsSubcommand::List
                    }
                    ContributorsCommands::Add { identity, name } => {
                        commands::collab::contributors::ContributorsSubcommand::Add {
                            name,
                            identity,
                        }
                    }
                    ContributorsCommands::Remove { target } => {
                        commands::collab::contributors::ContributorsSubcommand::Remove { target }
                    }
                    ContributorsCommands::Rename { target, new_name } => {
                        commands::collab::contributors::ContributorsSubcommand::Rename {
                            target,
                            new_name,
                        }
                    }
                    ContributorsCommands::Invite { .. } => unreachable!(),
                };
                commands::collab::contributors::run(
                    &cli.cwd,
                    commands::collab::contributors::ContributorsArgs { subcommand },
                    &opts,
                )
            }
        },

        Commands::Remote(subcmd) => {
            let subcommand = match subcmd {
                RemoteCommands::List => commands::remote::RemoteSubcommand::List,
                RemoteCommands::Add {
                    name,
                    host,
                    key,
                    peer,
                } => commands::remote::RemoteSubcommand::Add {
                    name,
                    host,
                    key,
                    peer,
                },
                RemoteCommands::Remove { name } => {
                    commands::remote::RemoteSubcommand::Remove { name }
                }
                RemoteCommands::Show { name } => commands::remote::RemoteSubcommand::Show { name },
            };
            commands::remote::run(&cli.cwd, commands::remote::RemoteArgs { subcommand }, &opts)
        }

        Commands::Workspace(subcmd) => {
            let subcommand = match subcmd {
                WorkspaceCommands::List => commands::workspace::WorkspaceSubcommand::List,
                WorkspaceCommands::Create { name, branch, path } => {
                    commands::workspace::WorkspaceSubcommand::Create { name, branch, path }
                }
                WorkspaceCommands::Remove { name } => {
                    commands::workspace::WorkspaceSubcommand::Remove { name }
                }
                WorkspaceCommands::Prune => commands::workspace::WorkspaceSubcommand::Prune,
            };
            commands::workspace::run(
                &cli.cwd,
                commands::workspace::WorkspaceArgs { subcommand },
                &opts,
            )
        }

        Commands::Publish {
            commit,
            output,
            push,
            no_identity,
            contributors,
            verbose: _,
            crates_io,
            execute,
            no_verify,
        } => {
            if crates_io {
                commands::publish::run_crates_io(execute, no_verify, &cli.cwd, &opts)
            } else {
                commands::publish::run(
                    &cli.cwd,
                    commands::publish::PublishArgs {
                        commit,
                        output,
                        push,
                        no_identity,
                        contributors,
                    },
                    &opts,
                )
            }
        }

        Commands::ExportCar { commit, output } => commands::export_car::run(
            &cli.cwd,
            commands::export_car::ExportCarArgs { commit, output },
            &opts,
        ),

        Commands::PinRemote { remote, commit } => commands::pin_remote::run(
            &cli.cwd,
            commands::pin_remote::PinRemoteArgs { remote, commit },
            &opts,
        ),

        Commands::Daemon(subcmd) => {
            commands::daemon::run(subcmd, &opts)
        }

        Commands::Tor(subcmd) => {
            let subcommand = match subcmd {
                TorCommands::Setup {
                    output,
                    platform,
                    socks_port,
                    control_port,
                    p2p_port,
                    kubo_api,
                } => commands::tor::TorSubcommand::Setup {
                    output,
                    platform,
                    socks_port,
                    control_port,
                    p2p_port,
                    kubo_api,
                },
            };
            commands::tor::run(&cli.cwd, commands::tor::TorArgs { subcommand }, &opts)
        }

        Commands::Conflicts => commands::conflicts::run(&cli.cwd, &opts),
        Commands::Graph { max_count, order } => {
            commands::graph::run(&cli.cwd, max_count, &order, &opts)
        }

        // Branch commands
        Commands::Branch {
            name,
            delete,
            force,
            target,
        } => commands::branch::run(
            &cli.cwd,
            commands::branch::BranchArgs {
                name,
                target,
                delete,
                force,
            },
            &opts,
        ),
        Commands::Switch {
            target,
            create,
            detach,
            force,
        } => commands::switch::run(
            &cli.cwd,
            commands::switch::SwitchArgs {
                target,
                create,
                detach,
                force,
            },
            &opts,
        ),
        Commands::Merge {
            target,
            force,
            continue_merge,
            abort,
        } => commands::merge::run(
            &cli.cwd,
            commands::merge::MergeArgs {
                target,
                force,
                continue_merge,
                abort_merge: abort,
            },
            &opts,
        ),
        Commands::Resolve {
            paths,
            ours,
            theirs,
            all,
        } => commands::resolve::run(
            &cli.cwd,
            commands::resolve::ResolveArgs {
                paths,
                ours,
                theirs,
                all,
            },
            &opts,
        ),
        Commands::Stash { message, action } => {
            // If message is provided without a subcommand, treat as save
            let stash_action = match action {
                Some(StashCommands::Save { message: sub_msg }) => {
                    // Prefer subcommand message if both provided
                    commands::stash::StashAction::Save {
                        message: sub_msg.or(message),
                    }
                }
                Some(StashCommands::List) => commands::stash::StashAction::List,
                Some(StashCommands::Pop { index }) => commands::stash::StashAction::Pop { index },
                Some(StashCommands::Drop { index }) => commands::stash::StashAction::Drop { index },
                Some(StashCommands::Clear) => commands::stash::StashAction::Clear,
                None => {
                    // No subcommand: if message provided, save; otherwise list
                    if message.is_some() {
                        commands::stash::StashAction::Save { message }
                    } else {
                        commands::stash::StashAction::List
                    }
                }
            };
            commands::stash::run(
                &cli.cwd,
                commands::stash::StashArgs {
                    action: stash_action,
                },
                &opts,
            )
        }
        Commands::Tag {
            name,
            list,
            delete,
            force,
            target,
        } => commands::tag::run(
            &cli.cwd,
            commands::tag::TagArgs {
                name,
                list,
                target,
                delete,
                force,
            },
            &opts,
        ),

        // Network commands
        Commands::Push {
            commit,
            backend,
            kubo,
            gateway,
            timeout,
            pin,
            remote,
            full,
            force,
        } => {
            let local = remote.is_none();
            let specific_remote = match remote.as_deref() {
                Some("*") | None => None,
                Some(name) => Some(name.to_string()),
            };
            commands::network::push::run(
                &cli.cwd,
                commands::network::push::PushArgs {
                    commit,
                    backend,
                    kubo_url: kubo,
                    gateway,
                    timeout_ms: timeout,
                    pin,
                    local,
                    remote: specific_remote,
                    full,
                    force,
                },
                &opts,
            )
        }
        Commands::Pull {
            commit,
            backend,
            kubo,
            gateway,
            timeout,
            mode,
        } => commands::network::pull::run(
            &cli.cwd,
            commands::network::pull::PullArgs {
                commit,
                backend,
                kubo_url: kubo,
                gateway_url: gateway,
                timeout_ms: timeout,
                mode,
            },
            &opts,
        ),
        Commands::Clone {
            source,
            path,
            key,
            content_key,
            backend,
            kubo,
            gateway,
            timeout,
            mode,
            full,
            lazy,
            yes,
        } => {
            // --full and --lazy override --mode
            let effective_mode = if full {
                "full".to_string()
            } else if lazy {
                "lazy".to_string()
            } else {
                mode
            };
            commands::network::clone::run(
                &cli.cwd,
                commands::network::clone::CloneArgs {
                    source,
                    key,
                    content_key,
                    path,
                    backend,
                    kubo_url: kubo,
                    gateway_url: gateway,
                    timeout_ms: timeout,
                    mode: effective_mode,
                    yes,
                },
                &opts,
            )
        }

        Commands::Fork {
            source,
            path,
            content_key,
            backend,
            kubo,
            gateway,
            timeout,
        } => commands::fork::run(
            &cli.cwd,
            commands::fork::ForkArgs {
                source,
                path,
                content_key,
                backend,
                kubo_url: kubo,
                gateway_url: gateway,
                timeout_ms: timeout,
            },
            &opts,
        ),

        Commands::PullRequest {
            source,
            name,
            content_key,
            backend,
            gateway,
            kubo,
            timeout,
        } => commands::pull_request::run(
            &cli.cwd,
            commands::pull_request::PullRequestArgs {
                source,
                name,
                content_key,
                backend,
                kubo_url: kubo,
                gateway_url: gateway,
                timeout_ms: timeout,
            },
            &opts,
        ),

        // Debug commands
        Commands::Debug(subcmd) => match subcmd {
            DebugCommands::Audit { max_commits } => commands::debug::audit::run(
                &cli.cwd,
                commands::debug::audit::AuditArgs { max_commits },
                &opts,
            ),
            DebugCommands::AuditTui => commands::debug::audit_tui::run(&cli.cwd, &opts),
            DebugCommands::Fsck {
                full,
                unreferenced,
            } => commands::debug::fsck::run(
                &cli.cwd,
                commands::debug::fsck::FsckArgs {
                    full,
                    unreferenced,
                },
                &opts,
            ),
            DebugCommands::CatFile { cid } => commands::debug::cat_file::run(
                &cli.cwd,
                commands::debug::cat_file::CatFileArgs { cid },
                &opts,
            ),
            DebugCommands::Gc { dry_run } => {
                commands::debug::gc::run(&cli.cwd, commands::debug::gc::GcArgs { dry_run }, &opts)
            }
            DebugCommands::ReadShard { cid } => commands::debug::read_shard::run(
                &cli.cwd,
                commands::debug::read_shard::ReadShardArgs { cid },
                &opts,
            ),
            DebugCommands::CreateShard { files } => commands::debug::create_shard::run(
                &cli.cwd,
                commands::debug::create_shard::CreateShardArgs { files },
                &opts,
            ),
            DebugCommands::Encrypt { key, plaintext } => commands::debug::encrypt::run(
                commands::debug::encrypt::EncryptArgs { key, plaintext },
                &opts,
            ),
            DebugCommands::Decrypt { key, ciphertext } => commands::debug::decrypt::run(
                commands::debug::decrypt::DecryptArgs { key, ciphertext },
                &opts,
            ),
            DebugCommands::CreateCid => commands::debug::create_cid::run(
                &cli.cwd,
                commands::debug::create_cid::CreateCidArgs {},
                &opts,
            ),
            DebugCommands::DebugShards { commit } => commands::debug::debug_shards::run(
                &cli.cwd,
                commands::debug::debug_shards::DebugShardsArgs { commit_ref: commit },
                &opts,
            ),
            DebugCommands::GenerateKey => commands::debug::generate_key::run(&opts),
            DebugCommands::RepoKey => commands::debug::repo_key::run(&cli.cwd, &opts),
            DebugCommands::RebuildIndex => commands::debug::rebuild_index::run(&cli.cwd, &opts),
            DebugCommands::ReadShardFile { shard_cid, path } => {
                commands::debug::read_shard_file::run(
                    &cli.cwd,
                    commands::debug::read_shard_file::ReadShardFileArgs { shard_cid, path },
                    &opts,
                )
            }
            DebugCommands::Repair {
                mode,
                target_branch,
                dry_run,
            } => commands::debug::repair::run(
                &cli.cwd,
                commands::debug::repair::RepairArgs {
                    mode,
                    target_branch,
                    dry_run,
                },
                &opts,
            ),
            DebugCommands::Reparent {
                commit_cid,
                new_parent_cids,
            } => commands::debug::reparent::run(
                &cli.cwd,
                commands::debug::reparent::ReparentArgs {
                    commit_cid,
                    new_parent_cids,
                },
                &opts,
            ),
            DebugCommands::InspectObject { cid } => commands::debug::inspect_object::run(
                &cli.cwd,
                commands::debug::inspect_object::InspectObjectArgs { cid },
                &opts,
            ),
        },
    };

    if let Err(e) = result {
        std::process::exit(e.exit_code());
    }
}