cokit-cli 1.0.8 → 1.0.9

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

@@ -1,436 +0,0 @@
-"""
-Tests for docker-optimize.py
-
-Run with: pytest test_docker_optimize.py -v
-"""
-
-import pytest
-import json
-from pathlib import Path
-import sys
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from docker_optimize import DockerfileAnalyzer
-
-
-@pytest.fixture
-def temp_dockerfile(tmp_path):
-    """Create temporary Dockerfile"""
-    dockerfile = tmp_path / "Dockerfile"
-    return dockerfile
-
-
-def write_dockerfile(filepath, content):
-    """Helper to write Dockerfile content"""
-    with open(filepath, 'w') as f:
-        f.write(content)
-
-
-class TestDockerfileAnalyzerInit:
-    """Test DockerfileAnalyzer initialization"""
-
-    def test_init(self, temp_dockerfile):
-        write_dockerfile(temp_dockerfile, "FROM node:20\n")
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-
-        assert analyzer.dockerfile_path == temp_dockerfile
-        assert analyzer.verbose is False
-        assert analyzer.lines == []
-        assert analyzer.issues == []
-        assert analyzer.suggestions == []
-
-
-class TestLoadDockerfile:
-    """Test Dockerfile loading"""
-
-    def test_load_success(self, temp_dockerfile):
-        content = "FROM node:20\nWORKDIR /app\n"
-        write_dockerfile(temp_dockerfile, content)
-
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        result = analyzer.load_dockerfile()
-
-        assert result is True
-        assert len(analyzer.lines) == 2
-
-    def test_load_nonexistent(self, tmp_path):
-        analyzer = DockerfileAnalyzer(tmp_path / "nonexistent")
-
-        with pytest.raises(FileNotFoundError):
-            analyzer.load_dockerfile()
-
-
-class TestAnalyzeBaseImage:
-    """Test base image analysis"""
-
-    def test_latest_tag(self, temp_dockerfile):
-        write_dockerfile(temp_dockerfile, "FROM node:latest\n")
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_base_image()
-
-        assert len(analyzer.issues) == 1
-        assert analyzer.issues[0]['category'] == 'base_image'
-        assert 'latest' in analyzer.issues[0]['message']
-
-    def test_no_tag(self, temp_dockerfile):
-        write_dockerfile(temp_dockerfile, "FROM node\n")
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_base_image()
-
-        assert len(analyzer.issues) == 1
-        assert 'no tag' in analyzer.issues[0]['message']
-
-    def test_specific_tag(self, temp_dockerfile):
-        write_dockerfile(temp_dockerfile, "FROM node:20-alpine\n")
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_base_image()
-
-        # Should have no issues with specific tag
-        base_image_issues = [i for i in analyzer.issues if i['category'] == 'base_image']
-        assert len(base_image_issues) == 0
-
-    def test_non_alpine_suggestion(self, temp_dockerfile):
-        write_dockerfile(temp_dockerfile, "FROM node:20\n")
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_base_image()
-
-        assert len(analyzer.suggestions) >= 1
-        assert any('Alpine' in s['message'] for s in analyzer.suggestions)
-
-
-class TestAnalyzeMultiStage:
-    """Test multi-stage build analysis"""
-
-    def test_single_stage_with_build_tools(self, temp_dockerfile):
-        content = """
-FROM node:20
-WORKDIR /app
-COPY package.json .
-RUN npm install
-COPY . .
-CMD ["node", "server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_multi_stage()
-
-        assert len(analyzer.issues) == 1
-        assert analyzer.issues[0]['category'] == 'optimization'
-        assert 'multi-stage' in analyzer.issues[0]['message'].lower()
-
-    def test_multi_stage_no_issues(self, temp_dockerfile):
-        content = """
-FROM node:20 AS build
-WORKDIR /app
-COPY package.json .
-RUN npm install
-COPY . .
-RUN npm run build
-
-FROM node:20-alpine
-WORKDIR /app
-COPY --from=build /app/dist ./dist
-CMD ["node", "dist/server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_multi_stage()
-
-        multi_stage_issues = [i for i in analyzer.issues if i['category'] == 'optimization']
-        assert len(multi_stage_issues) == 0
-
-
-class TestAnalyzeLayerCaching:
-    """Test layer caching analysis"""
-
-    def test_source_before_dependencies(self, temp_dockerfile):
-        content = """
-FROM node:20
-WORKDIR /app
-COPY . .
-RUN npm install
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_layer_caching()
-
-        assert len(analyzer.issues) == 1
-        assert analyzer.issues[0]['category'] == 'caching'
-
-    def test_correct_order(self, temp_dockerfile):
-        content = """
-FROM node:20
-WORKDIR /app
-COPY package.json .
-RUN npm install
-COPY . .
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_layer_caching()
-
-        caching_issues = [i for i in analyzer.issues if i['category'] == 'caching']
-        assert len(caching_issues) == 0
-
-
-class TestAnalyzeSecurity:
-    """Test security analysis"""
-
-    def test_no_user_instruction(self, temp_dockerfile):
-        content = """
-FROM node:20
-WORKDIR /app
-COPY . .
-CMD ["node", "server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_security()
-
-        assert len(analyzer.issues) >= 1
-        security_issues = [i for i in analyzer.issues if i['category'] == 'security']
-        assert any('root' in i['message'] for i in security_issues)
-
-    def test_with_user_instruction(self, temp_dockerfile):
-        content = """
-FROM node:20
-WORKDIR /app
-COPY . .
-USER node
-CMD ["node", "server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_security()
-
-        # Should not have root user issue
-        root_issues = [i for i in analyzer.issues
-                      if i['category'] == 'security' and 'root' in i['message']]
-        assert len(root_issues) == 0
-
-    def test_detect_secrets(self, temp_dockerfile):
-        content = """
-FROM node:20
-ENV API_KEY=secret123
-ENV PASSWORD=mypassword
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_security()
-
-        secret_issues = [i for i in analyzer.issues
-                        if i['category'] == 'security' and 'secret' in i['message'].lower()]
-        assert len(secret_issues) >= 1
-
-
-class TestAnalyzeAptCache:
-    """Test apt cache cleanup analysis"""
-
-    def test_apt_without_cleanup(self, temp_dockerfile):
-        content = """
-FROM ubuntu:22.04
-RUN apt-get update && apt-get install -y curl
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_apt_cache()
-
-        assert len(analyzer.suggestions) >= 1
-        assert any('apt cache' in s['message'] for s in analyzer.suggestions)
-
-    def test_apt_with_cleanup(self, temp_dockerfile):
-        content = """
-FROM ubuntu:22.04
-RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_apt_cache()
-
-        apt_suggestions = [s for s in analyzer.suggestions if 'apt cache' in s['message']]
-        assert len(apt_suggestions) == 0
-
-
-class TestAnalyzeCombineRun:
-    """Test RUN command combination analysis"""
-
-    def test_consecutive_runs(self, temp_dockerfile):
-        content = """
-FROM node:20
-RUN apt-get update
-RUN apt-get install -y curl
-RUN apt-get clean
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_combine_run()
-
-        assert len(analyzer.suggestions) >= 1
-        assert any('consecutive' in s['message'] for s in analyzer.suggestions)
-
-    def test_non_consecutive_runs(self, temp_dockerfile):
-        content = """
-FROM node:20
-RUN apt-get update
-COPY package.json .
-RUN npm install
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_combine_run()
-
-        consecutive_suggestions = [s for s in analyzer.suggestions
-                                  if 'consecutive' in s['message']]
-        assert len(consecutive_suggestions) == 0
-
-
-class TestAnalyzeWorkdir:
-    """Test WORKDIR analysis"""
-
-    def test_no_workdir(self, temp_dockerfile):
-        content = """
-FROM node:20
-COPY . /app
-CMD ["node", "/app/server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_workdir()
-
-        assert len(analyzer.suggestions) >= 1
-        assert any('WORKDIR' in s['message'] for s in analyzer.suggestions)
-
-    def test_with_workdir(self, temp_dockerfile):
-        content = """
-FROM node:20
-WORKDIR /app
-COPY . .
-CMD ["node", "server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        analyzer.load_dockerfile()
-        analyzer.analyze_workdir()
-
-        workdir_suggestions = [s for s in analyzer.suggestions if 'WORKDIR' in s['message']]
-        assert len(workdir_suggestions) == 0
-
-
-class TestFullAnalyze:
-    """Test complete analysis"""
-
-    def test_analyze_poor_dockerfile(self, temp_dockerfile):
-        content = """
-FROM node:latest
-COPY . .
-RUN npm install
-CMD ["node", "server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        results = analyzer.analyze()
-
-        assert 'dockerfile' in results
-        assert 'total_lines' in results
-        assert 'issues' in results
-        assert 'suggestions' in results
-        assert 'summary' in results
-
-        # Should have multiple issues and suggestions
-        assert results['summary']['warnings'] > 0
-        assert results['summary']['suggestions'] > 0
-
-    def test_analyze_good_dockerfile(self, temp_dockerfile):
-        content = """
-FROM node:20-alpine AS build
-WORKDIR /app
-COPY package.json .
-RUN npm ci --only=production
-COPY . .
-RUN npm run build
-
-FROM node:20-alpine
-WORKDIR /app
-COPY --from=build /app/dist ./dist
-COPY --from=build /app/node_modules ./node_modules
-USER node
-EXPOSE 3000
-CMD ["node", "dist/server.js"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        results = analyzer.analyze()
-
-        # Should have minimal issues
-        assert results['summary']['errors'] == 0
-        # May have some suggestions, but fewer issues overall
-
-
-class TestPrintResults:
-    """Test results printing"""
-
-    def test_print_results(self, temp_dockerfile, capsys):
-        content = "FROM node:latest\n"
-        write_dockerfile(temp_dockerfile, content)
-
-        analyzer = DockerfileAnalyzer(temp_dockerfile)
-        results = analyzer.analyze()
-        analyzer.print_results(results)
-
-        captured = capsys.readouterr()
-        assert "Dockerfile Analysis" in captured.out
-        assert "Summary:" in captured.out
-        assert "ISSUES:" in captured.out or "SUGGESTIONS:" in captured.out
-
-
-class TestIntegration:
-    """Integration tests"""
-
-    def test_full_analysis_workflow(self, temp_dockerfile):
-        content = """
-FROM python:3.11
-COPY . /app
-RUN pip install -r /app/requirements.txt
-ENV API_KEY=secret
-CMD ["python", "/app/app.py"]
-"""
-        write_dockerfile(temp_dockerfile, content)
-
-        analyzer = DockerfileAnalyzer(temp_dockerfile, verbose=True)
-        results = analyzer.analyze()
-
-        # Verify all expected checks ran
-        assert len(analyzer.issues) > 0
-        assert len(analyzer.suggestions) > 0
-
-        # Should flag multiple categories
-        categories = {i['category'] for i in analyzer.issues}
-        assert 'security' in categories
-
-        # Verify summary calculations
-        total_findings = (results['summary']['errors'] +
-                         results['summary']['warnings'] +
-                         results['summary']['suggestions'])
-        assert total_findings > 0
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

package/templates/repo/.github/skills/ck-docs-seeker/.env.example

@@ -1,15 +0,0 @@
-# Context7 API Configuration (optional)
-# Get your API key from https://context7.com/dashboard/api-keys
-CONTEXT7_API_KEY=
-
-# Gemini API Configuration (optional, for ai-multimodal integration)
-# Get your API key from https://aistudio.google.com/app/apikey
-GEMINI_API_KEY=
-
-# GitHub Token (optional, for higher rate limits on repository analysis)
-# Create at https://github.com/settings/tokens
-GITHUB_TOKEN=
-
-# Output settings
-OUTPUT_FORMAT=json
-DEBUG=false

package/templates/repo/.github/skills/ck-docs-seeker/SKILL.md

@@ -1,96 +0,0 @@
----
-name: 'ck-docs-seeker'
-description: 'Search technical documentation using executable scripts to detect query type, fetch from llms.txt sources (context7.com), and analyze results. Use when user needs: (1) Topic-specific documentation (features/components/concepts), (2) Library/framework documentation, (3) GitHub repository analysis, (4) Documentation discovery with automated agent distribution strategy'
----
-
-# Documentation Discovery via Scripts
-
-## Overview
-
-**Script-first** documentation discovery using llms.txt standard.
-
-Execute scripts to handle entire workflow - no manual URL construction needed.
-
-## Primary Workflow
-
-**ALWAYS execute scripts in this order:**
-
-```bash
-# 1. DETECT query type (topic-specific vs general)
-node scripts/detect-topic.js "<user query>"
-
-# 2. FETCH documentation using script output
-node scripts/fetch-docs.js "<user query>"
-
-# 3. ANALYZE results (if multiple URLs returned)
-cat llms.txt | node scripts/analyze-llms-txt.js -
-```
-
-Scripts handle URL construction, fallback chains, and error handling automatically.
-
-## Scripts
-
-**`detect-topic.js`** - Classify query type
-- Identifies topic-specific vs general queries
-- Extracts library name + topic keyword
-- Returns JSON: `{topic, library, isTopicSpecific}`
-- Zero-token execution
-
-**`fetch-docs.js`** - Retrieve documentation
-- Constructs context7.com URLs automatically
-- Handles fallback: topic → general → error
-- Outputs llms.txt content or error message
-- Zero-token execution
-
-**`analyze-llms-txt.js`** - Process llms.txt
-- Categorizes URLs (critical/important/supplementary)
-- Recommends agent distribution (1 agent, 3 agents, 7 agents, phased)
-- Returns JSON with strategy
-- Zero-token execution
-
-## Workflow References
-
-**[Topic-Specific Search](./workflows/topic-search.md)** - Fastest path (10-15s)
-
-**[General Library Search](./workflows/library-search.md)** - Comprehensive coverage (30-60s)
-
-**[Repository Analysis](./workflows/repo-analysis.md)** - Fallback strategy
-
-## References
-
-**[context7-patterns.md](./references/context7-patterns.md)** - URL patterns, known repositories
-
-**[errors.md](./references/errors.md)** - Error handling, fallback strategies
-
-**[advanced.md](./references/advanced.md)** - Edge cases, versioning, multi-language
-
-## Execution Principles
-
-1. **Scripts first** - Execute scripts instead of manual URL construction
-2. **Zero-token overhead** - Scripts run without context loading
-3. **Automatic fallback** - Scripts handle topic → general → error chains
-4. **Progressive disclosure** - Load workflows/references only when needed
-5. **Agent distribution** - Scripts recommend parallel agent strategy
-
-## Quick Start
-
-**Topic query:** "How do I use date picker in shadcn?"
-```bash
-node scripts/detect-topic.js "<query>"  # → {topic, library, isTopicSpecific}
-node scripts/fetch-docs.js "<query>"    # → 2-3 URLs
-# Read URLs with WebFetch
-```
-
-**General query:** "Documentation for Next.js"
-```bash
-node scripts/detect-topic.js "<query>"         # → {isTopicSpecific: false}
-node scripts/fetch-docs.js "<query>"           # → 8+ URLs
-cat llms.txt | node scripts/analyze-llms-txt.js -  # → {totalUrls, distribution}
-# Deploy agents per recommendation
-```
-
-## Environment
-
-Scripts load `.env`: `process.env` >  >  > 
-
-See `.env.example` for configuration options.

package/templates/repo/.github/skills/ck-docs-seeker/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "docs-seeker-scripts",
-  "version": "3.0.0",
-  "description": "Documentation discovery scripts for docs-seeker skill",
-  "private": true,
-  "scripts": {
-    "test": "node scripts/tests/run-tests.js",
-    "test:detect": "node scripts/tests/test-detect-topic.js",
-    "test:fetch": "node scripts/tests/test-fetch-docs.js",
-    "test:analyze": "node scripts/tests/test-analyze-llms.js"
-  },
-  "keywords": [
-    "documentation",
-    "llms.txt",
-    "context7",
-    "docs-discovery"
-  ],
-  "author": "ClaudeKit",
-  "license": "MIT",
-  "dependencies": {},
-  "devDependencies": {},
-  "engines": {
-    "node": ">=14.0.0"
-  }
-}

package/templates/repo/.github/skills/ck-docs-seeker/references/advanced.md

@@ -1,79 +0,0 @@
-# Advanced Scenarios & Edge Cases
-
-## Multi-Language Documentation
-
-**Challenge:** Docs in multiple languages
-
-**Approach:**
-1. Identify target language from user
-2. Search for language-specific llms.txt
-   - `llms-es.txt`, `llms-ja.txt`
-3. Fallback to English if not found
-4. Note language limitations in report
-
-## Version-Specific Documentation
-
-**Latest (default):**
-- Use base llms.txt URL
-- No version specifier needed
-
-**Specific version:**
-```
-WebSearch: "[library] v[version] llms.txt"
-Check paths:
-- /v2/llms.txt
-- /docs/v2/llms.txt
-- /{version}/llms.txt
-
-For repos:
-git checkout v[version] or tags/[version]
-```
-
-## Framework with Plugins
-
-**Challenge:** Core framework + 50 plugins
-
-**Strategy:**
-1. Focus on core framework first
-2. Ask user which plugins needed
-3. Launch targeted search for specific plugins
-4. Note available plugins in report
-5. Don't document everything upfront
-
-## Documentation Under Construction
-
-**Signs:**
-- New release with incomplete docs
-- Many "Coming soon" pages
-- GitHub issues requesting docs
-
-**Approach:**
-1. Note status upfront in report
-2. Combine available docs + repo analysis
-3. Check tests/ and examples/ directories
-4. Clearly mark "inferred from code"
-5. Link to GitHub issues for updates
-
-## Conflicting Information
-
-**When sources disagree:**
-1. Identify primary official source
-2. Note version differences
-3. Present both approaches with context
-4. Recommend official/latest
-5. Explain why conflict exists
-
-**Priority order:**
-1. Official docs (latest version)
-2. Official docs (versioned)
-3. GitHub README
-4. Community tutorials
-5. Stack Overflow
-
-## Rate Limiting
-
-**If hitting API limits:**
-- Use CONTEXT7_API_KEY from .env
-- Implement exponential backoff
-- Cache results in session
-- Batch requests where possible