@llm-dev-ops/agentics-cli 1.4.29 → 1.4.32

package/dist/bundled-agents/analytics-hub-agents/src/cli/utils/connect.rs

@@ -0,0 +1,267 @@
+//! Interactive database connection utilities
+
+use anyhow::{Context, Result};
+use clap::{Parser, ValueEnum};
+use colored::Colorize;
+use tokio::process::Command;
+use tracing::info;
+
+use crate::common::ExecutionContext;
+use crate::infra::k8s::K8sClient;
+
+/// Database type for connection
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum DatabaseType {
+    /// TimescaleDB (PostgreSQL)
+    Timescaledb,
+    /// Redis
+    Redis,
+    /// Kafka
+    Kafka,
+}
+
+/// Connect to database arguments
+#[derive(Debug, Parser)]
+pub struct ConnectArgs {
+    /// Database type to connect to
+    #[arg(value_enum)]
+    pub database: DatabaseType,
+
+    /// Kubernetes namespace
+    #[arg(short = 'n', long, default_value = "llm-analytics-hub")]
+    pub namespace: String,
+
+    /// Pod name (optional, will auto-detect if not specified)
+    #[arg(short, long)]
+    pub pod: Option<String>,
+
+    /// Database name (for TimescaleDB)
+    #[arg(short = 'd', long)]
+    pub db_name: Option<String>,
+
+    /// Database user (for TimescaleDB)
+    #[arg(short, long)]
+    pub user: Option<String>,
+}
+
+impl ConnectArgs {
+    /// Execute connect command
+    pub async fn execute(&self, ctx: &ExecutionContext) -> Result<()> {
+        if ctx.json_output {
+            anyhow::bail!("Interactive connection not supported in JSON mode");
+        }
+
+        if ctx.dry_run {
+            println!("{}", "DRY RUN MODE".yellow().bold());
+            println!("Would connect to: {:?}", self.database);
+            println!("Namespace: {}", self.namespace);
+            if let Some(pod) = &self.pod {
+                println!("Pod: {}", pod);
+            }
+            return Ok(());
+        }
+
+        // Create K8s client
+        let k8s_client = K8sClient::new(&self.namespace).await?;
+
+        // Determine pod name
+        let pod_name = if let Some(pod) = &self.pod {
+            pod.clone()
+        } else {
+            self.find_pod(&k8s_client).await?
+        };
+
+        // Connect based on database type
+        match self.database {
+            DatabaseType::Timescaledb => self.connect_timescaledb(&pod_name).await?,
+            DatabaseType::Redis => self.connect_redis(&pod_name).await?,
+            DatabaseType::Kafka => self.connect_kafka(&pod_name).await?,
+        }
+
+        Ok(())
+    }
+
+    /// Find pod for the database type
+    async fn find_pod(&self, k8s_client: &K8sClient) -> Result<String> {
+        info!("Auto-detecting pod for {:?}...", self.database);
+
+        let pods = k8s_client.list_pods_in_namespace(&self.namespace).await?;
+
+        let pod_prefix = match self.database {
+            DatabaseType::Timescaledb => "timescaledb",
+            DatabaseType::Redis => "redis",
+            DatabaseType::Kafka => "kafka",
+        };
+
+        for pod in pods {
+            if let Some(name) = pod.metadata.name {
+                if name.starts_with(pod_prefix) {
+                    info!("Found pod: {}", name);
+                    return Ok(name);
+                }
+            }
+        }
+
+        anyhow::bail!(
+            "No pod found for {:?}. Specify pod name with --pod",
+            self.database
+        )
+    }
+
+    /// Connect to TimescaleDB
+    async fn connect_timescaledb(&self, pod_name: &str) -> Result<()> {
+        let database = self.db_name.as_deref().unwrap_or("llm_analytics");
+        let user = self.user.as_deref().unwrap_or("postgres");
+
+        println!("{}", "=== Connecting to TimescaleDB ===".bold().cyan());
+        println!("Pod: {}", pod_name);
+        println!("Database: {}", database);
+        println!("User: {}", user);
+        println!();
+
+        let status = Command::new("kubectl")
+            .args([
+                "exec",
+                "-it",
+                "-n",
+                &self.namespace,
+                pod_name,
+                "--",
+                "psql",
+                "-U",
+                user,
+                "-d",
+                database,
+            ])
+            .status()
+            .await
+            .context("Failed to execute kubectl exec")?;
+
+        if !status.success() {
+            anyhow::bail!("Connection to TimescaleDB failed");
+        }
+
+        Ok(())
+    }
+
+    /// Connect to Redis
+    async fn connect_redis(&self, pod_name: &str) -> Result<()> {
+        println!("{}", "=== Connecting to Redis ===".bold().cyan());
+        println!("Pod: {}", pod_name);
+        println!();
+
+        // Get Redis password from secret
+        let password_output = Command::new("kubectl")
+            .args([
+                "get",
+                "secret",
+                "analytics-hub-secrets",
+                "-n",
+                &self.namespace,
+                "-o",
+                "jsonpath={.data.REDIS_PASSWORD}",
+            ])
+            .output()
+            .await
+            .context("Failed to get Redis password from secret")?;
+
+        if !password_output.status.success() {
+            println!(
+                "{} Could not retrieve Redis password from secret",
+                "⚠".yellow().bold()
+            );
+            println!("  Attempting connection without password...");
+
+            // Try without password
+            let status = Command::new("kubectl")
+                .args([
+                    "exec",
+                    "-it",
+                    "-n",
+                    &self.namespace,
+                    pod_name,
+                    "--",
+                    "redis-cli",
+                ])
+                .status()
+                .await
+                .context("Failed to execute kubectl exec")?;
+
+            if !status.success() {
+                anyhow::bail!("Connection to Redis failed");
+            }
+
+            return Ok(());
+        }
+
+        // Decode base64 password using bash and base64
+        let encoded_password = String::from_utf8_lossy(&password_output.stdout).trim().to_string();
+        let password_decode = Command::new("bash")
+            .arg("-c")
+            .arg(format!("echo {} | base64 -d", encoded_password))
+            .output()
+            .await;
+
+        let password = if let Ok(output) = password_decode {
+            if output.status.success() {
+                String::from_utf8_lossy(&output.stdout).trim().to_string()
+            } else {
+                // Fallback: use encoded password as-is
+                encoded_password
+            }
+        } else {
+            // Fallback: use encoded password as-is
+            encoded_password
+        };
+
+        // Connect with password
+        let status = Command::new("kubectl")
+            .args([
+                "exec",
+                "-it",
+                "-n",
+                &self.namespace,
+                pod_name,
+                "--",
+                "redis-cli",
+                "--pass",
+                password.as_ref(),
+            ])
+            .status()
+            .await
+            .context("Failed to execute kubectl exec")?;
+
+        if !status.success() {
+            anyhow::bail!("Connection to Redis failed");
+        }
+
+        Ok(())
+    }
+
+    /// Connect to Kafka
+    async fn connect_kafka(&self, pod_name: &str) -> Result<()> {
+        println!("{}", "=== Connecting to Kafka ===".bold().cyan());
+        println!("Pod: {}", pod_name);
+        println!();
+        println!(
+            "You will be dropped into a shell in the Kafka pod."
+        );
+        println!("Useful commands:");
+        println!("  kafka-topics.sh --list --bootstrap-server localhost:9092");
+        println!("  kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic <topic>");
+        println!("  kafka-console-producer.sh --bootstrap-server localhost:9092 --topic <topic>");
+        println!();
+
+        let status = Command::new("kubectl")
+            .args(["exec", "-it", "-n", &self.namespace, pod_name, "--", "/bin/bash"])
+            .status()
+            .await
+            .context("Failed to execute kubectl exec")?;
+
+        if !status.success() {
+            anyhow::bail!("Connection to Kafka failed");
+        }
+
+        Ok(())
+    }
+}

package/dist/bundled-agents/analytics-hub-agents/src/cli/utils/mod.rs

@@ -0,0 +1,39 @@
+//! Utility CLI commands
+//!
+//! This module provides utility commands for operational tasks:
+//! - scale: Scale deployments up/down
+//! - cleanup: Safe infrastructure teardown
+//! - connect: Interactive connection helpers
+
+pub mod cleanup;
+pub mod connect;
+pub mod scale;
+
+use anyhow::Result;
+use clap::Subcommand;
+
+use crate::common::ExecutionContext;
+
+/// Utils command
+#[derive(Debug, Subcommand)]
+pub enum UtilsCommand {
+    /// Scale deployments
+    Scale(scale::ScaleArgs),
+
+    /// Cleanup/destroy infrastructure
+    Cleanup(cleanup::CleanupArgs),
+
+    /// Connect to database interactively
+    Connect(connect::ConnectArgs),
+}
+
+impl UtilsCommand {
+    /// Execute the utils command
+    pub async fn execute(&self, ctx: &ExecutionContext) -> Result<()> {
+        match self {
+            UtilsCommand::Scale(args) => args.execute(ctx).await,
+            UtilsCommand::Cleanup(args) => args.execute(ctx).await,
+            UtilsCommand::Connect(args) => args.execute(ctx).await,
+        }
+    }
+}

package/dist/bundled-agents/analytics-hub-agents/src/cli/utils/scale.rs

@@ -0,0 +1,157 @@
+//! Scaling utilities for deployments
+
+use anyhow::Result;
+use clap::Parser;
+use colored::Colorize;
+use comfy_table::{presets::UTF8_FULL, Table};
+use indicatif::{ProgressBar, ProgressStyle};
+
+use crate::common::ExecutionContext;
+use crate::infra::k8s::K8sClient;
+
+/// Scale deployment arguments
+#[derive(Debug, Parser)]
+pub struct ScaleArgs {
+    /// Deployment name to scale
+    #[arg(short, long)]
+    pub deployment: String,
+
+    /// Number of replicas
+    #[arg(short, long)]
+    pub replicas: i32,
+
+    /// Kubernetes namespace
+    #[arg(short = 'n', long, default_value = "llm-analytics-hub")]
+    pub namespace: String,
+
+    /// Wait for scaling to complete
+    #[arg(short, long)]
+    pub wait: bool,
+
+    /// Timeout in seconds (when waiting)
+    #[arg(long, default_value = "300")]
+    pub timeout: u64,
+
+    /// Scale all deployments in namespace
+    #[arg(long)]
+    pub all: bool,
+}
+
+impl ScaleArgs {
+    /// Execute scale command
+    pub async fn execute(&self, ctx: &ExecutionContext) -> Result<()> {
+        if !ctx.json_output {
+            println!("{}", "=== Scale Deployments ===".bold().cyan());
+            println!();
+        }
+
+        // Validate replicas
+        if self.replicas < 0 {
+            anyhow::bail!("Replicas must be non-negative, got: {}", self.replicas);
+        }
+
+        if ctx.dry_run {
+            if ctx.json_output {
+                let output = serde_json::json!({
+                    "dry_run": true,
+                    "deployment": self.deployment,
+                    "namespace": self.namespace,
+                    "replicas": self.replicas,
+                    "all": self.all,
+                });
+                println!("{}", serde_json::to_string_pretty(&output)?);
+            } else {
+                println!("{}", "DRY RUN MODE".yellow().bold());
+                if self.all {
+                    println!("Would scale all deployments to {} replicas", self.replicas);
+                } else {
+                    println!(
+                        "Would scale deployment '{}' to {} replicas",
+                        self.deployment, self.replicas
+                    );
+                }
+                println!("Namespace: {}", self.namespace);
+            }
+            return Ok(());
+        }
+
+        // Create K8s client
+        let k8s_client = K8sClient::new(&self.namespace).await?;
+
+        // Show progress
+        let spinner = if !ctx.json_output {
+            let pb = ProgressBar::new_spinner();
+            pb.set_style(
+                ProgressStyle::default_spinner()
+                    .template("{spinner:.cyan} {msg}")
+                    .unwrap(),
+            );
+            if self.all {
+                pb.set_message("Scaling all deployments...");
+            } else {
+                pb.set_message(format!("Scaling deployment '{}'...", self.deployment));
+            }
+            pb.enable_steady_tick(std::time::Duration::from_millis(100));
+            Some(pb)
+        } else {
+            None
+        };
+
+        // Scale deployments
+        let results = if self.all {
+            k8s_client.scale_all_deployments(self.replicas).await?
+        } else {
+            let result = k8s_client
+                .scale_deployment(&self.deployment, self.replicas)
+                .await?;
+            vec![result]
+        };
+
+        // Wait for scaling if requested
+        if self.wait {
+            if let Some(ref spinner) = spinner {
+                spinner.set_message("Waiting for scaling to complete...");
+            }
+
+            for deployment_name in &results {
+                k8s_client
+                    .wait_for_deployment(deployment_name, self.timeout)
+                    .await?;
+            }
+        }
+
+        if let Some(spinner) = spinner {
+            spinner.finish_and_clear();
+        }
+
+        // Output results
+        if ctx.json_output {
+            let output = serde_json::json!({
+                "success": true,
+                "deployments_scaled": results,
+                "replicas": self.replicas,
+                "namespace": self.namespace,
+            });
+            println!("{}", serde_json::to_string_pretty(&output)?);
+        } else {
+            println!("{} Scaling completed successfully", "✓".green().bold());
+            println!();
+
+            let mut table = Table::new();
+            table.load_preset(UTF8_FULL);
+            table.set_header(vec!["Deployment", "Replicas", "Status"]);
+
+            for deployment in &results {
+                table.add_row(vec![
+                    deployment.clone(),
+                    self.replicas.to_string(),
+                    if self.wait { "Ready" } else { "Scaling" }.to_string(),
+                ]);
+            }
+
+            println!("{table}");
+        }
+
+        Ok(())
+    }
+}

package/dist/bundled-agents/analytics-hub-agents/src/cli/validate/all.rs

@@ -0,0 +1,228 @@
+//! Comprehensive validation command
+
+use anyhow::{Context, Result};
+use clap::Args;
+use std::path::PathBuf;
+use tracing::info;
+
+use crate::common::{
+    output::{print_error, print_header, print_step, print_success, CommandOutput, FormattedTable},
+    progress::ProgressTracker,
+    ExecutionContext,
+};
+use crate::infra::k8s::K8sClient;
+use crate::infra::validation::{
+    PrerequisiteValidator, ClusterValidator, ServiceValidator, DatabaseValidator,
+    SecurityValidator, NetworkValidator, ResourceValidator, ValidationReport, CheckStatus,
+};
+
+/// Validation arguments
+#[derive(Debug, Args)]
+pub struct ValidateAllArgs {
+    /// Namespace to validate
+    #[arg(short, long)]
+    pub namespace: Option<String>,
+
+    /// Kubeconfig path (overrides default)
+    #[arg(long)]
+    pub kubeconfig: Option<PathBuf>,
+
+    /// Kubernetes context to use
+    #[arg(long)]
+    pub context: Option<String>,
+
+    /// Skip non-critical checks
+    #[arg(short, long)]
+    pub fast: bool,
+}
+
+impl ValidateAllArgs {
+    /// Execute validation
+    pub async fn execute(&self, ctx: &ExecutionContext) -> Result<()> {
+        print_header("Comprehensive Validation");
+
+        // Determine namespace
+        let namespace = self
+            .namespace
+            .clone()
+            .unwrap_or_else(|| ctx.config.kubernetes.namespace.clone());
+
+        info!("Running comprehensive validation on namespace: {}", namespace);
+
+        // Create validation report
+        let mut report = ValidationReport::new(&namespace);
+
+        // Step 1: Prerequisites
+        print_step(1, 7, "Checking prerequisites");
+        let spinner = ProgressTracker::spinner("Validating prerequisites...");
+        let prereq_validator = PrerequisiteValidator::new();
+        let prereq_results = prereq_validator
+            .validate()
+            .await
+            .context("Failed to run prerequisite checks")?;
+        spinner.finish_success("Prerequisites checked");
+        report.add_category(prereq_results);
+
+        // Only proceed if prerequisites pass
+        if !report.healthy {
+            return self.output_results(ctx, report).await;
+        }
+
+        // Create Kubernetes client
+        let client = self.create_client(&namespace).await?;
+
+        // Step 2: Cluster health
+        print_step(2, 7, "Validating cluster health");
+        let spinner = ProgressTracker::spinner("Checking cluster and nodes...");
+        let cluster_validator = ClusterValidator::new(client.clone());
+        let cluster_results = cluster_validator
+            .validate()
+            .await
+            .context("Failed to run cluster validation")?;
+        spinner.finish_success("Cluster validation complete");
+        report.add_category(cluster_results);
+
+        // Step 3: Service availability
+        print_step(3, 7, "Validating service availability");
+        let spinner = ProgressTracker::spinner("Checking services and pods...");
+        let service_validator = ServiceValidator::new(client.clone());
+        let service_results = service_validator
+            .validate()
+            .await
+            .context("Failed to run service validation")?;
+        spinner.finish_success("Service validation complete");
+        report.add_category(service_results);
+
+        // Step 4: Database connectivity
+        if !self.fast {
+            print_step(4, 7, "Validating database connectivity");
+            let spinner = ProgressTracker::spinner("Checking database connections...");
+            let database_validator = DatabaseValidator::new(client.clone());
+            let database_results = database_validator
+                .validate()
+                .await
+                .context("Failed to run database validation")?;
+            spinner.finish_success("Database validation complete");
+            report.add_category(database_results);
+        } else {
+            print_step(4, 7, "Skipping database validation (fast mode)");
+        }
+
+        // Step 5: Security compliance
+        print_step(5, 7, "Validating security compliance");
+        let spinner = ProgressTracker::spinner("Checking security policies...");
+        let security_validator = SecurityValidator::new(client.clone());
+        let security_results = security_validator
+            .validate()
+            .await
+            .context("Failed to run security validation")?;
+        spinner.finish_success("Security validation complete");
+        report.add_category(security_results);
+
+        // Step 6: Network connectivity
+        if !self.fast {
+            print_step(6, 7, "Validating network connectivity");
+            let spinner = ProgressTracker::spinner("Checking network and DNS...");
+            let network_validator = NetworkValidator::new(client.clone());
+            let network_results = network_validator
+                .validate()
+                .await
+                .context("Failed to run network validation")?;
+            spinner.finish_success("Network validation complete");
+            report.add_category(network_results);
+        } else {
+            print_step(6, 7, "Skipping network validation (fast mode)");
+        }
+
+        // Step 7: Resource utilization
+        print_step(7, 7, "Validating resource utilization");
+        let spinner = ProgressTracker::spinner("Checking resource usage...");
+        let resource_validator = ResourceValidator::new(client.clone());
+        let resource_results = resource_validator
+            .validate()
+            .await
+            .context("Failed to run resource validation")?;
+        spinner.finish_success("Resource validation complete");
+        report.add_category(resource_results);
+
+        // Output results
+        self.output_results(ctx, report).await
+    }
+
+    /// Create Kubernetes client
+    async fn create_client(&self, namespace: &str) -> Result<K8sClient> {
+        if let Some(kubeconfig) = &self.kubeconfig {
+            K8sClient::with_kubeconfig(namespace, kubeconfig.clone(), self.context.clone())
+                .await
+                .context("Failed to create Kubernetes client with custom kubeconfig")
+        } else {
+            K8sClient::new(namespace)
+                .await
+                .context("Failed to create Kubernetes client")
+        }
+    }
+
+    /// Output validation results
+    async fn output_results(&self, ctx: &ExecutionContext, report: ValidationReport) -> Result<()> {
+        if ctx.json_output {
+            let output = if report.healthy {
+                CommandOutput::success_with_data("All validations passed", serde_json::to_value(&report)?)
+            } else {
+                CommandOutput::failure_with_data("Some validations failed", serde_json::to_value(&report)?)
+            };
+            output.output_json();
+        } else {
+            // Human-readable output
+            for category in &report.categories {
+                println!("\n=== {} ===", category.category);
+                let mut table = FormattedTable::new(vec!["Check", "Status", "Message"]);
+
+                for check in &category.checks {
+                    let status = match check.status {
+                        CheckStatus::Pass => "✓ PASS",
+                        CheckStatus::Fail => "✗ FAIL",
+                        CheckStatus::Warn => "⚠ WARN",
+                        CheckStatus::Skip => "⊘ SKIP",
+                    };
+
+                    table.add_row(vec![
+                        check.name.clone(),
+                        status.to_string(),
+                        check.message.clone(),
+                    ]);
+                }
+
+                table.print();
+                println!("  Passed: {} | Failed: {} | Warnings: {} | Success Rate: {:.1}%",
+                    category.passed, category.failed, category.warnings, category.success_rate());
+            }
+
+            println!("\n=== Overall Summary ===");
+            println!("Total Checks: {}", report.total_checks);
+            println!("Passed: {} | Failed: {} | Warnings: {}",
+                report.total_passed, report.total_failed, report.total_warnings);
+            println!("Overall Success Rate: {:.1}%", report.success_rate());
+            println!();
+
+            if report.healthy {
+                print_success("All validations passed");
+            } else {
+                print_error("Some validations failed - review errors above");
+                anyhow::bail!("Validation failed");
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_all_args() {
+        // Test construction
+        assert!(true);
+    }
+}