feat(deploy): add whimsical Makefile rice

Makefile

@@ -1,68 +1,103 @@
 .PHONY: help venv install run test lint format clean setup-secrets check-creds deploy-k8s deploy-helm cleanup-k8s cleanup-helm
 
-PYTHON=python
-PIP=pip
-VENV=.venv
-ACTIVATE=. $(VENV)/bin/activate
+# Colors and formatting
+BOLD := \033[1m
+RED := \033[31m
+GREEN := \033[32m
+YELLOW := \033[33m
+BLUE := \033[34m
+MAGENTA := \033[35m
+CYAN := \033[36m
+RESET := \033[0m
+
+PYTHON := python
+PIP := pip
+VENV := .venv
+ACTIVATE := . $(VENV)/bin/activate
 
 help:
-	@echo "Yuga Planner Makefile"
-	@echo "Available targets:"
-	@echo "  venv            Create a Python virtual environment"
-	@echo "  install         Install all Python dependencies"
-	@echo "  run             Run the Gradio app locally"
-	@echo "  test            Run all tests with pytest"
-	@echo "  lint            Run pre-commit hooks (includes black, yaml, gitleaks)"
-	@echo "  format          Format code with black"
-	@echo "  setup-secrets   Copy and edit secrets template for local dev"
-	@echo "  check-creds     Check and validate all required credentials"
-	@echo "  deploy-k8s      Deploy application to Kubernetes"
-	@echo "  deploy-helm     Deploy application using Helm"
-	@echo "  cleanup-k8s     Clean up Kubernetes deployment"
-	@echo "  cleanup-helm    Clean up Helm deployment"
-	@echo "  clean           Remove Python cache and virtual environment"
+	@printf "$(BOLD)🚀 Yuga Planner$(RESET)\n"
+	@printf "$(CYAN)━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━$(RESET)\n"
+	@printf "\n"
+	@printf "$(BOLD)📦 Development Commands:$(RESET)\n"
+	@printf "  $(GREEN)venv$(RESET)            🐍 Create Python virtual environment\n"
+	@printf "  $(GREEN)install$(RESET)         📋 Install all dependencies\n"
+	@printf "  $(GREEN)run$(RESET)             🏃 Run the Gradio app locally\n"
+	@printf "  $(GREEN)test$(RESET)            🧪 Run tests with pytest\n"
+	@printf "\n"
+	@printf "$(BOLD)🔧 Code Quality:$(RESET)\n"
+	@printf "  $(BLUE)lint$(RESET)            ✨ Run pre-commit hooks (black, yaml, gitleaks)\n"
+	@printf "  $(BLUE)format$(RESET)          🎨 Format code with black\n"
+	@printf "\n"
+	@printf "$(BOLD)🔐 Credentials:$(RESET)\n"
+	@printf "  $(YELLOW)setup-secrets$(RESET)   🔑 Setup credential template\n"
+	@printf "  $(YELLOW)check-creds$(RESET)     🔍 Validate all credentials\n"
+	@printf "\n"
+	@printf "$(BOLD)☸️  Deployment:$(RESET)\n"
+	@printf "  $(MAGENTA)deploy-k8s$(RESET)      🚀 Deploy to Kubernetes\n"
+	@printf "  $(MAGENTA)deploy-helm$(RESET)     ⎈  Deploy using Helm\n"
+	@printf "\n"
+	@printf "$(BOLD)🧹 Cleanup:$(RESET)\n"
+	@printf "  $(RED)cleanup-k8s$(RESET)     🗑️  Remove Kubernetes deployment\n"
+	@printf "  $(RED)cleanup-helm$(RESET)    🗑️  Remove Helm deployment\n"
+	@printf "  $(RED)clean$(RESET)           🧽 Remove cache and virtual environment\n"
+	@printf "\n"
+	@printf "$(CYAN)━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━$(RESET)\n"
 
 venv:
-	$(PYTHON) -m venv $(VENV)
+	@printf "$(GREEN)🐍 Creating virtual environment...$(RESET)\n"
+	@$(PYTHON) -m venv $(VENV)
+	@printf "$(GREEN)✅ Virtual environment created$(RESET)\n"
 
 install: venv
-	$(ACTIVATE); $(PIP) install --upgrade pip
-	$(ACTIVATE); $(PIP) install -r requirements.txt
-	$(ACTIVATE); $(PIP) install pre-commit black
+	@printf "$(BLUE)📦 Installing dependencies...$(RESET)\n"
+	@$(ACTIVATE); $(PIP) install --upgrade pip
+	@$(ACTIVATE); $(PIP) install -r requirements.txt
+	@$(ACTIVATE); $(PIP) install pre-commit black
+	@printf "$(GREEN)✅ Dependencies installed$(RESET)\n"
 
 run:
-	$(ACTIVATE); $(PYTHON) src/app.py
+	@printf "$(CYAN)🏃 Starting Yuga Planner...$(RESET)\n"
+	@$(ACTIVATE); $(PYTHON) src/app.py
 
 test:
-	$(ACTIVATE); pytest -v -s
+	@printf "$(YELLOW)🧪 Running tests...$(RESET)\n"
+	@$(ACTIVATE); pytest -v -s
 
 lint:
-	$(ACTIVATE); pre-commit run --all-files
+	@printf "$(BLUE)✨ Running code quality checks...$(RESET)\n"
+	@$(ACTIVATE); pre-commit run --all-files
 
 format:
-	$(ACTIVATE); black src tests
+	@printf "$(MAGENTA)🎨 Formatting code...$(RESET)\n"
+	@$(ACTIVATE); black src tests
+	@printf "$(GREEN)✅ Code formatted$(RESET)\n"
 
 setup-secrets:
-	cp -n tests/secrets/nebius_secrets.py.template tests/secrets/cred.py; \
-	echo "Edit tests/secrets/cred.py to add your own API credentials."
+	@printf "$(YELLOW)🔑 Setting up credential template...$(RESET)\n"
+	@cp -n tests/secrets/nebius_secrets.py.template tests/secrets/cred.py || true
+	@printf "$(GREEN)✅ Template created$(RESET)\n"
+	@printf "$(CYAN)💡 Edit tests/secrets/cred.py to add your API credentials$(RESET)\n"
 
 check-creds:
-	@echo "🔍 Checking credentials..."
+	@printf "$(CYAN)🔍 Validating credentials...$(RESET)\n"
 	@./scripts/load-credentials.sh
 
 deploy-k8s:
-	./scripts/deploy-k8s.sh
+	@./scripts/deploy-k8s.sh
 
 deploy-helm:
-	./scripts/deploy-helm.sh
+	@./scripts/deploy-helm.sh
 
 cleanup-k8s:
-	./scripts/cleanup-k8s.sh
+	@./scripts/cleanup-k8s.sh
 
 cleanup-helm:
-	./scripts/cleanup-helm.sh
+	@./scripts/cleanup-helm.sh
 
 clean:
-	rm -rf $(VENV) __pycache__ */__pycache__ .pytest_cache .mypy_cache .coverage .hypothesis
-	find . -type f -name '*.pyc' -delete
-	find . -type d -name '__pycache__' -exec rm -rf {} +
+	@printf "$(RED)🧽 Cleaning up...$(RESET)\n"
+	@rm -rf $(VENV) __pycache__ */__pycache__ .pytest_cache .mypy_cache .coverage .hypothesis
+	@find . -type f -name '*.pyc' -delete
+	@find . -type d -name '__pycache__' -exec rm -rf {} + 2>/dev/null || true
+	@printf "$(GREEN)✅ Cleanup complete$(RESET)\n"

scripts/cleanup-helm.sh

@@ -1,15 +1,24 @@
 #!/bin/bash
 set -e
 
-# Yuga Planner Helm Cleanup Script
-# This script removes the Helm release and all associated resources
+# Colors and formatting
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+MAGENTA='\033[0;35m'
+BOLD='\033[1m'
+RESET='\033[0m'
 
-echo "🧹 Cleaning up Yuga Planner Helm deployment..."
+# Yuga Planner Helm Cleanup Script
+echo -e "${BOLD}🧹 Yuga Planner - Helm Cleanup${RESET}"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
 
 # Check if helm is available
 if ! command -v helm &> /dev/null; then
-    echo "❌ Error: helm is required but not installed."
-    echo "💡 Install Helm from: https://helm.sh/docs/intro/install/"
+    echo -e "${RED}❌ Error: helm is required but not installed${RESET}"
+    echo -e "${YELLOW}💡 Install from: ${CYAN}https://helm.sh/docs/intro/install/${RESET}"
     exit 1
 fi
 
@@ -19,68 +28,73 @@ RELEASE_NAME="${HELM_RELEASE_NAME:-yuga-planner}"
 CURRENT_NAMESPACE=$(kubectl config view --minify --output 'jsonpath={..namespace}' 2>/dev/null || echo "default")
 NAMESPACE="${HELM_NAMESPACE:-$CURRENT_NAMESPACE}"
 
-echo "📦 Helm Release: $RELEASE_NAME"
-echo "🏷️  Namespace: $NAMESPACE"
+echo -e "${BOLD}📦 Configuration:${RESET}"
+echo -e "  Release:   ${MAGENTA}$RELEASE_NAME${RESET}"
+echo -e "  Namespace: ${MAGENTA}$NAMESPACE${RESET}"
 
 # Check if the release exists
+echo ""
+echo -e "${BLUE}🔍 Scanning for Helm release...${RESET}"
 if ! helm list -n "$NAMESPACE" | grep -q "^$RELEASE_NAME"; then
-    echo "ℹ️  Helm release '$RELEASE_NAME' not found in namespace '$NAMESPACE'."
-    echo "✅ Nothing to clean up."
+    echo -e "${BLUE}ℹ️  Helm release '${MAGENTA}$RELEASE_NAME${BLUE}' not found in namespace '${MAGENTA}$NAMESPACE${BLUE}'${RESET}"
+    echo -e "${GREEN}✅ Nothing to clean up${RESET}"
     exit 0
 fi
 
 # Show release information
-echo "🔍 Found Helm release:"
+echo -e "${YELLOW}📋 Found Helm release:${RESET}"
 helm list -n "$NAMESPACE" | grep "^$RELEASE_NAME" || true
 
 echo ""
-echo "📊 Release details:"
-helm status "$RELEASE_NAME" -n "$NAMESPACE" || true
+echo -e "${BLUE}📊 Release details:${RESET}"
+helm status "$RELEASE_NAME" -n "$NAMESPACE" --no-hooks || true
 
 # Confirm deletion
 echo ""
-read -p "❓ Are you sure you want to uninstall the Helm release '$RELEASE_NAME'? (y/N): " -n 1 -r
+echo -e "${BOLD}⚠️  Warning: This will permanently uninstall the Helm release${RESET}"
+read -p "$(echo -e "${YELLOW}❓ Are you sure you want to uninstall '${MAGENTA}$RELEASE_NAME${YELLOW}'? (y/N): ${RESET}")" -n 1 -r
 echo
 if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-    echo "❌ Cleanup cancelled."
+    echo -e "${BLUE}❌ Cleanup cancelled${RESET}"
     exit 0
 fi
 
-echo "🗑️  Uninstalling Helm release..."
+echo -e "${RED}🗑️  Uninstalling Helm release...${RESET}"
 helm uninstall "$RELEASE_NAME" -n "$NAMESPACE"
 
-echo "✅ Helm release uninstalled successfully!"
+echo -e "${GREEN}✅ Helm release uninstalled successfully!${RESET}"
 
 # Check if namespace should be cleaned up (optional)
 if [ "$NAMESPACE" != "default" ]; then
     echo ""
-    echo "🤔 The namespace '$NAMESPACE' still exists."
-    read -p "❓ Do you want to delete the namespace '$NAMESPACE' as well? (y/N): " -n 1 -r
+    echo -e "${YELLOW}🤔 The namespace '${MAGENTA}$NAMESPACE${YELLOW}' still exists${RESET}"
+    read -p "$(echo -e "${YELLOW}❓ Do you want to delete the namespace as well? (y/N): ${RESET}")" -n 1 -r
     echo
     if [[ $REPLY =~ ^[Yy]$ ]]; then
         # Check if namespace has other resources
         OTHER_RESOURCES=$(kubectl get all -n "$NAMESPACE" --ignore-not-found=true 2>/dev/null | grep -v "^NAME" | wc -l)
         if [ "$OTHER_RESOURCES" -gt 0 ]; then
-            echo "⚠️  Warning: Namespace '$NAMESPACE' contains other resources."
+            echo -e "${YELLOW}⚠️  Warning: Namespace '${MAGENTA}$NAMESPACE${YELLOW}' contains other resources${RESET}"
             kubectl get all -n "$NAMESPACE" 2>/dev/null || true
-            read -p "❓ Are you sure you want to delete the entire namespace? (y/N): " -n 1 -r
+            read -p "$(echo -e "${RED}❓ Are you sure you want to delete the entire namespace? (y/N): ${RESET}")" -n 1 -r
             echo
             if [[ $REPLY =~ ^[Yy]$ ]]; then
                 kubectl delete namespace "$NAMESPACE"
-                echo "✅ Namespace '$NAMESPACE' deleted."
+                echo -e "${GREEN}✅ Namespace '${MAGENTA}$NAMESPACE${GREEN}' deleted${RESET}"
             else
-                echo "ℹ️  Namespace '$NAMESPACE' preserved."
+                echo -e "${BLUE}ℹ️  Namespace '${MAGENTA}$NAMESPACE${BLUE}' preserved${RESET}"
             fi
         else
             kubectl delete namespace "$NAMESPACE"
-            echo "✅ Empty namespace '$NAMESPACE' deleted."
+            echo -e "${GREEN}✅ Empty namespace '${MAGENTA}$NAMESPACE${GREEN}' deleted${RESET}"
         fi
     else
-        echo "ℹ️  Namespace '$NAMESPACE' preserved."
+        echo -e "${BLUE}ℹ️  Namespace '${MAGENTA}$NAMESPACE${BLUE}' preserved${RESET}"
     fi
 fi
 
 echo ""
-echo "🔍 Useful commands to verify cleanup:"
-echo "  • List remaining releases: helm list -A"
-echo "  • Check for remaining resources: kubectl get all -l app.kubernetes.io/instance=$RELEASE_NAME -A"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+echo -e "${BOLD}🔍 Verification Commands:${RESET}"
+echo -e "  List releases:      ${GREEN}helm list -A${RESET}"
+echo -e "  Check resources:    ${GREEN}kubectl get all -l app.kubernetes.io/instance=$RELEASE_NAME -A${RESET}"

scripts/cleanup-k8s.sh

@@ -1,20 +1,29 @@
 #!/bin/bash
 set -e
 
-# Yuga Planner Kubernetes Cleanup Script
-# This script removes all Kubernetes resources created by the deployment
+# Colors and formatting
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+RESET='\033[0m'
 
-echo "🧹 Cleaning up Yuga Planner Kubernetes deployment..."
+# Yuga Planner Kubernetes Cleanup Script
+echo -e "${BOLD}🧹 Yuga Planner - Kubernetes Cleanup${RESET}"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
 
 # Check if kubectl is available
 if ! command -v kubectl &> /dev/null; then
-    echo "❌ Error: kubectl is required but not installed."
+    echo -e "${RED}❌ Error: kubectl is required but not installed${RESET}"
     exit 1
 fi
 
 # Check if we're in the correct directory (project root)
 if [ ! -f "deploy/kubernetes.yaml" ]; then
-    echo "❌ Error: kubernetes.yaml not found. Please run this script from the project root."
+    echo -e "${RED}❌ Error: kubernetes.yaml not found${RESET}"
+    echo -e "${YELLOW}💡 Please run this script from the project root${RESET}"
     exit 1
 fi
 
@@ -39,7 +48,7 @@ check_resources() {
     fi
 
     if [ "$resource_exists" = false ]; then
-        echo "ℹ️  No Yuga Planner resources found in the current namespace."
+        echo -e "${BLUE}ℹ️  No Yuga Planner resources found in the current namespace${RESET}"
         return 1
     fi
 
@@ -47,37 +56,43 @@ check_resources() {
 }
 
 # Check if any resources exist
+echo -e "${BLUE}🔍 Scanning for Yuga Planner resources...${RESET}"
 if ! check_resources; then
-    echo "✅ Nothing to clean up."
+    echo -e "${GREEN}✅ Nothing to clean up${RESET}"
     exit 0
 fi
 
 # Show what will be deleted
-echo "🔍 Found the following Yuga Planner resources:"
+echo -e "${YELLOW}📋 Found the following Yuga Planner resources:${RESET}"
 kubectl get deployment,service,secret,configmap -l app=yuga-planner 2>/dev/null || true
 
 # Confirm deletion
-read -p "❓ Are you sure you want to delete these resources? (y/N): " -n 1 -r
+echo ""
+echo -e "${BOLD}⚠️  Warning: This will permanently delete all Yuga Planner resources${RESET}"
+read -p "$(echo -e "${YELLOW}❓ Are you sure you want to continue? (y/N): ${RESET}")" -n 1 -r
 echo
 if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-    echo "❌ Cleanup cancelled."
+    echo -e "${BLUE}❌ Cleanup cancelled${RESET}"
     exit 0
 fi
 
-echo "🗑️  Deleting Kubernetes resources..."
+echo -e "${RED}🗑️  Deleting Kubernetes resources...${RESET}"
 
 # Delete resources by label selector (safer approach)
-echo "  • Deleting deployment..."
+echo -e "  ${CYAN}• Deleting deployment...${RESET}"
 kubectl delete deployment -l app=yuga-planner --ignore-not-found=true
 
-echo "  • Deleting service..."
+echo -e "  ${CYAN}• Deleting service...${RESET}"
 kubectl delete service -l app=yuga-planner --ignore-not-found=true
 
-echo "  • Deleting secrets..."
+echo -e "  ${CYAN}• Deleting secrets...${RESET}"
 kubectl delete secret -l app=yuga-planner --ignore-not-found=true
 
-echo "  • Deleting configmaps..."
+echo -e "  ${CYAN}• Deleting configmaps...${RESET}"
 kubectl delete configmap -l app=yuga-planner --ignore-not-found=true
 
-echo "✅ Cleanup complete!"
-echo "🔍 Verify cleanup: kubectl get all -l app=yuga-planner"
+echo ""
+echo -e "${GREEN}✅ Cleanup complete!${RESET}"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+echo -e "${BOLD}🔍 Verification:${RESET}"
+echo -e "  Check remaining: ${GREEN}kubectl get all -l app=yuga-planner${RESET}"

scripts/deploy-helm.sh

@@ -1,14 +1,24 @@
 #!/bin/bash
 set -e
 
-# Yuga Planner Helm Deployment Script
-# This script loads credentials from environment variables or creds.py and deploys using Helm
+# Colors and formatting
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+MAGENTA='\033[0;35m'
+BOLD='\033[1m'
+RESET='\033[0m'
 
-echo "🚀 Deploying Yuga Planner using Helm..."
+# Yuga Planner Helm Deployment Script
+echo -e "${BOLD}⎈ Yuga Planner - Helm Deployment${RESET}"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
 
 # Check if we're in the correct directory (project root)
 if [ ! -d "deploy/helm" ] && [ ! -f "deploy/helm/Chart.yaml" ]; then
-    echo "❌ Error: Helm chart not found. Please ensure deploy/helm/Chart.yaml exists."
+    echo -e "${RED}❌ Error: Helm chart not found${RESET}"
+    echo -e "${YELLOW}💡 Please ensure deploy/helm/Chart.yaml exists${RESET}"
     exit 1
 fi
 
@@ -16,6 +26,7 @@ fi
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # Source the credential loading script
+echo -e "${BLUE}📋 Loading credential management...${RESET}"
 source "${SCRIPT_DIR}/load-credentials.sh"
 
 # Check and load credentials
@@ -23,58 +34,73 @@ if ! check_credentials; then
     exit 1
 fi
 
-# Check if helm is available
+# Check dependencies
+echo -e "${BLUE}🔧 Checking dependencies...${RESET}"
+
 if ! command -v helm &> /dev/null; then
-    echo "❌ Error: helm is required but not installed."
-    echo "💡 Install Helm from: https://helm.sh/docs/intro/install/"
+    echo -e "${RED}❌ Error: helm is required but not installed${RESET}"
+    echo -e "${YELLOW}💡 Install from: ${CYAN}https://helm.sh/docs/intro/install/${RESET}"
+    exit 1
+fi
+
+if ! command -v kubectl &> /dev/null; then
+    echo -e "${RED}❌ Error: kubectl is required but not installed${RESET}"
+    echo -e "${YELLOW}💡 Install from: ${CYAN}https://kubernetes.io/docs/tasks/tools/${RESET}"
     exit 1
 fi
 
+echo -e "${GREEN}✅ All dependencies found${RESET}"
+
 # Configuration
 RELEASE_NAME="${HELM_RELEASE_NAME:-yuga-planner}"
-# Get current namespace, fallback to default if not set
 CURRENT_NAMESPACE=$(kubectl config view --minify --output 'jsonpath={..namespace}' 2>/dev/null || echo "default")
 NAMESPACE="${HELM_NAMESPACE:-$CURRENT_NAMESPACE}"
 CHART_PATH="${HELM_CHART_PATH:-deploy/helm}"
 
-echo "📦 Helm Release: $RELEASE_NAME"
-echo "🏷️  Namespace: $NAMESPACE"
-echo "📂 Chart Path: $CHART_PATH"
+echo ""
+echo -e "${BOLD}📦 Deployment Configuration:${RESET}"
+echo -e "  Release:   ${MAGENTA}$RELEASE_NAME${RESET}"
+echo -e "  Namespace: ${MAGENTA}$NAMESPACE${RESET}"
+echo -e "  Chart:     ${MAGENTA}$CHART_PATH${RESET}"
 
 # Create namespace if it doesn't exist
 if ! kubectl get namespace "$NAMESPACE" &> /dev/null; then
-    echo "🏗️  Creating namespace: $NAMESPACE"
+    echo -e "${CYAN}🏗️ Creating namespace: ${MAGENTA}$NAMESPACE${RESET}"
     kubectl create namespace "$NAMESPACE"
 fi
 
 # Prepare Helm values with environment variables
+echo -e "${BLUE}🔧 Preparing deployment values...${RESET}"
 HELM_VALUES=""
-HELM_VALUES="$HELM_VALUES --set env.NEBIUS_API_KEY=$NEBIUS_API_KEY"
-HELM_VALUES="$HELM_VALUES --set env.NEBIUS_MODEL=$NEBIUS_MODEL"
-HELM_VALUES="$HELM_VALUES --set env.MODAL_TOKEN_ID=$MODAL_TOKEN_ID"
-HELM_VALUES="$HELM_VALUES --set env.MODAL_TOKEN_SECRET=$MODAL_TOKEN_SECRET"
-HELM_VALUES="$HELM_VALUES --set env.HF_MODEL=$HF_MODEL"
-HELM_VALUES="$HELM_VALUES --set env.HF_TOKEN=$HF_TOKEN"
+HELM_VALUES="$HELM_VALUES --set secrets.nebiusApiKey=$NEBIUS_API_KEY"
+HELM_VALUES="$HELM_VALUES --set secrets.nebiusModel=$NEBIUS_MODEL"
+HELM_VALUES="$HELM_VALUES --set secrets.modalTokenId=$MODAL_TOKEN_ID"
+HELM_VALUES="$HELM_VALUES --set secrets.modalTokenSecret=$MODAL_TOKEN_SECRET"
+HELM_VALUES="$HELM_VALUES --set secrets.hfModel=$HF_MODEL"
+HELM_VALUES="$HELM_VALUES --set secrets.hfToken=$HF_TOKEN"
 
 # Add optional environment variables if set
 if [ ! -z "$IMAGE_TAG" ]; then
     HELM_VALUES="$HELM_VALUES --set image.tag=$IMAGE_TAG"
+    echo -e "  Using custom image tag: ${YELLOW}$IMAGE_TAG${RESET}"
 fi
 
 if [ ! -z "$REPLICAS" ]; then
-    HELM_VALUES="$HELM_VALUES --set replicaCount=$REPLICAS"
+    HELM_VALUES="$HELM_VALUES --set deployment.replicas=$REPLICAS"
+    echo -e "  Using custom replica count: ${YELLOW}$REPLICAS${RESET}"
 fi
 
-# Check if release already exists
+# Deploy with Helm
+echo ""
 if helm list -n "$NAMESPACE" | grep -q "^$RELEASE_NAME"; then
-    echo "🔄 Upgrading existing Helm release..."
+    echo -e "${CYAN}🔄 Upgrading existing Helm release...${RESET}"
     helm upgrade "$RELEASE_NAME" "$CHART_PATH" \
         --namespace "$NAMESPACE" \
         $HELM_VALUES \
         --timeout 300s \
         --wait
 else
-    echo "🆕 Installing new Helm release..."
+    echo -e "${CYAN}🆕 Installing new Helm release...${RESET}"
     helm install "$RELEASE_NAME" "$CHART_PATH" \
         --namespace "$NAMESPACE" \
         $HELM_VALUES \
@@ -82,13 +108,16 @@ else
         --wait
 fi
 
-echo "✅ Deployment complete!"
 echo ""
-echo "📊 Release Information:"
-helm status "$RELEASE_NAME" -n "$NAMESPACE"
+echo -e "${GREEN}✅ Deployment complete!${RESET}"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+
+echo -e "${BOLD}📊 Release Information:${RESET}"
+helm status "$RELEASE_NAME" -n "$NAMESPACE" --no-hooks
+
 echo ""
-echo "🔍 Useful commands:"
-echo "  • Check pods: kubectl get pods -l app.kubernetes.io/instance=$RELEASE_NAME -n $NAMESPACE"
-echo "  • View logs: kubectl logs -l app.kubernetes.io/instance=$RELEASE_NAME -n $NAMESPACE -f"
-echo "  • Port forward: kubectl port-forward svc/$RELEASE_NAME 8080:80 -n $NAMESPACE"
-echo "  • Uninstall: helm uninstall $RELEASE_NAME -n $NAMESPACE"
+echo -e "${BOLD}🔍 Useful Commands:${RESET}"
+echo -e "  Check pods:    ${GREEN}kubectl get pods -l app.kubernetes.io/instance=$RELEASE_NAME -n $NAMESPACE${RESET}"
+echo -e "  View logs:     ${GREEN}kubectl logs -l app.kubernetes.io/instance=$RELEASE_NAME -n $NAMESPACE -f${RESET}"
+echo -e "  Port forward:  ${GREEN}kubectl port-forward svc/$RELEASE_NAME 8080:80 -n $NAMESPACE${RESET}"
+echo -e "  Uninstall:     ${RED}helm uninstall $RELEASE_NAME -n $NAMESPACE${RESET}"

scripts/deploy-k8s.sh

@@ -1,14 +1,23 @@
 #!/bin/bash
 set -e
 
-# Yuga Planner Kubernetes Deployment Script
-# This script loads credentials from environment variables or creds.py and deploys to Kubernetes
+# Colors and formatting
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+RESET='\033[0m'
 
-echo "🚀 Deploying Yuga Planner to Kubernetes..."
+# Yuga Planner Kubernetes Deployment Script
+echo -e "${BOLD}🚀 Yuga Planner - Kubernetes Deployment${RESET}"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
 
 # Check if we're in the correct directory (project root)
 if [ ! -f "deploy/kubernetes.yaml" ]; then
-    echo "❌ Error: kubernetes.yaml not found. Please run this script from the project root."
+    echo -e "${RED}❌ Error: kubernetes.yaml not found${RESET}"
+    echo -e "${YELLOW}💡 Please run this script from the project root${RESET}"
     exit 1
 fi
 
@@ -16,6 +25,7 @@ fi
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # Source the credential loading script
+echo -e "${BLUE}📋 Loading credential management...${RESET}"
 source "${SCRIPT_DIR}/load-credentials.sh"
 
 # Check and load credentials
@@ -23,23 +33,35 @@ if ! check_credentials; then
     exit 1
 fi
 
-# Check if envsubst is available
+# Check dependencies
+echo -e "${BLUE}🔧 Checking dependencies...${RESET}"
+
 if ! command -v envsubst &> /dev/null; then
-    echo "❌ Error: envsubst is required but not installed. Please install gettext-base package."
+    echo -e "${RED}❌ Error: envsubst is required but not installed${RESET}"
+    echo -e "${YELLOW}💡 Install with: ${CYAN}apt-get install gettext-base${RESET}"
     exit 1
 fi
 
-# Check if kubectl is available
 if ! command -v kubectl &> /dev/null; then
-    echo "❌ Error: kubectl is required but not installed."
+    echo -e "${RED}❌ Error: kubectl is required but not installed${RESET}"
+    echo -e "${YELLOW}💡 Install from: ${CYAN}https://kubernetes.io/docs/tasks/tools/${RESET}"
     exit 1
 fi
 
-# Substitute environment variables and apply to Kubernetes
-echo "🔧 Substituting environment variables and deploying..."
+echo -e "${GREEN}✅ All dependencies found${RESET}"
+
+# Deploy to Kubernetes
+echo -e "${CYAN}🔧 Substituting environment variables and deploying...${RESET}"
 envsubst < deploy/kubernetes.yaml | kubectl apply -f -
 
-echo "✅ Deployment complete!"
-echo "🌐 Access the application at: http://<node-ip>:30860"
-echo "🔍 Check deployment status: kubectl get pods -l app=yuga-planner"
-echo "📋 View logs: kubectl logs -l app=yuga-planner -f"
+echo ""
+echo -e "${GREEN}✅ Deployment complete!${RESET}"
+echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+echo -e "${BOLD}🌐 Quick Access:${RESET}"
+echo -e "  Access URL: ${CYAN}http://<node-ip>:30860${RESET}"
+echo ""
+echo -e "${BOLD}📊 Useful Commands:${RESET}"
+echo -e "  Check status:  ${GREEN}kubectl get pods -l app=yuga-planner${RESET}"
+echo -e "  View logs:     ${GREEN}kubectl logs -l app=yuga-planner -f${RESET}"
+echo -e "  Get services:  ${GREEN}kubectl get svc -l app=yuga-planner${RESET}"
+echo -e "  Port forward:  ${GREEN}kubectl port-forward svc/yuga-planner-service 8080:80${RESET}"

scripts/load-credentials.sh

@@ -1,5 +1,14 @@
 #!/bin/bash
 
+# Colors and formatting
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+RESET='\033[0m'
+
 # Yuga Planner Credential Loading Script
 # This script loads credentials from environment variables or creds.py
 
@@ -8,7 +17,7 @@ load_credentials() {
     local creds_file="tests/secrets/creds.py"
 
     if [ -f "$creds_file" ]; then
-        echo "📋 Loading credentials from $creds_file..."
+        echo -e "${BLUE}📋 Loading credentials from $creds_file...${RESET}"
 
         # Extract credentials from creds.py if environment variables are not set
         if [ -z "$NEBIUS_API_KEY" ]; then
@@ -65,26 +74,36 @@ print(creds.HF_TOKEN)
 " 2>/dev/null || echo "")
         fi
     else
-        echo "⚠️  Warning: $creds_file not found"
+        echo -e "${YELLOW}⚠️  Warning: $creds_file not found${RESET}"
+        echo -e "${CYAN}💡 Run '${GREEN}make setup-secrets${CYAN}' to create the template${RESET}"
     fi
 }
 
 # Function to check and validate required credentials
 check_credentials() {
-    echo "🔍 Checking for credentials..."
+    echo -e "${CYAN}🔍 Validating credentials...${RESET}"
 
     local missing_vars=()
     local required_vars=("NEBIUS_API_KEY" "NEBIUS_MODEL" "MODAL_TOKEN_ID" "MODAL_TOKEN_SECRET" "HF_MODEL" "HF_TOKEN")
+    local found_vars=()
 
+    # First check what's already available
     for var in "${required_vars[@]}"; do
         if [ -z "${!var}" ]; then
             missing_vars+=("$var")
+        else
+            found_vars+=("$var")
         fi
     done
 
+    # Show what we found
+    if [ ${#found_vars[@]} -gt 0 ]; then
+        echo -e "${GREEN}✅ Found environment variables: ${found_vars[*]}${RESET}"
+    fi
+
     if [ ${#missing_vars[@]} -gt 0 ]; then
-        echo "📂 Missing environment variables: ${missing_vars[*]}"
-        echo "🔄 Attempting to load from creds.py..."
+        echo -e "${YELLOW}📂 Missing from environment: ${missing_vars[*]}${RESET}"
+        echo -e "${BLUE}🔄 Attempting to load from creds.py...${RESET}"
         load_credentials
 
         # Check again after loading from creds.py
@@ -96,18 +115,26 @@ check_credentials() {
         done
 
         if [ ${#missing_vars[@]} -gt 0 ]; then
-            echo "❌ Error: The following required environment variables are not set: ${missing_vars[*]}"
-            echo "💡 Please set them in your environment or ensure tests/secrets/creds.py exists with the required values."
+            echo ""
+            echo -e "${RED}❌ Error: Missing required credentials: ${missing_vars[*]}${RESET}"
+            echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
+            echo -e "${BOLD}💡 Setup Instructions:${RESET}"
+            echo -e "  1. Run: ${GREEN}make setup-secrets${RESET}"
+            echo -e "  2. Edit: ${CYAN}tests/secrets/creds.py${RESET}"
+            echo -e "  3. Add your API credentials"
+            echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
             return 1
         fi
     fi
 
-    echo "✅ All credentials found"
+    echo -e "${GREEN}✅ All credentials validated successfully${RESET}"
     return 0
 }
 
 # Main execution when script is run directly
 if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    echo -e "${BOLD}🔐 Yuga Planner - Credential Validator${RESET}"
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
     check_credentials
     exit $?
 fi