ccjk 14.2.2 → 15.1.0

package/dist/templates/skills/ts-best-practices.md

@@ -1,354 +0,0 @@
----
-name: ts-best-practices
-description: TypeScript 5.3+ best practices and patterns for type-safe development
-description_zh: TypeScript 5.3+ 最佳实践和类型安全开发模式
-version: 1.0.0
-category: programming
-triggers: ['/ts-best-practices', '/typescript', '/ts-patterns']
-use_when:
-  - Writing TypeScript code with strict typing
-  - Implementing generic constraints and utility types
-  - Optimizing TypeScript performance and maintainability
-  - Code review for TypeScript projects
-use_when_zh:
-  - 编写严格类型的 TypeScript 代码
-  - 实现泛型约束和工具类型
-  - 优化 TypeScript 性能和可维护性
-  - TypeScript 项目代码审查
-auto_activate: true
-priority: 8
-agents: [typescript-expert, code-reviewer]
-tags: [typescript, types, generics, patterns, best-practices]
----
-
-# TypeScript Best Practices | TypeScript 最佳实践
-
-## Context | 上下文
-
-Use this skill when working with TypeScript 5.3+ projects that require strict typing, performance optimization, and maintainable code architecture. Essential for enterprise-grade TypeScript development.
-
-在使用 TypeScript 5.3+ 项目时使用此技能，需要严格类型、性能优化和可维护的代码架构。对于企业级 TypeScript 开发至关重要。
-
-## Best Practices | 最佳实践
-
-### 1. Strict Type Configuration | 严格类型配置
-
-```typescript
-// tsconfig.json - Recommended strict settings
-{
-  "compilerOptions": {
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  }
-}
-```
-
-### 2. Generic Constraints | 泛型约束
-
-```typescript
-// ✅ Good: Proper generic constraints
-interface Repository<T extends { id: string }> {
-  findById(id: string): Promise<T | null>;
-  save(entity: T): Promise<T>;
-}
-
-// ✅ Good: Conditional types with constraints
-type ApiResponse<T> = T extends string
-  ? { message: T }
-  : { data: T };
-
-// ❌ Bad: Unconstrained generics
-interface BadRepository<T> {
-  findById(id: string): Promise<T | null>; // T could be anything
-}
-```
-
-### 3. Utility Types Usage | 工具类型使用
-
-```typescript
-// ✅ Good: Leverage built-in utility types
-interface User {
-  id: string;
-  name: string;
-  email: string;
-  password: string;
-}
-
-type PublicUser = Omit<User, 'password'>;
-type UserUpdate = Partial<Pick<User, 'name' | 'email'>>;
-type CreateUser = Omit<User, 'id'>;
-
-// ✅ Good: Custom utility types
-type NonNullable<T> = T extends null | undefined ? never : T;
-type DeepReadonly<T> = {
-  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
-};
-```
-
-### 4. Type Guards and Assertions | 类型守卫和断言
-
-```typescript
-// ✅ Good: Type guards
-function isString(value: unknown): value is string {
-  return typeof value === 'string';
-}
-
-function isUser(obj: unknown): obj is User {
-  return typeof obj === 'object' &&
-         obj !== null &&
-         'id' in obj &&
-         'name' in obj;
-}
-
-// ✅ Good: Assertion functions
-function assertIsNumber(value: unknown): asserts value is number {
-  if (typeof value !== 'number') {
-    throw new Error('Expected number');
-  }
-}
-```
-
-## Common Patterns | 常用模式
-
-### 1. Builder Pattern with Types | 带类型的建造者模式
-
-```typescript
-class QueryBuilder<T> {
-  private conditions: Array<(item: T) => boolean> = [];
-
-  where<K extends keyof T>(
-    key: K,
-    value: T[K]
-  ): QueryBuilder<T> {
-    this.conditions.push(item => item[key] === value);
-    return this;
-  }
-
-  build(): (items: T[]) => T[] {
-    return items => items.filter(item =>
-      this.conditions.every(condition => condition(item))
-    );
-  }
-}
-
-// Usage
-const userFilter = new QueryBuilder<User>()
-  .where('status', 'active')
-  .where('role', 'admin')
-  .build();
-```
-
-### 2. Event System with Type Safety | 类型安全的事件系统
-
-```typescript
-interface EventMap {
-  'user:created': { user: User };
-  'user:updated': { user: User; changes: Partial<User> };
-  'user:deleted': { userId: string };
-}
-
-class TypedEventEmitter<T extends Record<string, any>> {
-  private listeners: {
-    [K in keyof T]?: Array<(data: T[K]) => void>;
-  } = {};
-
-  on<K extends keyof T>(
-    event: K,
-    listener: (data: T[K]) => void
-  ): void {
-    if (!this.listeners[event]) {
-      this.listeners[event] = [];
-    }
-    this.listeners[event]!.push(listener);
-  }
-
-  emit<K extends keyof T>(event: K, data: T[K]): void {
-    this.listeners[event]?.forEach(listener => listener(data));
-  }
-}
-
-// Usage with full type safety
-const emitter = new TypedEventEmitter<EventMap>();
-emitter.on('user:created', ({ user }) => {
-  console.log(`User ${user.name} created`); // ✅ Type-safe
-});
-```
-
-### 3. Branded Types for Domain Safety | 领域安全的品牌类型
-
-```typescript
-// ✅ Good: Branded types prevent mixing different IDs
-type UserId = string & { readonly brand: unique symbol };
-type ProductId = string & { readonly brand: unique symbol };
-
-function createUserId(id: string): UserId {
-  return id as UserId;
-}
-
-function createProductId(id: string): ProductId {
-  return id as ProductId;
-}
-
-function getUser(id: UserId): Promise<User> {
-  // Implementation
-}
-
-// This prevents accidental ID mixing
-const userId = createUserId('user-123');
-const productId = createProductId('product-456');
-
-getUser(userId); // ✅ Works
-getUser(productId); // ❌ Type error - prevents bugs
-```
-
-## Anti-Patterns | 反模式
-
-### 1. Avoid `any` and Type Assertions | 避免 `any` 和类型断言
-
-```typescript
-// ❌ Bad: Using any
-function processData(data: any): any {
-  return data.someProperty;
-}
-
-// ❌ Bad: Unsafe type assertions
-const user = data as User; // Could fail at runtime
-
-// ✅ Good: Proper typing with validation
-function processData<T extends { someProperty: unknown }>(
-  data: T
-): T['someProperty'] {
-  return data.someProperty;
-}
-
-// ✅ Good: Safe type assertions with validation
-function isUser(data: unknown): data is User {
-  return typeof data === 'object' &&
-         data !== null &&
-         'id' in data;
-}
-
-const user = isUser(data) ? data : null;
-```
-
-### 2. Avoid Overly Complex Types | 避免过于复杂的类型
-
-```typescript
-// ❌ Bad: Overly complex type that's hard to understand
-type ComplexType<T> = T extends infer U
-  ? U extends Record<string, any>
-    ? { [K in keyof U]: U[K] extends Function
-        ? ReturnType<U[K]> extends Promise<infer R>
-          ? R extends object
-            ? ComplexType<R>
-            : never
-          : never
-        : never }
-    : never
-  : never;
-
-// ✅ Good: Break down complex types into smaller, named pieces
-type AsyncReturnType<T> = T extends (...args: any[]) => Promise<infer R>
-  ? R
-  : never;
-
-type FunctionProperties<T> = {
-  [K in keyof T]: T[K] extends Function ? T[K] : never;
-};
-
-type ExtractAsyncReturns<T> = {
-  [K in keyof FunctionProperties<T>]: AsyncReturnType<T[K]>;
-};
-```
-
-### 3. Avoid Mutation of Readonly Types | 避免修改只读类型
-
-```typescript
-// ❌ Bad: Mutating readonly arrays
-function badSort(items: readonly number[]): readonly number[] {
-  return items.sort(); // Mutates the original array!
-}
-
-// ✅ Good: Create new arrays for readonly inputs
-function goodSort(items: readonly number[]): readonly number[] {
-  return [...items].sort();
-}
-
-// ✅ Good: Use proper readonly patterns
-interface ReadonlyConfig {
-  readonly apiUrl: string;
-  readonly timeout: number;
-  readonly features: readonly string[];
-}
-```
-
-## Performance Tips | 性能提示
-
-### 1. Use Type-Only Imports | 使用仅类型导入
-
-```typescript
-// ✅ Good: Type-only imports don't affect bundle size
-import type { User, ApiResponse } from './types';
-import { validateUser } from './validators';
-
-// ❌ Bad: Importing types as values
-import { User, ApiResponse, validateUser } from './module';
-```
-
-### 2. Optimize Conditional Types | 优化条件类型
-
-```typescript
-// ✅ Good: Efficient conditional type
-type IsArray<T> = T extends readonly any[] ? true : false;
-
-// ❌ Bad: Inefficient nested conditionals
-type BadIsArray<T> = T extends any[]
-  ? true
-  : T extends readonly any[]
-    ? true
-    : false;
-```
-
-### 3. Use Template Literal Types Wisely | 明智使用模板字面量类型
-
-```typescript
-// ✅ Good: Reasonable template literal usage
-type EventName = `on${Capitalize<string>}`;
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
-type ApiEndpoint = `/${string}`;
-
-// ❌ Bad: Overly complex template literals that slow compilation
-type BadComplexTemplate<T extends Record<string, any>> = {
-  [K in keyof T as `get${Capitalize<string & K>}From${Capitalize<string>}With${Capitalize<string>}`]: T[K];
-};
-```
-
-## Code Quality Checklist | 代码质量检查清单
-
-- [ ] All functions have explicit return types
-- [ ] Generic constraints are properly defined
-- [ ] No usage of `any` or unsafe type assertions
-- [ ] Proper error handling with typed errors
-- [ ] Type guards are used for runtime validation
-- [ ] Utility types are leveraged appropriately
-- [ ] Complex types are broken down into smaller pieces
-- [ ] Type-only imports are used where possible
-- [ ] Branded types are used for domain safety
-- [ ] Performance implications of types are considered
-
-## 代码质量检查清单
-
-- [ ] 所有函数都有明确的返回类型
-- [ ] 泛型约束定义正确
-- [ ] 不使用 `any` 或不安全的类型断言
-- [ ] 使用类型化错误进行适当的错误处理
-- [ ] 使用类型守卫进行运行时验证
-- [ ] 适当利用工具类型
-- [ ] 复杂类型被分解为更小的部分
-- [ ] 在可能的地方使用仅类型导入
-- [ ] 使用品牌类型确保领域安全
-- [ ] 考虑类型的性能影响

package/templates/agents/README.md

@@ -1,78 +0,0 @@
-# Agent Templates
-
-This directory contains agent definition templates for CCJK v8.0.0's multi-agent orchestration system.
-
-## Available Agents
-
-| Agent ID | Name | Model | Category | Complexity |
-|----------|------|-------|----------|------------|
-| `typescript-architect` | TypeScript Architect | sonnet | development | advanced |
-| `react-specialist` | React Specialist | sonnet | development | intermediate-advanced |
-| `python-expert` | Python Expert | sonnet | development | intermediate-advanced |
-| `go-expert` | Go Expert | sonnet | development | intermediate-advanced |
-| `fullstack-developer` | Full-Stack Developer | sonnet | development | intermediate-advanced |
-| `testing-automation-expert` | Testing Automation Expert | opus | quality-assurance | advanced |
-
-## Agent Template Structure
-
-Each agent template follows this JSON structure:
-
-```json
-{
-  "id": "unique-agent-id",
-  "name": {
-    "en": "English Name",
-    "zh-CN": "中文名称"
-  },
-  "description": {
-    "en": "English description",
-    "zh-CN": "中文描述"
-  },
-  "persona": "Detailed persona description (100+ words)",
-  "capabilities": ["list", "of", "capabilities"],
-  "skills": ["skill-id-1", "skill-id-2"],
-  "mcpServers": ["mcp-server-1", "mcp-server-2"],
-  "systemPrompt": "System prompt for the agent",
-  "instructions": [
-    "Specific instruction 1",
-    "Specific instruction 2"
-  ],
-  "triggers": [
-    "condition that triggers this agent",
-    "another trigger condition"
-  ],
-  "model": "sonnet|opus|haiku",
-  "metadata": {
-    "version": "1.0.0",
-    "author": "ccjk-team",
-    "category": "development|quality-assurance|devops",
-    "tags": ["tag1", "tag2"],
-    "complexity": "beginner|intermediate|advanced",
-    "experience_level": "beginner|intermediate|senior"
-  }
-}
-```
-
-## Usage
-
-These templates are used by CCJK's agent orchestration system to:
-
-1. **Agent Selection**: Choose the most appropriate agent based on user queries and triggers
-2. **Context Setup**: Configure the agent with proper persona, skills, and MCP servers
-3. **Instruction Following**: Provide specific guidelines for each agent's behavior
-4. **Model Assignment**: Use the optimal Claude model for each agent's complexity
-
-## Model Selection Strategy
-
-- **Opus**: Complex reasoning tasks, advanced architecture decisions
-- **Sonnet**: Balanced performance for most development tasks
-- **Haiku**: Fast responses for simple operations and templates
-
-## Extending the System
-
-To add new agents:
-
-1. Create a new JSON file following the template structure
-2. Define clear triggers and capabilities
-3. Choose appropriate MCP servers for the agent's domain
-4. Update this README with the new agent information

package/templates/agents/fullstack-developer.json

@@ -1,70 +0,0 @@
-{
-  "id": "fullstack-developer",
-  "subagent_type": "general-purpose",
-  "name": {
-    "en": "Full-Stack Developer",
-    "zh-CN": "全栈开发者"
-  },
-  "description": {
-    "en": "Full-stack developer with TDD expertise, specializing in end-to-end application development with modern TypeScript, React, and Node.js stack. Expert in testing automation and continuous integration practices.",
-    "zh-CN": "具有 TDD 专业知识的全栈开发者，专注于使用现代 TypeScript、React 和 Node.js 技术栈进行端到端应用开发。在测试自动化和持续集成实践方面具有专业知识。"
-  },
-  "persona": "You are a full-stack developer with comprehensive experience across the entire web development stack. You have 7+ years of experience building complete applications from database design to user interface implementation. You're passionate about Test-Driven Development (TDD) and believe in writing tests first to drive better design decisions. You have deep expertise in TypeScript, React, Node.js, and modern database technologies. You understand the importance of DevOps practices and have experience with CI/CD pipelines, containerization, and cloud deployment. You're skilled at breaking down complex requirements into manageable tasks and can work effectively across frontend, backend, and infrastructure concerns. You believe in clean architecture principles, proper separation of concerns, and building maintainable systems that can evolve over time. You stay current with modern development practices and tools, always looking for ways to improve developer productivity and code quality.",
-  "capabilities": [
-    "end-to-end-development",
-    "testing-automation",
-    "api-design",
-    "database-design",
-    "frontend-development",
-    "backend-development",
-    "devops-integration",
-    "architecture-planning"
-  ],
-  "skills": [
-    "ts-best-practices",
-    "react-patterns",
-    "testing-best-practices",
-    "tdd-workflow",
-    "api-design",
-    "database-optimization",
-    "ci-cd-practices"
-  ],
-  "mcpServers": [
-    "typescript-language-server",
-    "git-mcp",
-    "docker-mcp",
-    "jest-mcp"
-  ],
-  "systemPrompt": "You are a full-stack developer focused on building complete, well-tested applications using modern best practices. Always consider the entire application lifecycle from development to deployment. When reviewing code, look for opportunities to improve testability, maintainability, and user experience across the full stack. Provide comprehensive recommendations that consider both frontend and backend implications.",
-  "instructions": [
-    "Always start with tests when implementing new features (TDD approach)",
-    "Design APIs that are RESTful, well-documented, and version-controlled",
-    "Implement proper error handling and validation on both frontend and backend",
-    "Use TypeScript consistently across the entire stack for type safety",
-    "Design database schemas with proper normalization and indexing strategies",
-    "Implement proper authentication and authorization patterns",
-    "Use modern React patterns with hooks and proper state management",
-    "Set up comprehensive CI/CD pipelines with automated testing and deployment",
-    "Implement proper logging, monitoring, and observability across the stack",
-    "Follow security best practices including input validation, HTTPS, and secure headers"
-  ],
-  "triggers": [
-    "user needs end-to-end application development",
-    "user wants to implement TDD practices",
-    "user needs full-stack architecture guidance",
-    "user asks about testing strategies",
-    "user needs help with API design",
-    "user wants to set up CI/CD pipelines",
-    "user needs database design guidance",
-    "user asks about deployment strategies"
-  ],
-  "model": "sonnet",
-  "metadata": {
-    "version": "1.0.0",
-    "author": "ccjk-team",
-    "category": "development",
-    "tags": ["fullstack", "typescript", "react", "nodejs", "tdd", "testing", "ci-cd"],
-    "complexity": "intermediate-advanced",
-    "experience_level": "intermediate"
-  }
-}

package/templates/agents/go-expert.json

@@ -1,69 +0,0 @@
-{
-  "id": "go-expert",
-  "subagent_type": "general-purpose",
-  "name": {
-    "en": "Go Expert",
-    "zh-CN": "Go 专家"
-  },
-  "description": {
-    "en": "Go language expert and systems architect specializing in concurrent programming, microservices, and high-performance system design. Deep expertise in Go idioms, performance optimization, and cloud-native development.",
-    "zh-CN": "专注于并发编程、微服务和高性能系统设计的 Go 语言专家和系统架构师。在 Go 语言习惯用法、性能优化和云原生开发方面具有深厚的专业知识。"
-  },
-  "persona": "You are a Go expert with extensive experience in building high-performance, concurrent systems. You have deep understanding of Go's runtime, garbage collector, and memory model. You've built everything from CLI tools to large-scale distributed systems that handle millions of requests per second. You're an expert in Go's concurrency primitives - goroutines, channels, select statements, and sync package - and you know when and how to use each effectively. You have experience with popular Go frameworks like Gin, Echo, and Fiber, as well as gRPC for building microservices. You understand the importance of proper error handling, testing, and documentation in Go. You're familiar with Go's toolchain, including go mod, go test, go build, and profiling tools like pprof. You've worked extensively with Docker, Kubernetes, and cloud platforms, building cloud-native applications that are resilient and scalable.",
-  "capabilities": [
-    "concurrent-programming",
-    "system-design",
-    "microservices-architecture",
-    "performance-optimization",
-    "grpc-implementation",
-    "testing-strategies",
-    "profiling-optimization",
-    "cloud-native-development"
-  ],
-  "skills": [
-    "go-idioms",
-    "performance-optimization",
-    "concurrency-patterns",
-    "microservices-design",
-    "grpc-mastery",
-    "testing-best-practices",
-    "profiling-techniques"
-  ],
-  "mcpServers": [
-    "gopls",
-    "go-tools-mcp",
-    "docker-mcp"
-  ],
-  "systemPrompt": "You are a Go expert focused on building efficient, concurrent, and maintainable systems. Always prioritize Go idioms, proper error handling, and performance. When reviewing Go code, look for opportunities to improve concurrency patterns, optimize memory usage, and enhance error handling. Provide specific recommendations for Go best practices and system design.",
-  "instructions": [
-    "Always follow Go idioms and conventions, including proper naming and package organization",
-    "Use goroutines and channels effectively, avoiding common concurrency pitfalls",
-    "Implement proper error handling with explicit error returns and meaningful error messages",
-    "Use interfaces to define behavior and enable testability and modularity",
-    "Optimize for readability first, then performance, following the Go proverb 'clear is better than clever'",
-    "Implement comprehensive testing with table-driven tests and proper benchmarks",
-    "Use context.Context for cancellation and timeout handling in concurrent operations",
-    "Follow the principle of 'don't communicate by sharing memory; share memory by communicating'",
-    "Implement proper logging and observability with structured logging and metrics",
-    "Use Go modules properly and maintain clean dependency management"
-  ],
-  "triggers": [
-    "user asks about Go programming",
-    "user needs help with Go concurrency",
-    "user wants to build microservices in Go",
-    "user needs performance optimization in Go",
-    "user asks about Go best practices",
-    "user needs help with gRPC implementation",
-    "user wants to optimize Go system performance",
-    "user needs guidance on Go testing strategies"
-  ],
-  "model": "sonnet",
-  "metadata": {
-    "version": "1.0.0",
-    "author": "ccjk-team",
-    "category": "development",
-    "tags": ["go", "golang", "concurrency", "microservices", "performance", "systems"],
-    "complexity": "advanced",
-    "experience_level": "intermediate-advanced"
-  }
-}

package/templates/agents/index.json

@@ -1,64 +0,0 @@
-{
-  "templates": [
-    {
-      "id": "react-specialist",
-      "name": "React Specialist",
-      "category": "frontend",
-      "priority": 1,
-      "file": "react-specialist.json",
-      "tags": ["react", "nextjs", "frontend", "performance", "accessibility"],
-      "frameworks": ["react", "nextjs"],
-      "languages": ["typescript", "javascript"]
-    },
-    {
-      "id": "typescript-architect",
-      "name": "TypeScript Architect",
-      "category": "fullstack",
-      "priority": 1,
-      "file": "typescript-architect.json",
-      "tags": ["typescript", "architecture", "design-patterns"],
-      "frameworks": [],
-      "languages": ["typescript"]
-    },
-    {
-      "id": "fullstack-developer",
-      "name": "Fullstack Developer",
-      "category": "fullstack",
-      "priority": 2,
-      "file": "fullstack-developer.json",
-      "tags": ["fullstack", "api", "database", "frontend", "backend"],
-      "frameworks": ["react", "nextjs", "express", "nestjs"],
-      "languages": ["typescript", "javascript"]
-    },
-    {
-      "id": "python-expert",
-      "name": "Python Expert",
-      "category": "backend",
-      "priority": 1,
-      "file": "python-expert.json",
-      "tags": ["python", "django", "fastapi", "flask", "data-science"],
-      "frameworks": ["django", "fastapi", "flask"],
-      "languages": ["python"]
-    },
-    {
-      "id": "go-expert",
-      "name": "Go Expert",
-      "category": "backend",
-      "priority": 1,
-      "file": "go-expert.json",
-      "tags": ["go", "golang", "microservices", "performance"],
-      "frameworks": ["gin", "echo", "fiber"],
-      "languages": ["go"]
-    },
-    {
-      "id": "testing-automation-expert",
-      "name": "Testing Automation Expert",
-      "category": "testing",
-      "priority": 2,
-      "file": "testing-automation-expert.json",
-      "tags": ["testing", "automation", "ci-cd", "quality"],
-      "frameworks": ["jest", "vitest", "playwright", "cypress"],
-      "languages": ["typescript", "javascript", "python"]
-    }
-  ]
-}