feat(mcp): add PatternAnalysisService and wire to dev_inspect

- Created PatternAnalysisService in @lytics/dev-agent-core
  - 5 core patterns: file size, testing, imports, error handling, types
  - Pattern comparison against similar files
  - 31/31 tests passing with comprehensive fixtures

- Integrated PatternAnalysisService into InspectAdapter
  - Removed action parameter (single-purpose tool)
  - Added patternsAnalyzed field to output schema
  - Real pattern analysis in compact & verbose formats
  - 18/18 tests passing with dedicated fixtures

- Clean architecture
  - Barrel exports for types
  - Fixtures excluded from compilation, linting, and type-checking
  - Separate fixture sets for unit (core) and integration (adapter) tests

Test coverage:
- PatternAnalysisService: 31 tests ✅
- InspectAdapter: 18 tests ✅
- Build: successful ✅

Author: prosdev

biome.json

@@ -26,6 +26,12 @@
           }
         }
       }
+    },
+    {
+      "includes": ["**/__fixtures__/**"],
+      "linter": {
+        "enabled": false
+      }
     }
   ],
   "formatter": {

packages/core/src/services/__fixtures__/README.md

@@ -0,0 +1,114 @@
+# Pattern Analysis Fixtures
+
+This directory contains realistic code examples for testing pattern detection.
+
+## Files
+
+### `modern-typescript.ts`
+**Pattern characteristics:**
+- ✅ ESM imports (`import` statements)
+- ✅ Result<T> error handling
+- ✅ Full type annotations
+- ✅ Explicit return types
+- ✅ Has test file (`modern-typescript.test.ts`)
+
+**Use for testing:**
+- Import style detection (ESM)
+- Error handling detection (Result<T>)
+- Type annotation coverage (full)
+- Test coverage (present)
+
+---
+
+### `react-component.tsx`
+**Pattern characteristics:**
+- ✅ ESM imports
+- ✅ TypeScript interfaces for props
+- ✅ React hooks in proper order
+- ✅ Full type annotations
+- ✅ Throws exceptions (try/catch pattern)
+- ❌ No test file
+
+**Use for testing:**
+- React hook detection
+- Error handling (throw in async functions)
+- Type annotation (full)
+- Test coverage (missing)
+
+---
+
+### `legacy-javascript.js`
+**Pattern characteristics:**
+- ❌ CommonJS (`require`, `module.exports`)
+- ❌ Throw-based error handling
+- ❌ No type annotations
+- ❌ No test file
+
+**Use for testing:**
+- Import style detection (CJS)
+- Error handling (throw)
+- Type annotation coverage (none)
+- Older codebase patterns
+
+---
+
+### `mixed-patterns.ts`
+**Pattern characteristics:**
+- ⚠️ Mixed ESM and CJS (`import` + `require`)
+- ⚠️ Mixed error handling (throw + Result<T>)
+- ⚠️ Partial type annotations
+- ❌ No test file
+
+**Use for testing:**
+- Inconsistency detection
+- Mixed pattern analysis
+- What to flag for review
+
+---
+
+### `go-service.go`
+**Pattern characteristics:**
+- ✅ Go error returns (`(T, error)`)
+- ✅ Exported naming (PascalCase)
+- ✅ Standard library imports
+- ✅ Error wrapping with `fmt.Errorf`
+
+**Use for testing:**
+- Go-specific patterns
+- Error return detection
+- Multi-language support
+
+---
+
+## Usage in Tests
+
+```typescript
+import { PatternAnalysisService } from '../pattern-analysis-service';
+
+const service = new PatternAnalysisService({
+  repositoryPath: path.join(__dirname, '../__fixtures__')
+});
+
+// Analyze modern TypeScript file
+const patterns = await service.analyzeFile('modern-typescript.ts');
+expect(patterns.importStyle.style).toBe('esm');
+expect(patterns.errorHandling.style).toBe('result');
+expect(patterns.typeAnnotations.coverage).toBe('full');
+expect(patterns.testing.hasTest).toBe(true);
+
+// Compare against legacy code
+const comparison = await service.comparePatterns(
+  'modern-typescript.ts',
+  ['legacy-javascript.js']
+);
+expect(comparison.importStyle.common).toBe('cjs');
+```
+
+## Adding New Fixtures
+
+When adding new fixtures:
+1. Use realistic code examples
+2. Document pattern characteristics
+3. Add test file if demonstrating test coverage
+4. Update this README
+

packages/core/src/services/__fixtures__/go-service.go

@@ -0,0 +1,92 @@
+/**
+ * Go Service Example
+ *
+ * Demonstrates Go best practices:
+ * - Error returns
+ * - Exported naming (PascalCase)
+ * - Standard library imports
+ * - Table-driven tests pattern (in corresponding test file)
+ */
+
+package service
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+var (
+	ErrInvalidEmail  = errors.New("invalid email address")
+	ErrEmptyName     = errors.New("name cannot be empty")
+	ErrShortPassword = errors.New("password must be at least 8 characters")
+)
+
+// User represents a user in the system
+type User struct {
+	ID       string
+	Email    string
+	Name     string
+	Password string
+}
+
+// ValidateEmail checks if an email address is valid
+func ValidateEmail(email string) error {
+	if email == "" {
+		return ErrInvalidEmail
+	}
+
+	if !strings.Contains(email, "@") {
+		return ErrInvalidEmail
+	}
+
+	return nil
+}
+
+// ValidatePassword checks if a password meets requirements
+func ValidatePassword(password string) error {
+	if len(password) < 8 {
+		return ErrShortPassword
+	}
+
+	return nil
+}
+
+// CreateUser creates a new user with validation
+func CreateUser(email, name, password string) (*User, error) {
+	if name == "" {
+		return nil, ErrEmptyName
+	}
+
+	if err := ValidateEmail(email); err != nil {
+		return nil, fmt.Errorf("email validation failed: %w", err)
+	}
+
+	if err := ValidatePassword(password); err != nil {
+		return nil, fmt.Errorf("password validation failed: %w", err)
+	}
+
+	user := &User{
+		ID:       generateID(),
+		Email:    email,
+		Name:     name,
+		Password: hashPassword(password),
+	}
+
+	return user, nil
+}
+
+// Private helpers
+func generateID() string {
+	return "user-" + randomString(16)
+}
+
+func hashPassword(password string) string {
+	// Simplified for example
+	return "hashed:" + password
+}
+
+func randomString(length int) string {
+	// Simplified for example
+	return strings.Repeat("x", length)
+}

packages/core/src/services/__fixtures__/legacy-javascript.js

@@ -0,0 +1,86 @@
+/**
+ * Legacy JavaScript Example
+ *
+ * Demonstrates older patterns:
+ * - CommonJS requires
+ * - throw-based error handling
+ * - No type annotations
+ * - module.exports
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+
+/**
+ * Validate email address
+ */
+function validateEmail(email) {
+  if (!email) {
+    throw new Error('Email is required');
+  }
+
+  if (!email.includes('@')) {
+    throw new Error('Invalid email format');
+  }
+
+  return true;
+}
+
+/**
+ * Hash password using crypto
+ */
+function hashPassword(password) {
+  if (!password || password.length < 8) {
+    throw new Error('Password must be at least 8 characters');
+  }
+
+  const salt = crypto.randomBytes(16).toString('hex');
+  const hash = crypto.pbkdf2Sync(password, salt, 1000, 64, 'sha512').toString('hex');
+
+  return { hash, salt };
+}
+
+/**
+ * Read user data from file
+ */
+function readUserData(filePath) {
+  if (!filePath) {
+    throw new Error('File path is required');
+  }
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error('File not found');
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Create user with validation
+ */
+function createUser(email, password, name) {
+  validateEmail(email);
+
+  if (!name) {
+    throw new Error('Name is required');
+  }
+
+  const { hash, salt } = hashPassword(password);
+
+  return {
+    id: crypto.randomUUID(),
+    email,
+    name,
+    passwordHash: hash,
+    salt,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+module.exports = {
+  validateEmail,
+  hashPassword,
+  readUserData,
+  createUser,
+};

packages/core/src/services/__fixtures__/mixed-patterns.ts

@@ -0,0 +1,58 @@
+/**
+ * Mixed Patterns Example
+ *
+ * Demonstrates inconsistent patterns (what we want to detect):
+ * - Mixed ESM and CJS (ESM imports but still some requires)
+ * - Mixed error handling (both throw and Result<T>)
+ * - Partial type annotations
+ */
+
+import type { User } from './types';
+
+const fs = require('node:fs'); // CJS require mixed with ESM!
+
+export type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+
+/**
+ * Load config from file - uses throw
+ */
+export function loadConfig(filePath) {
+  // Missing types!
+  if (!filePath) {
+    throw new Error('File path required'); // Uses throw
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return JSON.parse(content);
+}
+
+/**
+ * Validate user - uses Result<T>
+ */
+export function validateUser(data: unknown): Result<User> {
+  // Has types
+  if (!data) {
+    return { ok: false, error: new Error('Invalid data') }; // Uses Result
+  }
+
+  return { ok: true, value: data as User };
+}
+
+/**
+ * Process data - missing return type
+ */
+export async function processData(input: string) {
+  // Missing return type!
+  if (!input) {
+    throw new Error('Input required'); // Back to throw
+  }
+
+  return input.toUpperCase();
+}
+
+/**
+ * Helper with full types
+ */
+export function formatName(firstName: string, lastName: string): string {
+  return `${firstName} ${lastName}`;
+}