✅ Implement type-safe mocking pattern with ESLint enforcement

MAJOR FEATURES:
- ✅ Type-safe mocking pattern using production DTOs (CommitDataDTO, RepositoryDataDTO, etc.)
- ✅ Custom ESLint rule 'prefer-production-types-in-mocks' for test files
- ✅ Comprehensive documentation in docs/Type-Safe-Mocking-Guide.md
- ✅ Applied pattern to RepositoryFactCollector and ProjectFactCollector tests

TECHNICAL DETAILS:
- Replace 'as any' with production types like 'as CommitDataDTO[]'
- ESLint rule targets only test files with helpful error messages
- Pattern confirmed working: all 91 tests passing
- Philosophy: "Mocking is like hot sauce - a little bit is all you need"

COMPLETED REFACTOR PHASE 6: Pure fact validation testing
- MathematicalCalculator tests (56 tests)
- RepositoryFactCollector integration tests (10 tests)
- ProjectFactCollector tests (25 tests)
- All tests validate no analysis violations

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: LTSCommerce

cc-commands-ts/docs/Type-Safe-Mocking-Guide.md

@@ -0,0 +1,168 @@
+# Type-Safe Mocking Guide
+
+> **Philosophy**: "Mocking is like hot sauce - a little bit is all you need."
+
+## The Problem
+
+Traditional mocking approaches use `any` types, which breaks type safety and hides potential issues:
+
+```typescript
+// ❌ WRONG - Unsafe and brittle
+vi.mocked(service.getData).mockResolvedValue(mockData as any)
+const mockRepo = { name: 'test' } as any
+```
+
+## The Solution: Production Type Casting
+
+Use actual production DTOs and interfaces with minimal type casting:
+
+```typescript
+// ✅ CORRECT - Type-safe with production types
+import { CommitDataDTO, RepositoryDataDTO } from '@/dto'
+
+const mockCommits = [{ sha: 'abc123' }] as CommitDataDTO[]
+const mockRepo = { name: 'test-repo', stargazersCount: 42 } as RepositoryDataDTO
+
+vi.mocked(service.searchCommits).mockResolvedValue(mockCommits)
+vi.mocked(service.getRepository).mockResolvedValue(mockRepo)
+```
+
+## Benefits
+
+1. **Type Safety**: TypeScript enforces compatibility with production interfaces
+2. **Minimal Mocking**: Only provide what the test needs
+3. **Real Contracts**: Tests validate against actual production types
+4. **IDE Support**: Full autocomplete and error checking
+5. **Refactor Safe**: Type changes break tests appropriately
+
+## Patterns
+
+### ✅ Arrays of DTOs
+```typescript
+const mockCommits = [
+  { sha: 'abc123', message: 'Initial commit' },
+  { sha: 'def456', message: 'Fix bug' }
+] as CommitDataDTO[]
+
+vi.mocked(service.searchCommits).mockResolvedValue(mockCommits)
+```
+
+### ✅ Complex Objects
+```typescript
+const mockRepo = {
+  name: 'test-repo',
+  stargazersCount: 42,
+  getAgeInDays: vi.fn().mockReturnValue(365),
+  getDaysSinceUpdate: vi.fn().mockReturnValue(7)
+} as RepositoryDataDTO
+
+vi.mocked(service.getRepository).mockResolvedValue(mockRepo)
+```
+
+### ✅ Empty Arrays
+```typescript
+vi.mocked(service.searchIssues).mockResolvedValue([] as IssueDataDTO[])
+```
+
+### ✅ Service Interfaces
+```typescript
+const mockService: vi.Mocked<IDataService> = {
+  getData: vi.fn(),
+  processData: vi.fn()
+}
+```
+
+## Anti-Patterns
+
+### ❌ Using `any`
+```typescript
+// NEVER DO THIS
+const mockData = { field: 'value' } as any
+vi.mocked(service.process).mockResolvedValue(data as any)
+```
+
+### ❌ Using `unknown`
+```typescript
+// AVOID - No better than any for mocking
+const mockData = { field: 'value' } as unknown
+```
+
+### ❌ Over-Mocking
+```typescript
+// DON'T CREATE ELABORATE MOCK TYPES
+type ComplexMockType = {
+  // 50 lines of mock-specific types
+}
+```
+
+### ❌ Mock Types Instead of Production Types
+```typescript
+// WRONG - Use actual production types, not mock types
+type MockCommit = { sha: string } // Don't create this
+const mock = {} as MockCommit     // Use CommitDataDTO instead
+```
+
+## Testing Strategy
+
+Tests should validate production behavior, not mock behavior:
+
+```typescript
+// ✅ GOOD - Test real behavior
+it('should process commit data correctly', async () => {
+  const mockCommits = [{ sha: 'abc123' }] as CommitDataDTO[]
+  vi.mocked(service.getCommits).mockResolvedValue(mockCommits)
+  
+  const result = await processor.analyzeCommits('owner', 'repo')
+  
+  expect(result.TOTAL_COMMITS).toBe('1')
+  expect(result.COMMIT_SHA_LIST).toContain('abc123')
+})
+```
+
+## ESLint Enforcement
+
+The custom rule `cc-commands/prefer-production-types-in-mocks` enforces this pattern:
+
+- **Detects**: `as any` and `as unknown` in test files
+- **Suggests**: Use specific production types instead
+- **Scope**: Only applies to `test/**/*.ts` files
+
+## Migration Guide
+
+### From `any` to Production Types
+
+```typescript
+// Before
+const mockData = { name: 'test' } as any
+vi.mocked(service.getData).mockResolvedValue(mockData as any)
+
+// After  
+const mockData = { name: 'test' } as RepositoryDataDTO
+vi.mocked(service.getData).mockResolvedValue(mockData)
+```
+
+### From `unknown` to Production Types
+
+```typescript
+// Before
+vi.mocked(service.getItems).mockResolvedValue([{}] as unknown[])
+
+// After
+vi.mocked(service.getItems).mockResolvedValue([{} as ItemDTO])
+```
+
+## Rule Configuration
+
+```javascript
+// eslint.config.mjs
+{
+  files: ['test/**/*.ts'],
+  rules: {
+    'cc-commands/prefer-production-types-in-mocks': 'error'
+  }
+}
+```
+
+## Conclusion
+
+Type-safe mocking ensures tests validate real contracts while maintaining development velocity. Use production types, mock minimally, and let TypeScript catch compatibility issues early.

cc-commands-ts/eslint-rules/index.mjs

@@ -7,13 +7,15 @@ import noUnsafeTypeCasting from './no-unsafe-type-casting.js'
 import noStringBasedServiceArgs from './no-string-based-service-args.js'
 import requireTypedDataAccess from './require-typed-data-access.js'
 import noApiResponseAny from './no-api-response-any.js'
+import preferProductionTypesInMocks from './prefer-production-types-in-mocks.js'
 
 export default {
   rules: {
     'no-direct-abstract-types': noDirectAbstractTypes,
     'no-unsafe-type-casting': noUnsafeTypeCasting,
     'no-string-based-service-args': noStringBasedServiceArgs,
     'require-typed-data-access': requireTypedDataAccess,
-    'no-api-response-any': noApiResponseAny
+    'no-api-response-any': noApiResponseAny,
+    'prefer-production-types-in-mocks': preferProductionTypesInMocks
   }
 }

cc-commands-ts/eslint-rules/prefer-production-types-in-mocks.js

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Enforce production types over any/unknown in test mocks
+ * 
+ * This rule prevents the use of 'any' and 'unknown' type casting in test files,
+ * encouraging the use of specific production types for type-safe mocking.
+ * 
+ * Philosophy: "Mocking is like hot sauce - a little bit is all you need."
+ * Use actual production DTOs and interfaces with minimal type casting.
+ */
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce production types over any/unknown in test mocks',
+      category: 'Best Practices',
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      avoidAnyInTests: 'Avoid using "as any" in test files. Use specific production types instead (e.g., "as CommitDataDTO[]").',
+      avoidUnknownInTests: 'Avoid using "as unknown" in test files. Use specific production types instead (e.g., "as RepositoryDataDTO").',
+      avoidAnyUnknownArray: 'Avoid using "as any[]" or "as unknown[]" in test files. Use typed arrays like "as CommitDataDTO[]" instead.',
+      preferProductionTypes: 'Use production DTOs and interfaces for type-safe mocking. Import the actual types from your codebase.',
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+    
+    // Only apply this rule to test files
+    if (!filename.includes('/test/') && !filename.includes('\\test\\') && 
+        !filename.endsWith('.test.ts') && !filename.endsWith('.test.js') &&
+        !filename.endsWith('.spec.ts') && !filename.endsWith('.spec.js')) {
+      return {};
+    }
+
+    return {
+      TSAsExpression(node) {
+        const typeAnnotation = node.typeAnnotation;
+
+        // Check for "as any"
+        if (typeAnnotation.type === 'TSAnyKeyword') {
+          context.report({
+            node,
+            messageId: 'avoidAnyInTests',
+            data: {},
+          });
+          return;
+        }
+
+        // Check for "as unknown"
+        if (typeAnnotation.type === 'TSUnknownKeyword') {
+          context.report({
+            node,
+            messageId: 'avoidUnknownInTests',
+            data: {},
+          });
+          return;
+        }
+
+        // Check for "as any[]" or "as unknown[]"
+        if (typeAnnotation.type === 'TSArrayType') {
+          const elementType = typeAnnotation.elementType;
+          if (elementType.type === 'TSAnyKeyword' || elementType.type === 'TSUnknownKeyword') {
+            context.report({
+              node,
+              messageId: 'avoidAnyUnknownArray',
+              data: {},
+            });
+            return;
+          }
+        }
+
+        // Check for more complex cases like Array<any> or Array<unknown>
+        if (typeAnnotation.type === 'TSTypeReference' && 
+            typeAnnotation.typeName && typeAnnotation.typeName.name === 'Array' &&
+            typeAnnotation.typeParameters && typeAnnotation.typeParameters.params.length > 0) {
+          const firstParam = typeAnnotation.typeParameters.params[0];
+          if (firstParam.type === 'TSAnyKeyword' || firstParam.type === 'TSUnknownKeyword') {
+            context.report({
+              node,
+              messageId: 'avoidAnyUnknownArray',
+              data: {},
+            });
+            return;
+          }
+        }
+      },
+
+      // Also catch variable declarations with explicit any/unknown types
+      TSTypeAnnotation(node) {
+        const parent = node.parent;
+        
+        // Only check if we're in a variable declaration or similar context that might be a mock
+        if (parent && (parent.type === 'VariableDeclarator' || parent.type === 'Parameter')) {
+          const typeAnnotation = node.typeAnnotation;
+          
+          if (typeAnnotation.type === 'TSAnyKeyword') {
+            context.report({
+              node: parent,
+              messageId: 'preferProductionTypes',
+              data: {},
+            });
+          }
+          
+          if (typeAnnotation.type === 'TSUnknownKeyword') {
+            context.report({
+              node: parent,
+              messageId: 'preferProductionTypes', 
+              data: {},
+            });
+          }
+        }
+      }
+    };
+  },
+};

cc-commands-ts/eslint.config.mjs

@@ -69,5 +69,13 @@ export default [
     rules: {
       'camelcase': 'off' // GitHub API responses use snake_case properties
     }
+  },
+  {
+    // Test files - enforce type-safe mocking patterns and relax some rules for mock data
+    files: ['test/**/*.ts', 'test/**/*.js', '**/*.test.ts', '**/*.spec.ts'],
+    rules: {
+      'cc-commands/prefer-production-types-in-mocks': 'error', // Enforce production types over any/unknown in mocks
+      'camelcase': 'off' // Allow snake_case in test mocks to match API responses
+    }
   }
 ]