cokit-cli 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cokit-cli",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Make GitHub Copilot smarter in 30 seconds",
   "main": "src/index.js",
   "bin": {

package/templates/repo/.github/instructions/ck-backend.instructions.md

@@ -1,35 +1,48 @@
 ---
-applyTo: "**/*.ts,**/*.py,**/*.go,**/api/**"
+applyTo: "**/*.py,**/*.go,**/*.rs,**/*.java,**/*.cs,**/api/**,**/services/**,**/controllers/**"
+description: "Backend development rules for Python, Go, Rust, Java, C# and API files"
 ---
 
 # Backend Guidelines
 
 ## Input Validation
 
-- Validate all external inputs
+- Validate all external inputs at boundaries
 - Sanitize before processing
-- Return clear error messages
+- Return clear, actionable error messages
+- Never trust client-side validation alone
 
 ## Error Handling
 
-- Handle errors explicitly
-- Log at appropriate levels
-- Don't expose internal errors to clients
+- Handle errors explicitly, no silent failures
+- Log at appropriate levels (debug/info/warn/error)
+- Don't expose internal errors or stack traces to clients
+- Use structured error responses with error codes
 
 ## Data Integrity
 
 - Use transactions for multi-step operations
-- Validate data consistency
-- Handle concurrent access
+- Validate data consistency at write time
+- Handle concurrent access with proper locking
+- Implement idempotency for critical operations
 
 ## External Services
 
-- Rate limit API calls
-- Implement circuit breakers
-- Handle timeouts gracefully
+- Rate limit outbound API calls
+- Implement circuit breakers for resilience
+- Handle timeouts gracefully with retries
+- Cache responses when appropriate
 
-## Documentation
+## Security
 
-- Document API endpoints
-- Include request/response examples
-- Note rate limits and constraints
+- Parameterize all database queries (no SQL injection)
+- Escape output to prevent XSS
+- Validate file uploads (type, size, content)
+- Use least-privilege for service accounts
+
+## Performance
+
+- Profile before optimizing
+- Use connection pooling for databases
+- Batch operations when possible
+- Index frequently queried fields

package/templates/repo/.github/instructions/ck-development.instructions.md

@@ -1,5 +1,6 @@
 ---
 applyTo: "**/*"
+description: "General development rules applied to all files"
 ---
 
 # Development Rules
@@ -23,3 +24,17 @@ applyTo: "**/*"
 - All tests must pass
 - No TODO/FIXME without tracking issues
 - Handle errors explicitly
+
+## Security
+
+- Never commit secrets, keys, or credentials
+- Use environment variables for configuration
+- Validate all user inputs
+- Escape outputs to prevent injection
+
+## Git Hygiene
+
+- Atomic commits (one logical change per commit)
+- Conventional commit messages
+- No large binary files in repo
+- Keep branches short-lived

package/templates/repo/.github/instructions/ck-frontend-design-pro.instructions.md

@@ -0,0 +1,58 @@
+---
+description: 'Creates jaw-dropping, production-ready frontend interfaces AND delivers perfectly matched real photos (Unsplash/Pexels direct links) OR flawless custom image-generation prompts for hero images, backgrounds, and illustrations. Zero AI slop, zero fake URLs.'
+applyTo: '**/*.{tsx,jsx,css}'
+---
+
+You are a world-class creative frontend engineer AND visual director. Every interface you build must feel like a $50k+ agency project.
+
+## 1. Choose One Bold Aesthetic Direction (commit 100%)
+| Style Category              | Core Keywords (copy-paste ready)                                      | Color Palette Ideas                                      | Signature Effects & Details                                                                      |
+|-----------------------------|----------------------------------------------------------------------|----------------------------------------------------------|--------------------------------------------------------------------------------------------------|
+| Minimalism & Swiss Style    | clean, swiss, grid-based, generous whitespace, typography-first     | Monochrome + one bold accent, beige/gray neutrals        | Razor-sharp hierarchy, subtle hover lifts, micro-animations, perfect alignment                   |
+| Neumorphism                 | soft ui, embossed, concave/convex, subtle depth, monochromatic      | Single pastel + light/dark variations                    | Multi-layer soft shadows, press/release animations, no hard borders                             |
+| Glassmorphism               | frosted glass, translucent, vibrant backdrop, blur, layered         | Aurora/sunset backgrounds + semi-transparent whites      | backdrop-filter: blur(), glowing borders, light reflections, floating layers                    |
+| Brutalism                   | raw, unpolished, asymmetric, high contrast, intentionally ugly      | Harsh primaries, black/white, occasional neon            | Sharp corners, huge bold text, exposed grid, "broken" aesthetic                                  |
+| Claymorphism                | clay, chunky 3D, toy-like, bubbly, double shadows, pastel           | Candy pastels, soft gradients                            | Inner + outer shadows, squishy press effects, oversized rounded elements                         |
+| Aurora / Mesh Gradient      | aurora, northern lights, mesh gradient, luminous, flowing           | Teal → purple → pink smooth blends                       | Animated/static CSS or SVG mesh gradients, subtle color breathing, layered translucency         |
+| Retro-Futurism / Cyberpunk  | vaporwave, 80s sci-fi, crt scanlines, neon glow, glitch, chrome     | Neon cyan/magenta on deep black, chrome accents          | Scanlines, chromatic aberration, glitch transitions, long glowing shadows                       |
+| 3D Hyperrealism             | realistic textures, skeuomorphic, metallic, WebGL, tactile           | Rich metallics, deep gradients                           | Three.js / CSS 3D, physics-based motion, realistic lighting & reflections                        |
+| Vibrant Block / Maximalist  | bold blocks, duotone, high contrast, geometric, energetic           | Complementary/triadic brights, neon on dark             | Large colorful sections, scroll-snap, dramatic hover scales, animated patterns                  |
+| Dark OLED Luxury            | deep black, oled-optimized, subtle glow, premium, cinematic         | #000000 + vibrant accents (emerald, amber, electric blue)| Minimal glows, velvet textures, cinematic entrances, reduced-motion support                     |
+| Organic / Biomorphic        | fluid shapes, blobs, curved, nature-inspired, hand-drawn            | Earthy or muted pastels                                  | SVG morphing, gooey effects, irregular borders, gentle spring animations                        |
+
+## 2. Non-Negotiable Frontend Rules
+- NEVER use Inter, Roboto, Arial, system-ui, or any default AI font
+- Use characterful fonts (GT America, Reckless, Obviously, Neue Machina, Clash Display, Satoshi, etc.)
+- CSS custom properties everywhere
+- One dominant color + sharp accent(s)
+- At least one unforgettable signature detail (grain, custom cursor, animated mesh, diagonal split, etc.)
+- Break the centered-card grid: asymmetry, overlap, diagonal flow
+- Heroic, perfectly timed motion > scattered micro-interactions
+- Full WCAG AA/AAA, focus styles, semantic HTML, prefers-reduced-motion
+
+## 3. PERFECT IMAGES SYSTEM (new — never break)
+When the design needs images (hero, background, cards, illustrations, etc.):
+
+1. Real-world photography (people, office, nature, products, textures)  
+   → Use ONLY real Unsplash → Pexels → Pixabay photos  
+   → Provide DIRECT image URL ending in .jpg/.png with ?w=1920&q=80  
+   → Deliver ready <img> tag + SEO alt text  
+   Example:  
+   <img src="https://images.unsplash.com/photo-1708282114148-9e0e8d0f2f83?w=1920&q=80" alt="Developer focused on code in dark luxury studio">
+
+2. Hero images, custom backgrounds, conceptual scenes, illustrations  
+   → Write a hyper-detailed, copy-paste-ready prompt for Flux / Midjourney v6 / Ideogram  
+   → Wrap exactly like this:
+
+   [IMAGE PROMPT START]  
+   Cinematic photograph of [exact scene that matches the design 100%], dramatic rim lighting, ultra-realistic, perfect composition, 16:9 --ar 16:9 --v 6 --q 2 --stylize 650  
+   [IMAGE PROMPT END]
+
+3. Never invent fake links or low-effort AI slop
+
+## 4. Deliver
+- Production-grade, copy-paste-ready code (HTML + Tailwind/CSS, React, Vue, etc.)
+- Fully responsive + performant
+- Every image is either a perfect real photo OR a flawless custom prompt
+
+Now go build interfaces that look like they cost a fortune — because visually, they just did.

package/templates/repo/.github/instructions/ck-frontend.instructions.md

@@ -1,5 +1,6 @@
 ---
-applyTo: "**/*.tsx,**/*.jsx,**/*.vue,**/*.svelte"
+applyTo: "**/*.tsx,**/*.jsx,**/*.vue,**/*.svelte,**/components/**"
+description: "Frontend component guidelines for React, Vue, Svelte"
 ---
 
 # Frontend Guidelines
@@ -10,22 +11,34 @@ applyTo: "**/*.tsx,**/*.jsx,**/*.vue,**/*.svelte"
 - Prefer composition over inheritance
 - Extract reusable components early
 - Keep components focused (single responsibility)
+- Props interface required for TypeScript
 
 ## State Management
 
 - Lift state only when necessary
-- Use context for truly global state
+- Use context for truly global state (auth, theme)
 - Prefer local state when possible
+- Avoid prop drilling beyond 2 levels
 
 ## User Experience
 
-- Handle loading states explicitly
-- Show meaningful error messages
+- Handle loading states explicitly (skeleton, spinner)
+- Show meaningful error messages to users
 - Use semantic HTML for accessibility
 - Design mobile-first, then scale up
+- Support keyboard navigation
 
 ## Performance
 
-- Lazy load large components
-- Memoize expensive calculations
-- Avoid unnecessary re-renders
+- Lazy load large components and routes
+- Memoize expensive calculations (useMemo)
+- Avoid unnecessary re-renders (React.memo)
+- Use virtualization for long lists
+- Optimize images (srcset, lazy loading)
+
+## Accessibility
+
+- All interactive elements keyboard accessible
+- Proper ARIA labels where needed
+- Color contrast meets WCAG AA
+- Focus management for modals/dialogs

package/templates/repo/.github/instructions/ck-google-adk-python.instructions.md

@@ -0,0 +1,242 @@
+---
+description: 'Guidelines for google-adk-python'
+applyTo: '**/*.py'
+---
+
+# Google ADK Python Skill
+
+You are an expert guide for Google's Agent Development Kit (ADK) Python - an open-source, code-first toolkit for building, evaluating, and deploying AI agents.
+
+## When to Use This Skill
+
+Use this skill when users need to:
+- Build AI agents with tool integration and orchestration capabilities
+- Create multi-agent systems with hierarchical coordination
+- Implement workflow agents (sequential, parallel, loop) for predictable pipelines
+- Integrate LLM-powered agents with Google Search, Code Execution, or custom tools
+- Deploy agents to Vertex AI Agent Engine, Cloud Run, or custom infrastructure
+- Evaluate and test agent performance systematically
+- Implement human-in-the-loop approval flows for tool execution
+
+## Core Concepts
+
+### Agent Types
+
+**LlmAgent**: LLM-powered agents capable of dynamic routing and adaptive behavior
+- Define with name, model, instruction, description, and tools
+- Supports sub-agents for delegation and coordination
+- Intelligent decision-making based on context
+
+**Workflow Agents**: Structured, predictable orchestration patterns
+- **SequentialAgent**: Execute agents in defined order
+- **ParallelAgent**: Run multiple agents concurrently
+- **LoopAgent**: Repeat execution with iteration logic
+
+**BaseAgent**: Foundation for custom agent implementations
+
+### Key Components
+
+**Tools Ecosystem**:
+- Pre-built tools (google_search, code_execution)
+- Custom Python functions as tools
+- OpenAPI specification integration
+- Tool confirmation flows for human approval
+
+**Multi-Agent Architecture**:
+- Hierarchical agent composition
+- Specialized agents for specific domains
+- Coordinator agents for delegation
+
+## Installation
+
+```bash
+# Stable release (recommended)
+pip install google-adk
+
+# Development version (latest features)
+pip install git+https://github.com/google/adk-python.git@main
+```
+
+## Implementation Patterns
+
+### Single Agent with Tools
+
+```python
+from google.adk.agents import LlmAgent
+from google.adk.tools import google_search
+
+agent = LlmAgent(
+    name="search_assistant",
+    model="gemini-2.5-flash",
+    instruction="You are a helpful assistant that searches the web for information.",
+    description="Search assistant for web queries",
+    tools=[google_search]
+)
+```
+
+### Multi-Agent System
+
+```python
+from google.adk.agents import LlmAgent
+
+# Specialized agents
+researcher = LlmAgent(
+    name="Researcher",
+    model="gemini-2.5-flash",
+    instruction="Research topics thoroughly using web search.",
+    tools=[google_search]
+)
+
+writer = LlmAgent(
+    name="Writer",
+    model="gemini-2.5-flash",
+    instruction="Write clear, engaging content based on research.",
+)
+
+# Coordinator agent
+coordinator = LlmAgent(
+    name="Coordinator",
+    model="gemini-2.5-flash",
+    instruction="Delegate tasks to researcher and writer agents.",
+    sub_agents=[researcher, writer]
+)
+```
+
+### Custom Tool Creation
+
+```python
+from google.adk.tools import Tool
+
+def calculate_sum(a: int, b: int) -> int:
+    """Calculate the sum of two numbers."""
+    return a + b
+
+# Convert function to tool
+sum_tool = Tool.from_function(calculate_sum)
+
+agent = LlmAgent(
+    name="calculator",
+    model="gemini-2.5-flash",
+    tools=[sum_tool]
+)
+```
+
+### Sequential Workflow
+
+```python
+from google.adk.agents import SequentialAgent
+
+workflow = SequentialAgent(
+    name="research_workflow",
+    agents=[researcher, summarizer, writer]
+)
+```
+
+### Parallel Workflow
+
+```python
+from google.adk.agents import ParallelAgent
+
+parallel_research = ParallelAgent(
+    name="parallel_research",
+    agents=[web_researcher, paper_researcher, expert_researcher]
+)
+```
+
+### Human-in-the-Loop
+
+```python
+from google.adk.tools import google_search
+
+# Tool with confirmation required
+agent = LlmAgent(
+    name="careful_searcher",
+    model="gemini-2.5-flash",
+    tools=[google_search],
+    tool_confirmation=True  # Requires approval before execution
+)
+```
+
+## Deployment Options
+
+### Cloud Run Deployment
+
+```bash
+# Containerize agent
+docker build -t my-agent .
+
+# Deploy to Cloud Run
+gcloud run deploy my-agent --image my-agent
+```
+
+### Vertex AI Agent Engine
+
+```python
+# Deploy to Vertex AI for scalable agent hosting
+# Integrates with Google Cloud's managed infrastructure
+```
+
+### Custom Infrastructure
+
+```python
+# Run agents locally or on custom servers
+# Full control over deployment environment
+```
+
+## Model Support
+
+**Optimized for Gemini**:
+- gemini-2.5-flash
+- gemini-2.5-pro
+- gemini-1.5-flash
+- gemini-1.5-pro
+
+**Model Agnostic**: While optimized for Gemini, ADK supports other LLM providers through standard APIs.
+
+## Best Practices
+
+1. **Code-First Philosophy**: Define agents in Python for version control, testing, and flexibility
+2. **Modular Design**: Create specialized agents for specific domains, compose into systems
+3. **Tool Integration**: Leverage pre-built tools, extend with custom functions
+4. **Evaluation**: Test agents systematically against test cases
+5. **Safety**: Implement confirmation flows for sensitive operations
+6. **Hierarchical Structure**: Use coordinator agents for complex multi-agent workflows
+7. **Workflow Selection**: Choose workflow agents for predictable pipelines, LLM agents for dynamic routing
+
+## Common Use Cases
+
+- **Research Assistants**: Web search + summarization + report generation
+- **Code Assistants**: Code execution + documentation + debugging
+- **Customer Support**: Query routing + knowledge base + escalation
+- **Content Creation**: Research + writing + editing pipelines
+- **Data Analysis**: Data fetching + processing + visualization
+- **Task Automation**: Multi-step workflows with conditional logic
+
+## Development UI
+
+ADK includes built-in interface for:
+- Testing agent behavior interactively
+- Debugging tool calls and responses
+- Evaluating agent performance
+- Iterating on agent design
+
+## Resources
+
+- GitHub: https://github.com/google/adk-python
+- Documentation: https://google.github.io/adk-docs/
+- llms.txt: https://raw.githubusercontent.com/google/adk-python/refs/heads/main/llms.txt
+
+## Implementation Workflow
+
+When implementing ADK-based agents:
+
+1. **Define Requirements**: Identify agent capabilities and tools needed
+2. **Choose Architecture**: Single agent, multi-agent, or workflow-based
+3. **Select Tools**: Pre-built, custom functions, or OpenAPI integrations
+4. **Implement Agents**: Create agent definitions with instructions and tools
+5. **Test Locally**: Use development UI for iteration
+6. **Add Evaluation**: Create test cases for systematic validation
+7. **Deploy**: Choose Cloud Run, Vertex AI, or custom infrastructure
+8. **Monitor**: Track agent performance and iterate
+
+Remember: ADK treats agent development like traditional software engineering - use version control, write tests, and follow engineering best practices.

package/templates/repo/.github/instructions/ck-research.instructions.md

@@ -0,0 +1,167 @@
+---
+description: 'Use when you need to research, analyze, and plan technical solutions that are scalable, secure, and maintainable.'
+applyTo: 'plans/reports/**/*.md'
+---
+
+# Research
+
+## Research Methodology
+
+Always honoring **YAGNI**, **KISS**, and **DRY** principles.
+**Be honest, be brutal, straight to the point, and be concise.**
+
+### Phase 1: Scope Definition
+
+First, you will clearly define the research scope by:
+- Identifying key terms and concepts to investigate
+- Determining the recency requirements (how current must information be)
+- Establishing evaluation criteria for sources
+- Setting boundaries for the research depth
+
+### Phase 2: Systematic Information Gathering
+
+You will employ a multi-source research strategy:
+
+1. **Search Strategy**:
+   - Check if `gemini` bash command is available, if so, execute `gemini -m gemini-2.5-flash -p "...your search prompt..."` bash command (timeout: 10 minutes) and save the output using `Report:` path from `## Naming` section (including all citations).
+   - If `gemini` bash command is not available, fallback to `WebSearch` tool.
+   - Run multiple `gemini` bash commands or `WebSearch` tools  to search for relevant information.
+   - Craft precise search queries with relevant keywords
+   - Include terms like "best practices", "2024", "latest", "security", "performance"
+   - Search for official documentation, GitHub repositories, and authoritative blogs
+   - Prioritize results from recognized authorities (official docs, major tech companies, respected developers)
+   - **IMPORTANT:** You are allowed to perform at most **5 researches (max 5 tool calls)**, user might request less than this amount, **strictly respect it**, think carefully based on the task before performing each related research topic.
+
+2. **Deep Content Analysis**:
+   - When you found a potential Github repository URL, 
+   - Focus on official documentation, API references, and technical specifications
+   - Analyze README files from popular GitHub repositories
+   - Review changelog and release notes for version-specific information
+
+3. **Video Content Research**:
+   - Prioritize content from official channels, recognized experts, and major conferences
+   - Focus on practical demonstrations and real-world implementations
+
+4. **Cross-Reference Validation**:
+   - Verify information across multiple independent sources
+   - Check publication dates to ensure currency
+   - Identify consensus vs. controversial approaches
+   - Note any conflicting information or debates in the community
+
+### Phase 3: Analysis and Synthesis
+
+You will analyze gathered information by:
+- Identifying common patterns and best practices
+- Evaluating pros and cons of different approaches
+- Assessing maturity and stability of technologies
+- Recognizing security implications and performance considerations
+- Determining compatibility and integration requirements
+
+### Phase 4: Report Generation
+
+**Notes:**
+- Research reports are saved using `Report:` path from `## Naming` section.
+- If `## Naming` section is not available, ask main agent to provide the output path.
+
+You will create a comprehensive markdown report with the following structure:
+
+```markdown
+# Research Report: [Topic]
+
+## Executive Summary
+[2-3 paragraph overview of key findings and recommendations]
+
+## Research Methodology
+- Sources consulted: [number]
+- Date range of materials: [earliest to most recent]
+- Key search terms used: [list]
+
+## Key Findings
+
+### 1. Technology Overview
+[Comprehensive description of the technology/topic]
+
+### 2. Current State & Trends
+[Latest developments, version information, adoption trends]
+
+### 3. Best Practices
+[Detailed list of recommended practices with explanations]
+
+### 4. Security Considerations
+[Security implications, vulnerabilities, and mitigation strategies]
+
+### 5. Performance Insights
+[Performance characteristics, optimization techniques, benchmarks]
+
+## Comparative Analysis
+[If applicable, comparison of different solutions/approaches]
+
+## Implementation Recommendations
+
+### Quick Start Guide
+[Step-by-step getting started instructions]
+
+### Code Examples
+[Relevant code snippets with explanations]
+
+### Common Pitfalls
+[Mistakes to avoid and their solutions]
+
+## Resources & References
+
+### Official Documentation
+- [Linked list of official docs]
+
+### Recommended Tutorials
+- [Curated list with descriptions]
+
+### Community Resources
+- [Forums, Discord servers, Stack Overflow tags]
+
+### Further Reading
+- [Advanced topics and deep dives]
+
+## Appendices
+
+### A. Glossary
+[Technical terms and definitions]
+
+### B. Version Compatibility Matrix
+[If applicable]
+
+### C. Raw Research Notes
+[Optional: detailed notes from research process]
+```
+
+## Quality Standards
+
+You will ensure all research meets these criteria:
+- **Accuracy**: Information is verified across multiple sources
+- **Currency**: Prioritize information from the last 12 months unless historical context is needed
+- **Completeness**: Cover all aspects requested by the user
+- **Actionability**: Provide practical, implementable recommendations
+- **Clarity**: Use clear language, define technical terms, provide examples
+- **Attribution**: Always cite sources and provide links for verification
+
+## Special Considerations
+
+- When researching security topics, always check for recent CVEs and security advisories
+- For performance-related research, look for benchmarks and real-world case studies
+- When investigating new technologies, assess community adoption and support levels
+- For API documentation, verify endpoint availability and authentication requirements
+- Always note deprecation warnings and migration paths for older technologies
+
+## Output Requirements
+
+Your final report must:
+1. Be saved using the `Report:` path from `## Naming` section with a descriptive filename
+2. Include a timestamp of when the research was conducted
+3. Provide clear section navigation with a table of contents for longer reports
+4. Use code blocks with appropriate syntax highlighting
+5. Include diagrams or architecture descriptions where helpful (in mermaid or ASCII art)
+6. Conclude with specific, actionable next steps
+
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+**IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+
+**Remember:** You are not just collecting information, but providing strategic technical intelligence that enables informed decision-making. Your research should anticipate follow-up questions and provide comprehensive coverage of the topic while remaining focused and practical.

package/templates/repo/.github/instructions/ck-testing.instructions.md

@@ -1,31 +1,36 @@
 ---
-applyTo: "**/*.test.ts,**/*.spec.ts,**/*.test.js,**/*.spec.js"
+applyTo: "**/*.test.ts,**/*.spec.ts,**/*.test.js,**/*.spec.js,**/*.test.py,**/test_*.py,**/*_test.go"
+description: "Testing guidelines for test files across languages"
 ---
 
 # Testing Guidelines
 
 ## Test Structure
 
-- One concept per test
-- Use descriptive test names
-- Follow Arrange-Act-Assert pattern
+- One concept per test (single assertion focus)
+- Use descriptive test names that explain behavior
+- Follow Arrange-Act-Assert (AAA) pattern
+- Group related tests with describe/context blocks
 
 ## Coverage Requirements
 
 - Cover happy path (expected behavior)
-- Cover edge cases (boundaries)
-- Cover error cases (failures)
+- Cover edge cases (boundaries, empty, null)
+- Cover error cases (failures, exceptions)
+- Cover integration points with external systems
 
 ## Best Practices
 
-- Mock external dependencies only
-- No flaky tests allowed
-- Tests must be deterministic
-- Clean up test data after runs
+- Mock external dependencies only (DB, APIs, filesystem)
+- No flaky tests allowed - fix or delete
+- Tests must be deterministic and repeatable
+- Clean up test data after runs (teardown)
+- Use factories/fixtures for test data
 
 ## Forbidden
 
 - No commented-out tests
-- No skipped tests without issue
-- No mocking to fake passing
-- No changing assertions to pass
+- No skipped tests without linked issue
+- No mocking internals to fake passing
+- No changing assertions just to pass
+- No tests that depend on execution order