tsikol 0.1.0

data/docs/examples/devops-tools.md

@@ -0,0 +1,1382 @@
+# DevOps Tools Example
+
+A comprehensive MCP server providing DevOps automation tools including Docker management, Kubernetes operations, CI/CD pipelines, and infrastructure monitoring.
+
+## Overview
+
+This example demonstrates:
+- Docker container management
+- Kubernetes deployment operations
+- CI/CD pipeline execution
+- Infrastructure monitoring
+- Log aggregation and analysis
+- Configuration management
+- Deployment automation
+
+## Implementation
+
+### server.rb
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'tsikol'
+require 'docker-api'
+require 'kubeclient'
+require 'net/ssh'
+require 'yaml'
+
+# Docker operations tool
+class DockerTool < Tsikol::Tool
+  name "docker"
+  description "Manage Docker containers and images"
+  
+  parameter :operation do
+    type :string
+    required
+    enum ["list", "run", "stop", "remove", "logs", "inspect", "build"]
+    description "Docker operation to perform"
+  end
+  
+  parameter :options do
+    type :object
+    optional
+    default {}
+    description "Operation-specific options"
+  end
+  
+  def execute(operation:, options: {})
+    case operation
+    when "list"
+      list_containers(options)
+    when "run"
+      run_container(options)
+    when "stop"
+      stop_container(options)
+    when "remove"
+      remove_container(options)
+    when "logs"
+      get_logs(options)
+    when "inspect"
+      inspect_container(options)
+    when "build"
+      build_image(options)
+    else
+      "Unknown operation: #{operation}"
+    end
+  rescue Docker::Error::NotFoundError => e
+    "Docker error: #{e.message}"
+  rescue Excon::Error::Socket => e
+    "Cannot connect to Docker daemon. Is it running?"
+  end
+  
+  private
+  
+  def list_containers(options)
+    all = options["all"] || false
+    containers = Docker::Container.all(all: all)
+    
+    if containers.empty?
+      return "No containers found"
+    end
+    
+    lines = ["CONTAINER ID    IMAGE                 STATUS           NAMES"]
+    lines << "-" * 70
+    
+    containers.each do |container|
+      info = container.info
+      id = info["Id"][0..11]
+      image = info["Image"]
+      status = info["Status"]
+      names = info["Names"].join(", ").gsub(/^\//, "")
+      
+      lines << "%-15s %-20s %-15s %s" % [id, image[0..19], status[0..14], names]
+    end
+    
+    lines.join("\n")
+  end
+  
+  def run_container(options)
+    image = options["image"] || raise("Image name required")
+    name = options["name"]
+    ports = options["ports"] || {}
+    env = options["env"] || []
+    volumes = options["volumes"] || {}
+    command = options["command"]
+    
+    config = {
+      'Image' => image,
+      'Env' => env
+    }
+    
+    config['Cmd'] = command.split if command
+    
+    host_config = {
+      'PortBindings' => {},
+      'Binds' => []
+    }
+    
+    # Configure port mappings
+    ports.each do |container_port, host_port|
+      host_config['PortBindings']["#{container_port}/tcp"] = [
+        { 'HostPort' => host_port.to_s }
+      ]
+    end
+    
+    # Configure volume mounts
+    volumes.each do |host_path, container_path|
+      host_config['Binds'] << "#{host_path}:#{container_path}"
+    end
+    
+    config['HostConfig'] = host_config
+    config['name'] = name if name
+    
+    container = Docker::Container.create(config)
+    container.start
+    
+    "Container started: #{container.id[0..11]} (#{image})"
+  end
+  
+  def stop_container(options)
+    id = options["id"] || raise("Container ID required")
+    timeout = options["timeout"] || 10
+    
+    container = Docker::Container.get(id)
+    container.stop(t: timeout)
+    
+    "Container stopped: #{id}"
+  end
+  
+  def get_logs(options)
+    id = options["id"] || raise("Container ID required")
+    lines = options["lines"] || 100
+    follow = options["follow"] || false
+    
+    container = Docker::Container.get(id)
+    
+    logs = container.logs(
+      stdout: true,
+      stderr: true,
+      tail: lines
+    )
+    
+    logs
+  end
+end
+
+# Kubernetes operations tool
+class KubernetesTool < Tsikol::Tool
+  name "kubernetes"
+  description "Manage Kubernetes resources"
+  
+  parameter :operation do
+    type :string
+    required
+    enum ["get", "create", "apply", "delete", "scale", "rollout", "logs"]
+    description "Kubernetes operation"
+  end
+  
+  parameter :resource_type do
+    type :string
+    required
+    enum ["pod", "deployment", "service", "configmap", "secret", "ingress"]
+    description "Type of Kubernetes resource"
+  end
+  
+  parameter :options do
+    type :object
+    optional
+    default {}
+    description "Operation-specific options"
+  end
+  
+  def execute(operation:, resource_type:, options: {})
+    client = create_k8s_client(resource_type)
+    
+    case operation
+    when "get"
+      get_resources(client, resource_type, options)
+    when "create", "apply"
+      apply_resource(client, resource_type, options)
+    when "delete"
+      delete_resource(client, resource_type, options)
+    when "scale"
+      scale_resource(client, resource_type, options)
+    when "rollout"
+      manage_rollout(client, resource_type, options)
+    when "logs"
+      get_pod_logs(resource_type, options)
+    end
+  rescue Kubeclient::HttpError => e
+    "Kubernetes error: #{JSON.parse(e.response)['message']}"
+  rescue => e
+    "Error: #{e.message}"
+  end
+  
+  private
+  
+  def create_k8s_client(resource_type)
+    config = Kubeclient::Config.read(ENV['KUBECONFIG'] || "#{ENV['HOME']}/.kube/config")
+    context = config.context
+    
+    endpoint = context.api_endpoint
+    
+    case resource_type
+    when "deployment", "replicaset"
+      Kubeclient::Client.new(
+        endpoint + '/apis/apps',
+        'v1',
+        ssl_options: context.ssl_options,
+        auth_options: context.auth_options
+      )
+    else
+      Kubeclient::Client.new(
+        endpoint,
+        'v1',
+        ssl_options: context.ssl_options,
+        auth_options: context.auth_options
+      )
+    end
+  end
+  
+  def get_resources(client, resource_type, options)
+    namespace = options["namespace"] || "default"
+    name = options["name"]
+    
+    if name
+      resource = client.send("get_#{resource_type}", name, namespace)
+      format_resource(resource_type, [resource])
+    else
+      resources = client.send("get_#{resource_type}s", namespace: namespace)
+      format_resource(resource_type, resources)
+    end
+  end
+  
+  def format_resource(type, resources)
+    if resources.empty?
+      return "No #{type}s found"
+    end
+    
+    case type
+    when "pod"
+      format_pods(resources)
+    when "deployment"
+      format_deployments(resources)
+    when "service"
+      format_services(resources)
+    else
+      # Generic formatting
+      resources.map { |r| "#{r.metadata.name} (#{r.metadata.namespace})" }.join("\n")
+    end
+  end
+  
+  def format_pods(pods)
+    lines = ["NAME                          READY   STATUS    RESTARTS   AGE"]
+    lines << "-" * 70
+    
+    pods.each do |pod|
+      name = pod.metadata.name
+      ready = "#{pod.status.containerStatuses&.count { |c| c.ready }}/#{pod.spec.containers.count}"
+      status = pod.status.phase
+      restarts = pod.status.containerStatuses&.sum { |c| c.restartCount } || 0
+      age = format_age(pod.metadata.creationTimestamp)
+      
+      lines << "%-30s %-7s %-9s %-10s %s" % [name[0..29], ready, status, restarts, age]
+    end
+    
+    lines.join("\n")
+  end
+  
+  def format_age(timestamp)
+    seconds = Time.now - Time.parse(timestamp)
+    
+    if seconds < 60
+      "#{seconds.to_i}s"
+    elsif seconds < 3600
+      "#{(seconds / 60).to_i}m"
+    elsif seconds < 86400
+      "#{(seconds / 3600).to_i}h"
+    else
+      "#{(seconds / 86400).to_i}d"
+    end
+  end
+end
+
+# CI/CD Pipeline tool
+class PipelineTool < Tsikol::Tool
+  name "pipeline"
+  description "Execute CI/CD pipeline stages"
+  
+  parameter :action do
+    type :string
+    required
+    enum ["run", "status", "logs", "retry", "cancel"]
+    description "Pipeline action"
+  end
+  
+  parameter :pipeline_file do
+    type :string
+    optional
+    default ".pipeline.yml"
+    description "Path to pipeline configuration"
+    
+    complete do |partial|
+      Dir.glob("#{partial}*.yml") + Dir.glob("#{partial}*.yaml")
+    end
+  end
+  
+  parameter :stage do
+    type :string
+    optional
+    description "Specific stage to run"
+  end
+  
+  parameter :env do
+    type :object
+    optional
+    default {}
+    description "Environment variables"
+  end
+  
+  def execute(action:, pipeline_file: ".pipeline.yml", stage: nil, env: {})
+    unless File.exist?(pipeline_file)
+      return "Pipeline file not found: #{pipeline_file}"
+    end
+    
+    pipeline = YAML.load_file(pipeline_file)
+    
+    case action
+    when "run"
+      run_pipeline(pipeline, stage, env)
+    when "status"
+      pipeline_status(pipeline)
+    when "logs"
+      show_logs(pipeline, stage)
+    else
+      "Action not implemented: #{action}"
+    end
+  end
+  
+  private
+  
+  def run_pipeline(pipeline, specific_stage, env)
+    stages = specific_stage ? [pipeline["stages"].find { |s| s["name"] == specific_stage }] : pipeline["stages"]
+    
+    results = []
+    
+    stages.compact.each do |stage|
+      log :info, "Running stage", name: stage["name"]
+      
+      result = run_stage(stage, env.merge(pipeline["env"] || {}))
+      results << "#{stage['name']}: #{result[:status]}"
+      
+      if result[:status] == "failed" && !stage["allow_failure"]
+        results << "Pipeline failed at stage: #{stage['name']}"
+        break
+      end
+    end
+    
+    results.join("\n")
+  end
+  
+  def run_stage(stage, env)
+    start_time = Time.now
+    
+    # Run pre-scripts
+    if stage["before_script"]
+      run_scripts(stage["before_script"], env)
+    end
+    
+    # Run main scripts
+    success = run_scripts(stage["script"], env)
+    
+    # Run post-scripts
+    if stage["after_script"]
+      run_scripts(stage["after_script"], env)
+    end
+    
+    {
+      status: success ? "passed" : "failed",
+      duration: Time.now - start_time
+    }
+  end
+  
+  def run_scripts(scripts, env)
+    scripts = [scripts] unless scripts.is_a?(Array)
+    
+    scripts.all? do |script|
+      log :debug, "Executing", script: script
+      
+      system(env, script)
+    end
+  end
+end
+
+# Server monitoring resource
+class MonitoringResource < Tsikol::Resource
+  uri "monitoring/:target/:metric?"
+  description "System and application monitoring metrics"
+  
+  def read
+    target = params[:target]
+    metric = params[:metric]
+    
+    case target
+    when "system"
+      system_metrics(metric)
+    when "docker"
+      docker_metrics(metric)
+    when "kubernetes"
+      kubernetes_metrics(metric)
+    when "applications"
+      application_metrics(metric)
+    else
+      { error: "Unknown monitoring target: #{target}" }.to_json
+    end
+  end
+  
+  private
+  
+  def system_metrics(metric)
+    metrics = {
+      timestamp: Time.now.iso8601,
+      hostname: `hostname`.strip
+    }
+    
+    if metric.nil? || metric == "cpu"
+      metrics[:cpu] = {
+        load_average: `uptime`.match(/load average: (.+)$/)[1].split(", ").map(&:to_f),
+        usage_percent: get_cpu_usage
+      }
+    end
+    
+    if metric.nil? || metric == "memory"
+      metrics[:memory] = get_memory_info
+    end
+    
+    if metric.nil? || metric == "disk"
+      metrics[:disk] = get_disk_usage
+    end
+    
+    if metric.nil? || metric == "network"
+      metrics[:network] = get_network_stats
+    end
+    
+    metrics.to_json
+  end
+  
+  def get_cpu_usage
+    # Read from /proc/stat on Linux
+    if File.exist?("/proc/stat")
+      stat1 = File.read("/proc/stat").lines.first.split
+      sleep(0.1)
+      stat2 = File.read("/proc/stat").lines.first.split
+      
+      # Calculate CPU usage
+      prev_idle = stat1[4].to_i
+      prev_total = stat1[1..8].map(&:to_i).sum
+      
+      idle = stat2[4].to_i
+      total = stat2[1..8].map(&:to_i).sum
+      
+      diff_idle = idle - prev_idle
+      diff_total = total - prev_total
+      
+      usage = 100.0 * (1.0 - diff_idle.to_f / diff_total)
+      usage.round(2)
+    else
+      # Fallback for macOS
+      `top -l 1 | grep "CPU usage" | awk '{print $3}'`.to_f
+    end
+  end
+  
+  def get_memory_info
+    if File.exist?("/proc/meminfo")
+      # Linux
+      meminfo = File.read("/proc/meminfo")
+      total = meminfo.match(/MemTotal:\s+(\d+)/)[1].to_i
+      available = meminfo.match(/MemAvailable:\s+(\d+)/)[1].to_i
+      
+      {
+        total_mb: total / 1024,
+        available_mb: available / 1024,
+        used_mb: (total - available) / 1024,
+        usage_percent: ((total - available).to_f / total * 100).round(2)
+      }
+    else
+      # macOS fallback
+      vm_stat = `vm_stat`.lines
+      page_size = vm_stat[0].match(/page size of (\d+) bytes/)[1].to_i
+      
+      stats = {}
+      vm_stat[1..-1].each do |line|
+        if match = line.match(/(.+):\s+(\d+)/)
+          stats[match[1]] = match[2].to_i * page_size / 1024 / 1024
+        end
+      end
+      
+      total = `sysctl -n hw.memsize`.to_i / 1024 / 1024
+      used = stats["Pages active"] + stats["Pages wired down"]
+      
+      {
+        total_mb: total,
+        used_mb: used,
+        available_mb: total - used,
+        usage_percent: (used.to_f / total * 100).round(2)
+      }
+    end
+  end
+end
+
+# Deployment automation tool
+class DeploymentTool < Tsikol::Tool
+  name "deploy"
+  description "Automated deployment operations"
+  
+  parameter :environment do
+    type :string
+    required
+    enum ["development", "staging", "production"]
+    description "Target environment"
+  end
+  
+  parameter :service do
+    type :string
+    required
+    description "Service to deploy"
+  end
+  
+  parameter :version do
+    type :string
+    required
+    description "Version to deploy"
+  end
+  
+  parameter :strategy do
+    type :string
+    optional
+    default "rolling"
+    enum ["rolling", "blue-green", "canary"]
+    description "Deployment strategy"
+  end
+  
+  parameter :config do
+    type :object
+    optional
+    default {}
+    description "Deployment configuration"
+  end
+  
+  def execute(environment:, service:, version:, strategy: "rolling", config: {})
+    log :info, "Starting deployment", 
+        environment: environment,
+        service: service,
+        version: version,
+        strategy: strategy
+    
+    # Load deployment configuration
+    deploy_config = load_deploy_config(environment, service)
+    deploy_config.merge!(config)
+    
+    # Execute deployment strategy
+    case strategy
+    when "rolling"
+      rolling_deployment(deploy_config, version)
+    when "blue-green"
+      blue_green_deployment(deploy_config, version)
+    when "canary"
+      canary_deployment(deploy_config, version)
+    end
+  end
+  
+  private
+  
+  def load_deploy_config(environment, service)
+    config_file = "deploy/#{environment}/#{service}.yml"
+    
+    if File.exist?(config_file)
+      YAML.load_file(config_file)
+    else
+      # Default configuration
+      {
+        "replicas" => 3,
+        "health_check" => "/health",
+        "timeout" => 300
+      }
+    end
+  end
+  
+  def rolling_deployment(config, version)
+    steps = []
+    
+    steps << "1. Building new version: #{version}"
+    # Simulate build
+    sleep(2)
+    
+    steps << "2. Pushing to registry"
+    # Simulate push
+    sleep(1)
+    
+    steps << "3. Updating Kubernetes deployment"
+    # Would actually update k8s deployment
+    
+    steps << "4. Waiting for rollout to complete"
+    # Monitor rollout status
+    
+    steps << "5. Running health checks"
+    # Verify deployment health
+    
+    steps << "\nDeployment completed successfully!"
+    
+    steps.join("\n")
+  end
+end
+
+# Log aggregation resource
+class LogAggregatorResource < Tsikol::Resource
+  uri "logs/:source/:filter?"
+  description "Aggregate and search logs from multiple sources"
+  
+  def read
+    source = params[:source]
+    filter = params[:filter]
+    options = parse_query_params
+    
+    case source
+    when "application"
+      search_application_logs(filter, options)
+    when "system"
+      search_system_logs(filter, options)
+    when "container"
+      search_container_logs(filter, options)
+    else
+      { error: "Unknown log source: #{source}" }.to_json
+    end
+  end
+  
+  private
+  
+  def search_application_logs(filter, options)
+    # In production, this would query a log aggregation service
+    logs = []
+    
+    # Simulate log entries
+    10.times do |i|
+      logs << {
+        timestamp: (Time.now - i * 60).iso8601,
+        level: ["INFO", "WARN", "ERROR"].sample,
+        service: ["api", "web", "worker"].sample,
+        message: "Sample log message #{i}",
+        metadata: {
+          request_id: SecureRandom.uuid,
+          user_id: rand(1000)
+        }
+      }
+    end
+    
+    # Apply filter if provided
+    if filter
+      logs = logs.select { |log| log[:message].include?(filter) || log[:level] == filter.upcase }
+    end
+    
+    {
+      source: "application",
+      filter: filter,
+      count: logs.count,
+      logs: logs
+    }.to_json
+  end
+end
+
+# Configuration management tool
+class ConfigTool < Tsikol::Tool
+  name "config"
+  description "Manage application configuration"
+  
+  parameter :action do
+    type :string
+    required
+    enum ["get", "set", "list", "validate", "diff"]
+    description "Configuration action"
+  end
+  
+  parameter :app do
+    type :string
+    required
+    description "Application name"
+  end
+  
+  parameter :env do
+    type :string
+    optional
+    default "production"
+    description "Environment"
+  end
+  
+  parameter :key do
+    type :string
+    optional
+    description "Configuration key"
+  end
+  
+  parameter :value do
+    type :string
+    optional
+    description "Configuration value"
+  end
+  
+  def execute(action:, app:, env: "production", key: nil, value: nil)
+    config_store = ConfigStore.new(app, env)
+    
+    case action
+    when "get"
+      config_store.get(key)
+    when "set"
+      raise "Key and value required for set action" unless key && value
+      config_store.set(key, value)
+    when "list"
+      config_store.list
+    when "validate"
+      config_store.validate
+    when "diff"
+      config_store.diff(params[:compare_env] || "staging")
+    end
+  end
+end
+
+# Configuration store
+class ConfigStore
+  def initialize(app, env)
+    @app = app
+    @env = env
+    @config_dir = "config/apps/#{app}"
+    @config_file = "#{@config_dir}/#{env}.yml"
+  end
+  
+  def get(key)
+    config = load_config
+    
+    if key
+      value = key.split('.').reduce(config) { |hash, k| hash[k] if hash }
+      value ? "#{key}: #{value}" : "Key not found: #{key}"
+    else
+      format_config(config)
+    end
+  end
+  
+  def set(key, value)
+    config = load_config
+    
+    # Navigate to the key and set value
+    keys = key.split('.')
+    last_key = keys.pop
+    
+    hash = keys.reduce(config) { |h, k| h[k] ||= {} }
+    hash[last_key] = value
+    
+    save_config(config)
+    
+    "Configuration updated: #{key} = #{value}"
+  end
+  
+  def list
+    config = load_config
+    format_config(config)
+  end
+  
+  def validate
+    config = load_config
+    schema_file = "#{@config_dir}/schema.yml"
+    
+    if File.exist?(schema_file)
+      schema = YAML.load_file(schema_file)
+      errors = validate_against_schema(config, schema)
+      
+      if errors.empty?
+        "Configuration is valid"
+      else
+        "Validation errors:\n" + errors.join("\n")
+      end
+    else
+      "No schema found for validation"
+    end
+  end
+  
+  private
+  
+  def load_config
+    FileUtils.mkdir_p(@config_dir)
+    
+    if File.exist?(@config_file)
+      YAML.load_file(@config_file) || {}
+    else
+      {}
+    end
+  end
+  
+  def save_config(config)
+    File.write(@config_file, config.to_yaml)
+  end
+  
+  def format_config(config, prefix = "")
+    lines = []
+    
+    config.each do |key, value|
+      full_key = prefix.empty? ? key : "#{prefix}.#{key}"
+      
+      if value.is_a?(Hash)
+        lines.concat(format_config(value, full_key))
+      else
+        lines << "#{full_key}: #{value}"
+      end
+    end
+    
+    lines.join("\n")
+  end
+end
+
+# DevOps assistant prompt
+class DevOpsAssistantPrompt < Tsikol::Prompt
+  name "devops_assistant"
+  description "Expert DevOps automation assistant"
+  
+  argument :specialization do
+    type :string
+    required
+    enum ["containers", "kubernetes", "ci_cd", "monitoring", "security"]
+    description "Area of specialization"
+  end
+  
+  argument :experience_level do
+    type :string
+    optional
+    default "intermediate"
+    enum ["beginner", "intermediate", "advanced"]
+    description "User's DevOps experience level"
+  end
+  
+  def get_messages(specialization:, experience_level: "intermediate")
+    [
+      {
+        role: "system",
+        content: {
+          type: "text",
+          text: build_system_prompt(specialization, experience_level)
+        }
+      },
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: "Initialize DevOps assistant"
+        }
+      },
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text: "I'm ready to help with your #{specialization.gsub('_', '/')} needs. I can assist with automation, troubleshooting, best practices, and optimization. What DevOps challenge are you working on?"
+        }
+      }
+    ]
+  end
+  
+  private
+  
+  def build_system_prompt(specialization, level)
+    base = <<~PROMPT
+      You are an expert DevOps engineer specializing in #{specialization.gsub('_', ' ')}.
+      
+      Available tools:
+      - docker: Manage containers and images
+      - kubernetes: Deploy and manage Kubernetes resources
+      - pipeline: Execute CI/CD pipelines
+      - deploy: Automated deployment operations
+      - config: Configuration management
+      
+      User level: #{level}
+      
+      Key responsibilities:
+      1. Automate infrastructure and deployment processes
+      2. Implement best practices for reliability and security
+      3. Optimize performance and resource usage
+      4. Troubleshoot issues systematically
+      5. Guide on tool selection and architecture
+    PROMPT
+    
+    base + specialization_details(specialization)
+  end
+  
+  def specialization_details(spec)
+    case spec
+    when "containers"
+      "\n\nContainer expertise:\n- Docker best practices\n- Image optimization\n- Security scanning\n- Multi-stage builds\n- Registry management"
+    when "kubernetes"
+      "\n\nKubernetes expertise:\n- Resource management\n- Scaling strategies\n- Service mesh\n- Observability\n- Security policies"
+    when "ci_cd"
+      "\n\nCI/CD expertise:\n- Pipeline optimization\n- Testing strategies\n- Artifact management\n- Deployment automation\n- GitOps practices"
+    when "monitoring"
+      "\n\nMonitoring expertise:\n- Metrics collection\n- Log aggregation\n- Alerting strategies\n- Performance analysis\n- Incident response"
+    else
+      ""
+    end
+  end
+end
+
+# Start the server
+Tsikol.start(
+  name: "devops-tools",
+  version: "1.0.0",
+  description: "Comprehensive DevOps automation MCP server"
+) do
+  # Enable capabilities
+  logging true
+  prompts true
+  
+  # Middleware
+  use Tsikol::LoggingMiddleware, level: :info
+  use Tsikol::AuthenticationMiddleware,
+      type: :api_key,
+      validator: ->(key) { validate_api_key(key) }
+  use Tsikol::RateLimitMiddleware,
+      max_requests: 100,
+      window_seconds: 60
+  
+  # Tools
+  tool DockerTool
+  tool KubernetesTool
+  tool PipelineTool
+  tool DeploymentTool
+  tool ConfigTool
+  
+  # Resources
+  resource MonitoringResource
+  resource LogAggregatorResource
+  
+  # Prompts
+  prompt DevOpsAssistantPrompt
+  
+  # Health check endpoint
+  resource "health" do
+    description "Service health status"
+    
+    def read
+      {
+        status: "healthy",
+        timestamp: Time.now.iso8601,
+        version: "1.0.0",
+        checks: {
+          docker: docker_healthy?,
+          kubernetes: kubernetes_healthy?
+        }
+      }.to_json
+    end
+    
+    def docker_healthy?
+      Docker.version
+      true
+    rescue
+      false
+    end
+    
+    def kubernetes_healthy?
+      # Check if kubectl is available
+      system("kubectl version --client > /dev/null 2>&1")
+    end
+  end
+  
+  def validate_api_key(key)
+    # In production, validate against secure key store
+    valid_keys = {
+      "admin-key" => { role: "admin", rate_limit: 1000 },
+      "user-key" => { role: "user", rate_limit: 100 }
+    }
+    
+    valid_keys[key]
+  end
+end
+```
+
+### Pipeline Configuration Example
+
+```yaml
+# .pipeline.yml
+name: microservice-pipeline
+description: CI/CD pipeline for microservice
+
+env:
+  DOCKER_REGISTRY: registry.example.com
+  APP_NAME: my-service
+
+stages:
+  - name: test
+    script:
+      - echo "Running tests..."
+      - bundle install
+      - bundle exec rspec
+      - bundle exec rubocop
+    
+  - name: build
+    script:
+      - echo "Building Docker image..."
+      - docker build -t $DOCKER_REGISTRY/$APP_NAME:$CI_COMMIT_SHA .
+      - docker tag $DOCKER_REGISTRY/$APP_NAME:$CI_COMMIT_SHA $DOCKER_REGISTRY/$APP_NAME:latest
+    only:
+      - main
+      - develop
+    
+  - name: push
+    script:
+      - echo "Pushing to registry..."
+      - docker push $DOCKER_REGISTRY/$APP_NAME:$CI_COMMIT_SHA
+      - docker push $DOCKER_REGISTRY/$APP_NAME:latest
+    only:
+      - main
+    
+  - name: deploy-staging
+    script:
+      - echo "Deploying to staging..."
+      - kubectl set image deployment/$APP_NAME $APP_NAME=$DOCKER_REGISTRY/$APP_NAME:$CI_COMMIT_SHA -n staging
+      - kubectl rollout status deployment/$APP_NAME -n staging
+    only:
+      - develop
+    environment: staging
+    
+  - name: deploy-production
+    script:
+      - echo "Deploying to production..."
+      - kubectl set image deployment/$APP_NAME $APP_NAME=$DOCKER_REGISTRY/$APP_NAME:$CI_COMMIT_SHA -n production
+      - kubectl rollout status deployment/$APP_NAME -n production
+    only:
+      - main
+    environment: production
+    when: manual
+```
+
+### Kubernetes Deployment Example
+
+```yaml
+# deploy/production/my-service.yml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: my-service
+  namespace: production
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: my-service
+  template:
+    metadata:
+      labels:
+        app: my-service
+    spec:
+      containers:
+      - name: my-service
+        image: registry.example.com/my-service:latest
+        ports:
+        - containerPort: 3000
+        env:
+        - name: RAILS_ENV
+          value: production
+        - name: DATABASE_URL
+          valueFrom:
+            secretKeyRef:
+              name: my-service-secrets
+              key: database-url
+        resources:
+          requests:
+            memory: "256Mi"
+            cpu: "100m"
+          limits:
+            memory: "512Mi"
+            cpu: "500m"
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 30
+          periodSeconds: 10
+        readinessProbe:
+          httpGet:
+            path: /ready
+            port: 3000
+          initialDelaySeconds: 5
+          periodSeconds: 5
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: my-service
+  namespace: production
+spec:
+  selector:
+    app: my-service
+  ports:
+  - protocol: TCP
+    port: 80
+    targetPort: 3000
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: my-service
+  namespace: production
+  annotations:
+    kubernetes.io/ingress.class: nginx
+    cert-manager.io/cluster-issuer: letsencrypt-prod
+spec:
+  tls:
+  - hosts:
+    - api.example.com
+    secretName: my-service-tls
+  rules:
+  - host: api.example.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: my-service
+            port:
+              number: 80
+```
+
+### Testing
+
+```ruby
+require 'minitest/autorun'
+require 'tsikol/test_helpers'
+
+class DevOpsToolsTest < Minitest::Test
+  include Tsikol::TestHelpers
+  
+  def setup
+    @server = create_test_server
+    @client = TestClient.new(@server)
+    
+    # Mock Docker and Kubernetes
+    setup_mocks
+  end
+  
+  def test_docker_list_containers
+    response = @client.call_tool("docker", {
+      "operation" => "list",
+      "options" => { "all" => true }
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /CONTAINER ID/, result
+  end
+  
+  def test_kubernetes_get_pods
+    response = @client.call_tool("kubernetes", {
+      "operation" => "get",
+      "resource_type" => "pod",
+      "options" => { "namespace" => "default" }
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /NAME.*READY.*STATUS/, result
+  end
+  
+  def test_pipeline_execution
+    # Create test pipeline file
+    File.write("test.pipeline.yml", {
+      "name" => "test-pipeline",
+      "stages" => [
+        {
+          "name" => "test",
+          "script" => ["echo 'Running tests'", "exit 0"]
+        }
+      ]
+    }.to_yaml)
+    
+    response = @client.call_tool("pipeline", {
+      "action" => "run",
+      "pipeline_file" => "test.pipeline.yml"
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /test: passed/, result
+  ensure
+    File.delete("test.pipeline.yml") if File.exist?("test.pipeline.yml")
+  end
+  
+  def test_deployment_simulation
+    response = @client.call_tool("deploy", {
+      "environment" => "staging",
+      "service" => "test-service",
+      "version" => "v1.2.3",
+      "strategy" => "rolling"
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /Deployment completed successfully/, result
+  end
+  
+  def test_monitoring_metrics
+    response = @client.read_resource("monitoring/system/cpu")
+    
+    assert_successful_response(response)
+    metrics = JSON.parse(response.dig(:result, :contents, 0, :text))
+    
+    assert metrics["cpu"]
+    assert metrics["cpu"]["usage_percent"]
+  end
+  
+  private
+  
+  def create_test_server
+    Tsikol::Server.new(name: "test-devops") do
+      tool DockerTool
+      tool KubernetesTool
+      tool PipelineTool
+      tool DeploymentTool
+      resource MonitoringResource
+    end
+  end
+  
+  def setup_mocks
+    # Mock Docker responses
+    Docker::Container.define_singleton_method(:all) do |options|
+      [
+        MockContainer.new("abc123", "nginx:latest", "Up 2 hours", ["web"])
+      ]
+    end
+    
+    # Mock Kubernetes client
+    # Would need actual mock implementation
+  end
+end
+
+class MockContainer
+  attr_reader :info
+  
+  def initialize(id, image, status, names)
+    @info = {
+      "Id" => id,
+      "Image" => image,
+      "Status" => status,
+      "Names" => names.map { |n| "/#{n}" }
+    }
+  end
+end
+```
+
+## Best Practices Demonstrated
+
+1. **Infrastructure as Code** - Configuration-driven deployments
+2. **Container Management** - Docker best practices
+3. **Kubernetes Operations** - Production-ready deployments
+4. **CI/CD Automation** - Pipeline-driven development
+5. **Monitoring Integration** - Comprehensive metrics
+6. **Security First** - API key validation, secure deployments
+7. **Error Handling** - Graceful degradation
+8. **Logging** - Structured logging for debugging
+9. **Testing** - Automated testing of DevOps operations
+10. **Documentation** - Self-documenting configurations
+
+## Advanced Features
+
+### GitOps Integration
+
+```ruby
+class GitOpsTool < Tsikol::Tool
+  name "gitops"
+  description "GitOps workflow management"
+  
+  parameter :action do
+    type :string
+    required
+    enum ["sync", "diff", "rollback", "promote"]
+  end
+  
+  def execute(action:, **options)
+    case action
+    when "sync"
+      sync_with_git(options)
+    when "diff"
+      show_git_diff(options)
+    when "rollback"
+      rollback_deployment(options)
+    when "promote"
+      promote_environment(options)
+    end
+  end
+  
+  private
+  
+  def sync_with_git(options)
+    # Pull latest from git
+    # Apply to cluster
+    # Update status
+  end
+end
+```
+
+### Secret Management
+
+```ruby
+class SecretsTool < Tsikol::Tool
+  name "secrets"
+  description "Secure secret management"
+  
+  parameter :action do
+    type :string
+    required
+    enum ["create", "read", "update", "rotate", "list"]
+  end
+  
+  parameter :backend do
+    type :string
+    optional
+    default "vault"
+    enum ["vault", "kubernetes", "aws-secrets-manager"]
+  end
+  
+  def execute(action:, backend: "vault", **options)
+    secret_manager = create_backend(backend)
+    
+    case action
+    when "create"
+      secret_manager.create(options)
+    when "read"
+      secret_manager.read(options)
+    when "rotate"
+      secret_manager.rotate(options)
+    end
+  end
+end
+```
+
+## Security Considerations
+
+1. **RBAC** - Role-based access control for all operations
+2. **Audit Logging** - Track all DevOps operations
+3. **Secret Management** - Never expose secrets in logs
+4. **Network Policies** - Restrict cluster communications
+5. **Image Scanning** - Scan containers for vulnerabilities
+
+## Performance Optimization
+
+1. **Parallel Execution** - Run independent tasks concurrently
+2. **Caching** - Cache build artifacts and test results
+3. **Resource Limits** - Set appropriate limits for all containers
+4. **Auto-scaling** - Scale based on metrics
+5. **Optimized Images** - Multi-stage builds, minimal base images
+
+## Next Steps
+
+- Add Terraform integration for infrastructure
+- Implement chaos engineering tools
+- Add cost optimization features
+- Create compliance checking tools
+- Implement disaster recovery automation
+- Add multi-cloud support