cp-toolkit 3.0.1 → 3.1.0

package/bin/cp-toolkit.js

@@ -46,6 +46,7 @@ program
   .description('Initialize cp-kit in a directory (creates .github/ structure)')
   .option('-y, --yes', 'Skip prompts and use defaults')
   .option('-f, --force', 'Overwrite existing configuration')
+  .option('-g, --global', 'Install instructions globally to VS Code User Prompts directory')
   .action(initCommand);
 
 // cp-kit add <type> <name>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cp-toolkit",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "Copilot Toolkit - Native AI Agents & Skills for GitHub Copilot (v2026)",
   "keywords": [
     "ai-agents",

package/src/commands/init.js

@@ -11,6 +11,7 @@
 
 import fs from 'fs-extra';
 import path from 'path';
+import os from 'os';
 import chalk from 'chalk';
 import ora from 'ora';
 import prompts from 'prompts';
@@ -20,10 +21,89 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+function getGlobalPromptsDir() {
+  const platform = os.platform();
+  const homeDir = os.homedir();
+  
+  if (platform === 'win32') {
+    return path.join(process.env.APPDATA, 'Code', 'User', 'prompts');
+  } else if (platform === 'darwin') {
+    return path.join(homeDir, 'Library', 'Application Support', 'Code', 'User', 'prompts');
+  } else {
+    // Linux and others
+    return path.join(homeDir, '.config', 'Code', 'User', 'prompts');
+  }
+}
+
+async function initGlobal(options, templatesDir) {
+  const targetDir = getGlobalPromptsDir();
+  console.log(chalk.bold.cyan('\n🌍 cp-toolkit - Installing Global Instructions\n'));
+  console.log(chalk.dim(`Target directory: ${targetDir}`));
+
+  if (!options.yes) {
+     const { confirm } = await prompts({
+      type: 'confirm',
+      name: 'confirm',
+      message: `Install instructions globally to VS Code User Data?`,
+      initial: true
+    });
+    if (!confirm) return;
+  }
+
+  const spinner = ora('Installing global instructions...').start();
+  
+  try {
+    // Check if Code/User exists (VS Code installed?)
+    if (!fs.existsSync(path.dirname(targetDir))) {
+      spinner.warn(chalk.yellow('VS Code User directory not found. Is VS Code installed?'));
+      const { create } = await prompts({
+        type: 'confirm',
+        name: 'create',
+        message: 'Create directory anyway?',
+        initial: true
+      });
+      if (!create) return;
+    }
+
+    await fs.ensureDir(targetDir);
+
+    // Copy instructions
+    // We flatten them: templates/instructions/*.md -> targetDir/*.md
+    const instructionsSourceDir = path.join(templatesDir, 'instructions');
+    const files = await fs.readdir(instructionsSourceDir);
+    
+    let count = 0;
+    for (const file of files) {
+      if (file.endsWith('.md')) {
+        await fs.copy(
+          path.join(instructionsSourceDir, file),
+          path.join(targetDir, file),
+          { overwrite: options.force }
+        );
+        count++;
+      }
+    }
+
+    spinner.succeed(chalk.green(`✨ Installed ${count} global instruction files!`));
+    console.log(chalk.bold('\n🚀 Next Steps:'));
+    console.log(`   1. Instructions are now available in ${chalk.cyan('ALL')} your projects.`);
+    console.log(`   2. Use ${chalk.yellow('Settings Sync')} in VS Code to sync them across machines.`);
+    
+  } catch (error) {
+    spinner.fail(chalk.red('❌ Failed to install global instructions'));
+    console.error(error);
+  }
+}
+
 export async function initCommand(directory, options) {
+  const templatesDir = path.join(__dirname, '../../templates');
+
+  if (options.global) {
+    return initGlobal(options, templatesDir);
+  }
+
   const targetDir = directory ? path.resolve(directory) : process.cwd();
   const dirName = path.basename(targetDir);
-  const templatesDir = path.join(__dirname, '../../templates');
 
   console.log(chalk.bold.cyan('\n🚀 cp-toolkit - GitHub Copilot Agent Toolkit\n'));
 

package/templates/instructions/testing-development.instructions.md

@@ -1,42 +1,49 @@
 ---
 name: testing-development
 description: Guidelines for test structure, frameworks, and code coverage best practices.
-version: 1.0
+version: 2.0
 applyTo: "**/*.test.*,**/*.spec.*,**/tests/**,**/__tests__/**"
 ---
 
 # Testing Development Guidelines
 
-## Test Structure
-- Unit tests for individual functions/classes
-- Integration tests for component interactions
-- End-to-end tests for user workflows
-- Performance tests for critical paths
-- Accessibility tests for UI components
-
-## Testing Frameworks
-- Jest for JavaScript/TypeScript
-- pytest for Python
-- RSpec for Ruby
-- JUnit for Java
-- Appropriate framework per language
-
-## Test Patterns
-- Arrange-Act-Assert (AAA) pattern
-- Descriptive test names (not test1, test2)
-- One assertion per test when possible
-- Mock external dependencies
-- Test edge cases and error conditions
-
-## Code Coverage
-- Aim for 80%+ coverage on critical code
-- Focus on business logic over getters/setters
-- Integration tests for coverage gaps
-- Coverage reports in CI/CD pipeline
-
-## Best Practices
-- Tests run independently (no shared state)
-- Fast execution for developer experience
-- CI/CD integration with quality gates
-- Test data management and cleanup
-- Documentation of test scenarios
+You are an expert in Software Quality Assurance and Test Automation.
+When writing or analyzing tests in this repository, you MUST follow these directives:
+
+## 1. Test Structure & Strategy
+- **Unit Tests**: Isolate individual functions/methods. Mock ALL external dependencies (DB, API, File System).
+- **Integration Tests**: Verify interaction between modules (e.g., API + DB). Use containerized services if possible.
+- **E2E Tests**: Simulate user journeys. Use Playwright/Cypress standards.
+
+## 2. The AAA Pattern (Strict Enforcement)
+Every test case MUST follow the **Arrange-Act-Assert** pattern structure explicitly.
+
+```javascript
+// ✅ CORRECT
+it('should calculate total validation', () => {
+  // Arrange
+  const input = 10;
+  const expected = 20;
+
+  // Act
+  const result = calculate(input);
+
+  // Assert
+  expect(result).toBe(expected);
+});
+```
+
+## 3. Naming Conventions
+- **Files**: `*.test.ts` (Unit), `*.spec.ts` (E2E/Integration).
+- **Descriptions**: Use "should [expected behavior] when [condition]".
+  - ❌ `test('login', ...)`
+  - ✅ `test('should return 401 when token is expired', ...)`
+
+## 4. Mocking & Isolation
+- **No side effects**: Tests must be atomic and order-independent.
+- **State reset**: Use `beforeEach`/`afterEach` to clean up state.
+- **External calls**: NEVER rely on real 3rd party APIs in unit tests.
+
+## 5. Agent Behavior
+- If the user asks to "fix a bug", **ALWAYS** ask to write a reproduction test case first.
+- If code coverage is low, proactively suggest adding missing test cases for edge conditions.