Benchmark: WebStorm 2026.1 vs VS Code 1.90 for Refactoring Large TypeScript 5.6 Monorepos

// api-types/src/response.ts
// TypeScript 5.6 monorepo shared type definition
// Original type to be renamed during benchmark
export type ApiResponse = {
  status: number;
  data: T;
  error?: string;
  metadata: {
    timestamp: Date;
    requestId: string;
    version: string;
  };
};

// Helper function to validate ApiResponse structure
export function isApiResponse(obj: unknown): obj is ApiResponse {
  try {
    if (typeof obj !== 'object' || obj === null) return false;
    const candidate = obj as Partial>;
    return (
      typeof candidate.status === 'number' &&
      'data' in candidate &&
      typeof candidate.metadata?.timestamp === 'object' &&
      candidate.metadata.timestamp instanceof Date &&
      typeof candidate.metadata.requestId === 'string'
    );
  } catch (err) {
    console.error(`ApiResponse validation failed: ${err instanceof Error ? err.message : String(err)}`);
    return false;
  }
}

// Usage in a downstream package: packages/user-service/src/handler.ts
import { ApiResponse } from '@monorepo/api-types';

interface User {
  id: string;
  email: string;
  roles: string[];
}

export async function getUser(id: string): Promise> {
  try {
    const response = await fetch(`/api/users/${id}`);
    if (!response.ok) {
      return {
        status: response.status,
        data: {} as User,
        error: `Failed to fetch user: ${response.statusText}`,
        metadata: {
          timestamp: new Date(),
          requestId: crypto.randomUUID(),
          version: '1.0.0'
        }
      };
    }
    const userData: User = await response.json();
    return {
      status: 200,
      data: userData,
      metadata: {
        timestamp: new Date(),
        requestId: crypto.randomUUID(),
        version: '1.0.0'
      }
    };
  } catch (err) {
    return {
      status: 500,
      data: {} as User,
      error: `getUser failed: ${err instanceof Error ? err.message : String(err)}`,
      metadata: {
        timestamp: new Date(),
        requestId: crypto.randomUUID(),
        version: '1.0.0'
      }
    };
  }
}

// Refactoring rename function with error handling
export function renameApiResponseType(newName: string): void {
  try {
    if (!newName || typeof newName !== 'string') {
      throw new Error('New type name must be a non-empty string');
    }
    if (!/^[A-Z][A-Za-z0-9]*$/.test(newName)) {
      throw new Error('Type name must start with uppercase letter and contain only alphanumeric characters');
    }
    console.log(`Renaming ApiResponse to ${newName}...`);
    // In practice, this would trigger IDE refactoring APIs
    // WebStorm 2026.1 uses: com.intellij.lang.javascript.refactoring.rename.JSRenameProcessor
    // VS Code 1.90 uses: vscode.commands.executeCommand('typescript.rename', uri, position)
  } catch (err) {
    console.error(`Rename failed: ${err instanceof Error ? err.message : String(err)}`);
    throw err; // Re-throw for caller handling
  }
}

// Example usage
if (require.main === module) {
  try {
    renameApiResponseType('ApiResult');
  } catch (err) {
    process.exit(1);
  }
}

// webstorm-benchmark.ts
// Node 20.11.0 script to benchmark WebStorm 2026.1 refactoring via CLI
// Requires WebStorm 2026.1 installed at /Applications/WebStorm.app
import { execSync, spawn } from 'child_process';
import { performance } from 'perf_hooks';
import fs from 'fs';
import path from 'path';

// Benchmark configuration
const MONOREPO_PATH = path.resolve('./ts-5.6-monorepo');
const WEBSTORM_CLI = '/Applications/WebStorm.app/Contents/MacOS/webstorm';
const REFACTOR_TYPE = 'rename';
const TARGET_FILE = path.join(MONOREPO_PATH, 'packages/api-types/src/response.ts');
const OLD_TYPE_NAME = 'ApiResponse';
const NEW_TYPE_NAME = 'ApiResult';

interface BenchmarkResult {
  tool: string;
  task: string;
  durationMs: number;
  ramMb: number;
  success: boolean;
  error?: string;
}

async function runWebStormRefactor(): Promise {
  const startTime = performance.now();
  let ramMb = 0;
  let success = false;
  let error: string | undefined;

  try {
    // Check if WebStorm CLI exists
    if (!fs.existsSync(WEBSTORM_CLI)) {
      throw new Error(`WebStorm CLI not found at ${WEBSTORM_CLI}`);
    }
    // Check if target file exists
    if (!fs.existsSync(TARGET_FILE)) {
      throw new Error(`Target file not found: ${TARGET_FILE}`);
    }

    // Start WebStorm refactoring via command line
    // Syntax: webstorm refactor rename   
    const refactorArgs = [
      'refactor',
      REFACTOR_TYPE,
      TARGET_FILE,
      OLD_TYPE_NAME,
      NEW_TYPE_NAME,
      '--monorepo-aware',
      '--type-script-5.6'
    ];

    console.log(`Running WebStorm refactor: ${WEBSTORM_CLI} ${refactorArgs.join(' ')}`);

    // Execute refactoring and capture RAM usage
    const proc = spawn(WEBSTORM_CLI, refactorArgs, {
      cwd: MONOREPO_PATH,
      stdio: ['ignore', 'pipe', 'pipe']
    });

    // Track RAM usage every 100ms
    const ramInterval = setInterval(() => {
      try {
        const ramOutput = execSync(`ps aux | grep -v grep | grep webstorm | awk '{print $6}'`).toString();
        const ramValues = ramOutput.split('\n').filter(v => v).map(Number);
        const currentRam = Math.max(...ramValues) / 1024; // Convert KB to MB
        if (currentRam > ramMb) ramMb = currentRam;
      } catch (err) {
        // Ignore RAM tracking errors
      }
    }, 100);

    // Wait for process to exit
    const exitCode = await new Promise((resolve) => {
      proc.on('close', resolve);
      proc.on('error', (err) => {
        error = err.message;
        resolve(1);
      });
    });

    clearInterval(ramInterval);

    if (exitCode !== 0) {
      throw new Error(`WebStorm refactor exited with code ${exitCode}: ${error}`);
    }

    // Verify rename succeeded
    const fileContent = fs.readFileSync(TARGET_FILE, 'utf-8');
    if (fileContent.includes(OLD_TYPE_NAME)) {
      throw new Error(`Rename failed: ${OLD_TYPE_NAME} still present in target file`);
    }
    if (!fileContent.includes(NEW_TYPE_NAME)) {
      throw new Error(`Rename failed: ${NEW_TYPE_NAME} not found in target file`);
    }

    success = true;
  } catch (err) {
    error = err instanceof Error ? err.message : String(err);
    success = false;
  } finally {
    const endTime = performance.now();
    return {
      tool: 'WebStorm 2026.1',
      task: `Rename ${OLD_TYPE_NAME} to ${NEW_TYPE_NAME}`,
      durationMs: endTime - startTime,
      ramMb,
      success,
      error
    };
  }
}

// Run benchmark if this is the main module
if (require.main === module) {
  runWebStormRefactor()
    .then((result) => {
      console.log(JSON.stringify(result, null, 2));
      process.exit(result.success ? 0 : 1);
    })
    .catch((err) => {
      console.error(`Benchmark failed: ${err.message}`);
      process.exit(1);
    });
}

// vscode-benchmark.ts
// Node 20.11.0 script to benchmark VS Code 1.90 refactoring via LSP
// Requires VS Code 1.90 installed at /Applications/Visual Studio Code.app
import { spawn, execSync } from 'child_process';
import { performance } from 'perf_hooks';
import fs from 'fs';
import path from 'path';
import { createInterface } from 'readline';

// Benchmark configuration (matches WebStorm config for parity)
const MONOREPO_PATH = path.resolve('./ts-5.6-monorepo');
const VSCODE_CLI = '/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code';
const LSP_PORT = 6009;
const TARGET_FILE = path.join(MONOREPO_PATH, 'packages/api-types/src/response.ts');
const OLD_TYPE_NAME = 'ApiResponse';
const NEW_TYPE_NAME = 'ApiResult';

interface BenchmarkResult {
  tool: string;
  task: string;
  durationMs: number;
  ramMb: number;
  success: boolean;
  error?: string;
}

async function runVSCodeRefactor(): Promise {
  const startTime = performance.now();
  let ramMb = 0;
  let success = false;
  let error: string | undefined;

  try {
    // Check if VS Code CLI exists
    if (!fs.existsSync(VSCODE_CLI)) {
      throw new Error(`VS Code CLI not found at ${VSCODE_CLI}`);
    }
    // Check if target file exists
    if (!fs.existsSync(TARGET_FILE)) {
      throw new Error(`Target file not found: ${TARGET_FILE}`);
    }

    // Start VS Code LSP server for TypeScript 5.6
    const lspArgs = [
      '--lsp',
      `--port=${LSP_PORT}`,
      '--type-script-version=5.6.2',
      '--monorepo'
    ];
    console.log(`Starting VS Code LSP: ${VSCODE_CLI} ${lspArgs.join(' ')}`);

    const lspProc = spawn(VSCODE_CLI, lspArgs, {
      cwd: MONOREPO_PATH,
      stdio: ['pipe', 'pipe', 'pipe']
    });

    // Track RAM usage every 100ms
    const ramInterval = setInterval(() => {
      try {
        const ramOutput = execSync(`ps aux | grep -v grep | grep code | awk '{print $6}'`).toString();
        const ramValues = ramOutput.split('\n').filter(v => v).map(Number);
        const currentRam = Math.max(...ramValues) / 1024; // Convert KB to MB
        if (currentRam > ramMb) ramMb = currentRam;
      } catch (err) {
        // Ignore RAM tracking errors
      }
    }, 100);

    // Wait for LSP server to start
    await new Promise(resolve => setTimeout(resolve, 5000));

    // Send rename request to LSP server
    const renameRequest = JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'textDocument/rename',
      params: {
        textDocument: { uri: `file://${TARGET_FILE}` },
        position: { line: 1, character: 13 }, // Position of ApiResponse type name
        newName: NEW_TYPE_NAME
      }
    });

    // Write request to LSP stdin
    lspProc.stdin.write(renameRequest + '\n');

    // Read LSP response
    const rl = createInterface({ input: lspProc.stdout });
    let responseReceived = false;
    rl.on('line', (line) => {
      if (line.includes('result')) {
        responseReceived = true;
        rl.close();
      }
    });

    // Wait for response or timeout after 30s
    await new Promise(resolve => setTimeout(resolve, 30000));
    if (!responseReceived) {
      throw new Error('LSP rename request timed out after 30s');
    }

    // Stop LSP server
    lspProc.kill();
    clearInterval(ramInterval);

    // Verify rename succeeded
    const fileContent = fs.readFileSync(TARGET_FILE, 'utf-8');
    if (fileContent.includes(OLD_TYPE_NAME)) {
      throw new Error(`Rename failed: ${OLD_TYPE_NAME} still present in target file`);
    }
    if (!fileContent.includes(NEW_TYPE_NAME)) {
      throw new Error(`Rename failed: ${NEW_TYPE_NAME} not found in target file`);
    }

    success = true;
  } catch (err) {
    error = err instanceof Error ? err.message : String(err);
    success = false;
  } finally {
    const endTime = performance.now();
    return {
      tool: 'VS Code 1.90',
      task: `Rename ${OLD_TYPE_NAME} to ${NEW_TYPE_NAME}`,
      durationMs: endTime - startTime,
      ramMb,
      success,
      error
    };
  }
}

// Run benchmark if this is the main module
if (require.main === module) {
  runVSCodeRefactor()
    .then((result) => {
      console.log(JSON.stringify(result, null, 2));
      process.exit(result.success ? 0 : 1);
    })
    .catch((err) => {
      console.error(`Benchmark failed: ${err.message}`);
      process.exit(1);
    });
}

rm -rf ~/Library/Caches/WebStorm2026.1/ts-monorepo-cache

{
  "typescript.tsdk": "node_modules/typescript/lib",
  "typescript.enablePromptUseWorkspaceTsdk": true,
  "typescript.preferences.useWorkspaceDependencies": true,
  "typescript.monorepoSupport": true
}

name: Refactoring Benchmark
on:
  schedule:
    - cron: '0 0 * * 1' # Run every Monday
jobs:
  benchmark:
    runs-on: macos-15
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20.11.0
      - name: Run WebStorm Benchmark
        run: ts-node webstorm-benchmark.ts
      - name: Run VS Code Benchmark
        run: ts-node vscode-benchmark.ts
      - name: Post Results to Slack
        uses: slackapi/slack-github-action@v1.24.0
        with:
          slack-bot-token: ${{ secrets.SLACK_BOT_TOKEN }}
          channel-id: 'benchmarks'
          text: 'Weekly refactoring benchmark results attached.'