Remove --vscode diff option from emitter-diff (HTML report is sufficient)

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: l0lawrence

eng/emitter-diff/README.md

@@ -15,7 +15,7 @@ contains no language-specific logic.
 ```
             baseline emitter ─┐
                               ├─ generate (adapter) ─► <work>/baseline ─┐
-   specs ─────────────────────┤                                        ├─► git diff ─► terminal / VS Code / HTML
+   specs ─────────────────────┤                                        ├─► git diff ─► terminal / HTML
                               ├─ generate (adapter) ─► <work>/head ─────┘
             head emitter ─────┘                                        └─► (optional) run test suites
 ```
@@ -53,14 +53,13 @@ npx tsx eng/emitter-diff/src/cli.ts --emitter python --baseline 0.34.0
 ### Common options
 
 By default the tool writes a **clickable HTML report** (`emitter-diff.html`) into the work dir and
-prints a `file://` link to it. Use `--vscode` for a live VS Code diff, `--terminal` for the full
-patch in your shell, or `--patch`/`--html` to write to a specific file.
+prints a `file://` link to it. Use `--terminal` for the full patch in your shell, or
+`--patch`/`--html` to write to a specific file.
 
 | Option                  | Description                                                                           |
 | ----------------------- | ------------------------------------------------------------------------------------- |
 | `--name <pattern>`      | Filter which specs/packages are generated                                             |
 | `--html <file>`         | Write the rendered HTML report to this path (default: `<work-dir>/emitter-diff.html`) |
-| `--vscode`              | Open the diff in VS Code instead of writing HTML                                      |
 | `--terminal`            | Print the full colored patch to the terminal instead                                  |
 | `--patch <file>`        | Write the raw unified diff to a file                                                  |
 | `--fail-on-diff`        | Exit non-zero when output differs (CI gating)                                         |
@@ -70,19 +69,13 @@ patch in your shell, or `--patch`/`--html` to write to a specific file.
 | `--opt key=value`       | Repeatable adapter-specific option (e.g. `--opt flavor=azure`)                        |
 | `-- <args>`             | Everything after `--` is forwarded to the adapter                                     |
 
-> `--open` is kept as an alias for `--vscode`.
-
 ### Examples
 
 ```bash
 # Default: writes a clickable emitter-diff.html and prints a file:// link.
 npx tsx eng/emitter-diff/src/cli.ts --emitter python --baseline 0.34.0 \
   --opt flavor=azure --name authentication-api-key
 
-# Open the diff live in VS Code instead:
-npx tsx eng/emitter-diff/src/cli.ts --emitter python --baseline 0.34.0 \
-  --opt flavor=azure --name authentication-api-key --vscode
-
 # Compare two source folders and write an HTML report to a specific path:
 npx tsx eng/emitter-diff/src/cli.ts --emitter python \
   --baseline local:/path/to/old/http-client-python \
@@ -95,49 +88,6 @@ npx tsx eng/emitter-diff/src/cli.ts --emitter python \
   flavor=azure --run-tests --test-env test,mypy,pyright < sha > --opt
 ```
 
-## Viewing the diff in VS Code
-
-`--vscode` gives you a native, side-by-side source diff of the two generated trees. VS Code has
-no CLI to diff two _folders_ (`code --diff` only compares two files), so the tool stages the
-comparison as a throwaway git working tree under `<work-dir>/vscode-diff`: the **baseline** tree
-is committed, the **head** tree is overlaid on top and left staged. Opening that folder shows
-every changed generated file in the **Source Control** panel with red/green diffs — click any
-file for the side-by-side view.
-
-```bash
-# Keep the scratch dir so it survives the run, and open the diff in VS Code:
-npx tsx eng/emitter-diff/src/cli.ts --emitter python \
-  --baseline npm:0.60.0 --opt flavor=azure --name encode/duration \
-  --work-dir ./emitter-diff-out --vscode
-```
-
-If you generated the trees without `--vscode` (or want to reopen later), build the same view by
-hand from the `baseline/` and `head/` folders under your `--work-dir` and open it in VS Code:
-
-```bash
-cd ./emitter-diff-out
-git init -q vscode-diff
-cp -r baseline/. vscode-diff/
-git -C vscode-diff add -A && git -C vscode-diff commit -qm baseline
-# overlay head on top, keeping .git
-find vscode-diff -mindepth 1 -maxdepth 1 ! -name .git -exec rm -rf {} +
-cp -r head/. vscode-diff/
-git -C vscode-diff add -A
-code vscode-diff # browse changes in the Source Control panel
-```
-
-```powershell
-# PowerShell equivalent of the overlay step:
-cd .\emitter-diff-out
-git init -q vscode-diff
-Copy-Item -Recurse -Force .\baseline\* .\vscode-diff
-git -C vscode-diff add -A; git -C vscode-diff commit -qm baseline
-Get-ChildItem .\vscode-diff -Force | Where-Object Name -ne ".git" | Remove-Item -Recurse -Force
-Copy-Item -Recurse -Force .\head\* .\vscode-diff
-git -C vscode-diff add -A
-code vscode-diff
-```
-
 ## CI integration
 
 `.github/workflows/ci-emitter-diff-python.yml` runs on PRs that touch the python emitter or this

eng/emitter-diff/src/cli.ts

@@ -9,7 +9,7 @@
 import { join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 
-import { diffDirs, openInVsCode, printDiff, printSummary, writeHtml, writePatch } from "./diff.js";
+import { diffDirs, printDiff, printSummary, writeHtml, writePatch } from "./diff.js";
 import { getAdapter, listAdapters } from "./registry.js";
 import {
   classifyRef,
@@ -42,7 +42,6 @@ ${color.bold("Options:")}
   --work-dir <dir>        Scratch dir (default: a temp dir).
   --html <file>           Write the rendered HTML diff to this path.
                           Default output: a clickable HTML report in the work dir.
-  --vscode                Open the diff in VS Code instead of writing HTML.
   --terminal              Print the full colored patch to the terminal instead.
   --patch <file>          Write the raw unified diff to a file.
   --fail-on-diff          Exit non-zero when output differs (CI gating). Exit
@@ -74,8 +73,6 @@ async function main(): Promise<number> {
       specs: { type: "string" },
       name: { type: "string" },
       "work-dir": { type: "string" },
-      open: { type: "boolean" },
-      vscode: { type: "boolean" },
       terminal: { type: "boolean" },
       patch: { type: "string" },
       html: { type: "string" },
@@ -119,9 +116,7 @@ async function main(): Promise<number> {
   // path handed to them — the resolved emitter dir and the baseline/head output
   // dirs — must be absolute or outputs land in the wrong tree and the diff is
   // silently empty (a false "no differences").
-  const workDir = ensureDir(
-    values["work-dir"] ? resolve(values["work-dir"]) : defaultWorkDir(),
-  );
+  const workDir = ensureDir(values["work-dir"] ? resolve(values["work-dir"]) : defaultWorkDir());
   log.info(`${color.dim("work dir:")} ${workDir}`);
 
   const ctx: AdapterContext = {
@@ -220,14 +215,10 @@ async function main(): Promise<number> {
 
   // Decide how to present the diff. Explicit flags win; otherwise the default
   // is a clickable HTML report written to the work dir.
-  const wantsVsCode = Boolean(values.vscode || values.open);
   const wantsTerminal = Boolean(values.terminal);
   const wantsPatch = Boolean(values.patch);
   const htmlTarget =
-    values.html ??
-    (!wantsVsCode && !wantsTerminal && !wantsPatch
-      ? join(workDir, "emitter-diff.html")
-      : undefined);
+    values.html ?? (!wantsTerminal && !wantsPatch ? join(workDir, "emitter-diff.html") : undefined);
 
   if (!diff.hasChanges) {
     log.success("No differences between baseline and head output.");
@@ -239,7 +230,6 @@ async function main(): Promise<number> {
 
   if (wantsPatch) writePatch(diff, values.patch as string, log);
   if (htmlTarget) await writeHtml(diff, htmlTarget, log);
-  if (wantsVsCode) await openInVsCode(baselineOut, headOut, workDir, log);
 
   // Optionally run test suites.
   if (values["run-tests"]) {

eng/emitter-diff/src/diff.ts

@@ -2,16 +2,15 @@
  * Diff engine. One canonical unified patch (`git diff --no-index`) is the
  * source of truth; it is then rendered for whichever environment is in use:
  *  - terminal: colored patch + summary
- *  - local `--open`: VS Code folder diff
  *  - CI `--html`: rendered via diff2html (optional dependency, lazily loaded)
  */
-import { cpSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import type { Logger } from "./types.js";
-import { color, run, runChecked } from "./util.js";
+import { color, run } from "./util.js";
 
 export interface DiffResult {
   /** The unified patch text (empty when there are no differences). */
@@ -190,73 +189,3 @@ ${body}
   log.success(`Wrote HTML diff to ${abs}`);
   log.info(`${color.bold("Open it:")} ${pathToFileURL(abs).href}`);
 }
-
-/**
- * Open a native side-by-side diff of the two generated trees in VS Code.
- *
- * VS Code has no CLI to diff two folders (`code --diff` only compares two
- * files), so we materialize the comparison as a throwaway git working-tree
- * change: commit the baseline tree, then overlay the head tree on top and leave
- * it unstaged. Opening that folder surfaces every changed generated file in the
- * Source Control view with red/green side-by-side diffs.
- */
-export async function openInVsCode(
-  baselineDir: string,
-  headDir: string,
-  workDir: string,
-  log: Logger,
-): Promise<void> {
-  log.step("Preparing VS Code diff");
-  const repo = join(workDir, "vscode-diff");
-  rmSync(repo, { recursive: true, force: true });
-  mkdirSync(repo, { recursive: true });
-
-  const git = (args: string[]) =>
-    runChecked("git", [
-      "-C",
-      repo,
-      "-c",
-      "user.email=emitter-diff@local",
-      "-c",
-      "user.name=emitter-diff",
-      "-c",
-      "commit.gpgsign=false",
-      "-c",
-      "core.autocrlf=false",
-      ...args,
-    ]);
-
-  await git(["init", "-q"]);
-  // Commit the baseline tree as the starting point.
-  cpSync(baselineDir, repo, { recursive: true });
-  await git(["add", "-A"]);
-  await git(["commit", "-q", "-m", "baseline", "--allow-empty"]);
-
-  // Overlay the head tree (keeping .git), then stage so VS Code shows the diff.
-  for (const entry of readdirSync(repo)) {
-    if (entry === ".git") continue;
-    rmSync(join(repo, entry), { recursive: true, force: true });
-  }
-  cpSync(headDir, repo, { recursive: true });
-  // Drop all index entries first, then re-add. A plain `git add -A` decides a
-  // file is unchanged from (size, mtime) and skips re-hashing it; because the
-  // baseline commit and the head overlay are written within the same second,
-  // a same-size content edit would be treated as clean and never staged (so it
-  // would silently not appear in VS Code). Clearing the index forces git to
-  // re-hash every file's content, surfacing every real modification.
-  await git(["rm", "-r", "--cached", "-q", "--", "."]);
-  await git(["add", "-A"]);
-
-  const result = await run("code", [repo]);
-  if (result.code !== 0) {
-    log.warn(
-      "Could not launch VS Code (`code` not on PATH?). Open the folder manually " +
-        `and use the Source Control view to browse the diff: ${repo}`,
-    );
-    return;
-  }
-  log.success(
-    `Opened ${repo} in VS Code — use the Source Control panel to browse the diff ` +
-      "(baseline = last commit, head = working tree).",
-  );
-}