Add CLI startup profiling feature to diagnose Windows performance issues

Author: bhouston

packages/cli/src/commands/test-profile.ts

@@ -0,0 +1,14 @@
+import { CommandModule } from 'yargs';
+import { SharedOptions } from '../options.js';
+
+export const command: CommandModule<object, SharedOptions> = {
+  command: 'test-profile',
+  describe: 'Test the profiling feature',
+  handler: async () => {
+    console.log('Profile test completed successfully');
+    // Profiling report will be automatically displayed by the main function
+    
+    // Force a delay to simulate some processing
+    await new Promise(resolve => setTimeout(resolve, 100));
+  },
+};

packages/cli/src/index.ts

@@ -8,24 +8,47 @@ import { hideBin } from 'yargs/helpers';
 import { command as defaultCommand } from './commands/$default.js';
 import { command as configCommand } from './commands/config.js';
 import { command as testSentryCommand } from './commands/test-sentry.js';
+import { command as testProfileCommand } from './commands/test-profile.js';
 import { command as toolsCommand } from './commands/tools.js';
 import { sharedOptions } from './options.js';
 import { initSentry, captureException } from './sentry/index.js';
-initSentry();
+import { enableProfiling, mark, reportTimings } from './utils/performance.js';
+
+mark('After imports');
 
 import type { PackageJson } from 'type-fest';
 
 // Add global declaration for our patched toolAgent
 
+mark('Before sourceMapSupport install');
 sourceMapSupport.install();
+mark('After sourceMapSupport install');
 
 const main = async () => {
+  // Parse argv early to check for profiling flag
+  const parsedArgv = await yargs(hideBin(process.argv)).options(sharedOptions).parse();
+  
+  // Enable profiling if --profile flag is set
+  enableProfiling(Boolean(parsedArgv.profile));
+  
+  mark('Main function start');
+  
   dotenv.config();
-
+  mark('After dotenv config');
+  
+  // Only initialize Sentry if needed
+  if (process.env.NODE_ENV !== 'development' || process.env.ENABLE_SENTRY === 'true') {
+    initSentry();
+    mark('After Sentry init');
+  }
+  
+  mark('Before package.json load');
   const require = createRequire(import.meta.url);
   const packageInfo = require('../package.json') as PackageJson;
-
+  mark('After package.json load');
+  
   // Set up yargs with the new CLI interface
+  mark('Before yargs setup');
   await yargs(hideBin(process.argv))
     .scriptName(packageInfo.name!)
     .version(packageInfo.version!)
@@ -35,16 +58,23 @@ const main = async () => {
     .command([
       defaultCommand,
       testSentryCommand,
+      testProfileCommand,
       toolsCommand,
       configCommand,
     ] as CommandModule[])
     .strict()
     .showHelpOnFail(true)
     .help().argv;
+  mark('After yargs setup');
+  
+  // Report timings if profiling is enabled
+  await reportTimings();
 };
 
-await main().catch((error) => {
+await main().catch(async (error) => {
   console.error(error);
+  // Report profiling data even if there's an error
+  await reportTimings();
   // Capture the error with Sentry
   captureException(error);
   process.exit(1);

packages/cli/src/options.ts

@@ -9,6 +9,7 @@ export type SharedOptions = {
   readonly sentryDsn?: string;
   readonly modelProvider?: string;
   readonly modelName?: string;
+  readonly profile?: boolean;
 };
 
 export const sharedOptions = {
@@ -19,6 +20,11 @@ export const sharedOptions = {
     default: 'info',
     choices: ['debug', 'verbose', 'info', 'warn', 'error'],
   } as const,
+  profile: {
+    type: 'boolean',
+    description: 'Enable performance profiling of CLI startup',
+    default: false,
+  } as const,
   modelProvider: {
     type: 'string',
     description: 'AI model provider to use',

packages/cli/src/utils/performance.ts

@@ -0,0 +1,88 @@
+import { performance } from 'perf_hooks';
+
+// Store start time as soon as this module is imported
+const cliStartTime = performance.now();
+const timings: Record<string, number> = {};
+let isEnabled = false;
+
+/**
+ * Enable or disable performance tracking
+ */
+export function enableProfiling(enabled: boolean): void {
+  isEnabled = enabled;
+}
+
+/**
+ * Mark a timing point in the application
+ */
+export function mark(label: string): void {
+  if (!isEnabled) return;
+  timings[label] = performance.now() - cliStartTime;
+}
+
+/**
+ * Log all collected performance metrics
+ */
+export async function reportTimings(): Promise<void> {
+  if (!isEnabled) return;
+  
+  console.log('\n📊 Performance Profile:');
+  console.log('=======================');
+  
+  // Sort timings by time value
+  const sortedTimings = Object.entries(timings)
+    .sort((a, b) => a[1] - b[1]);
+  
+  // Calculate durations between steps
+  let previousTime = 0;
+  for (const [label, time] of sortedTimings) {
+    const duration = time - previousTime;
+    console.log(`${label}: ${time.toFixed(2)}ms (${duration.toFixed(2)}ms)`);
+    previousTime = time;
+  }
+  
+  console.log(`Total startup time: ${previousTime.toFixed(2)}ms`);
+  console.log('=======================\n');
+
+  // Report platform-specific information if on Windows
+  if (process.platform === 'win32') {
+    await reportPlatformInfo();
+  }
+}
+
+/**
+ * Collect and report platform-specific information
+ */
+async function reportPlatformInfo(): Promise<void> {
+  if (!isEnabled) return;
+  
+  console.log('\n🖥️ Platform Information:');
+  console.log('=======================');
+  console.log(`Platform: ${process.platform}`);
+  console.log(`Architecture: ${process.arch}`);
+  console.log(`Node.js version: ${process.version}`);
+  
+  // Windows-specific information
+  if (process.platform === 'win32') {
+    console.log('Windows-specific details:');
+    console.log(`- Current working directory: ${process.cwd()}`);
+    console.log(`- Path length: ${process.cwd().length} characters`);
+    
+    // Check for antivirus markers by measuring file read time
+    try {
+      // Using dynamic import to avoid require
+      const fs = await import('fs');
+      const startTime = performance.now();
+      fs.readFileSync(process.execPath);
+      console.log(`- Time to read Node.js executable: ${(performance.now() - startTime).toFixed(2)}ms`);
+    } catch (error: unknown) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.log(`- Error reading Node.js executable: ${errorMessage}`);
+    }
+  }
+  
+  console.log('=======================\n');
+}
+
+// Initial mark for module load time
+mark('Module initialization');