# image_analyzer.py
import subprocess
import json
import re

class ImageAnalyzer:
    """Analyze Docker image size distribution and layer structure"""
    
    def analyze_layers(self, image_name: str) -> dict:
        """Analyze image size per layer"""
        result = subprocess.run(
            ["docker", "history", image_name, "--format", "{{.Size}}\t{{.CreatedBy}}"],
            capture_output=True, text=True
        )
        
        layers = []
        for line in result.stdout.strip().split("\n")[1:]:  # Skip HEADER
            parts = line.split("\t", 1)
            if len(parts) == 2:
                layers.append({
                    "size": parts[0],
                    "command": parts[1]
                })
        
        return {
            "image": image_name,
            "total_size": result.stdout.split("\n")[0].split()[0] if result.stdout else "0B",
            "layers": layers
        }
    
    def analyze_dependencies(self, dockerfile_path: str) -> dict:
        """Analyze dependency declarations in Dockerfile"""
        with open(dockerfile_path) as f:
            content = f.read()
        
        # Extract all RUN instructions with install commands
        install_patterns = {
            "npm": r'RUN\s+.*npm\s+(install|ci)',
            "pip": r'RUN\s+.*pip3?\s+(install|install)',
            "apt": r'RUN\s+.*apt-get\s+install',
            "go": r'RUN\s+.*go\s+build',
        }
        
        deps = {}
        for name, pattern in install_patterns.items():
            matches = re.findall(pattern, content, re.IGNORECASE)
            if matches:
                deps[name] = matches
        
        return deps

# ai_optimizer.py
import json
import requests

class AIImageOptimizer:
    """LLM-powered Docker image optimizer"""
    
    SYSTEM_PROMPT = """You are a senior DevOps engineer and Docker image optimization expert.
Your task is to generate specific optimization plans based on the user-provided Dockerfile
and image analysis results.

Follow these principles:
1. Prioritize the smallest base images (alpine, distroless, scratch)
2. Recommend multi-stage builds to separate build dependencies from runtime dependencies
3. Optimize instruction order to maximize layer cache hit rates
4. Identify and remove unnecessary dependencies and tools
5. Provide concrete Dockerfile modification suggestions, not abstract guidance
6. Consider security — avoid storing sensitive information in images"""

    def __init__(self, ollama_url="http://localhost:11434"):
        self.url = ollama_url

    def analyze_and_optimize(self, dockerfile_content: str, 
                             image_analysis: dict = None) -> dict:
        """Analyze Dockerfile and generate optimization plan"""
        
        prompt = f"""Please analyze the following Dockerfile and provide optimization recommendations:

## Original Dockerfile
```dockerfile
{dockerfile_content}
```"""

        if image_analysis:
            prompt += f"""

## Image Analysis Results
- Total size: {image_analysis.get('total_size', 'N/A')}
- Layers: {len(image_analysis.get('layers', []))}
- Dependencies: {json.dumps(image_analysis.get('dependencies', {}), ensure_ascii=False)}"""

        prompt += """

Please provide:
1. **Base image optimization**: Recommended minimal base image and replacement plan
2. **Multi-stage build plan**: Complete optimized Dockerfile
3. **Cache optimization**: Instruction reordering suggestions
4. **Size estimation**: Before/after size comparison
5. **Security recommendations**: Security issues that need fixing"""

        response = requests.post(
            f"{self.url}/api/generate",
            json={
                "model": "qwen2.5:7b",
                "prompt": prompt,
                "stream": False,
                "options": {"temperature": 0.2, "max_tokens": 4096}
            },
            timeout=120
        )
        
        return response.json()

    def optimize_dockerfile(self, original: str) -> str:
        """Directly generate optimized Dockerfile"""
        
        prompt = f"""Please optimize the following Dockerfile to minimum size and maximum security.
Output only the optimized Dockerfile, no other explanation:

```dockerfile
{original}

#!/bin/bash
# ai_docker_optimizer.sh - AI-powered Docker image auto-optimization
# Usage: bash ai_docker_optimizer.sh <Dockerfile_path> <image_tag>

set -euo pipefail

DOCKERFILE="${1:-./Dockerfile}"
IMAGE_TAG="${2:-myapp:optimized}"
OLLAMA_URL="http://localhost:11434"
MODEL="qwen2.5:7b"

echo "=== AI Docker Image Optimization Started ==="
echo "Dockerfile: $DOCKERFILE"
echo "Target image: $IMAGE_TAG"

# Step 1: Analyze original Dockerfile
echo "[1/4] Analyzing original Dockerfile..."
ORIGINAL_SIZE=$(docker images --format '{{.Size}}' | grep -i "$(basename $(dirname $DOCKERFILE))" | head -1 || echo "N/A")
echo "Original image size: $ORIGINAL_SIZE"

# Step 2: Call AI to generate optimization plan
echo "[2/4] AI analysis in progress..."
OPTIMIZED_DOCKERFILE=$(curl -s "$OLLAMA_URL/api/generate" \
    -d "{
        \"model\": \"$MODEL\",
        \"prompt\": \"Please optimize the following Dockerfile to minimum size version. 
Use alpine base image, implement multi-stage build, remove unnecessary dependencies,
optimize layer cache order. Output only the optimized Dockerfile code, no explanation:

\`\`\`dockerfile
$(cat $DOCKERFILE)
\`\`\`\",
        \"stream\": false,
        \"options\": {\"temperature\": 0.1, \"max_tokens\": 2048}
    }" 2>/dev/null | python3 -c "
import sys, json
data = json.load(sys.stdin)
print(data.get('response', '').strip())
" 2>/dev/null || echo "AI unavailable, please check Ollama")

if [ -z "$OPTIMIZED_DOCKERFILE" ]; then
    echo "⚠️ AI optimization failed, using original Dockerfile"
    cp "$DOCKERFILE" ./Dockerfile.optimized
else
    echo "$OPTIMIZED_DOCKERFILE" > ./Dockerfile.optimized
    echo "✅ AI optimization complete, saved to Dockerfile.optimized"
fi

# Step 3: Build optimized image
echo "[3/4] Building optimized image..."
docker build -f ./Dockerfile.optimized -t "${IMAGE_TAG}" . 2>&1 | tail -20

# Step 4: Compare optimization results
echo "[4/4] Comparing optimization results..."
if docker image inspect "$IMAGE_TAG" >/dev/null 2>&1; then
    OPTIMIZED_SIZE=$(docker image inspect "$IMAGE_TAG" --format '{{.Size}}' | awk '{print $1/1024/1024 " MB"}')
    echo ""
    echo "==========================="
    echo "Optimization Results:"
    echo "  Original: $ORIGINAL_SIZE"
    echo "  Optimized: $OPTIMIZED_SIZE"
    echo "==========================="
fi

# Security scan
echo ""
echo "Running security scan..."
if command -v trivy &>/dev/null; then
    trivy image --severity HIGH,CRITICAL "$IMAGE_TAG" || echo "Scan complete"
else
    echo "⚠️ Trivy not installed, skipping security scan"
fi

echo ""
echo "=== Optimization Complete ==="
echo "Optimized Dockerfile: ./Dockerfile.optimized"

# smart_dockerignore.py
import os
import re

class SmartDockerignoreGenerator:
    """Intelligently generate .dockerignore based on project structure"""
    
    # Default exclusion rules
    DEFAULT_PATTERNS = [
        '.git',
        '.svn',
        '.DS_Store',
        '__pycache__',
        '*.pyc',
        '*.pyo',
        '.env',
        '.env.*',
        'node_modules',
        '.next',
        '.nuxt',
        '.cache',
        '.idea',
        '.vscode',
        'docker-compose*.yml',
        'Dockerfile*',
        '.dockerignore',
        'tests/',
        '.test.js',
        '.spec.js',
        '*.test.ts',
        '*.spec.ts',
    ]
    
    def generate(self, project_root: str = ".", 
                 ai_suggestions: list = None) -> str:
        """Generate .dockerignore content"""
        
        patterns = set(self.DEFAULT_PATTERNS)
        
        # Scan for large directories in the project
        for root, dirs, files in os.walk(project_root):
            # Exclude hidden directories
            dirs[:] = [d for d in dirs if not d.startswith('.')]
            
            for d in dirs:
                dir_path = os.path.join(root, d)
                try:
                    size = sum(
                        os.path.getsize(os.path.join(dp, f))
                        for dp, dn, fn in os.walk(dir_path)
                        for f in fn
                    )
                    # Directories over 100MB get added to exclusions
                    if size > 100 * 1024 * 1024:
                        patterns.add(d + '/')
                except:
                    pass
        
        # Add AI suggestions
        if ai_suggestions:
            patterns.update(ai_suggestions)
        
        return '\n'.join(sorted(patterns)) + '\n'

# Call AI to analyze project structure and generate smarter exclusion rules
def generate_with_ai(project_root: str, ollama_url: str = "http://localhost:11434") -> str:
    """Use AI to analyze project and generate intelligent .dockerignore"""
    
    # Collect project file list
    files = []
    for root, dirs, filenames in os.walk(project_root):
        dirs[:] = [d for d in dirs if not d.startswith('.')]
        for f in filenames:
            rel_path = os.path.relpath(os.path.join(root, f), project_root)
            files.append(rel_path)
    
    prompt = f"""Analyze the following project file structure and generate optimal .dockerignore rules.
Output only .dockerignore content, one rule per line:

Project files (first 50):
{chr(10).join(files[:50])}

Requirements:
1. Exclude all development tool configurations
2. Exclude test files and test data
3. Exclude log files and temporary files
4. Exclude large data files (>10MB)
5. Exclude build artifacts"""

    response = requests.post(
        f"{ollama_url}/api/generate",
        json={"model": "qwen2.5:7b", "prompt": prompt,
              "stream": False, "options": {"temperature": 0.1}}
    )
    
    return response.json().get("response", "")

# vulnerability_fixer.py
import subprocess
import json
import requests

class VulnerabilityFixer:
    """AI-assisted image security vulnerability auto-fix"""
    
    def __init__(self, ollama_url="http://localhost:11434"):
        self.url = ollama_url
    
    def scan_and_fix(self, image_tag: str) -> dict:
        """Scan for vulnerabilities and auto-generate fix plans"""
        
        # Use Trivy to scan
        result = subprocess.run(
            ["trivy", "image", "--format", "json", image_tag],
            capture_output=True, text=True
        )
        
        vulnerabilities = []
        if result.stdout:
            try:
                scan_result = json.loads(result.stdout)
                for vuln in scan_result.get("Results", []):
                    for v in vuln.get("Vulnerabilities", []):
                        if v.get("Severity") in ["HIGH", "CRITICAL"]:
                            vulnerabilities.append({
                                "id": v.get("VulnerabilityID"),
                                "package": v.get("PkgName"),
                                "severity": v.get("Severity"),
                                "installed": v.get("InstalledVersion"),
                                "fixed": v.get("FixedVersion", "unknown"),
                                "title": v.get("Title", "")
                            })
            except json.JSONDecodeError:
                pass
        
        # Call AI to generate fix plan
        if vulnerabilities:
            fix_plan = self.generate_fix_plan(vulnerabilities)
            return {"vulnerabilities": vulnerabilities, "fix_plan": fix_plan}
        
        return {"vulnerabilities": [], "fix_plan": None}
    
    def generate_fix_plan(self, vulnerabilities: list) -> str:
        """Generate vulnerability fix plan"""
        
        vuln_list = "\n".join([
            f"- [{v['severity']}] {v['package']}: {v['id']} "
            f"(current: {v['installed']}, fix: {v['fixed']})"
            for v in vulnerabilities[:10]
        ])
        
        prompt = f"""The following security vulnerabilities were found in the Docker image:

{vuln_list}

Please provide specific fix commands for each vulnerability, in the following format:
1. For apt packages: provide apt-get install command
2. For npm packages: provide npm update or version pinning command
3. For pip packages: provide pip install version pinning command
4. For base image issues: recommend which version to upgrade to

Sort by priority and provide executable Dockerfile fix snippets."""

        response = requests.post(
            f"{self.url}/api/generate",
            json={
                "model": "qwen2.5:7b",
                "prompt": prompt,
                "stream": False,
                "options": {"temperature": 0.2, "max_tokens": 2048}
            },
            timeout=60
        )
        
        return response.json().get("response", "")

FROM node:20
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
EXPOSE 3000
CMD ["node", "server.js"]

# Stage 1: Dependency installation
FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

# Stage 2: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

# Stage 3: Production runtime
FROM nginx:alpine AS production
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001
USER nodejs
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# .github/workflows/docker-optimize.yml
name: AI Docker Image Optimization

on:
  push:
    branches: [main]
  workflow_dispatch:

jobs:
  optimize:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Build original image
        run: docker build -t myapp:original .
      
      - name: AI optimization
        run: |
          # Call local or remote AI service to optimize Dockerfile
          curl -s http://ai-service:8080/optimize \
            -F "dockerfile=@./Dockerfile" \
            -o ./Dockerfile.optimized
      
      - name: Build optimized image
        run: docker build -f ./Dockerfile.optimized -t myapp:optimized .
      
      - name: Compare sizes
        run: |
          ORIG=$(docker image inspect myapp:original --format '{{.Size}}')
          OPT=$(docker image inspect myapp:optimized --format '{{.Size}}')
          echo "Original: $((ORIG / 1024 / 1024)) MB"
          echo "Optimized: $((OPT / 1024 / 1024)) MB"
      
      - name: Security scan
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: myapp:optimized
          severity: HIGH,CRITICAL
      
      - name: Push optimized image
        if: success()
        run: |
          docker tag myapp:optimized registry.myvps.com/myapp:latest
          docker push registry.myvps.com/myapp:latest