"Analyze the architecture and dependencies of [legacy module]"
"Document how this legacy code works"

# Find all files related to the feature
grep -r "LegacyClass" --include="*.js" --include="*.py" --include="*.java"

# Trace execution flow
echo "=== LEGACY CODE MAP ===" > legacy_analysis.md
echo "Entry points:" >> legacy_analysis.md
grep -r "main\|init\|start" --include="*.js" >> legacy_analysis.md

# Find dependencies
echo "Dependencies:" >> legacy_analysis.md
grep -r "require\|import\|include" legacy_module/ >> legacy_analysis.md

// Add temporary logging to understand flow
function legacyFunction(data) {
  console.log('[LEGACY TRACE] Input:', JSON.stringify(data));
  // ... existing code ...
  console.log('[LEGACY TRACE] Output:', result);
  return result;
}

"Generate characterization tests for this legacy code"

// Not testing if it's "right", just what it currently does
describe('Legacy System - Current Behavior', () => {
  it('should handle normal input as currently implemented', () => {
    const result = legacyFunction({ id: 1, name: 'test' });

    // Capture EXACT current output
    expect(result).toEqual({
      status: 'OK',
      data: 'TEST', // Even if this seems wrong!
      timestamp: expect.any(Number)
    });
  });

  it('should handle null input as currently implemented', () => {
    // Even if it crashes, document it!
    expect(() => legacyFunction(null)).toThrow('Cannot read property');
  });
});

# Capture current outputs
for input in test_inputs/*; do
  ./legacy_app < "$input" > "golden_masters/$(basename $input).output"
done

# After changes, verify outputs match
for input in test_inputs/*; do
  ./modernized_app < "$input" > temp.output
  diff "golden_masters/$(basename $input).output" temp.output
done

// Step 1: Create wrapper (Facade)
class ModernInterface {
  constructor() {
    this.legacy = new LegacySystem();
  }

  async processData(input) {
    // Modern interface
    const legacyFormat = this.convertToLegacyFormat(input);
    const result = this.legacy.oldProcessMethod(legacyFormat);
    return this.convertToModernFormat(result);
  }

  convertToLegacyFormat(modern) {
    // Transform modern input to legacy format
  }

  convertToModernFormat(legacy) {
    // Transform legacy output to modern format
  }
}

class DataProcessor {
  constructor(useModern = false) {
    this.useModern = useModern;
  }

  process(data) {
    if (this.useModern) {
      return this.modernProcess(data);
    }
    return this.legacyProcess(data);
  }

  legacyProcess(data) {
    // Original implementation
  }

  modernProcess(data) {
    // New implementation
  }
}

async function processWithVerification(data) {
  const [legacyResult, modernResult] = await Promise.all([
    legacyProcess(data),
    modernProcess(data)
  ]);

  // Compare results
  if (JSON.stringify(legacyResult) !== JSON.stringify(modernResult)) {
    console.error('Results mismatch!', { legacyResult, modernResult });
    // Use legacy result for safety
    return legacyResult;
  }

  // Both match, safe to use modern
  return modernResult;
}

getData(function(err, data) {
  if (err) return handleError(err);
  processData(data, function(err, result) {
    if (err) return handleError(err);
    saveResult(result, function(err) {
      if (err) return handleError(err);
      done();
    });
  });
});

async function modernFlow() {
  try {
    const data = await getData();
    const result = await processData(data);
    await saveResult(result);
    done();
  } catch (err) {
    handleError(err);
  }
}

var globalConfig = {};
var globalState = {};

function doSomething() {
  globalState.counter++;
  return globalConfig.prefix + globalState.counter;
}

class AppModule {
  constructor(config) {
    this.config = config;
    this.state = { counter: 0 };
  }

  doSomething() {
    this.state.counter++;
    return this.config.prefix + this.state.counter;
  }
}

export default AppModule;

const query = `SELECT * FROM users WHERE id = ${userId}`;
db.query(query);

const query = 'SELECT * FROM users WHERE id = ?';
db.query(query, [userId]);

// Mapping old to new
const DEPENDENCY_MAP = {
  'request': 'axios',           // HTTP client
  'async': 'native-promises',   // Flow control
  'underscore': 'lodash',       // Utilities
  'bower': 'npm',              // Package management
  'grunt': 'webpack',          // Build tool
  'jquery': 'vanilla-js',      // DOM manipulation
};

// Safe migration approach:
// 1. Install new alongside old
// 2. Migrate one file at a time
// 3. Run tests after each migration
// 4. Remove old when complete

// 🚨 Date handling
new Date('2024-01-01')  // Timezone issues!

// 🚨 Type coercion
if (value == true)  // Use === instead

// 🚨 Eval usage
eval(userInput)  // Security nightmare!

// 🚨 Synchronous I/O
const data = fs.readFileSync()  // Blocks everything!

// 🚨 Magic numbers
if (status === 2)  // What does 2 mean?

// 🚨 No error handling
JSON.parse(data)  // Will crash on bad input

# Use automated tools first
npx lebab --transform arrow,let,template legacy.js -o modern.js
npx eslint --fix legacy.js

# TypeScript migration
npx tsc --init
mv legacy.js legacy.ts
npx tsc --allowJs --checkJs

# Automated conversion
2to3 -w legacy.py

# Common fixes
print "Hello"     → print("Hello")
xrange()         → range()
unicode()        → str()

// jQuery
$('#element').hide();
$('.class').on('click', handler);

// Vanilla
document.getElementById('element').style.display = 'none';
document.querySelectorAll('.class').forEach(el => {
  el.addEventListener('click', handler);
});

## Legacy Modernization Scorecard

### Week 1 | Week 4 | Week 8
----------|---------|--------
Coverage: 0% | 45% | 78%
Security Issues: 12 | 6 | 1
Tech Debt (hours): 200 | 120 | 40
Build Time: 5min | 3min | 1min
Bundle Size: 2.4MB | 1.2MB | 600KB
Load Time: 4s | 2.5s | 1.2s

// Feature flags for safe rollout
if (featureFlags.useModernSystem) {
  return modernImplementation();
} else {
  return legacyImplementation();
}

// Database migrations with rollback
// up.sql
ALTER TABLE users ADD COLUMN email_verified BOOLEAN DEFAULT false;

// down.sql
ALTER TABLE users DROP COLUMN email_verified;