cokit-cli 1.0.8 → 1.0.9

package/templates/repo/.github/skills/ck-devops/scripts/docker_optimize.py

@@ -1,331 +0,0 @@
-#!/usr/bin/env python3
-"""
-Dockerfile Optimization Analyzer
-
-Analyzes Dockerfiles for optimization opportunities including multi-stage builds,
-security issues, size reduction, and best practices.
-
-Usage:
-    python docker-optimize.py Dockerfile
-    python docker-optimize.py --json Dockerfile
-    python docker-optimize.py --verbose Dockerfile
-"""
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-
-# Windows UTF-8 compatibility
-sys.path.insert(0, str(Path.home() / '.claude' / 'scripts'))
-try:
-    from win_compat import ensure_utf8_stdout
-    ensure_utf8_stdout()
-except ImportError:
-    if sys.platform == 'win32':
-        import io
-        if hasattr(sys.stdout, 'buffer'):
-            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
-
-
-class DockerfileAnalyzer:
-    """Analyze Dockerfile for optimization opportunities."""
-
-    def __init__(self, dockerfile_path: Path, verbose: bool = False):
-        """
-        Initialize analyzer.
-
-        Args:
-            dockerfile_path: Path to Dockerfile
-            verbose: Enable verbose output
-        """
-        self.dockerfile_path = Path(dockerfile_path)
-        self.verbose = verbose
-        self.lines = []
-        self.issues = []
-        self.suggestions = []
-
-    def load_dockerfile(self) -> bool:
-        """
-        Load and parse Dockerfile.
-
-        Returns:
-            True if loaded successfully
-
-        Raises:
-            FileNotFoundError: If Dockerfile doesn't exist
-        """
-        if not self.dockerfile_path.exists():
-            raise FileNotFoundError(f"Dockerfile not found: {self.dockerfile_path}")
-
-        with open(self.dockerfile_path, 'r') as f:
-            self.lines = f.readlines()
-
-        return True
-
-    def analyze_base_image(self) -> None:
-        """Check base image for optimization opportunities."""
-        for i, line in enumerate(self.lines, 1):
-            line = line.strip()
-            if line.startswith('FROM'):
-                # Check for 'latest' tag
-                if ':latest' in line or (': ' not in line and 'AS' not in line and '@' not in line):
-                    self.issues.append({
-                        'line': i,
-                        'severity': 'warning',
-                        'category': 'base_image',
-                        'message': 'Base image uses :latest or no tag',
-                        'suggestion': 'Use specific version tags for reproducibility'
-                    })
-
-                # Check for non-alpine/slim variants
-                if 'node' in line.lower() and 'alpine' not in line.lower():
-                    self.suggestions.append({
-                        'line': i,
-                        'category': 'size',
-                        'message': 'Consider using Alpine variant',
-                        'suggestion': 'node:20-alpine is ~10x smaller than node:20'
-                    })
-
-    def analyze_multi_stage(self) -> None:
-        """Check if multi-stage build is used."""
-        from_count = sum(1 for line in self.lines if line.strip().startswith('FROM'))
-
-        if from_count == 1:
-            # Check if build tools are installed
-            has_build_tools = any(
-                any(tool in line.lower() for tool in ['gcc', 'make', 'build-essential', 'npm install', 'pip install'])
-                for line in self.lines
-            )
-
-            if has_build_tools:
-                self.issues.append({
-                    'line': 0,
-                    'severity': 'warning',
-                    'category': 'optimization',
-                    'message': 'Single-stage build with build tools',
-                    'suggestion': 'Use multi-stage build to exclude build dependencies from final image'
-                })
-
-    def analyze_layer_caching(self) -> None:
-        """Check for optimal layer caching order."""
-        copy_lines = []
-        run_lines = []
-
-        for i, line in enumerate(self.lines, 1):
-            stripped = line.strip()
-            if stripped.startswith('COPY'):
-                copy_lines.append((i, stripped))
-            elif stripped.startswith('RUN'):
-                run_lines.append((i, stripped))
-
-        # Check if dependency files copied before source
-        has_package_copy = any('package.json' in line or 'requirements.txt' in line or 'go.mod' in line
-                               for _, line in copy_lines)
-        has_source_copy = any('COPY . .' in line or 'COPY ./' in line
-                              for _, line in copy_lines)
-
-        if has_source_copy and not has_package_copy:
-            self.issues.append({
-                'line': 0,
-                'severity': 'warning',
-                'category': 'caching',
-                'message': 'Source copied before dependencies',
-                'suggestion': 'Copy dependency files first (package.json, requirements.txt) then run install, then copy source'
-            })
-
-    def analyze_security(self) -> None:
-        """Check for security issues."""
-        has_user = any(line.strip().startswith('USER') and 'root' not in line.lower()
-                      for line in self.lines)
-
-        if not has_user:
-            self.issues.append({
-                'line': 0,
-                'severity': 'error',
-                'category': 'security',
-                'message': 'Container runs as root',
-                'suggestion': 'Create and use non-root user with USER instruction'
-            })
-
-        # Check for secrets in build
-        for i, line in enumerate(self.lines, 1):
-            if any(secret in line.upper() for secret in ['PASSWORD', 'SECRET', 'TOKEN', 'API_KEY']):
-                if 'ENV' in line or 'ARG' in line:
-                    self.issues.append({
-                        'line': i,
-                        'severity': 'error',
-                        'category': 'security',
-                        'message': 'Potential secret in Dockerfile',
-                        'suggestion': 'Use build-time arguments or runtime environment variables'
-                    })
-
-    def analyze_apt_cache(self) -> None:
-        """Check for apt cache cleanup."""
-        for i, line in enumerate(self.lines, 1):
-            if 'apt-get install' in line.lower() or 'apt install' in line.lower():
-                # Check if same RUN command cleans cache
-                if 'rm -rf /var/lib/apt/lists/*' not in line:
-                    self.suggestions.append({
-                        'line': i,
-                        'category': 'size',
-                        'message': 'apt cache not cleaned in same layer',
-                        'suggestion': 'Add && rm -rf /var/lib/apt/lists/* to reduce image size'
-                    })
-
-    def analyze_combine_run(self) -> None:
-        """Check for multiple consecutive RUN commands."""
-        consecutive_runs = 0
-        first_run_line = 0
-
-        for i, line in enumerate(self.lines, 1):
-            if line.strip().startswith('RUN'):
-                if consecutive_runs == 0:
-                    first_run_line = i
-                consecutive_runs += 1
-            else:
-                if consecutive_runs > 1:
-                    self.suggestions.append({
-                        'line': first_run_line,
-                        'category': 'layers',
-                        'message': f'{consecutive_runs} consecutive RUN commands',
-                        'suggestion': 'Combine related RUN commands with && to reduce layers'
-                    })
-                consecutive_runs = 0
-
-    def analyze_workdir(self) -> None:
-        """Check for WORKDIR usage."""
-        has_workdir = any(line.strip().startswith('WORKDIR') for line in self.lines)
-
-        if not has_workdir:
-            self.suggestions.append({
-                'line': 0,
-                'category': 'best_practice',
-                'message': 'No WORKDIR specified',
-                'suggestion': 'Use WORKDIR to set working directory instead of cd commands'
-            })
-
-    def analyze(self) -> Dict:
-        """
-        Run all analyses.
-
-        Returns:
-            Analysis results dictionary
-        """
-        self.load_dockerfile()
-
-        self.analyze_base_image()
-        self.analyze_multi_stage()
-        self.analyze_layer_caching()
-        self.analyze_security()
-        self.analyze_apt_cache()
-        self.analyze_combine_run()
-        self.analyze_workdir()
-
-        return {
-            'dockerfile': str(self.dockerfile_path),
-            'total_lines': len(self.lines),
-            'issues': self.issues,
-            'suggestions': self.suggestions,
-            'summary': {
-                'errors': len([i for i in self.issues if i.get('severity') == 'error']),
-                'warnings': len([i for i in self.issues if i.get('severity') == 'warning']),
-                'suggestions': len(self.suggestions)
-            }
-        }
-
-    def print_results(self, results: Dict) -> None:
-        """
-        Print analysis results in human-readable format.
-
-        Args:
-            results: Analysis results from analyze()
-        """
-        print(f"\nDockerfile Analysis: {results['dockerfile']}")
-        print(f"Total lines: {results['total_lines']}")
-        print(f"\nSummary:")
-        print(f"  Errors: {results['summary']['errors']}")
-        print(f"  Warnings: {results['summary']['warnings']}")
-        print(f"  Suggestions: {results['summary']['suggestions']}")
-
-        if results['issues']:
-            print(f"\n{'='*60}")
-            print("ISSUES:")
-            print('='*60)
-            for issue in results['issues']:
-                severity = issue.get('severity', 'info').upper()
-                line_info = f"Line {issue['line']}" if issue['line'] > 0 else "General"
-                print(f"\n[{severity}] {line_info} - {issue['category']}")
-                print(f"  {issue['message']}")
-                print(f"  → {issue['suggestion']}")
-
-        if results['suggestions']:
-            print(f"\n{'='*60}")
-            print("SUGGESTIONS:")
-            print('='*60)
-            for sugg in results['suggestions']:
-                line_info = f"Line {sugg['line']}" if sugg['line'] > 0 else "General"
-                print(f"\n{line_info} - {sugg['category']}")
-                print(f"  {sugg['message']}")
-                print(f"  → {sugg['suggestion']}")
-
-        print()
-
-
-def main():
-    """CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="Analyze Dockerfile for optimization opportunities",
-        formatter_class=argparse.RawDescriptionHelpFormatter
-    )
-
-    parser.add_argument(
-        "dockerfile",
-        type=str,
-        help="Path to Dockerfile"
-    )
-
-    parser.add_argument(
-        "--json",
-        action="store_true",
-        help="Output results as JSON"
-    )
-
-    parser.add_argument(
-        "--verbose",
-        "-v",
-        action="store_true",
-        help="Enable verbose output"
-    )
-
-    args = parser.parse_args()
-
-    try:
-        analyzer = DockerfileAnalyzer(
-            dockerfile_path=args.dockerfile,
-            verbose=args.verbose
-        )
-
-        results = analyzer.analyze()
-
-        if args.json:
-            print(json.dumps(results, indent=2))
-        else:
-            analyzer.print_results(results)
-
-        # Exit with error code if issues found
-        if results['summary']['errors'] > 0:
-            sys.exit(1)
-
-    except FileNotFoundError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

package/templates/repo/.github/skills/ck-devops/scripts/requirements.txt

@@ -1,20 +0,0 @@
-# DevOps Skill Dependencies
-# Python 3.10+ required
-
-# No Python package dependencies - uses only standard library
-
-# Testing dependencies (dev)
-pytest>=8.0.0
-pytest-cov>=4.1.0
-pytest-mock>=3.12.0
-
-# Note: This skill requires various CLI tools depending on platform:
-#
-# Cloudflare:
-#   - wrangler CLI: npm install -g wrangler
-#
-# Docker:
-#   - docker CLI: https://docs.docker.com/get-docker/
-#
-# Google Cloud:
-#   - gcloud CLI: https://cloud.google.com/sdk/docs/install

package/templates/repo/.github/skills/ck-devops/scripts/tests/requirements.txt

@@ -1,3 +0,0 @@
-pytest>=7.0.0
-pytest-cov>=4.0.0
-pytest-mock>=3.10.0

package/templates/repo/.github/skills/ck-devops/scripts/tests/test_cloudflare_deploy.py

@@ -1,285 +0,0 @@
-"""
-Tests for cloudflare-deploy.py
-
-Run with: pytest test_cloudflare_deploy.py -v
-"""
-
-import pytest
-import subprocess
-from pathlib import Path
-from unittest.mock import Mock, patch, mock_open
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from cloudflare_deploy import CloudflareDeploy, CloudflareDeployError
-
-
-@pytest.fixture
-def temp_project(tmp_path):
-    """Create temporary project directory with wrangler.toml"""
-    project_dir = tmp_path / "test-worker"
-    project_dir.mkdir()
-
-    wrangler_toml = project_dir / "wrangler.toml"
-    wrangler_toml.write_text('''
-name = "test-worker"
-main = "src/index.ts"
-compatibility_date = "2024-01-01"
-''')
-
-    return project_dir
-
-
-@pytest.fixture
-def deployer(temp_project):
-    """Create CloudflareDeploy instance with temp project"""
-    return CloudflareDeploy(
-        project_dir=temp_project,
-        env="staging",
-        dry_run=False,
-        verbose=False
-    )
-
-
-class TestCloudflareDeployInit:
-    """Test CloudflareDeploy initialization"""
-
-    def test_init_with_defaults(self, temp_project):
-        deployer = CloudflareDeploy(project_dir=temp_project)
-        assert deployer.project_dir == temp_project.resolve()
-        assert deployer.env is None
-        assert deployer.dry_run is False
-        assert deployer.verbose is False
-
-    def test_init_with_custom_params(self, temp_project):
-        deployer = CloudflareDeploy(
-            project_dir=temp_project,
-            env="production",
-            dry_run=True,
-            verbose=True
-        )
-        assert deployer.env == "production"
-        assert deployer.dry_run is True
-        assert deployer.verbose is True
-
-
-class TestValidateProject:
-    """Test project validation"""
-
-    def test_validate_existing_project(self, deployer):
-        assert deployer.validate_project() is True
-
-    def test_validate_nonexistent_project(self, tmp_path):
-        deployer = CloudflareDeploy(project_dir=tmp_path / "nonexistent")
-        with pytest.raises(CloudflareDeployError, match="does not exist"):
-            deployer.validate_project()
-
-    def test_validate_missing_wrangler_toml(self, tmp_path):
-        project_dir = tmp_path / "no-toml"
-        project_dir.mkdir()
-        deployer = CloudflareDeploy(project_dir=project_dir)
-
-        with pytest.raises(CloudflareDeployError, match="wrangler.toml not found"):
-            deployer.validate_project()
-
-
-class TestCheckWranglerInstalled:
-    """Test wrangler CLI detection"""
-
-    @patch('subprocess.run')
-    def test_wrangler_installed(self, mock_run, deployer):
-        mock_run.return_value = Mock(
-            returncode=0,
-            stdout="wrangler 3.0.0",
-            stderr=""
-        )
-        assert deployer.check_wrangler_installed() is True
-
-    @patch('subprocess.run')
-    def test_wrangler_not_installed(self, mock_run, deployer):
-        mock_run.side_effect = FileNotFoundError()
-        assert deployer.check_wrangler_installed() is False
-
-    @patch('subprocess.run')
-    def test_wrangler_command_fails(self, mock_run, deployer):
-        mock_run.side_effect = subprocess.CalledProcessError(1, "wrangler")
-        assert deployer.check_wrangler_installed() is False
-
-
-class TestGetWorkerName:
-    """Test worker name extraction"""
-
-    def test_get_worker_name_success(self, deployer):
-        name = deployer.get_worker_name()
-        assert name == "test-worker"
-
-    def test_get_worker_name_no_name(self, tmp_path):
-        project_dir = tmp_path / "no-name"
-        project_dir.mkdir()
-
-        wrangler_toml = project_dir / "wrangler.toml"
-        wrangler_toml.write_text("main = 'index.ts'")
-
-        deployer = CloudflareDeploy(project_dir=project_dir)
-        with pytest.raises(CloudflareDeployError, match="Worker name not found"):
-            deployer.get_worker_name()
-
-    def test_get_worker_name_with_quotes(self, tmp_path):
-        project_dir = tmp_path / "quoted"
-        project_dir.mkdir()
-
-        wrangler_toml = project_dir / "wrangler.toml"
-        wrangler_toml.write_text('name = "my-worker"\n')
-
-        deployer = CloudflareDeploy(project_dir=project_dir)
-        assert deployer.get_worker_name() == "my-worker"
-
-    def test_get_worker_name_single_quotes(self, tmp_path):
-        project_dir = tmp_path / "single-quotes"
-        project_dir.mkdir()
-
-        wrangler_toml = project_dir / "wrangler.toml"
-        wrangler_toml.write_text("name = 'my-worker'\n")
-
-        deployer = CloudflareDeploy(project_dir=project_dir)
-        assert deployer.get_worker_name() == "my-worker"
-
-
-class TestBuildDeployCommand:
-    """Test deploy command construction"""
-
-    def test_basic_command(self, temp_project):
-        deployer = CloudflareDeploy(project_dir=temp_project)
-        cmd = deployer.build_deploy_command()
-        assert cmd == ["wrangler", "deploy"]
-
-    def test_command_with_env(self, temp_project):
-        deployer = CloudflareDeploy(project_dir=temp_project, env="production")
-        cmd = deployer.build_deploy_command()
-        assert cmd == ["wrangler", "deploy", "--env", "production"]
-
-    def test_command_with_dry_run(self, temp_project):
-        deployer = CloudflareDeploy(project_dir=temp_project, dry_run=True)
-        cmd = deployer.build_deploy_command()
-        assert cmd == ["wrangler", "deploy", "--dry-run"]
-
-    def test_command_with_env_and_dry_run(self, temp_project):
-        deployer = CloudflareDeploy(
-            project_dir=temp_project,
-            env="staging",
-            dry_run=True
-        )
-        cmd = deployer.build_deploy_command()
-        assert cmd == ["wrangler", "deploy", "--env", "staging", "--dry-run"]
-
-
-class TestRunCommand:
-    """Test command execution"""
-
-    @patch('subprocess.run')
-    def test_run_command_success(self, mock_run, deployer):
-        mock_run.return_value = Mock(
-            returncode=0,
-            stdout="Success",
-            stderr=""
-        )
-
-        exit_code, stdout, stderr = deployer.run_command(["echo", "test"])
-
-        assert exit_code == 0
-        assert stdout == "Success"
-        assert stderr == ""
-        mock_run.assert_called_once()
-
-    @patch('subprocess.run')
-    def test_run_command_failure_with_check(self, mock_run, deployer):
-        mock_run.side_effect = subprocess.CalledProcessError(
-            1, "cmd", stderr="Error"
-        )
-
-        with pytest.raises(CloudflareDeployError, match="Command failed"):
-            deployer.run_command(["false"], check=True)
-
-    @patch('subprocess.run')
-    def test_run_command_failure_no_check(self, mock_run, deployer):
-        mock_run.side_effect = subprocess.CalledProcessError(
-            1, "cmd", output="", stderr="Error"
-        )
-
-        exit_code, stdout, stderr = deployer.run_command(["false"], check=False)
-
-        assert exit_code == 1
-
-
-class TestDeploy:
-    """Test full deployment flow"""
-
-    @patch.object(CloudflareDeploy, 'check_wrangler_installed')
-    @patch.object(CloudflareDeploy, 'run_command')
-    def test_deploy_success(self, mock_run_cmd, mock_check_wrangler, deployer):
-        mock_check_wrangler.return_value = True
-        mock_run_cmd.return_value = (0, "Deployed successfully", "")
-
-        result = deployer.deploy()
-
-        assert result is True
-        mock_check_wrangler.assert_called_once()
-        mock_run_cmd.assert_called_once()
-
-    @patch.object(CloudflareDeploy, 'check_wrangler_installed')
-    def test_deploy_wrangler_not_installed(self, mock_check_wrangler, deployer):
-        mock_check_wrangler.return_value = False
-
-        with pytest.raises(CloudflareDeployError, match="wrangler CLI not installed"):
-            deployer.deploy()
-
-    @patch.object(CloudflareDeploy, 'check_wrangler_installed')
-    @patch.object(CloudflareDeploy, 'run_command')
-    def test_deploy_command_fails(self, mock_run_cmd, mock_check_wrangler, deployer):
-        mock_check_wrangler.return_value = True
-        mock_run_cmd.side_effect = CloudflareDeployError("Deploy failed")
-
-        with pytest.raises(CloudflareDeployError, match="Deploy failed"):
-            deployer.deploy()
-
-    def test_deploy_invalid_project(self, tmp_path):
-        deployer = CloudflareDeploy(project_dir=tmp_path / "nonexistent")
-
-        with pytest.raises(CloudflareDeployError):
-            deployer.deploy()
-
-
-class TestIntegration:
-    """Integration tests"""
-
-    @patch.object(CloudflareDeploy, 'check_wrangler_installed')
-    @patch.object(CloudflareDeploy, 'run_command')
-    def test_full_deployment_flow(self, mock_run_cmd, mock_check_wrangler, temp_project):
-        mock_check_wrangler.return_value = True
-        mock_run_cmd.return_value = (0, "Success", "")
-
-        deployer = CloudflareDeploy(
-            project_dir=temp_project,
-            env="production",
-            dry_run=False,
-            verbose=True
-        )
-
-        result = deployer.deploy()
-
-        assert result is True
-        assert mock_run_cmd.call_count == 1
-
-        # Verify correct command was built
-        call_args = mock_run_cmd.call_args[0][0]
-        assert "wrangler" in call_args
-        assert "deploy" in call_args
-        assert "--env" in call_args
-        assert "production" in call_args
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])