cokit-cli 1.0.0

package/src/commands/list.js

@@ -0,0 +1,91 @@
+// list command - Show installed components
+import { Command } from 'commander';
+import { pathExists, listDirs, countFiles } from '../utils/copy.js';
+import { getUserSkillsDir, getRepoGithubDir } from '../utils/paths.js';
+import { success, error, info, bold, cyan, dim } from '../utils/colors.js';
+import { join } from 'path';
+import { readdirSync, existsSync } from 'fs';
+
+export const listCommand = new Command('list')
+  .description('Show installed CoKit components')
+  .option('-a, --all', 'Show both project and global')
+  .action(async (options) => {
+    console.log();
+    console.log(bold(cyan('CoKit Installation Status')));
+    console.log();
+
+    // Check project-level installation
+    console.log(bold('Project (.github/):'));
+    const githubDir = getRepoGithubDir();
+
+    if (pathExists(githubDir)) {
+      // Check for copilot-instructions.md
+      const instructionsFile = join(githubDir, 'copilot-instructions.md');
+      if (pathExists(instructionsFile)) {
+        success('copilot-instructions.md');
+      }
+
+      // Check for AGENTS.md
+      const agentsFile = join(githubDir, 'AGENTS.md');
+      if (pathExists(agentsFile)) {
+        success('AGENTS.md');
+      }
+
+      // Check prompts
+      const promptsDir = join(githubDir, 'prompts');
+      if (pathExists(promptsDir)) {
+        const promptFiles = readdirSync(promptsDir).filter(f => f.endsWith('.prompt.md'));
+        if (promptFiles.length > 0) {
+          success(`prompts/ (${promptFiles.length} prompts)`);
+          promptFiles.forEach(f => {
+            console.log(dim(`    ${f}`));
+          });
+        }
+      }
+
+      // Check instructions
+      const instructionsDir = join(githubDir, 'instructions');
+      if (pathExists(instructionsDir)) {
+        const instructionFiles = readdirSync(instructionsDir).filter(f => f.endsWith('.instructions.md'));
+        if (instructionFiles.length > 0) {
+          success(`instructions/ (${instructionFiles.length} files)`);
+        }
+      }
+
+      // Check skills
+      const skillsDir = join(githubDir, 'skills');
+      if (pathExists(skillsDir)) {
+        const skills = listDirs(skillsDir);
+        if (skills.length > 0) {
+          success(`skills/ (${skills.length} skills)`);
+          skills.forEach(s => {
+            console.log(dim(`    ${s}`));
+          });
+        }
+      }
+    } else {
+      info('Not installed');
+    }
+
+    console.log();
+
+    // Check global skills
+    console.log(bold('Personal (~/.copilot/skills/):'));
+    const globalSkillsDir = getUserSkillsDir();
+
+    if (pathExists(globalSkillsDir)) {
+      const skills = listDirs(globalSkillsDir);
+      if (skills.length > 0) {
+        success(`${skills.length} skills installed`);
+        skills.forEach(s => {
+          console.log(dim(`    ${s}`));
+        });
+      } else {
+        info('No skills installed');
+      }
+    } else {
+      info('Not installed');
+    }
+
+    console.log();
+  });

package/src/commands/update.js

@@ -0,0 +1,22 @@
+// update command - Update CoKit to latest version
+import { Command } from 'commander';
+import { info, done, hint, bold, cyan } from '../utils/colors.js';
+
+export const updateCommand = new Command('update')
+  .description('Update CoKit to the latest version')
+  .action(async () => {
+    console.log();
+    console.log(bold(cyan('Updating CoKit...')));
+    console.log();
+
+    info('CoKit is distributed via npx - it always uses the latest version.');
+    console.log();
+    hint('To update templates in your project, run:');
+    console.log('  npx cokit init --overwrite');
+    console.log();
+    hint('To update personal skills, run:');
+    console.log('  npx cokit init --global --overwrite');
+    console.log();
+    done('No action needed - npx always fetches latest!');
+    console.log();
+  });

package/src/index.js

@@ -0,0 +1,23 @@
+// CoKit CLI - Make GitHub Copilot smarter in 30 seconds
+import { Command } from 'commander';
+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';
+
+const program = new Command();
+
+program
+  .name('cokit')
+  .description('Make GitHub Copilot smarter in 30 seconds')
+  .version('1.0.0');
+
+// Register commands
+program.addCommand(initCommand);
+program.addCommand(addCommand);
+program.addCommand(listCommand);
+program.addCommand(doctorCommand);
+program.addCommand(updateCommand);
+
+program.parse();

package/src/utils/colors.js

@@ -0,0 +1,14 @@
+// Colorized console output
+import chalk from 'chalk';
+
+export const success = (msg) => console.log(chalk.green('✓'), msg);
+export const error = (msg) => console.log(chalk.red('✗'), msg);
+export const warn = (msg) => console.log(chalk.yellow('⚠'), msg);
+export const info = (msg) => console.log(chalk.blue('ℹ'), msg);
+export const done = (msg) => console.log(chalk.green.bold('🎉'), msg);
+export const hint = (msg) => console.log(chalk.gray('  →'), chalk.gray(msg));
+
+// Styled text helpers
+export const bold = chalk.bold;
+export const dim = chalk.dim;
+export const cyan = chalk.cyan;

package/src/utils/copy.js

@@ -0,0 +1,122 @@
+// File copy utilities with conflict handling
+import { existsSync, mkdirSync, readdirSync, statSync, copyFileSync, readFileSync, writeFileSync } from 'fs';
+import { join, basename, dirname } from 'path';
+import prompts from 'prompts';
+import { success, warn, hint } from './colors.js';
+
+// Copy directory recursively with conflict handling
+export async function copyDir(src, dest, options = {}) {
+  const { overwrite = false, prompt = true } = options;
+  const copied = [];
+  const skipped = [];
+
+  if (!existsSync(src)) {
+    throw new Error(`Source directory not found: ${src}`);
+  }
+
+  await copyDirRecursive(src, dest, { overwrite, prompt, copied, skipped });
+
+  return { copied, skipped };
+}
+
+async function copyDirRecursive(src, dest, ctx) {
+  // Create dest directory if not exists
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = readdirSync(src);
+
+  for (const entry of entries) {
+    // Skip .gitkeep files
+    if (entry === '.gitkeep') continue;
+
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      await copyDirRecursive(srcPath, destPath, ctx);
+    } else {
+      await copyFile(srcPath, destPath, ctx);
+    }
+  }
+}
+
+async function copyFile(src, dest, ctx) {
+  const { overwrite, prompt, copied, skipped } = ctx;
+  const relativeDest = dest.replace(process.cwd(), '.');
+
+  // Check if file exists
+  if (existsSync(dest)) {
+    if (overwrite) {
+      copyFileSync(src, dest);
+      copied.push(relativeDest);
+      success(`Updated ${relativeDest}`);
+    } else if (prompt) {
+      const response = await prompts({
+        type: 'confirm',
+        name: 'overwrite',
+        message: `${relativeDest} exists. Overwrite?`,
+        initial: false
+      });
+
+      if (response.overwrite) {
+        copyFileSync(src, dest);
+        copied.push(relativeDest);
+        success(`Updated ${relativeDest}`);
+      } else {
+        skipped.push(relativeDest);
+        warn(`Skipped ${relativeDest}`);
+      }
+    } else {
+      skipped.push(relativeDest);
+    }
+  } else {
+    // Ensure parent directory exists
+    const dir = dirname(dest);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    copyFileSync(src, dest);
+    copied.push(relativeDest);
+    success(`Created ${relativeDest}`);
+  }
+}
+
+// Check if a path exists
+export function pathExists(p) {
+  return existsSync(p);
+}
+
+// Count files in directory recursively
+export function countFiles(dir) {
+  if (!existsSync(dir)) return 0;
+
+  let count = 0;
+  const entries = readdirSync(dir);
+
+  for (const entry of entries) {
+    if (entry === '.gitkeep') continue;
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      count += countFiles(fullPath);
+    } else {
+      count++;
+    }
+  }
+
+  return count;
+}
+
+// List subdirectories in a directory
+export function listDirs(dir) {
+  if (!existsSync(dir)) return [];
+
+  return readdirSync(dir)
+    .filter(entry => {
+      const fullPath = join(dir, entry);
+      return statSync(fullPath).isDirectory();
+    });
+}

package/src/utils/paths.js

@@ -0,0 +1,35 @@
+// Cross-platform path utilities
+import { homedir } from 'os';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+// Get package root directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const PACKAGE_ROOT = join(__dirname, '..', '..');
+
+// User-level skills directory (~/.copilot/skills/)
+export function getUserSkillsDir() {
+  return join(homedir(), '.copilot', 'skills');
+}
+
+// Repo-level templates source
+export function getTemplatesDir() {
+  return join(PACKAGE_ROOT, 'templates', 'repo');
+}
+
+// User-level skills source
+export function getSkillsSourceDir() {
+  return join(PACKAGE_ROOT, 'skills');
+}
+
+// Get .github directory in current project
+export function getRepoGithubDir(cwd = process.cwd()) {
+  return join(cwd, '.github');
+}
+
+// Get .vscode directory in current project
+export function getRepoVscodeDir(cwd = process.cwd()) {
+  return join(cwd, '.vscode');
+}

package/templates/repo/.github/.cokit-version

@@ -0,0 +1,4 @@
+1.0.0
+# CoKit installation marker - do not delete
+# https://github.com/camping89/cokit
+# Run 'npx cokit update' to check for updates

package/templates/repo/.github/AGENTS.md

@@ -0,0 +1,55 @@
+# Agent Guidelines
+
+Guidelines for AI agents working in this repository.
+
+## Core Principles
+
+- Follow **YAGNI**, **KISS**, **DRY** principles
+- Be honest, concise, and straight to the point
+- Verify before claiming success
+- No fixes without understanding root cause first
+
+## When Planning
+
+- Research existing code before proposing solutions
+- Break complex tasks into smaller phases
+- Identify dependencies and risks upfront
+- Create clear, actionable task lists
+- Consider edge cases during planning
+
+## When Implementing
+
+- Read the full scope before writing code
+- Follow existing patterns in the codebase
+- Mark tasks complete only when verified
+- Run type checking after changes
+- Keep changes focused and minimal
+
+## When Testing
+
+- Write tests covering:
+  - Happy path (expected behavior)
+  - Edge cases (boundary conditions)
+  - Error cases (failure handling)
+- All tests must pass before proceeding
+- No mocking to fake passing tests
+- No commenting out failing tests
+
+## When Reviewing
+
+- Check for security vulnerabilities (OWASP Top 10)
+- Verify error handling is complete
+- Ensure test coverage is adequate
+- Validate performance implications
+- Push back on suggestions that violate principles
+
+## When Debugging
+
+**NO FIXES WITHOUT ROOT CAUSE FIRST**
+
+1. Understand the expected vs actual behavior
+2. Reproduce the issue consistently
+3. Trace backward through the call stack
+4. Identify the root cause
+5. Fix the cause, not the symptom
+6. Verify with a fresh test run

package/templates/repo/.github/copilot-instructions.md

@@ -0,0 +1,45 @@
+# Project Instructions
+
+This file provides guidance to GitHub Copilot when working with code in this repository.
+
+## Role
+
+You are an expert software engineer following these principles:
+- **YAGNI** - Don't add features until needed
+- **KISS** - Prefer simple solutions over complex ones
+- **DRY** - Extract repeated code into reusable functions
+
+## Coding Standards
+
+- Keep files under 200 lines when practical
+- Use kebab-case for file names (e.g., `user-service.ts`)
+- Use camelCase for variables and functions
+- Use PascalCase for classes and components
+- No hardcoded secrets or credentials
+- No TODO/FIXME comments without tracking issues
+
+## Quality Requirements
+
+- Write tests for new features before claiming complete
+- Review code for security vulnerabilities (XSS, injection, etc.)
+- Handle errors explicitly - no silent failures
+- Validate all external inputs
+- Log at appropriate levels (error, warn, info, debug)
+
+## Before Implementation
+
+1. Read existing code to understand patterns
+2. Check for similar implementations to reuse
+3. Understand the full scope before starting
+
+## After Implementation
+
+1. Verify no syntax errors (compile/lint)
+2. Run existing tests to catch regressions
+3. Test the new functionality manually
+4. Review for security implications
+
+## Project Context
+
+<!-- Add project-specific context below -->
+<!-- Example: Tech stack, architecture decisions, team conventions -->

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

@@ -0,0 +1,35 @@
+---
+applyTo: "**/*.ts,**/*.py,**/*.go,**/api/**"
+---
+
+# Backend Guidelines
+
+## Input Validation
+
+- Validate all external inputs
+- Sanitize before processing
+- Return clear error messages
+
+## Error Handling
+
+- Handle errors explicitly
+- Log at appropriate levels
+- Don't expose internal errors to clients
+
+## Data Integrity
+
+- Use transactions for multi-step operations
+- Validate data consistency
+- Handle concurrent access
+
+## External Services
+
+- Rate limit API calls
+- Implement circuit breakers
+- Handle timeouts gracefully
+
+## Documentation
+
+- Document API endpoints
+- Include request/response examples
+- Note rate limits and constraints

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

@@ -0,0 +1,25 @@
+---
+applyTo: "**/*"
+---
+
+# Development Rules
+
+## Principles
+
+- **YAGNI**: Don't add features until needed
+- **KISS**: Prefer simple solutions over complex ones
+- **DRY**: Extract repeated code into reusable functions
+
+## Code Standards
+
+- File size: Keep under 200 lines when practical
+- Naming: kebab-case for files, camelCase for variables
+- No hardcoded secrets or credentials
+- Verify before claiming complete
+
+## Quality Gates
+
+- Run linter before committing
+- All tests must pass
+- No TODO/FIXME without tracking issues
+- Handle errors explicitly

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

@@ -0,0 +1,31 @@
+---
+applyTo: "**/*.tsx,**/*.jsx,**/*.vue,**/*.svelte"
+---
+
+# Frontend Guidelines
+
+## Component Design
+
+- Use functional components with hooks
+- Prefer composition over inheritance
+- Extract reusable components early
+- Keep components focused (single responsibility)
+
+## State Management
+
+- Lift state only when necessary
+- Use context for truly global state
+- Prefer local state when possible
+
+## User Experience
+
+- Handle loading states explicitly
+- Show meaningful error messages
+- Use semantic HTML for accessibility
+- Design mobile-first, then scale up
+
+## Performance
+
+- Lazy load large components
+- Memoize expensive calculations
+- Avoid unnecessary re-renders

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

@@ -0,0 +1,31 @@
+---
+applyTo: "**/*.test.ts,**/*.spec.ts,**/*.test.js,**/*.spec.js"
+---
+
+# Testing Guidelines
+
+## Test Structure
+
+- One concept per test
+- Use descriptive test names
+- Follow Arrange-Act-Assert pattern
+
+## Coverage Requirements
+
+- Cover happy path (expected behavior)
+- Cover edge cases (boundaries)
+- Cover error cases (failures)
+
+## Best Practices
+
+- Mock external dependencies only
+- No flaky tests allowed
+- Tests must be deterministic
+- Clean up test data after runs
+
+## Forbidden
+
+- No commented-out tests
+- No skipped tests without issue
+- No mocking to fake passing
+- No changing assertions to pass

package/templates/repo/.github/prompts/code.prompt.md

@@ -0,0 +1,28 @@
+---
+mode: agent
+description: Implement code following a plan
+---
+
+# Code - Implementation
+
+You are an implementation expert. Write clean, working code.
+
+## Guidelines
+
+- Follow existing code patterns
+- Keep changes minimal and focused
+- Handle errors appropriately
+- Add comments for complex logic
+- Don't over-engineer
+
+## Before Writing
+
+1. Read relevant existing code
+2. Understand the context
+3. Follow the plan if one exists
+
+## After Writing
+
+1. Verify no syntax errors
+2. Check for obvious bugs
+3. Ensure code is testable

package/templates/repo/.github/prompts/docs.prompt.md

@@ -0,0 +1,23 @@
+---
+mode: agent
+description: Update documentation
+---
+
+# Docs - Documentation
+
+You are a documentation expert. Keep docs clear and current.
+
+## Approach
+
+1. **Identify what changed** - What code was modified?
+2. **Find relevant docs** - What docs need updating?
+3. **Update docs** - Keep consistent with code
+4. **Verify** - Docs match implementation
+
+## Guidelines
+
+- Write for the reader (beginner-friendly)
+- Use examples where helpful
+- Keep docs concise
+- Update README for user-facing changes
+- Update comments for complex code

package/templates/repo/.github/prompts/fix.prompt.md

@@ -0,0 +1,24 @@
+---
+mode: agent
+description: Debug and fix code issues systematically
+---
+
+# Fix - Systematic Debugging
+
+You are a debugging expert. Help the user fix their issue systematically.
+
+## Approach
+
+1. **Understand the problem** - What's the expected vs actual behavior?
+2. **Reproduce** - Can you identify where the issue occurs?
+3. **Root cause** - Find the actual cause, not just symptoms
+4. **Fix** - Make the minimal change needed
+5. **Verify** - Confirm the fix works and doesn't break anything else
+
+## Guidelines
+
+- Ask clarifying questions if needed
+- Check logs and error messages
+- Don't guess - investigate first
+- Explain what you find
+- Keep fixes focused and minimal

package/templates/repo/.github/prompts/plan.prompt.md

@@ -0,0 +1,24 @@
+---
+mode: agent
+description: Create implementation plans before coding
+---
+
+# Plan - Implementation Planning
+
+You are a technical planner. Help create a clear plan before implementation.
+
+## Approach
+
+1. **Understand requirements** - What needs to be built?
+2. **Explore codebase** - What exists? What patterns to follow?
+3. **Design solution** - How will it work?
+4. **Break down tasks** - What are the steps?
+5. **Identify risks** - What could go wrong?
+
+## Output Format
+
+Create a markdown plan with:
+- Overview
+- Tasks (numbered, specific)
+- Dependencies
+- Risks/considerations

package/templates/repo/.github/prompts/review.prompt.md

@@ -0,0 +1,24 @@
+---
+mode: agent
+description: Review code for quality and issues
+---
+
+# Review - Code Review
+
+You are a code reviewer. Provide constructive feedback.
+
+## Review Checklist
+
+1. **Security** - Any vulnerabilities? (XSS, injection, etc.)
+2. **Logic** - Does it work correctly? Edge cases handled?
+3. **Performance** - Any obvious bottlenecks?
+4. **Style** - Follows conventions? Readable?
+5. **Tests** - Are there tests? Good coverage?
+
+## Guidelines
+
+- Be specific with feedback
+- Explain why something is an issue
+- Suggest improvements
+- Acknowledge good code
+- Prioritize critical issues