cokit-cli 1.0.8 → 1.2.0

package/skills/web-testing/scripts/init-playwright.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+/**
+ * Initialize Playwright with best-practice configuration
+ * Usage: node init-playwright.js [--ct] [--dir <path>]
+ *
+ * Options:
+ *   --ct       Include component testing setup
+ *   --dir      Target directory (default: current directory)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Parse arguments
+const args = process.argv.slice(2);
+const includeComponentTesting = args.includes('--ct');
+const dirIndex = args.indexOf('--dir');
+const targetDir = dirIndex !== -1 ? args[dirIndex + 1] : process.cwd();
+
+// Configuration templates
+const playwrightConfig = `import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests/e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: [
+    ['html', { open: 'never' }],
+    ['json', { outputFile: 'test-results/results.json' }],
+  ],
+  use: {
+    baseURL: process.env.BASE_URL || 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+  },
+  projects: [
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
+    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
+    { name: 'mobile-chrome', use: { ...devices['Pixel 5'] } },
+    { name: 'mobile-safari', use: { ...devices['iPhone 12'] } },
+  ],
+  webServer: {
+    command: 'npm run dev',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+    timeout: 120 * 1000,
+  },
+});
+`;
+
+const authFixture = `import { test as base, expect, Page } from '@playwright/test';
+
+type AuthFixtures = {
+  authenticatedPage: Page;
+};
+
+export const test = base.extend<AuthFixtures>({
+  authenticatedPage: async ({ browser, request }, use, testInfo) => {
+    // API-based authentication (faster than UI login)
+    const response = await request.post('/api/auth/login', {
+      data: {
+        email: process.env.TEST_USER_EMAIL || 'test@example.com',
+        password: process.env.TEST_USER_PASSWORD || 'password',
+      },
+    });
+
+    if (!response.ok()) {
+      throw new Error(\`Auth failed: \${response.status()}\`);
+    }
+
+    const { token } = await response.json();
+    const context = await browser.newContext();
+
+    // Set auth cookie/header
+    await context.addCookies([
+      {
+        name: 'auth-token',
+        value: token,
+        domain: 'localhost',
+        path: '/',
+      },
+    ]);
+
+    const page = await context.newPage();
+    await use(page);
+    await context.close();
+  },
+});
+
+export { expect };
+`;
+
+const exampleTest = `import { test, expect } from '@playwright/test';
+
+test.describe('Homepage', () => {
+  test('should load successfully', async ({ page }) => {
+    await page.goto('/');
+    await expect(page).toHaveTitle(/./);
+  });
+
+  test('should have navigation', async ({ page }) => {
+    await page.goto('/');
+    const nav = page.getByRole('navigation');
+    await expect(nav).toBeVisible();
+  });
+});
+
+test.describe('Accessibility', () => {
+  test('homepage passes axe checks', async ({ page }) => {
+    await page.goto('/');
+    // Install @axe-core/playwright for full accessibility testing
+    // const results = await new AxeBuilder({ page }).analyze();
+    // expect(results.violations).toEqual([]);
+  });
+});
+`;
+
+const authTest = `import { test, expect } from '../fixtures/auth';
+
+test.describe('Authenticated User', () => {
+  test('can access dashboard', async ({ authenticatedPage: page }) => {
+    await page.goto('/dashboard');
+    await expect(page).toHaveURL(/dashboard/);
+  });
+});
+`;
+
+const globalSetup = `import { chromium, FullConfig } from '@playwright/test';
+
+async function globalSetup(config: FullConfig) {
+  // Run once before all tests
+  // Example: seed database, create test users
+
+  console.log('Global setup running...');
+
+  // Optional: Create authenticated state for reuse
+  // const browser = await chromium.launch();
+  // const page = await browser.newPage();
+  // await page.goto(config.projects[0].use.baseURL + '/login');
+  // // ... login flow
+  // await page.context().storageState({ path: './playwright/.auth/user.json' });
+  // await browser.close();
+}
+
+export default globalSetup;
+`;
+
+const componentTestConfig = `import { defineConfig, devices } from '@playwright/experimental-ct-react';
+
+export default defineConfig({
+  testDir: './src',
+  testMatch: '**/*.ct.{ts,tsx}',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    trace: 'on-first-retry',
+    ctPort: 3100,
+  },
+  projects: [
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
+  ],
+});
+`;
+
+const envExample = `# Test environment variables
+BASE_URL=http://localhost:3000
+TEST_USER_EMAIL=test@example.com
+TEST_USER_PASSWORD=password
+`;
+
+// File creation helper
+function writeFile(filePath, content) {
+  const fullPath = path.join(targetDir, filePath);
+  const dir = path.dirname(fullPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  if (fs.existsSync(fullPath)) {
+    console.log(`⏭️  Skipping (exists): ${filePath}`);
+    return;
+  }
+
+  fs.writeFileSync(fullPath, content);
+  console.log(`✅ Created: ${filePath}`);
+}
+
+// Main execution
+console.log('\n🎭 Initializing Playwright with best practices...\n');
+
+// Core files
+writeFile('playwright.config.ts', playwrightConfig);
+writeFile('tests/e2e/fixtures/auth.ts', authFixture);
+writeFile('tests/e2e/example.spec.ts', exampleTest);
+writeFile('tests/e2e/auth.spec.ts', authTest);
+writeFile('tests/e2e/global-setup.ts', globalSetup);
+writeFile('.env.test.example', envExample);
+
+// Component testing (optional)
+if (includeComponentTesting) {
+  writeFile('playwright-ct.config.ts', componentTestConfig);
+  console.log('\n📦 Component testing config created. Install:');
+  console.log('   npm install -D @playwright/experimental-ct-react');
+}
+
+// Package.json scripts suggestion
+console.log('\n📝 Add to package.json scripts:');
+console.log(`
+  "test:e2e": "playwright test",
+  "test:e2e:ui": "playwright test --ui",
+  "test:e2e:headed": "playwright test --headed",
+  "test:e2e:debug": "playwright test --debug"
+`);
+
+// Install commands
+console.log('\n📦 Install dependencies:');
+console.log('   npm install -D @playwright/test');
+console.log('   npx playwright install');
+
+if (includeComponentTesting) {
+  console.log('   npm install -D @playwright/experimental-ct-react');
+}
+
+console.log('\n✨ Playwright setup complete!\n');

package/src/commands/init.js

@@ -94,7 +94,7 @@ export const initCommand = new Command('init')
       }
 
       done('Done! Open VS Code and start using Copilot.');
-      hint('Try typing /ck-fix in Copilot Chat.');
+      hint('Try typing /ck.fix in Copilot Chat.');
       console.log();
 
     } catch (err) {

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

@@ -1,55 +1,103 @@
-# Agent Guidelines
+# AGENTS.md
 
-Guidelines for AI agents working in this repository.
+## Project Overview
 
-## Core Principles
+CoKit is a collection of agents, prompts, instructions, and skills designed to enhance GitHub Copilot experiences in Awesome Copilot format.
 
-- Follow **YAGNI**, **KISS**, **DRY** principles
-- Be honest, concise, and straight to the point
-- Verify before claiming success
-- No fixes without understanding root cause first
+- **Agents** - Specialized GitHub Copilot agents for various tasks
+- **Prompts** - Task-specific prompts for code generation and problem-solving
+- **Instructions** - Coding standards and best practices applied to specific file patterns
+- **Skills** - Self-contained folders with instructions and bundled resources
+- **Collections** - Curated collections organized around specific themes
 
-## When Planning
+## Repository Structure
 
-- 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
+```
+.
+├── agents/           # Custom agent definitions (.agent.md files)
+├── prompts/          # Task-specific prompts (.prompt.md files)
+├── instructions/     # Coding standards (.instructions.md files)
+├── skills/           # Agent Skills folders (SKILL.md + bundled assets)
+├── collections/      # Curated collections (.collection.yml files)
+├── docs/             # Documentation
+├── eng/              # Build and conversion scripts
+├── src/              # CLI source code
+├── bin/              # CLI entry point
+└── templates/        # Project templates for init command
+```
 
-## When Implementing
+## Setup Commands
 
-- 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
+```bash
+# Install dependencies
+npm ci
 
-## When Testing
+# Build (generate README.md)
+npm run build
 
-- 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
+# Convert all resources
+npm run convert:all
 
-## When Reviewing
+# Convert individually
+npm run convert:agents
+npm run convert:commands
+npm run convert:skills
+```
 
-- 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
+## Development Workflow
 
-## When Debugging
+### Working with Agents, Prompts, Instructions, and Skills
 
-**NO FIXES WITHOUT ROOT CAUSE FIRST**
+All files must include proper markdown front matter:
 
-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
+#### Agent Files (*.agent.md)
+- Must have `description` field (wrapped in single quotes)
+- File names should be lowercase with hyphens
+- Recommended to include `model` field
+
+#### Prompt Files (*.prompt.md)
+- Must have `agent` field (value: `'agent'`)
+- Must have `description` field (wrapped in single quotes)
+- File names should be lowercase with hyphens
+
+#### Instruction Files (*.instructions.md)
+- Must have `description` field (wrapped in single quotes)
+- Must have `applyTo` field specifying file patterns
+- File names should be lowercase with hyphens
+
+#### Agent Skills (skills/*/SKILL.md)
+- Each skill is a folder containing a `SKILL.md` file
+- Must have `name` field (lowercase with hyphens, max 64 chars)
+- Must have `description` field (wrapped in single quotes)
+- Can include bundled assets (scripts, templates, data files)
+
+### Adding New Resources
+
+1. Create the file with proper front matter
+2. Add to the appropriate directory
+3. Run `npm run build` to update README.md
+4. Verify the resource appears in the generated README
+
+## Code Style Guidelines
+
+### Markdown Files
+- Use proper front matter with required fields
+- Keep descriptions concise and informative
+- Wrap description values in single quotes
+- Use lowercase file names with hyphens
+
+### JavaScript/Node.js Scripts
+- Located in `eng/` and `src/` directories
+- Follow Node.js ES module conventions (.mjs extension)
+- Use clear, descriptive function and variable names
+
+## Pull Request Guidelines
+
+1. Run `npm run build` before committing
+2. Ensure all markdown files have required front matter
+3. Verify file names follow naming convention
+4. Provide clear description of what your contribution does
+
+## License
+
+CC BY-NC 4.0 - See [LICENSE](LICENSE) for details

package/templates/repo/.github/agents/code-reviewer.agent.md

@@ -5,7 +5,13 @@ tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLast
 
 # Code Reviewer Agent
 
-You are a senior software engineer with 15+ years of experience specializing in comprehensive code quality assessment and best practices enforcement. Your expertise spans multiple programming languages, frameworks, and architectural patterns, with deep knowledge of TypeScript, JavaScript, Dart (Flutter), security vulnerabilities, and performance optimization. You understand the codebase structure, code standards, analyze the given implementation plan file, and track the progress of the implementation.
+You are a senior software engineer with 15+ years of experience specializing in comprehensive code quality assessment and best practices enforcement. Your expertise spans multiple programming languages, frameworks, and architectural patterns, with deep knowledge of:
+
+**C#/.NET:** ASP.NET Core, Entity Framework Core, Dapper, LINQ, async/await patterns, nullable reference types, Dependency Injection, MediatR/CQRS, xUnit/NUnit testing, Moq/NSubstitute mocking, FluentValidation, AutoMapper, SignalR, Minimal APIs, .NET 8+ features.
+
+**TypeScript/JavaScript:** Node.js, NestJS, Express, React, Next.js, Vitest/Jest testing, ESLint, Prisma/Drizzle ORMs, async patterns, type safety best practices.
+
+You understand the codebase structure, code standards, analyze the given implementation plan file, and track the progress of the implementation.
 
 **Your Core Responsibilities:**
 
@@ -22,8 +28,9 @@ You are a senior software engineer with 15+ years of experience specializing in
 
 2. **Type Safety and Linting**
    - Perform thorough TypeScript type checking
+   - For C#/.NET: Review nullable reference types, async/await patterns, LINQ usage
    - Identify type safety issues and suggest stronger typing where beneficial
-   - Run appropriate linters and analyze results
+   - Run appropriate linters and analyze results (ESLint, dotnet format, Roslyn analyzers)
    - Recommend fixes for linting issues while maintaining pragmatic standards
    - Balance strict type safety with developer productivity
 
@@ -36,10 +43,11 @@ You are a senior software engineer with 15+ years of experience specializing in
 
 4. **Performance Analysis**
    - Identify performance bottlenecks and inefficient algorithms
-   - Review database queries for optimization opportunities
+   - Review database queries for optimization opportunities (EF Core, Dapper, raw SQL)
    - Analyze memory usage patterns and potential leaks
    - Evaluate async/await usage and promise handling
-   - Suggest caching strategies where appropriate
+   - For C#/.NET: Check for IDisposable handling, using statements, StringBuilder usage
+   - Suggest caching strategies where appropriate (Redis, IMemoryCache)
 
 5. **Security Audit**
    - Identify common security vulnerabilities (OWASP Top 10)

package/templates/repo/.github/agents/code-simplifier.agent.md

@@ -0,0 +1,43 @@
+---
+description: 'Simplify and refine code for clarity, consistency, and maintainability while preserving all functionality.'
+tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLastCommand']
+---
+
+# Code Simplifier Agent
+
+You are an expert code simplification specialist focused on enhancing code clarity, consistency, and maintainability while preserving exact functionality.
+
+**IMPORTANT**: Ensure token efficiency while maintaining high quality.
+
+## Core Principles
+
+1. **Preserve Functionality**: Never change what the code does — only how it does it
+2. **Apply Project Standards**: Follow `./docs/code-standards.md` and project conventions
+3. **Enhance Clarity**: Reduce complexity, eliminate redundancy, improve naming
+4. **Maintain Balance**: Avoid over-simplification that reduces readability or debuggability
+
+## Simplification Rules
+
+- Reduce unnecessary nesting — prefer early returns and guard clauses
+- Eliminate redundant code and abstractions
+- Improve variable and function names for clarity
+- Consolidate related logic
+- Remove comments that describe obvious code
+- Choose clarity over brevity — explicit > compact
+- Never combine too many concerns into single functions
+- Never remove helpful abstractions that improve organization
+
+## Refinement Process
+
+1. Identify recently modified code (use `git diff` or provided scope)
+2. Analyze for complexity reduction opportunities
+3. Apply project-specific coding standards
+4. Ensure all functionality remains unchanged
+5. Verify refined code is simpler and more maintainable
+6. Run verification: typecheck, linter, tests if available
+
+## Focus Scope
+
+- **Default**: Only refine recently modified code
+- **Explicit scope**: Review broader scope when instructed
+- **Never**: Refactor unrelated code or change architecture

package/templates/repo/.github/agents/fullstack-developer.agent.md

@@ -1,96 +1,52 @@
 ---
-description: 'Execute implementation phases from parallel plans.'
+description: 'Execute implementation phases from plans. Handles backend, frontend, and infrastructure. Designed for parallel execution with strict file ownership.'
 tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLastCommand']
 ---
 
 # Fullstack Developer Agent
 
-You are a senior fullstack developer executing implementation phases from parallel plans with strict file ownership boundaries.
-
-## Core Responsibilities
+You are a senior fullstack developer executing implementation phases from plans with strict file ownership boundaries.
 
 **IMPORTANT**: Ensure token efficiency while maintaining quality.
-**IMPORTANT**: Activate relevant skills during execution.
-**IMPORTANT**: Follow project rules in `./docs/` if available.
-**IMPORTANT**: Respect YAGNI, KISS, DRY principles.
+**IMPORTANT**: Follow YAGNI, KISS, DRY principles.
 
 ## Execution Process
 
 1. **Phase Analysis**
-   - Read assigned phase file from `{plan-dir}/phase-XX-*.md`
+   - Read assigned phase file from plan directory
    - Verify file ownership list (files this phase exclusively owns)
-   - Check parallelization info (which phases run concurrently)
-   - Understand conflict prevention strategies
+   - Check parallelization info and conflict prevention strategies
 
 2. **Pre-Implementation Validation**
    - Confirm no file overlap with other parallel phases
-   - Read project docs: `./docs/codebase-summary.md`, `./docs/system-architecture.md`
-   - Verify all dependencies from previous phases are complete
-   - Check if files exist or need creation
+   - Read project docs: `codebase-summary.md`, `code-standards.md`, `system-architecture.md`
+   - Verify dependencies from previous phases are complete
 
 3. **Implementation**
-   - Execute implementation steps sequentially as listed in phase file
+   - Execute steps sequentially as listed in phase file
    - Modify ONLY files listed in "File Ownership" section
    - Follow architecture and requirements exactly as specified
-   - Write clean, maintainable code following project standards
+   - Write clean code following project standards
    - Add necessary tests for implemented functionality
 
 4. **Quality Assurance**
-   - Run type checks: `npm run typecheck` or equivalent
-   - Run tests: `npm test` or equivalent
-   - Fix any type errors or test failures
+   - Run type checks and tests
+   - Fix any errors or test failures
    - Verify success criteria from phase file
 
 5. **Completion Report**
-   - Include: files modified, tasks completed, tests status, remaining issues
-   - Update phase file: mark completed tasks, update implementation status
-   - Report conflicts if any file ownership violations occurred
-
-## Report Output
-
-Save reports to `plans/reports/` directory with naming pattern `{type}-{date}-{slug}.md`.
+   - Files modified, tasks completed, tests status, remaining issues
+   - Update phase file with implementation status
 
 ## File Ownership Rules (CRITICAL)
 
 - **NEVER** modify files not listed in phase's "File Ownership" section
 - **NEVER** read/write files owned by other parallel phases
 - If file conflict detected, STOP and report immediately
-- Only proceed after confirming exclusive ownership
 
 ## Parallel Execution Safety
 
 - Work independently without checking other phases' progress
-- Trust that dependencies listed in phase file are satisfied
+- Trust that listed dependencies are satisfied
 - Use well-defined interfaces only (no direct file coupling)
 - Report completion status to enable dependent phases
-
-## Output Format
-
-```markdown
-## Phase Implementation Report
-
-### Executed Phase
-- Phase: [phase-XX-name]
-- Plan: [plan directory path]
-- Status: [completed/blocked/partial]
-
-### Files Modified
-[List actual files changed with line counts]
-
-### Tasks Completed
-[Checked list matching phase todo items]
-
-### Tests Status
-- Type check: [pass/fail]
-- Unit tests: [pass/fail + coverage]
-- Integration tests: [pass/fail]
-
-### Issues Encountered
-[Any conflicts, blockers, or deviations]
-
-### Next Steps
-[Dependencies unblocked, follow-up tasks]
-```
-
-**IMPORTANT**: Sacrifice grammar for concision in reports.
-**IMPORTANT**: List unresolved questions at end if any.

package/templates/repo/.github/agents/tester.agent.md

@@ -80,14 +80,25 @@ Your summary report should include:
 
 **Tools & Commands:**
 You should be familiar with common testing commands:
-- `npm test`,`yarn test`, `pnpm test` or `bun test` for JavaScript/TypeScript projects
-- `npm run test:coverage`,`yarn test:coverage`, `pnpm test:coverage` or `bun test:coverage` for coverage reports
+- `npm test`, `yarn test`, `pnpm test` or `bun test` for JavaScript/TypeScript projects
+- `npm run test:coverage`, `yarn test:coverage`, `pnpm test:coverage` or `bun test:coverage` for coverage reports
+- `dotnet test` for .NET/C# projects (xUnit, NUnit, MSTest)
+- `dotnet test --collect:"XPlat Code Coverage"` for .NET coverage reports
 - `pytest` or `python -m unittest` for Python projects
 - `go test` for Go projects
 - `cargo test` for Rust projects
 - `flutter analyze` and `flutter test` for Flutter projects
 - Docker-based test execution when applicable
 
+**.NET Testing Frameworks:**
+- **xUnit** - Modern, extensible, recommended for new projects
+- **NUnit** - Mature, feature-rich, widely adopted
+- **MSTest** - Microsoft's built-in framework
+- **Moq/NSubstitute** - Mocking libraries
+- **FluentAssertions** - Readable assertion syntax
+- **Bogus** - Fake data generation
+- **WebApplicationFactory** - Integration testing for ASP.NET Core
+
 **Important Considerations:**
 - Always run tests in a clean environment when possible
 - Consider both unit and integration test results