Why VS Code 1.95 Is Worse Than JetBrains Fleet 2.0 for Large Monorepos

import psutil
import time
import subprocess
import sys
import logging
from typing import Optional, Dict, Tuple

# Configure logging to suppress unnecessary output
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

class EditorBenchmarker:
    """Benchmark editor startup and indexing performance for large monorepos."""

    def __init__(self, editor_path: str, monorepo_path: str, editor_name: str):
        self.editor_path = editor_path
        self.monorepo_path = monorepo_path
        self.editor_name = editor_name
        self.process: Optional[subprocess.Popen] = None
        self.editor_pid: Optional[int] = None

    def launch_editor(self) -> bool:
        """Launch the editor with the monorepo workspace. Returns True if successful."""
        try:
            logger.info(f"Launching {self.editor_name} at {self.editor_path}")
            self.process = subprocess.Popen(
                [self.editor_path, self.monorepo_path],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True
            )
            self.editor_pid = self.process.pid
            # Wait for editor process to initialize (max 30s)
            for _ in range(30):
                if psutil.pid_exists(self.editor_pid):
                    logger.info(f"Editor process started with PID {self.editor_pid}")
                    return True
                time.sleep(1)
            logger.error("Editor process failed to start within 30s")
            return False
        except FileNotFoundError:
            logger.error(f"Editor executable not found at {self.editor_path}")
            return False
        except Exception as e:
            logger.error(f"Unexpected error launching editor: {str(e)}")
            return False

    def wait_for_indexing_complete(self, timeout: int = 600) -> bool:
        """Wait for editor indexing to complete. Returns True if indexing finished within timeout."""
        start_time = time.time()
        # VS Code uses 'code' process, Fleet uses 'Fleet' process
        process_name = "code" if "Code" in self.editor_name else "Fleet"
        while time.time() - start_time < timeout:
            try:
                # Find all editor-related processes
                for proc in psutil.process_iter(["pid", "name", "cpu_percent"]):
                    if proc.info["name"] == process_name:
                        # Indexing typically uses >15% CPU for editors
                        if proc.info["cpu_percent"] < 5.0:
                            logger.info(f"Indexing complete for {self.editor_name}")
                            return True
                time.sleep(2)
            except psutil.NoSuchProcess:
                logger.error("Editor process terminated unexpectedly")
                return False
            except Exception as e:
                logger.error(f"Error checking indexing status: {str(e)}")
                return False
        logger.error(f"Indexing timed out after {timeout}s")
        return False

    def get_memory_usage(self) -> Optional[float]:
        """Get total memory usage (RSS) of editor and all child processes in GB."""
        if not self.editor_pid or not psutil.pid_exists(self.editor_pid):
            logger.error("Editor process not running")
            return None
        total_memory = 0.0
        try:
            main_proc = psutil.Process(self.editor_pid)
            # Sum memory of main process and all children
            for proc in [main_proc] + main_proc.children(recursive=True):
                total_memory += proc.memory_info().rss
            return total_memory / (1024 ** 3)  # Convert bytes to GB
        except psutil.NoSuchProcess:
            logger.error("Editor process terminated while measuring memory")
            return None

    def run_benchmark(self) -> Dict[str, float]:
        """Run full benchmark: startup time, indexing time, memory usage."""
        results = {}
        start_time = time.time()
        if not self.launch_editor():
            return results
        startup_time = time.time() - start_time
        results["startup_time_s"] = startup_time
        logger.info(f"Startup time: {startup_time:.2f}s")

        if not self.wait_for_indexing_complete():
            return results
        indexing_time = time.time() - start_time - startup_time
        results["indexing_time_s"] = indexing_time
        logger.info(f"Indexing time: {indexing_time:.2f}s")

        memory_usage = self.get_memory_usage()
        if memory_usage:
            results["memory_usage_gb"] = memory_usage
            logger.info(f"Memory usage: {memory_usage:.2f}GB")

        # Cleanup
        self.cleanup()
        return results

    def cleanup(self):
        """Terminate editor process and all children."""
        if self.editor_pid and psutil.pid_exists(self.editor_pid):
            try:
                main_proc = psutil.Process(self.editor_pid)
                main_proc.terminate()
                main_proc.wait(timeout=10)
                logger.info(f"Terminated {self.editor_name} process")
            except Exception as e:
                logger.error(f"Error terminating process: {str(e)}")

if __name__ == "__main__":
    # Configuration - update paths to match your environment
    VS_CODE_PATH = "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code"
    FLEET_PATH = "/Applications/JetBrains Fleet.app/Contents/MacOS/fleet"
    MONOREPO_PATH = "/Users/developer/monorepos/ts-large-12m"  # 12.4M line TS monorepo

    # Benchmark VS Code 1.95
    vs_code_benchmarker = EditorBenchmarker(
        editor_path=VS_CODE_PATH,
        monorepo_path=MONOREPO_PATH,
        editor_name="VS Code 1.95"
    )
    vs_code_results = vs_code_benchmarker.run_benchmark()
    logger.info(f"VS Code 1.95 Results: {vs_code_results}")

    # Benchmark Fleet 2.0
    fleet_benchmarker = EditorBenchmarker(
        editor_path=FLEET_PATH,
        monorepo_path=MONOREPO_PATH,
        editor_name="JetBrains Fleet 2.0"
    )
    fleet_results = fleet_benchmarker.run_benchmark()
    logger.info(f"Fleet 2.0 Results: {fleet_results}")

    # Print comparison
    print("\n=== Benchmark Comparison ===")
    for metric in ["startup_time_s", "indexing_time_s", "memory_usage_gb"]:
        vs_val = vs_code_results.get(metric, 0)
        fleet_val = fleet_results.get(metric, 0)
        if vs_val and fleet_val:
            diff = (vs_val / fleet_val) if fleet_val != 0 else 0
            print(f"{metric}: VS Code {vs_val:.2f}s vs Fleet {fleet_val:.2f}s (Fleet {diff:.1f}x faster)")

import { createConnection, TextDocuments, Diagnostic, DiagnosticSeverity, ProposedFeatures, InitializeParams, DidChangeConfigurationNotification, CompletionItem, CompletionItemKind, TextDocumentPositionParams, DocumentSymbolParams, SymbolInformation, RenameParams, WorkspaceEdit } from "vscode-languageserver/node";
import { TextDocument } from "vscode-languageserver-textdocument";
import { execSync } from "child_process";
import { writeFileSync, unlinkSync, existsSync } from "fs";
import { join } from "path";

// Initialize LSP connection with all proposed features
const connection = createConnection(ProposedFeatures.all);
const documents: TextDocuments = new TextDocuments(TextDocument);

let hasConfigurationCapability = false;
let hasWorkspaceFolderCapability = false;
let workspaceFolders: string[] = [];

// Track benchmark metrics
interface BenchmarkMetrics {
    renameTimeMs: number;
    filesAffected: number;
    errorCount: number;
}

// Generate a test monorepo structure with cross-file symbol references
function generateTestMonorepo(basePath: string, fileCount: number, linesPerFile: number): void {
    try {
        for (let i = 0; i < fileCount; i++) {
            const filePath = join(basePath, `test-file-${i}.ts`);
            // Generate a class with a symbol to rename, referenced in other files
            const content = `export class TestSymbol${i} {
    private name: string = "test";

    constructor(name: string) {
        this.name = name;
    }

    public getName(): string {
        return this.name;
    }
}

// Reference to symbol for renaming
const instance${i} = new TestSymbol${i}("sample-${i}");
console.log(instance${i}.getName());
`;
            writeFileSync(filePath, content, "utf-8");
        }
        connection.console.log(`Generated ${fileCount} test files in ${basePath}`);
    } catch (error) {
        connection.console.error(`Failed to generate test monorepo: ${error}`);
        throw error;
    }
}

// Benchmark symbol rename across multiple files
async function benchmarkSymbolRename(docUri: string, symbolName: string, newName: string, fileCount: number): Promise {
    const metrics: BenchmarkMetrics = {
        renameTimeMs: 0;
        filesAffected: 0;
        errorCount: 0
    };

    try {
        const startTime = Date.now();
        // Prepare rename parameters
        const renameParams: RenameParams = {
            textDocument: { uri: docUri },
            position: { line: 0, character: 13 }, // Position of class name
            newName: newName
        };

        // Send rename request to LSP server (simulates editor action)
        const edit: WorkspaceEdit | null = await connection.sendRequest("textDocument/rename", renameParams);
        metrics.renameTimeMs = Date.now() - startTime;

        if (!edit) {
            metrics.errorCount++;
            connection.console.error("Rename request returned no edits");
            return metrics;
        }

        // Count affected files
        metrics.filesAffected = Object.keys(edit.changes || {}).length;
        connection.console.log(`Rename completed in ${metrics.renameTimeMs}ms, affected ${metrics.filesAffected} files`);
    } catch (error) {
        metrics.errorCount++;
        connection.console.error(`Rename benchmark failed: ${error}`);
    }

    return metrics;
}

// Connection initialization handler
connection.onInitialize((params: InitializeParams) => {
    const capabilities = params.capabilities;
    workspaceFolders = params.workspaceFolders?.map(folder => folder.uri) || [];

    hasConfigurationCapability = !!(
        capabilities.workspace && !!capabilities.workspace.configuration
    );
    hasWorkspaceFolderCapability = !!(
        capabilities.workspace && !!capabilities.workspace.workspaceFolders
    );

    return {
        capabilities: {
            textDocumentSync: {
                openClose: true,
                change: 1, // Full document sync
                willSaveWaitUntil: false,
                save: { includeText: false }
            },
            renameProvider: {
                prepareProvider: true
            },
            completionProvider: {
                resolveProvider: true
            },
            documentSymbolProvider: true
        }
    };
});

// Workspace folder change handler
connection.onDidChangeWorkspaceFolders(event => {
    connection.console.log("Workspace folder change event received");
    workspaceFolders = event.added.map(folder => folder.uri).concat(
        workspaceFolders.filter(uri => !event.removed.some(removed => removed.uri === uri))
    );
});

// Start the server
documents.listen(connection);
connection.listen();

// Run benchmark if executed directly (not imported as module)
if (require.main === module) {
    const TEST_MONOREPO_PATH = "/tmp/ts-rename-benchmark";
    const FILE_COUNT = 50; // Simulate 50 files with cross references
    const TEST_URI = `file://${join(TEST_MONOREPO_PATH, "test-file-0.ts")}`;

    try {
        // Generate test files
        generateTestMonorepo(TEST_MONOREPO_PATH, FILE_COUNT, 100);

        // Run rename benchmark
        benchmarkSymbolRename(TEST_URI, "TestSymbol0", "RenamedSymbol0", FILE_COUNT)
            .then(metrics => {
                console.log("\n=== Symbol Rename Benchmark Results ===");
                console.log(`Rename Time: ${metrics.renameTimeMs}ms`);
                console.log(`Files Affected: ${metrics.filesAffected}`);
                console.log(`Error Count: ${metrics.errorCount}`);

                // Cleanup test files
                for (let i = 0; i < FILE_COUNT; i++) {
                    const filePath = join(TEST_MONOREPO_PATH, `test-file-${i}.ts`);
                    if (existsSync(filePath)) unlinkSync(filePath);
                }
                process.exit(0);
            })
            .catch(error => {
                console.error("Benchmark failed:", error);
                process.exit(1);
            });
    } catch (error) {
        console.error("Setup failed:", error);
        process.exit(1);
    }
}

#!/bin/bash

# Fleet Monorepo Workspace Setup Script
# Automates configuration of JetBrains Fleet 2.0 for large monorepos with 100+ workspace folders
# Requires: bash 4.0+, jq, fleet CLI installed in PATH

set -euo pipefail  # Exit on error, undefined variables, pipe failures

# Configuration - update these values for your monorepo
MONOREPO_ROOT="/Users/developer/monorepos/java-large-10m"
WORKSPACE_FILE="${MONOREPO_ROOT}/.fleet/workspace.json"
FLEET_CLI="fleet"
MAX_FOLDERS=200  # Maximum number of workspace folders to include
LOG_FILE="/tmp/fleet-setup-$(date +%Y%m%d-%H%M%S).log"

# Redirect all output to log file and stdout
exec > >(tee -a "${LOG_FILE}") 2>&1

log() {
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $1"
}

error() {
    log "ERROR: $1"
    exit 1
}

# Validate prerequisites
validate_prerequisites() {
    log "Validating prerequisites..."
    if ! command -v "${FLEET_CLI}" &> /dev/null; then
        error "Fleet CLI not found in PATH. Install Fleet 2.0 and add to PATH."
    fi
    if ! command -v jq &> /dev/null; then
        error "jq not installed. Install jq to parse JSON configs."
    fi
    if [ ! -d "${MONOREPO_ROOT}" ]; then
        error "Monorepo root not found: ${MONOREPO_ROOT}"
    fi
    log "Prerequisites validated successfully."
}

# Detect workspace folders (Maven modules for Java, package.json for TS, etc.)
detect_workspace_folders() {
    log "Detecting workspace folders in ${MONOREPO_ROOT}..."
    local folders=()

    # Detect Java Maven modules
    while IFS= read -r -d '' pom_file; do
        local module_dir=$(dirname "${pom_file}")
        folders+=("${module_dir}")
        if [ ${#folders[@]} -ge "${MAX_FOLDERS}" ]; then
            log "Reached maximum folder limit: ${MAX_FOLDERS}"
            break
        fi
    done < <(find "${MONOREPO_ROOT}" -name "pom.xml" -print0 2>/dev/null)

    # Detect TypeScript package.json folders
    while IFS= read -r -d '' package_file; do
        local module_dir=$(dirname "${package_file}")
        # Avoid duplicates
        if [[ ! " ${folders[@]} " =~ " ${module_dir} " ]]; then
            folders+=("${module_dir}")
            if [ ${#folders[@]} -ge "${MAX_FOLDERS}" ]; then
                log "Reached maximum folder limit: ${MAX_FOLDERS}"
                break
            fi
        fi
    done < <(find "${MONOREPO_ROOT}" -name "package.json" -print0 2>/dev/null)

    log "Detected ${#folders[@]} workspace folders."
    echo "${folders[@]}"
}

# Generate Fleet workspace configuration
generate_workspace_config() {
    local folders=("$@")
    log "Generating Fleet workspace config at ${WORKSPACE_FILE}..."

    # Create .fleet directory if it doesn't exist
    mkdir -p "$(dirname "${WORKSPACE_FILE}")"

    # Build JSON array of folder paths (convert to file:// URIs)
    local folder_uris=()
    for folder in "${folders[@]}"; do
        folder_uris+=("\"file://${folder}\"")
    done
    local folders_json=$(IFS=,; echo "${folder_uris[*]}")

    # Write workspace config with monorepo-optimized settings
    cat > "${WORKSPACE_FILE}" << EOF
{
  "folders": [${folders_json}],
  "settings": {
    "editor.maxMemory": "8192m",
    "indexing.exclude": ["**/node_modules/**", "**/target/**", "**/.git/**"],
    "search.exclude": ["**/node_modules/**", "**/target/**"],
    "typescript.preferences.includePackageJsonAutoImports": "on",
    "java.maven.downloadSources": false,
    "editor.formatOnSave": false
  }
}
EOF

    if [ -f "${WORKSPACE_FILE}" ]; then
        log "Workspace config generated successfully."
    else
        error "Failed to write workspace config to ${WORKSPACE_FILE}"
    fi
}

# Validate generated workspace config
validate_workspace_config() {
    log "Validating workspace config..."
    if ! jq empty "${WORKSPACE_FILE}" 2>/dev/null; then
        error "Invalid JSON in workspace config: ${WORKSPACE_FILE}"
    fi
    local folder_count=$(jq '.folders | length' "${WORKSPACE_FILE}")
    log "Workspace config contains ${folder_count} folders."
}

# Open Fleet with generated workspace
open_fleet_workspace() {
    log "Opening Fleet with configured workspace..."
    if ! "${FLEET_CLI}" "${MONOREPO_ROOT}"; then
        error "Failed to open Fleet workspace"
    fi
    log "Fleet workspace opened successfully. Check ${LOG_FILE} for details."
}

# Main execution flow
main() {
    log "Starting Fleet monorepo workspace setup..."
    validate_prerequisites
    local workspace_folders=($(detect_workspace_folders))
    if [ ${#workspace_folders[@]} -eq 0 ]; then
        error "No workspace folders detected in ${MONOREPO_ROOT}"
    fi
    generate_workspace_config "${workspace_folders[@]}"
    validate_workspace_config
    read -p "Open Fleet with this workspace now? (y/n) " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        open_fleet_workspace
    else
        log "Setup complete. Open workspace manually with: fleet ${MONOREPO_ROOT}"
    fi
}

main

// .vscode/settings.json
{
  "files.watcherExclude": {
    "**/node_modules/**": true,
    "**/target/**": true,
    "**/.git/**": true,
    "**/dist/**": true,
    "**/.turbo/**": true
  },
  "files.restoreExclude": [
    "**/node_modules/**",
    "**/target/**"
  ],
  "search.exclude": {
    "**/node_modules": true,
    "**/target": true
  }
}

// .fleet/workspace.json (native monorepo config)
{
  "folders": ["file:///monorepo/root"],
  "settings": {
    "monorepo.autoDetect": true,
    "monorepo.excludePatterns": ["**/node_modules/**", "**/target/**"],
    "indexing.priority": "monorepo-modules"
  }
}

// .fleet/settings.json (distributed cache config)
{
  "indexing.cachePath": "file:///shared-nas/fleet-index-cache",
  "indexing.cacheMode": "read-write",
  "indexing.updateInterval": "15m"
}