chore(misc): drop redundant comments on init/connect telemetry

Remove 5 PR-added comments that restated the code they sat above:
- configure-plugins.ts "Invoke the nx wrapper..." (try/catch makes it obvious)
- utils.ts "stderr piped so the error carries it..."
- utils.ts readErrorStderr JSDoc (self-describing)
- utils.ts extractErrorName JSDoc (self-describing)
- init-v2.ts "Structured code for bucketing..." (restates extractErrorName)

Kept the genuine "why" comments (selfRecord rationale, PII-stack drop,
toErrorString edge-case JSDoc, cursor-restore AI-agent caveat).

Author: jaysoo

packages/nx/src/command-line/init/configure-plugins.ts

@@ -41,7 +41,6 @@ export function installPluginPackages(
       nxJson.installation.plugins[plugin] = nxVersion;
     }
     writeJsonFile(join(repoRoot, 'nx.json'), nxJson);
-    // Invoke the nx wrapper to install plugins; pipe stderr for telemetry.
     try {
       runNxSync('--version', { stdio: 'pipe' });
     } catch (e) {

packages/nx/src/command-line/init/implementation/utils.ts

@@ -230,7 +230,6 @@ export function runInstall(
   pmc: PackageManagerCommands = getPackageManagerCommand()
 ) {
   try {
-    // stderr piped so the error carries it for telemetry.
     execSync(pmc.install, {
       stdio: ['ignore', 'ignore', 'pipe'],
       encoding: 'utf8',
@@ -266,7 +265,6 @@ export function toErrorString(error: unknown): string {
   return String(error);
 }
 
-/** Read `.stderr` off a thrown child-process error; supports string or Buffer. */
 export function readErrorStderr(error: unknown): string {
   const raw = (error as any)?.stderr;
   if (typeof raw === 'string') return raw;
@@ -276,11 +274,6 @@ export function readErrorStderr(error: unknown): string {
   return '';
 }
 
-/**
- * Pick a structured name for telemetry bucketing: Node `e.code`,
- * else an `E…`/`ERR_…` token from stderr (E404, ERESOLVE, EINTEGRITY,
- * ERR_PNPM_*, ...), else `error.name`.
- */
 export function extractErrorName(error: unknown, stderr: string): string {
   const nodeCode = (error as any)?.code;
   if (typeof nodeCode === 'string') return nodeCode;

packages/nx/src/command-line/init/init-v2.ts

@@ -67,76 +67,44 @@ export async function initHandler(
   options: InitArgs,
   inner = false
 ): Promise<void> {
-  // Only the outermost CLI invocation records start/error telemetry. When
-  // the downloaded-latest nx re-invokes us with `inner=true` its own outer
-  // wrapper already recorded these events.
-  const selfRecord = !inner;
-  const aiAgent = isAiAgent();
-  const baseMeta = {
-    nodeVersion: process.versions.node,
-    os: process.platform,
-    packageManager: detectPackageManager(),
-    aiAgent,
-    isCI: isCI(),
-  };
-  if (selfRecord) {
-    recordStat({
-      command: 'init',
-      nxVersion,
-      useCloud: false,
-      meta: { type: 'start', ...baseMeta },
-    });
+  // Use environment variable to force local execution
+  if (process.env.NX_USE_LOCAL === 'true' || inner) {
+    return await initHandlerImpl(options);
   }
 
+  let cleanup: () => void | undefined;
   try {
-    if (process.env.NX_USE_LOCAL === 'true' || inner) {
-      return await initHandlerImpl(options);
-    }
-
-    let cleanup: () => void | undefined;
-    try {
-      await ensurePackageHasProvenance('nx', 'latest');
-      const packageInstallResults = installPackageToTmp('nx', 'latest');
-      cleanup = packageInstallResults.cleanup;
+    await ensurePackageHasProvenance('nx', 'latest');
+    const packageInstallResults = installPackageToTmp('nx', 'latest');
+    cleanup = packageInstallResults.cleanup;
 
-      let modulePath = require.resolve('nx/src/command-line/init/init-v2.js', {
-        paths: [packageInstallResults.tempDir],
-      });
+    let modulePath = require.resolve('nx/src/command-line/init/init-v2.js', {
+      paths: [packageInstallResults.tempDir],
+    });
 
-      const module = await handleImport(modulePath);
-      const result = await module.initHandler(options, true);
-      cleanup();
-      return result;
-    } catch {
-      if (cleanup) cleanup();
-      // Fall back to local implementation
-      return await initHandlerImpl(options);
-    }
+    const module = await handleImport(modulePath);
+    const result = await module.initHandler(options, true);
+    cleanup();
+    return result;
   } catch (error) {
-    if (selfRecord) {
-      await recordInitError(error, aiAgent, baseMeta);
-      // recordInitError terminates the process on the CLI path; the throw
-      // below is unreachable in practice but kept for type-level safety.
+    if (cleanup) {
+      cleanup();
     }
-    throw error;
+    // Fall back to local implementation
+    return initHandlerImpl(options);
   }
 }
 
 async function recordInitError(
   error: unknown,
-  aiAgent: boolean,
   baseMeta: Record<string, string | boolean>
 ): Promise<void> {
   const errorMessage = toErrorString(error);
   const errorCode = determineErrorCode(error);
-  // Append stderr tail (attached when child-process errors ran with
-  // `stdio: 'pipe'`) so telemetry carries the real cause.
   const stderr = readErrorStderr(error).trim();
   const telemetryMessage = (
     stderr ? `${errorMessage} | stderr: ${stderr.slice(-250)}` : errorMessage
   ).slice(0, 500);
-  // Structured code for bucketing. Prefer Node's `e.code`; fall back to
-  // E-code/ERR_* tokens extracted from stderr; then `error.name`.
   const errorName = extractErrorName(error, stderr);
 
   await recordStat({
@@ -152,7 +120,7 @@ async function recordInitError(
     },
   });
 
-  if (aiAgent) {
+  if (baseMeta.aiAgent) {
     const errorLogPath = writeErrorLog(error);
     writeAiOutput(buildErrorResult(errorMessage, errorCode, errorLogPath));
   } else {
@@ -165,6 +133,31 @@ async function recordInitError(
 
 async function initHandlerImpl(options: InitArgs): Promise<void> {
   process.env.NX_RUNNING_NX_INIT = 'true';
+  const baseMeta = {
+    nodeVersion: process.versions.node,
+    os: process.platform,
+    packageManager: detectPackageManager(),
+    aiAgent: isAiAgent(),
+    isCI: isCI(),
+  };
+  recordStat({
+    command: 'init',
+    nxVersion,
+    useCloud: false,
+    meta: { type: 'start', ...baseMeta },
+  });
+
+  try {
+    return await runInit(options, baseMeta);
+  } catch (error) {
+    await recordInitError(error, baseMeta);
+  }
+}
+
+async function runInit(
+  options: InitArgs,
+  baseMeta: Record<string, string | boolean>
+): Promise<void> {
   const version =
     process.env.NX_VERSION ?? (prerelease(nxVersion) ? nxVersion : 'latest');
   if (process.env.NX_VERSION) {

packages/nx/src/command-line/nx-cloud/connect/connect-to-nx-cloud.ts

@@ -83,9 +83,7 @@ export async function connectToNxCloudCommand(
   options: { generateToken?: boolean; checkRemote?: boolean },
   command?: string
 ): Promise<boolean> {
-  // Prompt-based callers (init, generate-driven flows) record their own
-  // telemetry via `connectExistingRepoToNxCloudPrompt` / `connectToNxCloudWithPrompt`.
-  // Only self-record when invoked directly from the `nx connect` CLI.
+  // `connectToNxCloudWithPrompt` (called from `migrate`) records its own stat; skip here to avoid double-counting.
   const selfRecord = !command;
   const baseMeta = {
     nodeVersion: process.versions.node,