claude-profiles 0.5.0

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

mod combine;
mod commands;
mod extends;
mod fs_paths;
mod git;
mod index;
mod launch;
mod lock;
mod pack;
mod profile;
mod progress;
mod provision;
mod resolve;
mod vendor;
mod vendor_fs;

#[derive(Parser)]
#[command(name = "claude-profile", version, about)]
struct Cli {
    #[command(subcommand)]
    command: Option<Command>,
    /// Profile name(s) to launch (when no subcommand is given). Give several to launch a
    /// combined session; each may be a profile name or a repo reference (owner/repo, URL).
    profiles: Vec<String>,
    /// Skip the provisioning confirmation prompt.
    #[arg(long)]
    yes: bool,
    /// Extra args forwarded to claude after `--`.
    #[arg(last = true)]
    extra: Vec<String>,
}

#[derive(Subcommand)]
enum Command {
    /// List available profiles and their sources.
    List,
    /// Show a profile's details and what it would install. TARGET is a profile
    /// name or a repo reference (owner/repo[#ref], https://…, or git@…).
    Show { target: String },
    /// Install or refresh a profile repo (owner/repo[#ref]) without launching.
    Install { spec: String },
    /// Check whether a newer claude-profile release is available (no subcommand), or
    /// git-pull profile repos and re-resolve floating marketplaces (`update profiles`).
    Update {
        #[command(subcommand)]
        target: Option<UpdateTarget>,
    },
    /// Show each profile's vendored plugins/skills under ~/.claude-profiles/store/.
    Status,
    /// Delete a personal profile or cloned pack.
    Remove { target: String },
    /// Scaffold a new profile in ~/.claude-profiles/.
    New { name: String },
    /// Run `claude plugin eval` against a plugin/skill target.
    Test {
        target: String,
        #[arg(long)]
        json: bool,
        #[arg(last = true)]
        extra: Vec<String>,
    },
    /// Search a local index of plugins across marketplaces. Returns profile-ready
    /// `plugin@marketplace` ids. First run auto-syncs; use --sync to rebuild.
    Find {
        query: Vec<String>,
        #[arg(long)]
        sync: bool,
        #[arg(long)]
        refresh_seeds: bool,
        #[arg(long)]
        json: bool,
        #[arg(long)]
        limit: Option<usize>,
        #[arg(long)]
        marketplace: Option<String>,
    },
    /// Remove the claude-profile binary (and optionally profile data).
    SelfUninstall {
        /// Also remove ~/.claude-profiles (all personal profiles, packs, locks).
        #[arg(long)]
        purge: bool,
    },
    /// Print a shell completion script for installed profile names (bash, zsh, fish,
    /// powershell), or write it to the standard location with --install.
    Completions {
        shell: commands::completions::Shell,
        /// Write the script to the standard completion path (and wire it up) instead
        /// of printing it to stdout.
        #[arg(long)]
        install: bool,
    },
    /// (hidden) Print installed profile names, one per line. Used by shell completion
    /// scripts generated by `completions`.
    #[command(hide = true, name = "profile-names")]
    ProfileNames,
    /// Install or remove a statusline showing the active profile.
    Statusline {
        #[command(subcommand)]
        action: commands::statusline::Action,
    },
    /// (hidden) Render the statusline line. Invoked by Claude Code itself via the
    /// `statusLine` command installed by `statusline install` — not for direct use.
    #[command(hide = true, name = "statusline-render")]
    StatuslineRender,
}

#[derive(Subcommand)]
enum UpdateTarget {
    /// Git-pull profile repos and re-resolve floating marketplaces.
    Profiles {
        /// Fail if the lockfile is out of date instead of updating.
        #[arg(long)]
        frozen: bool,
    },
}

type LoadedProfiles = (Vec<(String, profile::Profile)>, Vec<(PathBuf, String)>);

fn load_all_profiles(
    paths: &fs_paths::Paths, cwd: &std::path::Path,
    env: Option<&std::path::Path>, bundled: &std::path::Path,
) -> LoadedProfiles {
    let mut out = Vec::new();
    let mut failed = Vec::new();
    for (name, path, _src) in resolve::list_available(paths, cwd, env, bundled) {
        match std::fs::read_to_string(&path) {
            Ok(body) => match profile::Profile::from_json_str(&body) {
                Ok(p) => out.push((name, p)),
                Err(e) => failed.push((path, e.to_string())),
            },
            Err(e) => failed.push((path, e.to_string())),
        }
    }
    (out, failed)
}

fn bundled_dir() -> PathBuf {
    // profiles/ holds the reference profiles shipped with the engine; resolved relative to
    // CARGO_MANIFEST_DIR at build time.
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("profiles")
}

fn env_dir() -> Option<PathBuf> {
    std::env::var_os("CLAUDE_PROFILE_DIR").map(PathBuf::from)
}

fn run() -> anyhow::Result<i32> {
    let cli = Cli::parse();
    let _progress = progress::install();
    let paths = fs_paths::Paths::detect()?;
    let cwd = std::env::current_dir()?;
    let bundled = bundled_dir();
    let env = env_dir();

    match cli.command {
        Some(command) => dispatch_command(command, &paths, &cwd, env.as_deref(), &bundled),
        None => handle_launch(&cli.profiles, cli.yes, &cli.extra, &paths, &cwd, env.as_deref(), &bundled),
    }
}

fn dispatch_command(
    command: Command,
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> anyhow::Result<i32> {
    match command {
        Command::List => {
            commands::list::run(paths, cwd, env, bundled)?;
            Ok(0)
        }
        Command::Show { target } => {
            commands::show::run(&target, paths, cwd, env, bundled)?;
            Ok(0)
        }
        Command::Install { spec } => {
            let dir = pack::install_pack(&git::RealGit, &spec, paths)?;
            progress::clear();
            println!("installed pack at {}", dir.display());
            Ok(0)
        }
        Command::Update { target: None } => {
            commands::check_update::run(&std::env::current_exe()?)?;
            Ok(0)
        }
        Command::Update { target: Some(UpdateTarget::Profiles { frozen }) } => {
            handle_update(frozen, paths, cwd, env, bundled)?;
            Ok(0)
        }
        Command::New { name } => {
            commands::new::run(&name, paths)?;
            Ok(0)
        }
        Command::Test { target, json, extra } => commands::test::run(&target, json, &extra),
        Command::Find { query, sync, refresh_seeds, json, limit, marketplace } => {
            commands::find::run(paths, &query, sync, refresh_seeds, json, limit, marketplace.as_deref())
        }
        Command::SelfUninstall { purge } => {
            commands::self_uninstall::run(paths, purge)?;
            Ok(0)
        }
        Command::Status => handle_status(paths, cwd, env, bundled),
        Command::Remove { target } => handle_remove(&target, paths, cwd, env, bundled),
        Command::Completions { shell, install } => {
            commands::completions::run(shell, install, paths)?;
            Ok(0)
        }
        Command::ProfileNames => {
            commands::list::run_names(paths, cwd, env, bundled)?;
            Ok(0)
        }
        Command::Statusline { action } => commands::statusline::run_action(action, paths, cwd),
        Command::StatuslineRender => {
            print!("{}", commands::statusline::render(paths, cwd));
            Ok(0)
        }
    }
}

fn handle_status(
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> anyhow::Result<i32> {
    let (profiles, failed) = load_all_profiles(paths, cwd, env, bundled);
    for (path, err) in &failed {
        eprintln!("warning: could not parse profile {}: {err}", path.display());
    }
    commands::status::run(paths, &profiles)?;
    Ok(0)
}

fn handle_remove(
    target: &str,
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> anyhow::Result<i32> {
    let plan = commands::remove::remove_target(target, paths, cwd, env, bundled)?;
    commands::remove::apply(&plan)?;
    println!("removed {target}");
    Ok(0)
}

fn handle_update(
    frozen: bool,
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> anyhow::Result<()> {
    pack::update_all_packs(&git::RealGit, paths)?;
    let (profiles, failed) = load_all_profiles(paths, cwd, env, bundled);
    for (path, err) in &failed {
        eprintln!("warning: skipping unparseable profile {}: {err}", path.display());
    }
    let dir_lookup = |n: &str| paths.marketplace_clone_dir(n);
    if frozen {
        let mut triples = Vec::new();
        for (name, profile) in &profiles {
            let Some(profile) = resolve_extends_or_warn(name, profile, paths, cwd, env, bundled) else { continue };
            let resolved = resolve::resolve(name, paths, cwd, env, bundled)?;
            let lp = lock::lock_path(name, &resolved.path, &resolved.source, paths);
            let lf = lock::Lockfile::load(&lp)?.unwrap_or_else(|| lock::Lockfile::new(name));
            triples.push((name.clone(), profile, lf));
        }
        commands::update::frozen_check(&triples)?;
        progress::clear();
        println!("--frozen: all locks up to date");
    } else {
        let total = profiles.len();
        for (i, (name, profile)) in profiles.iter().enumerate() {
            let Some(profile) = resolve_extends_or_warn(name, profile, paths, cwd, env, bundled) else { continue };
            let missing = profile.marketplaces.keys().find(|mkt| !paths.marketplace_clone_dir(mkt).is_dir());
            if let Some(mkt) = missing {
                eprintln!(
                    "skipping '{name}': marketplace '{mkt}' not cloned yet (launch the profile once to provision it)"
                );
                continue;
            }
            let resolved = resolve::resolve(name, paths, cwd, env, bundled)?;
            let lp = lock::lock_path(name, &resolved.path, &resolved.source, paths);
            let mut lf = lock::Lockfile::load(&lp)?.unwrap_or_else(|| lock::Lockfile::new(name));
            progress::step(&format!("re-resolving {name} ({}/{total})", i + 1));
            commands::update::reresolve_profile(&git::RealGit, &profile, name, cwd, paths, &dir_lookup, &mut lf)?;
            lf.save(&lp)?;
            let mkt_count = profile.marketplaces.len();
            let plugin_count = profile.plugins.len();
            let mkt_plural = if mkt_count == 1 { "marketplace" } else { "marketplaces" };
            let plugin_plural = if plugin_count == 1 { "plugin" } else { "plugins" };
            progress::done(&format!(
                "{name} — {mkt_count} {mkt_plural}, {plugin_count} {plugin_plural}"
            ));
        }
    }
    Ok(())
}

/// Resolve `extends` for a profile, printing a warning and returning `None`
/// (so the caller can skip it) instead of aborting the whole `update` run.
fn resolve_extends_or_warn(
    name: &str,
    profile: &profile::Profile,
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> Option<profile::Profile> {
    match extends::resolve_extends(profile.clone(), &|parent| {
        Ok(resolve::resolve(parent, paths, cwd, env, bundled)?.profile)
    }) {
        Ok(p) => Some(p),
        Err(e) => {
            eprintln!("warning: skipping '{name}': could not resolve extends: {e}");
            None
        }
    }
}

/// Dispatch a launch: no args prints help, one arg launches a single profile (with the
/// owner/repo sugar), several launch a combined session.
fn handle_launch(
    names: &[String],
    assume_yes: bool,
    extra: &[String],
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> anyhow::Result<i32> {
    match names {
        [] => {
            use clap::CommandFactory;
            Cli::command().print_help()?;
            println!();
            Ok(0)
        }
        [name] => {
            let one = resolve_one(name, paths, cwd, env, bundled)?;
            let lock_file = lock::lock_path(&one.key, &one.path, &one.source, paths);
            provision_pin_launch(&one.profile, &one.key, &lock_file, assume_yes, extra, cwd, paths)
        }
        _ => launch_combined(names, assume_yes, extra, paths, cwd, env, bundled),
    }
}

/// A resolved launch target: its display key, `extends`-expanded profile, and the source
/// file/origin (used to place a single profile's lockfile).
struct ResolvedTarget {
    key: String,
    profile: profile::Profile,
    path: std::path::PathBuf,
    source: resolve::ProfileSource,
}

/// Resolve one launch target (a profile name, or an owner/repo/URL installed as a pack).
fn resolve_one(
    name: &str,
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> anyhow::Result<ResolvedTarget> {
    let key = if name.contains('/') {
        let dir = pack::install_pack(&git::RealGit, name, paths)?;
        pack::default_profile_name(&dir)?
    } else {
        name.to_string()
    };
    let resolved = resolve::resolve(&key, paths, cwd, env, bundled)?;
    let (path, source) = (resolved.path.clone(), resolved.source.clone());
    let profile = extends::resolve_extends(resolved.profile, &|parent| {
        Ok(resolve::resolve(parent, paths, cwd, env, bundled)?.profile)
    })?;
    Ok(ResolvedTarget { key, profile, path, source })
}

/// Resolve several targets, merge them into one effective profile, and launch it with a
/// combined lockfile under `~/.claude-profiles/locks/`.
fn launch_combined(
    names: &[String],
    assume_yes: bool,
    extra: &[String],
    paths: &fs_paths::Paths,
    cwd: &std::path::Path,
    env: Option<&std::path::Path>,
    bundled: &std::path::Path,
) -> anyhow::Result<i32> {
    let mut resolved = Vec::new();
    for name in names {
        let t = resolve_one(name, paths, cwd, env, bundled)?;
        resolved.push((t.key, t.profile));
    }
    let combined = combine::combine_profiles(&resolved)?;
    let key = combined.name.clone();
    let lock_file = paths.locks_dir().join(format!("{key}.lock"));
    provision_pin_launch(&combined, &key, &lock_file, assume_yes, extra, cwd, paths)
}

/// Shared launch tail: provision the profile (cloning marketplaces / prompting as needed),
/// pin its marketplaces into `lock_file`, vendor plugins against the pinned checkout, then
/// spawn `claude` for the session with the vendored plugin dirs.
fn provision_pin_launch(
    profile: &profile::Profile,
    key: &str,
    lock_file: &std::path::Path,
    assume_yes: bool,
    extra: &[String],
    cwd: &std::path::Path,
    paths: &fs_paths::Paths,
) -> anyhow::Result<i32> {
    provision::provision(&git::RealGit, profile, key, cwd, paths, assume_yes)?;

    let mut lock = lock::Lockfile::load(lock_file)?.unwrap_or_else(|| lock::Lockfile::new(key));
    let dir_lookup = |n: &str| paths.marketplace_clone_dir(n);
    provision::pin_marketplaces(&git::RealGit, profile, &dir_lookup, &mut lock, false)?;

    provision::vendor_plugins(&git::RealGit, profile, key, cwd, paths, false, &mut lock)?;

    if let Some(parent) = lock_file.parent() {
        std::fs::create_dir_all(parent)?;
    }
    lock.save(lock_file)?;

    let args = launch::build_args(profile, key, paths, extra)?;
    progress::clear();
    launch::spawn(key, &args)
}

fn main() {
    match run() {
        Ok(code) => std::process::exit(code),
        Err(e) => {
            eprintln!("error: {e:#}");
            std::process::exit(1);
        }
    }
}