# Check file sizes
wc -l packages/*/src/**/*.ts

# Example output:
  456 packages/refactor-assistant/src/mcp-server.ts
  395 packages/security-scanner/src/scanner.ts
  411 packages/db-schema/src/designer.ts

// ❌ Magic numbers scattered throughout
if (complexity > 70) { /* ... */ }
if (lines > 1000) { /* ... */ }
if (imports > 50) { /* ... */ }
const threshold = 0.8;
const maxRetries = 3;

// ❌ Complex calculation embedded
function analyzeCode(file) {
  // 45 lines of complex logic
  // Multiple nested loops
  // Complex conditionals
  // Mathematical calculations
}

// ❌ Same pattern repeated 3+ times
function processFile1() {
  validateInput();
  parseContent();
  transformData();
}

function processFile2() {
  validateInput();  // Duplicate!
  parseContent();   // Duplicate!
  transformData();  // Duplicate!
}

// ❌ High cyclomatic complexity
function handleRequest(request) {
  if (condition1) {
    if (condition2) {
      if (condition3) {
        // Many nested branches
        // Multiple return paths
        // Complex error handling
      }
    }
  }
  // Complexity: 89
}

Is it a configuration value/threshold/pattern?
  YES → Extract to constants/

Is it a complex calculation (30+ LOC)?
  YES → Extract to helpers/

Is it used by multiple modules?
  YES → Extract to utils.ts

Is it cross-cutting concern (error handling, validation)?
  YES → Extract to utils.ts OR @j0kz/shared

Is it still >30 LOC after extraction?
  YES → Break into smaller functions

# Inside package directory
mkdir -p src/{constants,helpers}

# Verify structure
tree src/
src/
├── mcp-server.ts
├── main-logic.ts
├── types.ts
├── constants/
├── helpers/
└── utils.ts

/**
 * Complexity analysis thresholds
 */
export const COMPLEXITY_THRESHOLDS = {
  LOW: 20,
  MODERATE: 50,
  HIGH: 70,
  CRITICAL: 100,
} as const;

/**
 * File size limits (lines of code)
 */
export const SIZE_LIMITS = {
  TARGET: 300,
  WARNING: 400,
  MAXIMUM: 500,
} as const;

/**
 * Quality score weights
 */
export const QUALITY_WEIGHTS = {
  COMPLEXITY: 0.3,
  MAINTAINABILITY: 0.3,
  COVERAGE: 0.2,
  DUPLICATION: 0.2,
} as const;

if (complexity > 70) { /* ... */ }
if (lines > 300) { /* ... */ }
const score = complexity * 0.3 + maintainability * 0.3;

import { COMPLEXITY_THRESHOLDS, SIZE_LIMITS, QUALITY_WEIGHTS } from './constants/analysis-thresholds.js';

if (complexity > COMPLEXITY_THRESHOLDS.HIGH) { /* ... */ }
if (lines > SIZE_LIMITS.TARGET) { /* ... */ }
const score = complexity * QUALITY_WEIGHTS.COMPLEXITY +
              maintainability * QUALITY_WEIGHTS.MAINTAINABILITY;

import { COMPLEXITY_THRESHOLDS } from '../constants/analysis-thresholds.js';

/**
 * Calculate cyclomatic complexity for a function
 *
 * @param ast - Abstract syntax tree node
 * @returns Complexity score
 */
export function calculateComplexity(ast: any): number {
  let complexity = 1; // Base complexity

  // Count decision points
  const decisionNodes = [
    'IfStatement',
    'SwitchCase',
    'ConditionalExpression',
    'LogicalExpression',
    'ForStatement',
    'WhileStatement',
    'CatchClause',
  ];

  function traverse(node: any) {
    if (!node) return;

    if (decisionNodes.includes(node.type)) {
      complexity++;
    }

    // Recursive traversal
    for (const key in node) {
      if (node[key] && typeof node[key] === 'object') {
        traverse(node[key]);
      }
    }
  }

  traverse(ast);
  return complexity;
}

/**
 * Categorize complexity level
 *
 * @param complexity - Complexity score
 * @returns Level category
 */
export function categorizeComplexity(complexity: number): string {
  if (complexity <= COMPLEXITY_THRESHOLDS.LOW) return 'low';
  if (complexity <= COMPLEXITY_THRESHOLDS.MODERATE) return 'moderate';
  if (complexity <= COMPLEXITY_THRESHOLDS.HIGH) return 'high';
  return 'critical';
}

function analyzeFunction(ast) {
  // 45 lines of complexity calculation
  // Nested traversal logic
  // Multiple conditionals
  // Returns complexity score
}

import { calculateComplexity, categorizeComplexity } from './helpers/complexity-calculator.js';

function analyzeFunction(ast) {
  const complexity = calculateComplexity(ast);
  return categorizeComplexity(complexity);
}

/**
 * Validate file path for security
 *
 * @param filePath - Path to validate
 * @throws Error if path is invalid or unsafe
 */
export function validateFilePath(filePath: string): void {
  if (!filePath) {
    throw new Error('File path is required');
  }

  // Prevent path traversal
  if (filePath.includes('..')) {
    throw new Error('Path traversal detected');
  }

  // Ensure supported extension
  const ext = filePath.split('.').pop();
  const supported = ['ts', 'js', 'tsx', 'jsx'];
  if (!ext || !supported.includes(ext)) {
    throw new Error(`Unsupported file type: ${ext}`);
  }
}

/**
 * Format error message with context
 *
 * @param operation - Operation that failed
 * @param error - Original error
 * @returns Formatted error message
 */
export function formatError(operation: string, error: Error): string {
  return `Failed to ${operation}: ${error.message}`;
}

/**
 * Truncate long strings for logging
 *
 * @param str - String to truncate
 * @param maxLength - Maximum length
 * @returns Truncated string
 */
export function truncate(str: string, maxLength: number = 100): string {
  if (str.length <= maxLength) return str;
  return str.substring(0, maxLength - 3) + '...';
}

import { validateFilePath, formatError } from './utils.js';

try {
  validateFilePath(args.filePath);
  // Process file...
} catch (error) {
  return {
    success: false,
    errors: [formatError('process file', error)]
  };
}

cat .claude/skills/modular-refactoring-pattern/references/security-scanner-example.md

# 1. Analyze current state
npx @j0kz/smart-reviewer@latest review src/*.ts --metrics

# 2. Identify refactoring targets
wc -l src/*.ts | sort -rn

# 3. Apply refactoring pattern
npx @j0kz/refactor-assistant@latest refactor src/scanner.ts \
  --extract-constants \
  --extract-helpers \
  --target-size=300

# 4. Verify improvements
npx @j0kz/smart-reviewer@latest review src/*.ts --metrics

# 5. Run tests
npm test

# 6. Commit changes
git add -A
git commit -m "refactor: apply modular pattern to scanner

- Extract constants to constants/
- Extract helpers to helpers/
- Reduce main file from 395 to 209 LOC
- Improve complexity from 57 to 28"

// Extract to constants/config.ts
export const DEFAULT_CONFIG = {
  maxFileSize: 100000,
  excludePatterns: ['node_modules', 'dist'],
  supportedExtensions: ['.ts', '.js', '.tsx', '.jsx'],
  // ...
};

// Extract to helpers/validators.ts
export function isValidPath(path: string): boolean { /* ... */ }
export function isSupported(file: string): boolean { /* ... */ }
export function validateConfig(config: Config): void { /* ... */ }

// Extract to helpers/[domain].ts
export function calculateScore(metrics: Metrics): number { /* ... */ }
export function generateReport(results: Results): Report { /* ... */ }
export function analyzePatterns(code: string): Pattern[] { /* ... */ }

// Extract to utils.ts
export function wrapError(error: Error, context: string): Error { /* ... */ }
export function isRecoverableError(error: Error): boolean { /* ... */ }
export function formatErrorResponse(error: Error): Response { /* ... */ }