# .gitlab-ci.yml - Base pipeline configuration
stages:
  - build
  - test
  - deploy

variables:
  DOCKER_REGISTRY: registry.example.com
  AI_CACHE_DB: /data/cache-index.db

build:app:
  stage: build
  script:
    - |
      # 1. Check AI cache index
      CACHE_RESULT=$(python3 ai_cache_checker.py \
        --project "$CI_PROJECT_PATH" \
        --commit "$CI_COMMIT_SHA" \
        --base-commit "$CI_COMMIT_BEFORE_SHA")
      
      if echo "$CACHE_RESULT" | grep -q "FULL_CACHE_HIT"; then
        echo "✅ AI cache hit, skipping build"
        cp -r /cache/build ./dist
      else
        echo "🔨 Building..."
        docker build -t $DOCKER_REGISTRY/app:$CI_COMMIT_SHA .
        python3 ai_cache_updater.py \
          --project "$CI_PROJECT_PATH" \
          --commit "$CI_COMMIT_SHA" \
          --dependencies "$(cat requirements.txt)"
      fi
  cache:
    key: "${CI_COMMIT_REF_SLUG}"
    paths:
      - .cache/
  artifacts:
    paths:
      - dist/
    expire_in: 1 week

# ai_cache_checker.py - AI Cache Checker
import json
import hashlib
import sqlite3
from datetime import datetime, timedelta

class AICacheChecker:
    def __init__(self, db_path="/data/cache-index.db"):
        self.db = sqlite3.connect(db_path)
        self._init_db()
    
    def _init_db(self):
        self.db.executescript("""
            CREATE TABLE IF NOT EXISTS build_cache (
                project TEXT,
                commit_hash TEXT,
                dependency_hash TEXT,
                build_artifacts_hash TEXT,
                cache_hit_rate REAL,
                last_build TIMESTAMP,
                PRIMARY KEY (project, dependency_hash)
            );
            CREATE INDEX IF NOT EXISTS idx_dep_hash ON build_cache(dependency_hash);
        """)
    
    def analyze_dependencies(self, current_deps: str, base_deps: str) -> dict:
        """
        Use AI to analyze the impact scope of dependency changes
        
        Traditional approach: full rebuild after any diff
        AI approach: understand dependency graph, precisely calculate affected modules
        """
        current_hash = hashlib.sha256(current_deps.encode()).hexdigest()
        base_hash = hashlib.sha256(base_deps.encode()).hexdigest()
        
        if current_hash == base_hash:
            return {"change_type": "none", "rebuild_modules": []}
        
        # Query historical cache hit rate
        cursor = self.db.execute(
            """
            SELECT cache_hit_rate, COUNT(*) as build_count
            FROM build_cache
            WHERE dependency_hash = ?
            GROUP BY dependency_hash
            ORDER BY last_build DESC
            LIMIT 10
            """,
            (current_hash,)
        )
        
        results = cursor.fetchall()
        avg_hit_rate = sum(r[0] for r in results) / len(results) if results else 0.5
        
        if avg_hit_rate > 0.8:
            return {"change_type": "cached", "confidence": avg_hit_rate}
        elif avg_hit_rate < 0.3:
            return {"change_type": "full_rebuild", "confidence": 1 - avg_hit_rate}
        else:
            return {
                "change_type": "partial_rebuild",
                "confidence": avg_hit_rate,
                "strategy": "incremental"
            }
    
    def check(self, project: str, commit: str, base_commit: str, deps: str) -> str:
        analysis = self.analyze_dependencies(deps, "")
        
        if analysis["change_type"] == "cached" and analysis["confidence"] > 0.8:
            return "FULL_CACHE_HIT"
        elif analysis["change_type"] == "full_rebuild":
            return "NO_CACHE"
        else:
            return "PARTIAL_CACHE"

# build_parallelizer.py - AI Build Parallelization Strategy Generator
import networkx as nx

def generate_build_graph(requirements: list, package_info: dict) -> nx.DiGraph:
    """
    Build module dependency graph
    
    Example project structure:
      - frontend (depends on: shared-utils, api-client)
      - backend (depends on: shared-utils, db-driver)
      - shared-utils (no dependencies)
      - api-client (depends on: shared-utils)
      - db-driver (depends on: shared-utils)
    """
    graph = nx.DiGraph()
    
    for pkg in requirements:
        deps = package_info.get(pkg, {}).get("depends", [])
        graph.add_node(pkg)
        for dep in deps:
            graph.add_edge(dep, pkg)
    
    return graph

def optimal_parallel_strategy(graph: nx.DiGraph) -> list:
    """
    Generate optimal parallel build batches using topological sort
    Returns: [[independent modules], [batch 2], ...]
    """
    levels = []
    remaining = set(graph.nodes())
    
    while remaining:
        ready = []
        for node in remaining:
            dependents_in_remaining = [
                m for m in remaining 
                if node in graph.predecessors(m)
            ]
            if not dependents_in_remaining:
                ready.append(node)
        
        if not ready:
            break
        
        levels.append(sorted(ready))
        remaining -= set(ready)
    
    return levels

# Usage example
if __name__ == "__main__":
    requirements = [
        "frontend", "backend", "shared-utils", 
        "api-client", "db-driver"
    ]
    package_info = {
        "frontend": {"depends": ["shared-utils", "api-client"]},
        "backend": {"depends": ["shared-utils", "db-driver"]},
        "shared-utils": {"depends": []},
        "api-client": {"depends": ["shared-utils"]},
        "db-driver": {"depends": ["shared-utils"]},
    }
    
    graph = generate_build_graph(requirements, package_info)
    batches = optimal_parallel_strategy(graph)
    
    print("📊 Recommended Build Batches:")
    for i, batch in enumerate(batches, 1):
        print(f"   Batch {i} (parallelizable): {', '.join(batch)}")

# test_selector.py - AI Test Selector
import difflib
import re
from collections import defaultdict

class TestImpactAnalyzer:
    def __init__(self):
        # Map file paths to test files
        self.file_to_tests = {
            "src/models/user.py": ["tests/test_user_model.py"],
            "src/api/auth.py": ["tests/test_auth.py", "tests/test_api.py"],
            "src/utils/cache.py": ["tests/test_cache.py"],
            "src/services/payment.py": ["tests/test_payment.py"],
            "docker-compose.yml": ["tests/test_deploy.py"],
        }
    
    def analyze_changes(self, old_content: str, new_content: str, 
                        changed_files: list) -> dict:
        """
        Analyze code changes to determine which tests to run
        
        Uses semantic analysis + rule matching, more precise than glob patterns
        """
        affected_tests = set()
        
        for file_path in changed_files:
            if file_path in self.file_to_tests:
                affected_tests.update(self.file_to_tests[file_path])
            
            if file_path.endswith(".py"):
                changes = self._analyze_python_changes(old_content, new_content)
                if changes["type"] == "api_change":
                    affected_tests.update(["tests/test_api.py"])
                elif changes["type"] == "model_change":
                    affected_tests.update(["tests/test_user_model.py"])
        
        return {
            "affected_tests": list(affected_tests),
            "test_count": len(affected_tests),
            "original_total": 150,
            "reduction_ratio": round(1 - len(affected_tests)/150, 2)
        }
    
    def _analyze_python_changes(self, old: str, new: str) -> dict:
        """Analyze Python code change type"""
        diff = difflib.unified_diff(old.splitlines(), new.splitlines())
        added_lines = []
        
        for line in diff:
            if line.startswith("+") and not line.startswith("+++"):
                added_lines.append(line[1:])
        
        api_patterns = [r"def\s+\w+\(", r"@router\.", r"@app\."]
        model_patterns = [r"class\s+\w+\(BaseModel\)", r"class\s+\w+\(SQLModel\)"]
        
        has_api_change = any(
            re.search(p, "\n".join(added_lines)) 
            for p in api_patterns
        )
        has_model_change = any(
            re.search(p, "\n".join(added_lines))
            for p in model_patterns
        )
        
        if has_api_change:
            return {"type": "api_change"}
        elif has_model_change:
            return {"type": "model_change"}
        return {"type": "minor"}

# test_diagnoser.py - AI Test Failure Diagnoser
import subprocess
import json

class TestDiagnoser:
    def __init__(self, llm_endpoint="http://localhost:11434"):
        self.llm_url = llm_endpoint
    
    def diagnose_failure(self, test_name: str, error_output: str, 
                         test_code: str, recent_commits: list) -> dict:
        """
        Diagnose the root cause of test failures
        
        Traditional: return raw stack trace
        AI: analyze error context and provide actionable fix suggestions
        """
        prompt = f"""You are a senior QA engineer. The following test failed. Analyze the cause and suggest fixes.

## Test Name
{test_name}

## Error Output

# auto_rollback.py - Smart Rollback Decision Engine
import time

class AutoRollbackEngine:
    def __init__(self):
        self.metrics_history = []
        self.alert_thresholds = {
            "error_rate": 0.05,
            "latency_p99": 2000,
            "cpu_usage": 90,
            "memory_usage": 85,
        }
    
    def monitor_and_decide(self, deployment_id: str, 
                           current_metrics: dict) -> dict:
        """
        Monitor metrics post-deployment and decide on rollback
        
        Not just single-metric checks — multi-dimensional trend analysis
        """
        self.metrics_history.append({
            "timestamp": time.time(),
            "metrics": current_metrics,
            "deployment": deployment_id
        })
        
        anomalies = {}
        for metric, threshold in self.alert_thresholds.items():
            if metric in current_metrics:
                value = current_metrics[metric]
                deviation = abs(value - threshold) / threshold * 100
                
                anomalies[metric] = {
                    "value": value,
                    "threshold": threshold,
                    "deviation_pct": round(deviation, 1)
                }
        
        critical_count = sum(
            1 for a in anomalies.values() 
            if a["deviation_pct"] > 50
        )
        
        if critical_count >= 2:
            return {
                "action": "immediate_rollback",
                "reason": f"{critical_count} critical metrics exceeded thresholds",
                "anomalies": anomalies,
                "confidence": 0.95
            }
        elif critical_count == 1:
            return {
                "action": "monitor_closely",
                "reason": "Single critical metric anomaly, continue monitoring",
                "anomalies": anomalies,
                "check_interval_seconds": 30
            }
        elif len(anomalies) > 0:
            return {
                "action": "proceed",
                "reason": "Minor metric fluctuation within normal range",
                "anomalies": anomalies
            }
        else:
            return {
                "action": "proceed",
                "reason": "All metrics normal"
            }

# Integration into GitLab CI
stages:
  - build
  - test
  - notify

notify:smart:
  stage: test
  script:
    - |
      if [ "$PIPELINE_STATUS" = "failed" ]; then
        FAILED_JOBS=$(gitlab-ci-jobs list --failed --json)
        AGGREGATED=$(python3 ai_alert_aggregator.py \
          --jobs "$FAILED_JOBS" \
          --pipeline-id "$CI_PIPELINE_ID")
        curl -X POST "$SLACK_WEBHOOK" \
          -H "Content-Type: application/json" \
          -d "{\"text\": \"$AGGREGATED\"}"
      fi

# ai_alert_aggregator.py - AI Alert Aggregator
class AlertAggregator:
    def __init__(self):
        self.failure_patterns = {
            "build_failure": {
                "keywords": ["compile error", "syntax error", "missing dependency"],
                "severity": "high"
            },
            "test_failure": {
                "keywords": ["assertion failed", "timeout", "connection refused"],
                "severity": "medium"
            },
            "deploy_failure": {
                "keywords": ["port already in use", "image pull failed", "permission denied"],
                "severity": "critical"
            }
        }
    
    def aggregate(self, failed_jobs: list) -> str:
        categories = defaultdict(list)
        
        for job in failed_jobs:
            category = self._categorize(job)
            categories[category].append(job)
        
        report_parts = ["🚨 CI/CD Pipeline Failure Report\n"]
        
        for category, jobs in categories.items():
            if len(jobs) == 1:
                report_parts.append(f"• {category}: {jobs[0]['name']}")
            else:
                report_parts.append(
                    f"• {category} ({len(jobs)} jobs failed): "
                    f"{', '.join(j['name'] for j in jobs)}"
                )
        
        summary_prompt = (
            f"CI/CD pipeline failed with the above issues. "
            f"Provide a brief summary and recommendation:\n"
            + "\n".join(report_parts)
        )
        
        return self._get_ai_summary(summary_prompt)
    
    def _categorize(self, job: dict) -> str:
        name = job.get("name", "").lower()
        output = job.get("output", "").lower()
        
        for pattern, config in self.failure_patterns.items():
            for keyword in config["keywords"]:
                if keyword in output or keyword in name:
                    return pattern
        
        return "unknown_failure"
    
    def _get_ai_summary(self, prompt: str) -> str:
        """Call local LLM for summary"""
        return "Priority: check compilation errors in the build stage first, as these typically cascade to all subsequent test and deployment failures."

# .gitlab-ci.yml
stages:
  - validate
  - build
  - test
  - security
  - deploy

variables:
  AI_MODEL: qwen2.5:7b-instruct
  AI_ENDPOINT: http://localhost:11434
  CACHE_DIR: .cache/build

validate:code:
  stage: validate
  script:
    - python3 ai_code_validator.py --diff HEAD~1 HEAD
  only:
    - merge_requests

build:app:
  stage: build
  script:
    - |
      CACHE_STATUS=$(python3 ai_cache_checker.py \
        --deps "$(cat requirements.txt)")
      
      if [ "$CACHE_STATUS" = "FULL_CACHE_HIT" ]; then
        echo "Using AI cache, skipping build"
        cp -r $CACHE_DIR/dist ./dist
      else
        echo "Building..."
        docker build -t app:$CI_COMMIT_SHA .
        mkdir -p $CACHE_DIR/dist
        cp -r dist/* $CACHE_DIR/dist/
      fi
  cache:
    key: ${CI_COMMIT_REF_SLUG}
    paths:
      - .cache/
  artifacts:
    paths:
      - dist/

test:unit:
  stage: test
  script:
    - |
      AFFECTED_TESTS=$(python3 test_selector.py \
        --changed-files $(git diff --name-only HEAD~1 HEAD))
      pytest $AFFECTED_TESTS -v
      
      if [ $? -eq 0 ]; then
        python3 test_success_logger.py \
          --pipeline $CI_PIPELINE_ID
      fi

security:scan:
  stage: security
  script:
    - trivy image --severity HIGH,CRITICAL app:$CI_COMMIT_SHA
    - python3 ai_security_reviewer.py --scan-results ./trivy-report.json

deploy:staging:
  stage: deploy
  script:
    - |
      RISK=$(python3 deploy_risk_assessor.py \
        --change-log "$CHANGELOG" \
        --diff-summary "$(git diff --stat HEAD~1)")
      
      echo "📊 Deployment Risk: $RISK"
      
      STRATEGY=$(echo "$RISK" | jq -r '.recommended_strategy')
      
      case "$STRATEGY" in
        direct)
          kubectl rollout restart deployment/app
          ;;
        canary)
          kubectl set image deployment/app-canary \
            app=app:$CI_COMMIT_SHA
          sleep 60
          python3 canary_monitor.py --deployment app-canary
          ;;
        blue_green)
          kubectl apply -f deploy/blue-green.yaml
          kubectl patch service/app \
            -p '{"spec":{"selector":{"version":"green"}}}'
          ;;
      esac
      
      python3 auto_rollback.py \
        --deployment-id $CI_PIPELINE_ID \
        --metrics-endpoint http://prometheus:9090
  environment:
    name: staging
  when: manual

deploy:production:
  stage: deploy
  script:
    - |
      RISK=$(python3 deploy_risk_assessor.py \
        --change-log "$CHANGELOG" \
        --diff-summary "$(git diff --stat HEAD~1)" \
        --previous-success-rate 0.95)
      
      echo "📊 Production Deployment Risk: $RISK"
      
      if [ "$(echo "$RISK" | jq -r '.risk_level')" = "high" ]; then
        echo "⚠️ High-risk deployment, requires extra confirmation"
      fi
      
      kubectl apply -f deploy/blue-green-prod.yaml
      kubectl rollout status deployment/app-green
      
      timeout 1800 python3 deploy_health_monitor.py \
        --deployment app-green
  environment:
    name: production
  when: manual
  rules:
    - if: $CI_COMMIT_BRANCH == "main"

#!/bin/bash
# setup_ai_engine.sh - Set up local AI inference engine

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull the inference model
ollama pull qwen2.5:7b-instruct

# Create AI working directory
mkdir -p ~/ai-cicd/{cache,models,policies}

# Initialize cache database
python3 -c "
import sqlite3
conn = sqlite3.connect('~/ai-cicd/cache/build-index.db')
conn.executescript('''
    CREATE TABLE build_cache (
        project TEXT, commit_hash TEXT,
        dependency_hash TEXT, build_time REAL,
        cache_hit BOOLEAN, timestamp TIMESTAMP
    );
    CREATE INDEX idx_project ON build_cache(project);
''')
print('✅ AI engine initialized')
"

echo "🎉 AI-CI/CD Engine Ready!"
echo "   Model: qwen2.5:7b-instruct"
echo "   Cache: ~/ai-cicd/cache/"
echo "   Port: 11434"