cokit-cli 1.0.4 → 1.0.5

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

@@ -0,0 +1,436 @@
+"""
+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

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,96 @@
+---
+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

@@ -0,0 +1,25 @@
+{
+  "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

@@ -0,0 +1,79 @@
+# 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