cokit-cli 1.0.3 → 1.0.5

package/package.json

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

package/src/index.js

@@ -1,17 +1,26 @@
 // CoKit CLI - Make GitHub Copilot smarter in 30 seconds
 import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 import { initCommand } from './commands/init.js';
 import { addCommand } from './commands/add.js';
 import { listCommand } from './commands/list.js';
 import { doctorCommand } from './commands/doctor.js';
 import { updateCommand } from './commands/update.js';
+import { checkForUpdates } from './utils/update-checker.js';
+
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
 
 const program = new Command();
 
 program
   .name('cokit')
   .description('Make GitHub Copilot smarter in 30 seconds')
-  .version('1.0.0');
+  .version(pkg.version);
 
 // Register commands
 program.addCommand(initCommand);
@@ -20,4 +29,7 @@ program.addCommand(listCommand);
 program.addCommand(doctorCommand);
 program.addCommand(updateCommand);
 
-program.parse();
+// Check for updates (async, non-blocking)
+checkForUpdates().then(() => {
+  program.parse();
+});

package/src/utils/update-checker.js

@@ -0,0 +1,126 @@
+// Update checker - Notify users when new version is available
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { warn, hint, bold, cyan, dim } from './colors.js';
+import { PACKAGE_ROOT } from './paths.js';
+
+const CACHE_DIR = join(homedir(), '.cokit');
+const CACHE_FILE = join(CACHE_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org/cokit-cli';
+
+// Get current version from package.json
+function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+    return pkg.version;
+  } catch {
+    return null;
+  }
+}
+
+// Read cache file
+function readCache() {
+  try {
+    if (existsSync(CACHE_FILE)) {
+      return JSON.parse(readFileSync(CACHE_FILE, 'utf8'));
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+// Write cache file
+function writeCache(data) {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
+  } catch { /* ignore */ }
+}
+
+// Fetch latest version from npm registry
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000); // 3s timeout
+
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { 'Accept': 'application/json' }
+    });
+    clearTimeout(timeout);
+
+    if (!response.ok) return null;
+
+    const data = await response.json();
+    return data['dist-tags']?.latest || null;
+  } catch {
+    return null;
+  }
+}
+
+// Compare semver versions (returns 1 if a > b, -1 if a < b, 0 if equal)
+function compareVersions(a, b) {
+  const partsA = a.split('.').map(Number);
+  const partsB = b.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA > numB) return 1;
+    if (numA < numB) return -1;
+  }
+  return 0;
+}
+
+// Display update notification
+function showUpdateNotification(currentVersion, latestVersion) {
+  console.log();
+  console.log(bold(cyan('╭─────────────────────────────────────────╮')));
+  console.log(bold(cyan('│')) + '   Update available! ' + dim(currentVersion) + ' → ' + bold(cyan(latestVersion)) + '     ' + bold(cyan('│')));
+  console.log(bold(cyan('│')) + '                                         ' + bold(cyan('│')));
+  console.log(bold(cyan('│')) + '   Run: ' + bold('npx cokit-cli@latest init -g') + '   ' + bold(cyan('│')));
+  console.log(bold(cyan('╰─────────────────────────────────────────╯')));
+  console.log();
+}
+
+// Main update check function (non-blocking)
+export async function checkForUpdates() {
+  try {
+    const currentVersion = getCurrentVersion();
+    if (!currentVersion) return;
+
+    const cache = readCache();
+    const now = Date.now();
+
+    // Check if we have a cached result that's still valid
+    if (cache && cache.checkedAt && (now - cache.checkedAt) < CHECK_INTERVAL_MS) {
+      // Use cached result
+      if (cache.latestVersion && compareVersions(cache.latestVersion, currentVersion) > 0) {
+        showUpdateNotification(currentVersion, cache.latestVersion);
+      }
+      return;
+    }
+
+    // Fetch latest version (non-blocking, don't await in main flow)
+    const latestVersion = await fetchLatestVersion();
+
+    if (latestVersion) {
+      // Update cache
+      writeCache({
+        checkedAt: now,
+        latestVersion,
+        currentVersion
+      });
+
+      // Show notification if update available
+      if (compareVersions(latestVersion, currentVersion) > 0) {
+        showUpdateNotification(currentVersion, latestVersion);
+      }
+    }
+  } catch {
+    // Silently fail - don't disrupt user experience
+  }
+}

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.