claude-flow-novice 1.0.0

package/wiki/languages/typescript/workflows.md

@@ -0,0 +1,481 @@
+# TypeScript Development Workflows with Claude Flow
+
+Master type-safe development patterns using intelligent agent coordination. This guide covers workflow patterns, agent collaboration, and best practices for TypeScript development.
+
+## 🎯 Core Workflow Patterns
+
+### Type-First Development
+```typescript
+// Start with type definitions - agents coordinate around types
+interface User {
+  id: string;
+  email: string;
+  profile: UserProfile;
+  permissions: Permission[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+interface UserService {
+  createUser(data: CreateUserRequest): Promise<User>;
+  updateUser(id: string, data: UpdateUserRequest): Promise<User>;
+  deleteUser(id: string): Promise<void>;
+  findUser(id: string): Promise<User | null>;
+}
+```
+
+### Agent Coordination Workflow
+```javascript
+// Type-aware agent coordination pattern
+[Single Message - Type-Safe Feature Development]:
+  Task("Type Architect", "Design comprehensive type definitions for user management", "system-architect")
+  Task("Interface Designer", "Create service and repository interfaces", "code-analyzer")
+  Task("Implementation Developer", "Implement user service with full type safety", "coder")
+  Task("Validation Engineer", "Add runtime validation and error handling", "reviewer")
+  Task("Test Engineer", "Create type-safe tests with comprehensive coverage", "tester")
+
+  // Memory coordination for shared types
+  Bash("npx claude-flow@alpha memory store --key 'types/user' --value '$(cat src/types/user.ts)'")
+  Bash("npx claude-flow@alpha memory store --key 'interfaces/user-service' --value '$(cat src/interfaces/user-service.ts)'")
+```
+
+## 🔄 Development Lifecycle Workflows
+
+### Feature Development Workflow
+```javascript
+// Complete feature development with type safety
+[Feature: User Authentication System]
+
+Step 1: Type Definition Phase
+  Task("Type Architect", "Define authentication types and interfaces", "system-architect")
+  // Creates: AuthUser, AuthRequest, AuthResponse, AuthService interfaces
+
+Step 2: Interface Design Phase
+  Task("Interface Designer", "Design service contracts and API interfaces", "code-analyzer")
+  // Creates: IAuthService, IUserRepository, ITokenService interfaces
+
+Step 3: Implementation Phase
+  Task("Backend Developer", "Implement authentication service with type safety", "backend-dev")
+  Task("Middleware Developer", "Create type-safe authentication middleware", "coder")
+  // Implements services following strict type contracts
+
+Step 4: Validation Phase
+  Task("Type Validator", "Ensure complete type coverage and runtime validation", "reviewer")
+  Task("Security Auditor", "Review type safety for security implications", "reviewer")
+
+Step 5: Testing Phase
+  Task("Test Engineer", "Create comprehensive type-safe test suite", "tester")
+  // Creates unit, integration, and type tests
+```
+
+### Refactoring Workflow
+```javascript
+// Type-safe refactoring with agent coordination
+[Refactoring: Extract User Service]
+
+Phase 1: Analysis
+  Task("Code Analyzer", "Analyze current code structure and type dependencies", "code-analyzer")
+  Task("Type Dependency Mapper", "Map all type relationships and dependencies", "reviewer")
+
+Phase 2: Planning
+  Task("Refactoring Planner", "Plan extraction maintaining type safety", "system-architect")
+  Task("Breaking Change Analyzer", "Identify potential breaking changes", "reviewer")
+
+Phase 3: Execution
+  Task("Refactoring Engineer", "Extract service while preserving type contracts", "coder")
+  Task("Import Updater", "Update all imports and type references", "coder")
+
+Phase 4: Validation
+  Task("Type Checker", "Validate all types compile and work correctly", "reviewer")
+  Task("Test Validator", "Ensure all tests pass with new structure", "tester")
+```
+
+## 🧠 Intelligent Type Management
+
+### Auto-Generated Types Workflow
+```typescript
+// Database-first type generation
+interface DatabaseSchema {
+  users: {
+    id: string;
+    email: string;
+    profile_data: object;
+    created_at: Date;
+  };
+}
+
+// Agent-generated service types from schema
+Task("Type Generator", "Generate TypeScript types from database schema", "code-analyzer")
+Task("Service Type Creator", "Create service interfaces from database types", "coder")
+Task("Validation Schema Builder", "Generate Zod schemas for runtime validation", "reviewer")
+```
+
+### API-First Type Generation
+```typescript
+// OpenAPI to TypeScript workflow
+Task("API Type Generator", "Generate TypeScript types from OpenAPI specification", "code-analyzer")
+Task("Client Generator", "Create type-safe API client from generated types", "coder")
+Task("Validation Generator", "Generate request/response validation schemas", "reviewer")
+
+// Example generated types
+interface APIEndpoints {
+  'POST /users': {
+    request: CreateUserRequest;
+    response: APIResponse<User>;
+  };
+  'GET /users/:id': {
+    params: { id: string };
+    response: APIResponse<User>;
+  };
+}
+```
+
+## 🔍 Type Safety Validation Workflows
+
+### Pre-Commit Type Validation
+```bash
+# Automated type checking workflow
+npx claude-flow@alpha hooks add pre-commit "npm run type-check"
+npx claude-flow@alpha hooks add pre-commit "npm run type-coverage"
+npx claude-flow@alpha hooks add pre-commit "npm run validate-schemas"
+
+# Agent-assisted validation
+Task("Pre-Commit Validator", "Run comprehensive type checks before commit", "reviewer")
+Task("Type Coverage Analyzer", "Ensure type coverage meets requirements", "code-analyzer")
+```
+
+### Runtime Type Validation Workflow
+```typescript
+// Integration of compile-time and runtime validation
+import { z } from 'zod';
+
+// Compile-time type
+interface CreateUserRequest {
+  email: string;
+  password: string;
+  profile: {
+    firstName: string;
+    lastName: string;
+    age?: number;
+  };
+}
+
+// Runtime validation schema
+const CreateUserRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  profile: z.object({
+    firstName: z.string().min(1),
+    lastName: z.string().min(1),
+    age: z.number().int().min(0).max(150).optional(),
+  }),
+});
+
+// Agent workflow for validation setup
+Task("Schema Generator", "Generate Zod schemas from TypeScript interfaces", "coder")
+Task("Validation Middleware Creator", "Create Express middleware with type validation", "backend-dev")
+Task("Error Handler Designer", "Design type-safe error handling system", "reviewer")
+```
+
+## 🏗️ Architecture Workflows
+
+### Clean Architecture with TypeScript
+```typescript
+// Domain layer - pure TypeScript interfaces
+interface UserEntity {
+  readonly id: UserId;
+  readonly email: Email;
+  readonly profile: UserProfile;
+}
+
+// Application layer - use cases
+interface CreateUserUseCase {
+  execute(request: CreateUserRequest): Promise<Either<DomainError, User>>;
+}
+
+// Infrastructure layer - implementations
+class TypeORMUserRepository implements UserRepository {
+  async save(user: UserEntity): Promise<Either<RepositoryError, void>> {
+    // Implementation with full type safety
+  }
+}
+
+// Agent coordination for clean architecture
+Task("Domain Modeler", "Design pure domain entities and value objects", "system-architect")
+Task("Use Case Designer", "Create application use cases with strict typing", "code-analyzer")
+Task("Infrastructure Developer", "Implement infrastructure with type-safe adapters", "backend-dev")
+Task("Dependency Injection Setup", "Configure DI container with type safety", "coder")
+```
+
+### Microservices Type Coordination
+```typescript
+// Shared types across services
+// @shared/types package
+export interface UserEvent {
+  type: 'USER_CREATED' | 'USER_UPDATED' | 'USER_DELETED';
+  userId: string;
+  timestamp: Date;
+  data: unknown;
+}
+
+// Service-specific implementations
+// user-service/src/events.ts
+class UserEventPublisher implements EventPublisher<UserEvent> {
+  async publish(event: UserEvent): Promise<void> {
+    // Type-safe event publishing
+  }
+}
+
+// Agent workflow for microservices
+Task("Shared Type Manager", "Maintain shared types across microservices", "system-architect")
+Task("Event Schema Designer", "Design type-safe event schemas", "code-analyzer")
+Task("Service Integration Developer", "Implement type-safe service communication", "backend-dev")
+Task("Contract Validator", "Validate service contracts and compatibility", "reviewer")
+```
+
+## 🧪 Testing Workflows
+
+### Type-Safe Testing Patterns
+```typescript
+// Test type definitions
+interface UserTestData {
+  valid: User;
+  invalid: Partial<User>;
+  edge: User[];
+}
+
+// Test factory with types
+class UserTestFactory {
+  static create(overrides: Partial<User> = {}): User {
+    return {
+      id: 'test-id',
+      email: 'test@example.com',
+      profile: this.createProfile(),
+      permissions: [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      ...overrides,
+    };
+  }
+
+  static createInvalid(): InvalidUser {
+    // Type-safe invalid data for negative testing
+  }
+}
+
+// Agent workflow for testing
+Task("Test Data Designer", "Create type-safe test data factories", "tester")
+Task("Mock Generator", "Generate typed mocks for all dependencies", "tester")
+Task("Test Type Validator", "Ensure tests maintain type safety", "reviewer")
+Task("Coverage Analyzer", "Validate type coverage in tests", "code-analyzer")
+```
+
+### Integration Testing Workflow
+```typescript
+// Type-safe integration tests
+describe('UserService Integration', () => {
+  let userService: UserService;
+  let mockRepository: jest.Mocked<UserRepository>;
+
+  beforeEach(() => {
+    mockRepository = createMockRepository<UserRepository>();
+    userService = new UserService(mockRepository);
+  });
+
+  it('should create user with valid data', async () => {
+    const request: CreateUserRequest = UserTestFactory.createRequest();
+    const result = await userService.createUser(request);
+
+    expect(result).toMatchType<User>();
+    expect(result.email).toBe(request.email);
+  });
+});
+
+// Agent coordination for integration testing
+Task("Integration Test Designer", "Design comprehensive integration test suites", "tester")
+Task("Mock Strategy Planner", "Plan mocking strategy maintaining type safety", "reviewer")
+Task("Test Data Coordinator", "Coordinate test data across integration tests", "tester")
+```
+
+## 🔄 CI/CD Integration Workflows
+
+### Automated Type Checking Pipeline
+```yaml
+# .github/workflows/typescript-validation.yml
+name: TypeScript Validation
+on: [push, pull_request]
+
+jobs:
+  type-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+
+      - run: npm ci
+      - run: npm run type-check
+      - run: npm run type-coverage
+      - run: npm run validate-schemas
+
+      # Agent integration
+      - run: npx claude-flow@alpha validate typescript --strict
+      - run: npx claude-flow@alpha agents spawn reviewer "validate PR type safety"
+```
+
+### Deployment Workflow with Type Safety
+```javascript
+// Deployment validation with agents
+[Deployment Pipeline - Type Safety Focus]:
+  Task("Pre-Deploy Validator", "Validate all types compile for production", "reviewer")
+  Task("Schema Validator", "Ensure database schemas match TypeScript types", "code-analyzer")
+  Task("API Contract Validator", "Validate API contracts haven't broken", "reviewer")
+  Task("Dependency Type Checker", "Check all dependencies have valid types", "coder")
+  Task("Production Readiness Checker", "Final type safety validation", "reviewer")
+```
+
+## 🎨 Code Generation Workflows
+
+### Automated Code Generation
+```typescript
+// Template-based code generation with types
+interface CodegenConfig {
+  entities: string[];
+  operations: ('create' | 'read' | 'update' | 'delete')[];
+  validationLibrary: 'zod' | 'joi' | 'yup';
+  testing: boolean;
+}
+
+// Agent workflow for code generation
+Task("Template Designer", "Design type-safe code generation templates", "code-analyzer")
+Task("Generator Developer", "Implement configurable code generators", "coder")
+Task("Validation Generator", "Generate validation schemas from types", "reviewer")
+Task("Test Generator", "Generate comprehensive test suites", "tester")
+```
+
+### Documentation Generation
+```typescript
+// Auto-generate documentation from types
+/**
+ * User management service providing CRUD operations
+ * @template T User entity type
+ */
+interface UserService<T extends User = User> {
+  /**
+   * Creates a new user
+   * @param data User creation data
+   * @returns Promise resolving to created user
+   * @throws {ValidationError} When data is invalid
+   */
+  createUser(data: CreateUserRequest): Promise<T>;
+}
+
+// Agent workflow for documentation
+Task("Type Documentation Generator", "Generate API docs from TypeScript types", "code-analyzer")
+Task("Example Generator", "Create code examples from type definitions", "coder")
+Task("Documentation Validator", "Ensure docs match actual type implementations", "reviewer")
+```
+
+## 🔧 Development Environment Workflows
+
+### IDE Integration Workflow
+```json
+// VS Code settings for TypeScript workflows
+{
+  "typescript.preferences.importModuleSpecifier": "relative",
+  "typescript.suggest.autoImports": true,
+  "typescript.updateImportsOnFileMove.enabled": "always",
+  "claude-flow.typescript.autoValidate": true,
+  "claude-flow.typescript.generateOnSave": true,
+  "claude-flow.agents.typeAware": true
+}
+```
+
+### Hot Reload Development
+```bash
+# Development with type-aware hot reload
+npm run dev
+# Agents monitor and validate types on every change
+# Auto-generate missing type definitions
+# Provide real-time type safety feedback
+```
+
+## 🎯 Best Practices for Workflows
+
+### Workflow Organization
+1. **Start with types** - Always define interfaces before implementation
+2. **Agent coordination** - Use memory sharing for type consistency
+3. **Incremental validation** - Validate types at each development stage
+4. **Automated generation** - Generate boilerplate from type definitions
+5. **Continuous validation** - Integrate type checking into all workflows
+
+### Type Safety Workflow Rules
+1. **No `any` types** - Use proper typing or `unknown` with type guards
+2. **Runtime validation** - Always validate external data
+3. **Type coverage** - Maintain >95% type coverage
+4. **Interface segregation** - Keep interfaces focused and specific
+5. **Generic constraints** - Use constraints to maintain type relationships
+
+## 🚀 Advanced Workflow Patterns
+
+### Event-Driven Type Safety
+```typescript
+// Type-safe event system
+interface DomainEvents {
+  'user.created': { user: User; timestamp: Date };
+  'user.updated': { userId: string; changes: Partial<User> };
+  'user.deleted': { userId: string; deletedAt: Date };
+}
+
+// Agent workflow for event systems
+Task("Event Type Designer", "Design comprehensive event type system", "system-architect")
+Task("Event Handler Generator", "Generate type-safe event handlers", "coder")
+Task("Event Validation Developer", "Implement event validation and serialization", "reviewer")
+```
+
+### Multi-Package Type Coordination
+```typescript
+// Shared types across packages
+// @company/shared-types
+export interface User { /* ... */ }
+
+// @company/user-service
+import { User } from '@company/shared-types';
+
+// Agent workflow for package coordination
+Task("Package Type Coordinator", "Maintain consistency across packages", "system-architect")
+Task("Dependency Manager", "Manage type dependencies and versions", "code-analyzer")
+Task("Breaking Change Detector", "Detect and prevent breaking type changes", "reviewer")
+```
+
+## 📊 Workflow Metrics and Monitoring
+
+### Type Safety Metrics
+```bash
+# Automated metrics collection
+npx claude-flow@alpha metrics collect --typescript
+# - Type coverage percentage
+# - Number of `any` types
+# - Interface usage patterns
+# - Validation coverage
+# - Build time with types
+```
+
+### Workflow Performance
+- **Agent coordination efficiency** - Time from type change to full validation
+- **Build performance** - TypeScript compilation time optimization
+- **Developer experience** - Time from idea to working typed implementation
+- **Error detection** - How quickly type errors are caught and fixed
+
+---
+
+**Next Steps:**
+- Explore [Advanced Patterns](patterns.md) for complex TypeScript architectures
+- Learn [Framework Integration](frameworks.md) for React, Node.js, and more
+- Setup [Automation](automation.md) for CI/CD and automated workflows
+
+**Ready to implement type-safe workflows?**
+- Start with a simple feature using the Type-First Development pattern
+- Practice agent coordination with shared type definitions
+- Experiment with automated code generation from types