spool-memory 0.2.3

//! End-to-end smoke test for the bootstrap flow.
//!
//! Runs against a sandbox `~/.spool` under `/tmp/` to avoid clobbering the
//! developer's real installation. Useful before tagging a release.
//!
//! Run with:
//! ```
//! cargo run --example bootstrap_smoke
//! ```

use spool::bootstrap::{self, SpoolLayout};
use std::path::PathBuf;

fn main() -> anyhow::Result<()> {
    // Sandbox layout under /tmp/.
    let sandbox = std::env::temp_dir().join("spool-bootstrap-smoke");
    let _ = std::fs::remove_dir_all(&sandbox);
    let layout = SpoolLayout::from_root(sandbox.clone());

    // Use the workspace's actual release binaries as the "bundled" source.
    let workspace_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let bundled_dir = workspace_root.join("target/release");

    if !bundled_dir.exists() {
        eprintln!(
            "❌ Build the release binaries first:\n   cargo build --release --bin spool --bin spool-mcp --bin spool-daemon"
        );
        std::process::exit(1);
    }

    println!("🧪 spool bootstrap smoke test");
    println!("   sandbox:  {}", sandbox.display());
    println!("   bundled:  {}", bundled_dir.display());
    println!();

    let report = bootstrap::run_bootstrap_with_layout(&layout, &bundled_dir)?;

    println!("📋 Bootstrap messages:");
    for msg in &report.messages {
        println!("   • {msg}");
    }
    println!();

    println!("📦 Layout created:");
    for (label, path) in [
        ("root    ", layout.root().to_path_buf()),
        ("bin     ", layout.bin_dir()),
        ("data    ", layout.data_dir()),
        ("plugins ", layout.plugins_dir()),
        ("version ", layout.version_file()),
    ] {
        let mark = if path.exists() { "✅" } else { "❌" };
        println!("   {mark} {label}{}", path.display());
    }
    println!();

    println!("📁 Files in ~/.spool/bin/:");
    if let Ok(entries) = std::fs::read_dir(layout.bin_dir()) {
        for entry in entries.flatten() {
            let size = entry.metadata().map(|m| m.len()).unwrap_or(0);
            println!(
                "   • {} ({} bytes)",
                entry.file_name().to_string_lossy(),
                size
            );
        }
    }
    println!();

    if let Some(release) = &report.release {
        println!("🔄 Release report:");
        println!("   • copied:  {}", release.copied.len());
        println!("   • skipped: {}", release.skipped.len());
        println!();
    }

    if let Some(cfg) = &report.auto_configure {
        println!("🔌 AI client configuration:");
        for client in &cfg.clients {
            let icon = if client.installed {
                "✅"
            } else if client.detected {
                "⚠️ "
            } else {
                "⏭️ "
            };
            println!(
                "   {icon} {} — detected={} installed={} status={}",
                client.client, client.detected, client.installed, client.status
            );
            for note in &client.notes {
                println!("      ↳ {note}");
            }
        }
        println!();
    }

    if let Some(path) = &report.path_config {
        println!("🛣️  PATH configuration:");
        println!("   • configured:    {}", path.configured);
        println!("   • files modified: {}", path.modified_files.len());
        for f in &path.modified_files {
            println!("     ↳ {}", f.display());
        }
        println!();
    }

    println!("📋 Final state:");
    let s = &report.state_after;
    println!(
        "   • service version:  {:?}",
        s.service.as_ref().map(|s| &s.version)
    );
    println!("   • gui version:      {:?}", s.gui_version);
    println!("   • mcp_registered:   {}", s.mcp_registered);
    println!("   • hooks_installed:  {}", s.hooks_installed);
    println!("   • path_configured:  {}", s.path_configured);
    println!();

    println!("🎉 Bootstrap smoke test completed successfully");
    println!("   To inspect: ls -la {}", sandbox.display());
    Ok(())
}