difflore-cli 0.7.0

use crate::commands::providers::setup as providers_setup;
use crate::installer;
use crate::runtime::CommandContext;
use crate::style::{self, sym};
use anyhow::Context as _;

use crate::support::util::ensure_project;

/// Options for `difflore init`.
///
/// `init` is the first-time local setup path. `--check` is a readiness
/// preview that never writes.
///
/// Cloud login is handled by the explicit `difflore cloud login`
/// command, so `init` does not surprise-open a browser.
#[derive(Default, Clone, Copy)]
pub(crate) struct InitOptions {
    pub check: bool,
}

impl InitOptions {
    const fn run_agents(self) -> bool {
        !self.check
    }

    const fn run_provider(self) -> bool {
        !self.check
    }
}

/// `difflore init` — readiness summary + a single next best action.
///
/// Per the CLI redesign brief, `init` is the one safe command that
/// gets a user to local value. Output is shaped as:
///   `OK DiffLore initialized for <repo>`
///   `Readiness` block (repo / memory / agents / provider / cloud)
///   `Next best action` — one command.
pub(crate) async fn handle_init(ctx: &CommandContext, opts: InitOptions) -> anyhow::Result<()> {
    let cwd = std::env::current_dir().context("could not read current directory")?;
    let cwd_str = cwd.to_string_lossy().to_string();

    let git_dir = cwd.join(".git");
    let is_git = git_dir.is_dir() || git_dir.is_file();
    if !is_git {
        eprintln!(
            "{} {} `difflore init` expects to run inside a git repo (no .git found at {}).",
            style::warn(sym::WARN),
            style::warn("warning"),
            cwd.display(),
        );
    }

    let remote_url = crate::support::util::git_str(&["config", "--get", "remote.origin.url"]);
    // [fork, upstream(s)…] — the same alias chain review uses, so the
    // memory preview resolves to upstream for a fork the user hasn't imported
    // reviews under yet.
    let configured_gitlab_hosts = difflore_core::ingest::gitlab::auth::configured_hosts().await;
    let repo_aliases = difflore_core::infra::git::detect_repo_full_names_with_gitlab_hosts(
        &cwd.to_string_lossy(),
        &configured_gitlab_hosts,
    );

    let db = &ctx.db;
    // Called for its side effect: registering the cwd in the projects table so
    // later commands have a project_id to bind to.
    let _project = ensure_project(db, &cwd_str).await?;

    let repo_label = repo_aliases.first().cloned().unwrap_or_else(|| {
        // Fallback when detect failed and remote_url didn't parse: the
        // directory name keeps the header non-empty.
        cwd.file_name().map_or_else(
            || "this repo".to_owned(),
            |s| s.to_string_lossy().into_owned(),
        )
    });

    // Run setup steps before collecting snapshots so the readiness block
    // reflects the post-init state.
    if opts.run_agents() {
        installer::install_all(false);
    }
    if opts.run_provider() {
        let has_active = difflore_core::infra::providers::list(db)
            .await
            .is_ok_and(|ps| ps.iter().any(|p| p.is_active));
        if !has_active {
            providers_setup::run_setup(db).await;
        }
    }
    if opts.check {
        println!(
            "{} {} DiffLore would initialize for {}",
            style::pewter(sym::BULLET),
            style::pewter("[--check]"),
            style::title(&repo_label),
        );
    } else {
        println!(
            "{} DiffLore initialized for {}",
            style::ok(sym::OK),
            style::title(&repo_label),
        );
    }
    println!();

    println!("{}", style::pewter("Readiness"));

    println!(
        "  {:<10} {}",
        style::pewter("repo"),
        style::title(&repo_label),
    );
    if let Some(url) = &remote_url {
        let safe_url = redact_remote_url(url);
        println!(
            "  {:<10} {}",
            style::pewter(""),
            style::pewter(&format!("origin: {safe_url}")),
        );
    }

    let cloud_client = ctx.cloud().await;

    let total_rules = match difflore_core::skills::stats(db).await {
        Ok(s) => s.total,
        Err(_) => 0,
    };
    let memory_value = if total_rules == 0 {
        style::amber(&format!("0 rules - run `{}`", memory_import_command())).to_string()
    } else {
        style::title(&format!(
            "{} rule{}",
            total_rules,
            if total_rules == 1 { "" } else { "s" }
        ))
        .to_string()
    };
    println!("  {:<10} {}", style::pewter("rules"), memory_value);

    // Print a top-3 sample so the user sees concrete review judgments. Each
    // line ends with `<- from <repo>` (same framing as review and the
    // CLI memory surfaces) so the memory source is visible.
    if total_rules > 0 {
        let top = top_rules_preview(db, &repo_aliases, 3).await;
        for sample in &top {
            let suffix = sample.source_repo.as_deref().map_or_else(String::new, |r| {
                format!("  {}", style::pewter(&format!("<- from {r}")))
            });
            println!(
                "  {:<10} {} {}{suffix}",
                style::pewter(""),
                style::pewter(sym::BULLET),
                sample.name,
            );
        }
    }

    let snapshot = installer::collect_status_snapshot();
    let installed = snapshot
        .clients
        .iter()
        .filter(|c| matches!(c.state, installer::InstallState::Installed))
        .count();
    let detected = snapshot.clients.iter().filter(|c| c.detected).count();
    // Denominator = detected agents on this machine, not the full probe list.
    let agents_value = format!("{installed}/{detected} wired");
    println!(
        "  {:<10} {}",
        style::pewter("agents"),
        if installed > 0 {
            style::title(&agents_value).to_string()
        } else {
            style::amber(&agents_value).to_string()
        }
    );

    let providers = difflore_core::infra::providers::list(db)
        .await
        .unwrap_or_default();
    let active = providers.iter().find(|p| p.is_active);
    let provider_value = match active {
        Some(p) => style::title(&format!("{} active", p.name)).to_string(),
        None => style::amber("not configured").to_string(),
    };
    println!("  {:<10} {}", style::pewter("provider"), provider_value);

    // Tier badge making the OSS/Cloud split visible — the OSS line is the only
    // place a casual user sees a pointer to what cloud unlocks.
    let cloud_status = fetch_cloud_status_for_init(cloud_client).await;
    let on_cloud_team = is_cloud_team(&cloud_status);
    let cloud_value = tier_badge_line(&cloud_status);
    let styled_cloud = if on_cloud_team {
        style::title(&cloud_value).to_string()
    } else {
        style::pewter(&cloud_value).to_string()
    };
    println!("  {:<10} {}", style::pewter("cloud"), styled_cloud);

    // OSS-mode "what cloud adds" block. Skipped on Cloud Team (already
    // converted).
    if !on_cloud_team {
        let pricing = difflore_core::cloud::endpoints::pricing_url();
        println!();
        println!("{}", style::pewter("Optional cloud path:"));
        println!(
            "  {} One approved rule set shared by the whole team",
            style::pewter(sym::BULLET),
        );
        println!(
            "  {} Approval workflow: every rule traceable to the review that set it",
            style::pewter(sym::BULLET),
        );
        println!(
            "  {} CI gate plus team coverage and recall dashboards",
            style::pewter(sym::BULLET),
        );
        println!(
            "  {} Free for one person, forever; team plans start when a second person joins.",
            style::pewter(sym::BULLET),
        );
        println!("  {}", style::pewter(&pricing));
    }

    println!();
    println!("{}", style::pewter("Why this matters"));
    println!(
        "  {} Import private review backlog locally so agents see team judgment before they edit.",
        style::pewter(sym::BULLET),
    );
    println!(
        "  {} Use {} to inspect coverage and recall, then {} to see exact matches.",
        style::pewter(sym::BULLET),
        style::cmd("difflore status"),
        style::cmd("difflore recall --diff"),
    );

    let has_agent_rule_files = crate::support::util::dir_has_agent_rule_files(&cwd);
    let next = pick_next_best_action(
        total_rules,
        installed,
        active.is_some(),
        has_agent_rule_files,
    );
    if total_rules == 0 && has_agent_rule_files {
        style::println_wrapped(&format!(
            "  {} This repo already carries agent rule files (CLAUDE.md / .cursor/rules) — mine them into governed rules first.",
            style::pewter(sym::BULLET),
        ));
    }
    maybe_print_ollama_semantic_hint().await;

    println!();
    println!("{}", style::pewter("Next best action"));
    println!("  {}", style::cmd(next));

    Ok(())
}

/// One-line nudge when semantic recall is still on the keyword fallback but a
/// local Ollama server is reachable: keyless semantic vectors are one command
/// away. Probe budget is tiny and failures stay silent — init must not slow
/// down or warn because Ollama is absent.
async fn maybe_print_ollama_semantic_hint() {
    // Gate on the runtime resolver's own answer (BYOK -> cloud -> SHA1) so a
    // cloud-managed semantic user never sees a bogus keyword-only warning.
    let kind = difflore_core::context::embedding::probe_active_embedder().await;
    if kind != difflore_core::context::embedding::ActiveEmbedderKind::Sha1 {
        return;
    }
    let probe = reqwest::Client::builder()
        .timeout(std::time::Duration::from_millis(400))
        .build();
    let Ok(client) = probe else { return };
    let Ok(resp) = client.get("http://127.0.0.1:11434/api/tags").send().await else {
        return;
    };
    if !resp.status().is_success() {
        return;
    }
    let Ok(tags) = resp.json::<serde_json::Value>().await else {
        return;
    };
    println!();
    match installed_ollama_embedding_model(&tags) {
        Some((model, dim)) => {
            style::println_wrapped(&format!(
                "  {} Ollama with `{model}` detected — recall currently uses keyword matching only. Enable keyless semantic recall: {}",
                style::pewter(sym::BULLET),
                style::cmd(&format!(
                    "difflore embeddings setup --no-key --provider-url http://127.0.0.1:11434/v1 --model {model} --dim {dim}"
                )),
            ));
        }
        None => {
            style::println_wrapped(&format!(
                "  {} Ollama detected locally — recall currently uses keyword matching only. Pull an embedding model ({}), then: {}",
                style::pewter(sym::BULLET),
                style::cmd("ollama pull nomic-embed-text"),
                style::cmd(
                    "difflore embeddings setup --no-key --provider-url http://127.0.0.1:11434/v1 --model nomic-embed-text --dim 768"
                ),
            ));
        }
    }
}

/// Embedding models Ollama commonly serves, with their output dimensions.
/// Only models whose dimensionality is stable and documented are listed; an
/// unknown model must not be suggested with a guessed `--dim`.
const KNOWN_OLLAMA_EMBEDDING_MODELS: &[(&str, usize)] = &[
    ("nomic-embed-text", 768),
    ("mxbai-embed-large", 1024),
    ("all-minilm", 384),
    ("bge-m3", 1024),
];

fn installed_ollama_embedding_model(tags: &serde_json::Value) -> Option<(String, usize)> {
    let models = tags.get("models")?.as_array()?;
    for entry in models {
        let name = entry.get("name")?.as_str().unwrap_or_default();
        let base = name.split(':').next().unwrap_or_default();
        if let Some((known, dim)) = KNOWN_OLLAMA_EMBEDDING_MODELS
            .iter()
            .find(|(known, _)| *known == base)
        {
            return Some(((*known).to_owned(), *dim));
        }
    }
    None
}

/// Return true when the user is on a Cloud Team plan or has an active team
/// identity. The exact tier mapping lives in core so CLI surfaces cannot drift.
pub(crate) fn is_cloud_team(status: &difflore_core::cloud::sync::CloudStatus) -> bool {
    difflore_core::cloud::sync::cloud_tier_from_status(status).is_team()
}

async fn fetch_cloud_status_for_init(
    client: &difflore_core::cloud::client::CloudClient,
) -> difflore_core::cloud::sync::CloudStatus {
    if !client.is_logged_in() {
        return difflore_core::cloud::sync::fetch_cloud_status(client).await;
    }
    match tokio::time::timeout(
        std::time::Duration::from_secs(2),
        difflore_core::cloud::sync::fetch_cloud_status(client),
    )
    .await
    {
        Ok(status) if status.logged_in => status,
        Ok(_) | Err(_) => difflore_core::cloud::sync::CloudStatus {
            logged_in: true,
            email: None,
            plan: None,
            team_id: None,
            team_name: None,
        },
    }
}

/// Render the one-line tier badge used in the `cloud:` row of the
/// readiness block (and the doctor cloud reachability section).
///
/// Two states, both fit in a single readiness row:
///   - OSS local mode → highlights what the user already has locally
///   - Cloud Team active → highlights what they're paying for
pub(crate) fn tier_badge_line(status: &difflore_core::cloud::sync::CloudStatus) -> String {
    let tier = difflore_core::cloud::sync::cloud_tier_from_status(status);
    if tier.is_team() {
        format!(
            "{} | shared team rule system of record + approval workflow",
            tier.default_label()
        )
    } else if status.logged_in {
        "Cloud Free | logged in | optional team rule path".to_owned()
    } else {
        "Local | private repos + local AI CLI recall".to_owned()
    }
}

/// Pick the single highest-leverage next command for this user state.
///
/// Priority order:
///   1. No memory: import private review backlog locally.
///   2. Memory but no agents wired: wire an agent so recall is reachable.
///   3. Memory + agents but no provider: set up a provider (unblocks fix).
///   4. All set: preview recall on the current diff.
const fn pick_next_best_action(
    total_rules: i64,
    installed_agents: usize,
    has_active_provider: bool,
    has_agent_rule_files: bool,
) -> &'static str {
    if total_rules == 0 && has_agent_rule_files {
        // Fast-merge teams often have no PR review threads at all; their
        // judgment lives in committed agent rule files. Mining those is the
        // 10-minute first-value path, so it outranks the review import.
        "difflore rules import-agent-files"
    } else if total_rules == 0 {
        memory_import_command()
    } else if installed_agents == 0 {
        "difflore agents install"
    } else if !has_active_provider {
        "difflore providers setup"
    } else {
        "difflore recall --diff"
    }
}

const fn memory_import_command() -> &'static str {
    "difflore import-reviews --max-prs 50"
}

/// One rule preview row used by `init`'s memory section. Lightweight
/// because the readiness block only needs the user-facing name and the
/// source_repo provenance.
struct RulePreview {
    name: String,
    source_repo: Option<String>,
}

/// Pick the top N rules for the `init` memory section. Prefers rules whose
/// `source_repo` matches one of `repo_aliases`; falls back to the
/// highest-confidence active rules corpus-wide (common for a fresh,
/// not-yet-imported fork) so the section is never empty.
async fn top_rules_preview(
    db: &difflore_core::SqlitePool,
    repo_aliases: &[String],
    limit: usize,
) -> Vec<RulePreview> {
    if limit == 0 {
        return Vec::new();
    }
    let limit_i = i64::try_from(limit).unwrap_or(i64::MAX);
    let candidates: Vec<&str> = repo_aliases
        .iter()
        .map(String::as_str)
        .filter(|s| !s.trim().is_empty())
        .collect();

    if !candidates.is_empty() {
        let placeholders = std::iter::repeat_n("?", candidates.len())
            .collect::<Vec<_>>()
            .join(", ");
        let sql = format!(
            "SELECT name, source_repo FROM skills \
             WHERE source_repo IN ({placeholders}) \
               AND COALESCE(status, 'active') = 'active' \
             ORDER BY confidence_score DESC, name ASC \
             LIMIT ?"
        );
        let mut q = sqlx::query_as::<_, (String, Option<String>)>(&sql);
        for repo in &candidates {
            q = q.bind(*repo);
        }
        q = q.bind(limit_i);
        if let Ok(rows) = q.fetch_all(db).await
            && !rows.is_empty()
        {
            return rows
                .into_iter()
                .map(|(name, source_repo)| RulePreview { name, source_repo })
                .collect();
        }
    }

    let global: Result<Vec<(String, Option<String>)>, sqlx::Error> = sqlx::query_as(
        "SELECT name, source_repo FROM skills \
         WHERE COALESCE(status, 'active') = 'active' \
         ORDER BY confidence_score DESC, name ASC \
         LIMIT ?1",
    )
    .bind(limit_i)
    .fetch_all(db)
    .await;
    global
        .unwrap_or_default()
        .into_iter()
        .map(|(name, source_repo)| RulePreview { name, source_repo })
        .collect()
}

fn redact_remote_url(url: &str) -> String {
    let trimmed = url.trim();
    let Some((scheme, rest)) = trimmed.split_once("://") else {
        return trimmed.to_owned();
    };
    let Some((userinfo, host_and_path)) = rest.split_once('@') else {
        return trimmed.to_owned();
    };
    if userinfo.is_empty() || host_and_path.is_empty() {
        return trimmed.to_owned();
    }
    format!("{scheme}://***@{host_and_path}")
}

#[cfg(test)]
mod tests {
    use super::{
        InitOptions, is_cloud_team, memory_import_command, redact_remote_url, tier_badge_line,
    };
    use difflore_core::cloud::sync::CloudStatus;

    fn status(logged_in: bool, plan: Option<&str>) -> CloudStatus {
        CloudStatus {
            logged_in,
            email: None,
            plan: plan.map(String::from),
            team_id: None,
            team_name: None,
        }
    }

    #[test]
    fn tier_badge_oss_when_not_logged_in() {
        let s = status(false, None);
        assert!(!is_cloud_team(&s));
        let line = tier_badge_line(&s);
        assert!(line.starts_with("Local"), "unexpected: {line}");
        assert!(line.contains("private repos"));
        assert!(line.contains("local AI CLI recall"));
    }

    #[test]
    fn tier_badge_oss_when_logged_in_but_free() {
        // Logged in to a free / self-host plan is still OSS-tier; the
        // conversion line must still appear in the init block.
        for plan in ["free", "self_host", "typo_future_plan"] {
            let s = status(true, Some(plan));
            assert!(!is_cloud_team(&s), "plan {plan} should not be team-tier");
            let line = tier_badge_line(&s);
            assert!(line.starts_with("Cloud Free"), "unexpected: {line}");
            assert!(line.contains("logged in"));
        }
    }

    #[test]
    fn tier_badge_team_when_paid_plan() {
        for plan in ["team", "team_plus", "pro", "business", "enterprise"] {
            let s = status(true, Some(plan));
            assert!(is_cloud_team(&s), "plan {plan} should be team-tier");
            let line = tier_badge_line(&s);
            assert!(line.starts_with("Cloud Team"), "unexpected: {line}");
            assert!(line.contains("shared team rule system of record"));
            assert!(line.contains("approval workflow"));
        }
    }

    #[test]
    fn init_runs_local_setup_steps_by_default() {
        let opts = InitOptions::default();
        assert!(opts.run_agents());
        assert!(opts.run_provider());
    }

    #[test]
    fn memory_import_command_is_single_source_for_zero_rule_next_step() {
        assert_eq!(
            memory_import_command(),
            "difflore import-reviews --max-prs 50"
        );
    }

    #[test]
    fn redact_remote_url_masks_https_userinfo() {
        assert_eq!(
            redact_remote_url("https://oauth2:secret@github.com/org/repo.git"),
            "https://***@github.com/org/repo.git"
        );
        assert_eq!(
            redact_remote_url("git@github.com:org/repo.git"),
            "git@github.com:org/repo.git"
        );
    }
}