use anyhow::{Context, Result};
use std::process::Command;
use colored::*;
use std::path::PathBuf;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct TideCharts {
pub build_times: Vec<f64>,
pub error_counts: Vec<u32>,
pub warning_counts: Vec<u32>,
pub timestamps: Vec<String>,
}
impl TideCharts {
pub fn new() -> Result<Self> {
println!("📊 {}", "Tide charts require captain binary".bright_blue());
println!(" Delegating tide operations to captain...");
Ok(TideCharts {
build_times: Vec::new(),
error_counts: Vec::new(),
warning_counts: Vec::new(),
timestamps: Vec::new(),
})
}
pub fn record_build(&mut self, metrics: BuildMetrics) -> Result<()> {
println!(
"📊 {}", "Recording build metrics requires captain binary".bright_blue()
);
println!(
" Build recorded: {} ({:.2}s)", metrics.command, metrics.duration_seconds
);
Ok(())
}
pub fn show_interactive(&self) -> Result<()> {
println!(
"🌊 {}", "Interactive tide charts require captain binary".bright_blue()
);
delegate_to_captain(vec!["tide", "interactive"])
}
pub fn analyze_dependencies(&self) -> Result<()> {
println!("🌊 {}", "Dependency analysis requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "analyze", "deps"])
}
pub fn export_csv(&self, path: &str) -> Result<()> {
println!(
"🌊 {}", format!("Exporting tide data to '{}' requires captain binary",
path) .bright_blue()
);
delegate_to_captain(vec!["tide", "export", "csv", path])
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct BuildMetrics {
pub total_builds: u32,
pub successful_builds: u32,
pub failed_builds: u32,
pub average_build_time: f64,
pub top_errors: Vec<String>,
pub improvement_trend: String,
pub timestamp: String,
pub command: String,
pub duration_seconds: f64,
pub success: bool,
pub error_count: u32,
pub warning_count: u32,
pub incremental: bool,
pub profile: String,
pub features: Vec<String>,
pub dependencies_compiled: u32,
pub crate_units_compiled: u32,
pub memory_peak_mb: Option<f64>,
pub cpu_usage_percent: Option<f64>,
}
pub struct TideAnalyzer;
impl TideAnalyzer {
pub fn new() -> Result<Self> {
println!(
"🌊 {}", "Advanced tide analysis requires captain binary".bright_blue()
);
println!(" Delegating tide operations to captain...");
Ok(TideAnalyzer)
}
pub fn analyze_project(&self, path: &PathBuf) -> Result<()> {
println!(
"🌊 {}", format!("Project analysis for '{}' requires captain binary", path
.display()) .bright_blue()
);
let path_str = path.to_string_lossy();
delegate_to_captain(vec!["tide", "analyze", & path_str])
}
pub fn show_trends(&self) -> Result<()> {
println!("🌊 {}", "Trend analysis requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "trends"])
}
pub fn predict_issues(&self) -> Result<()> {
println!("🌊 {}", "Issue prediction requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "predict"])
}
pub fn generate_report(&self, format: &str) -> Result<()> {
println!(
"🌊 {}", format!("Report generation ({}) requires captain binary", format)
.bright_blue()
);
delegate_to_captain(vec!["tide", "report", format])
}
pub fn monitor_performance(&self) -> Result<()> {
println!(
"🌊 {}", "Performance monitoring requires captain binary".bright_blue()
);
delegate_to_captain(vec!["tide", "monitor"])
}
pub fn analyze_dependencies(&self) -> Result<()> {
println!("🌊 {}", "Dependency analysis requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "deps"])
}
pub fn check_security(&self) -> Result<()> {
println!("🌊 {}", "Security analysis requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "security"])
}
}
pub fn delegate_to_captain(args: Vec<&str>) -> Result<()> {
let captain_path = match crate::captain::captain_status::find_captain_binary() {
Some(path) => path,
None => {
println!("❌ {}", "Advanced captain binary not found".red().bold());
println!(
"🔄 {}", "Auto-downloading captain binary from get.cargo.do/".cyan()
);
match crate::captain::captain_status::auto_download_captain() {
Ok(path) => path,
Err(e) => {
println!(
"❌ {}", format!("Failed to download captain: {}", e) .red()
);
println!("💡 {}", "Please run: cm captain install".cyan());
println!(" Or upgrade at: https://cargo.do/pro");
println!();
println!(
"💡 {}", "Tide analysis features require the captain binary:"
.cyan()
);
println!(" • Advanced project analysis");
println!(" • Trend monitoring and prediction");
println!(" • Performance metrics");
println!(" • Security vulnerability scanning");
println!(" • Dependency analysis");
println!(" • Comprehensive reporting");
return Ok(());
}
}
}
};
let output = Command::new(&captain_path)
.args(&args)
.output()
.context("Failed to execute captain binary for tide analysis")?;
if !output.stdout.is_empty() {
print!("{}", String::from_utf8_lossy(& output.stdout));
}
if !output.stderr.is_empty() {
eprint!("{}", String::from_utf8_lossy(& output.stderr));
}
if !output.status.success() {
println!(
"❌ {}", format!("Captain binary exited with status: {}", output.status)
.red()
);
}
Ok(())
}
pub fn analyze_current_tide() -> Result<()> {
println!("🌊 {}", "Current tide analysis requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "current"])
}
pub fn show_tide_dashboard() -> Result<()> {
println!("🌊 {}", "Tide dashboard requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "dashboard"])
}
pub fn generate_tide_summary() -> Result<String> {
println!("🌊 {}", "Tide summary requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "summary"])
.map(|_| "Advanced tide summary available".to_string())
}
pub fn check_tide_health() -> Result<bool> {
println!("🌊 {}", "Health check requires captain binary".bright_blue());
delegate_to_captain(vec!["tide", "health"]).map(|_| true)
}
pub fn export_tide_data(format: &str, path: &str) -> Result<()> {
println!(
"🌊 {}", format!("Exporting tide data to '{}' requires captain binary", path)
.bright_blue()
);
delegate_to_captain(vec!["tide", "export", format, path])
}