syntarq-cli 0.1.0

//! Syntarq CLI - Command-line interface for identity management

mod commands;
mod ui;

use clap::{Parser, Subcommand};
use colored::Colorize;
use syntarq_core::IdentityBuilder;

#[derive(Parser)]
#[command(name = "syntarq")]
#[command(author, version, about, long_about = None)]
#[command(propagate_version = true)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

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

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

    /// Show information about Syntarq
    Info,

    /// Test cryptographic functions
    TestCrypto,

    /// Create a new identity
    #[command(alias = "new")]
    Create {
        /// Name for the identity
        #[arg(short, long)]
        name: Option<String>,
    },

    /// List all identities
    #[command(alias = "ls")]
    List,

    /// Show identity details
    Show {
        /// Identity ID or name
        identity: String,
    },

    /// Link an external service
    Link {
        /// Identity ID or name
        identity: String,

        /// Service type (github, email, domain)
        #[arg(short, long)]
        service: String,

        /// Service identifier
        identifier: String,
    },

    /// Verify a service link
    Verify {
        /// Identity ID or name
        identity: String,

        /// Service type
        service: String,
    },

    /// Export identity
    Export {
        /// Identity ID or name
        identity: String,

        /// Output file path
        #[arg(short, long)]
        output: Option<String>,
    },

    /// Import identity
    Import {
        /// Input file path
        file: String,
    },
}

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

    // Initialize logging
    init_logging(cli.verbose);

    match cli.command {
        Commands::Init => commands::init::run().await?,
        Commands::Info => commands::info::run().await?,
        Commands::TestCrypto => commands::test_crypto::run().await?,
        Commands::Create { name } => create_identity(name).await?,
        Commands::List => list_identities().await?,
        Commands::Show { identity } => show_identity(&identity).await?,
        Commands::Link {
            identity,
            service,
            identifier,
        } => link_service(&identity, &service, &identifier).await?,
        Commands::Verify { identity, service } => verify_service(&identity, &service).await?,
        Commands::Export { identity, output } => {
            export_identity(&identity, output.as_deref()).await?
        }
        Commands::Import { file } => import_identity(&file).await?,
    }

    Ok(())
}

fn init_logging(verbose: bool) {
    use tracing_subscriber::{fmt, EnvFilter};

    let level = if verbose { "debug" } else { "info" };

    fmt()
        .with_env_filter(
            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(level)),
        )
        .with_target(false)
        .without_time()
        .init();
}

async fn create_identity(name: Option<String>) -> anyhow::Result<()> {
    println!("{}", "Creating new identity...".cyan().bold());

    let name = if let Some(n) = name {
        n
    } else {
        dialoguer::Input::new()
            .with_prompt("Identity name")
            .allow_empty(true)
            .interact_text()?
    };

    let mut builder = IdentityBuilder::new();
    if !name.is_empty() {
        builder = builder.with_name(name);
    }

    let identity = builder.build()?;

    println!("\n{}", "Identity created successfully!".green().bold());
    println!("ID: {}", identity.id().to_string().yellow());
    if let Some(name) = identity.name() {
        println!("Name: {}", name.yellow());
    }
    println!(
        "\nPublic key: {}",
        hex::encode(identity.public_key().as_bytes()).dimmed()
    );

    Ok(())
}

async fn list_identities() -> anyhow::Result<()> {
    println!("{}", "Listing identities...".cyan().bold());
    println!(
        "\n{}",
        "No identities found. Use 'syntarq create' to create one.".dimmed()
    );
    Ok(())
}

async fn show_identity(identity: &str) -> anyhow::Result<()> {
    println!(
        "{} {}",
        "Showing identity:".cyan().bold(),
        identity.yellow()
    );
    println!("\n{}", "Identity not found.".red());
    Ok(())
}

async fn link_service(_identity: &str, service: &str, identifier: &str) -> anyhow::Result<()> {
    println!(
        "{} {} {} {} {}",
        "Linking".cyan().bold(),
        service.yellow(),
        "service".cyan(),
        identifier.yellow(),
        "to identity...".cyan()
    );
    println!("\n{}", "Feature not yet implemented.".dimmed());
    Ok(())
}

async fn verify_service(identity: &str, service: &str) -> anyhow::Result<()> {
    println!(
        "{} {} {} {}",
        "Verifying".cyan().bold(),
        service.yellow(),
        "service for identity".cyan(),
        identity.yellow()
    );
    println!("\n{}", "Feature not yet implemented.".dimmed());
    Ok(())
}

async fn export_identity(identity: &str, output: Option<&str>) -> anyhow::Result<()> {
    println!(
        "{} {}",
        "Exporting identity:".cyan().bold(),
        identity.yellow()
    );
    if let Some(path) = output {
        println!("Output: {}", path.dimmed());
    }
    println!("\n{}", "Feature not yet implemented.".dimmed());
    Ok(())
}

async fn import_identity(file: &str) -> anyhow::Result<()> {
    println!(
        "{} {}",
        "Importing identity from:".cyan().bold(),
        file.yellow()
    );
    println!("\n{}", "Feature not yet implemented.".dimmed());
    Ok(())
}