@hienlh/ppm 0.19.12 → 0.20.0

package/packages/ext-git-graph/src/panel-nav.ts

@@ -0,0 +1,65 @@
+/**
+ * Navigation between this extension's panels.
+ *
+ * `createWebviewPanel` alone is not enough: the frontend only *creates a tab*
+ * for a `webview:create` that some browser tab explicitly asked for
+ * (`locallyDispatchedViews` in `use-extension-ws.ts`). A panel the extension
+ * opens on its own initiative would exist server-side with no tab to show it.
+ *
+ * So navigation goes the other way round: ask the frontend to open an extension
+ * tab for the target viewType. `extension-webview.tsx` then finds a tab with no
+ * panel and dispatches the matching command itself — which *is* a local
+ * dispatch, so the panel binds to the tab.
+ *
+ * That recovery dispatch only forwards the project path, so the actual target
+ * (file to blame, refs to compare) is stashed here and picked up by the panel
+ * when it opens. If the stash is empty the panel just shows its own picker.
+ */
+import type { ExtensionContext } from "@ppm/vscode-compat";
+import type { VscodeApi } from "./git-exec.ts";
+import { resolveProjectName } from "./ppm-api.ts";
+
+const pendingTargets = new Map<string, unknown>();
+
+function targetKey(viewType: string, projectPath: string): string {
+  return `${viewType} ${projectPath}`;
+}
+
+export function setPendingTarget(viewType: string, projectPath: string, target: unknown): void {
+  pendingTargets.set(targetKey(viewType, projectPath), target);
+}
+
+/** Read and clear the target a navigation left for this panel. */
+export function takePendingTarget<T>(viewType: string, projectPath: string): T | undefined {
+  const k = targetKey(viewType, projectPath);
+  const value = pendingTargets.get(k) as T | undefined;
+  pendingTargets.delete(k);
+  return value;
+}
+
+export interface NavigateOptions {
+  vscode: VscodeApi;
+  context: ExtensionContext;
+  /** Target viewType, identical to the command that opens it. */
+  viewType: string;
+  title: string;
+  projectPath: string;
+  /** Handed to the target panel via the stash. */
+  target?: unknown;
+}
+
+export async function navigateToPanel(options: NavigateOptions): Promise<void> {
+  const { vscode, context, viewType, title, projectPath, target } = options;
+  if (target !== undefined) setPendingTarget(viewType, projectPath, target);
+  const projectName = await resolveProjectName(projectPath);
+  await vscode.window.openTab("extension", title, projectName, {
+    viewType,
+    extensionId: context.extensionId,
+    projectName,
+  });
+}
+
+/** Test seam. */
+export function _resetPendingTargets(): void {
+  pendingTargets.clear();
+}

package/packages/ext-git-graph/src/panel-registry.ts

@@ -0,0 +1,72 @@
+/**
+ * One live panel per (viewType, project).
+ *
+ * Keying by project alone would make opening Blame dispose the Git Graph panel
+ * of the same project, since both go through this registry. Keying by viewType
+ * alone would let one project's panel hijack another's tab across browser tabs
+ * — the bug fixed in v0.9.x. Both parts of the key are required.
+ */
+import type { ExtWebviewPanel, VscodeApi } from "./git-exec.ts";
+
+const panels = new Map<string, ExtWebviewPanel>();
+
+function key(viewType: string, projectPath: string): string {
+  // Written as an escape, never as the byte itself: one raw NUL makes git
+  // call the whole file binary, and every diff of it becomes "Binary files
+  // differ" — the file stops being reviewable at all.
+  return `${viewType}\u0000${projectPath}`;
+}
+
+export interface OpenPanelOptions {
+  vscode: VscodeApi;
+  viewType: string;
+  title: string;
+  projectPath: string;
+  html: string;
+  onMessage: (msg: unknown, panel: ExtWebviewPanel) => void | Promise<void>;
+  /** Extra teardown for timers the caller owns. */
+  onDispose?: () => void;
+}
+
+export function openPanel(options: OpenPanelOptions): ExtWebviewPanel {
+  const { vscode, viewType, title, projectPath, html, onMessage, onDispose } = options;
+  const k = key(viewType, projectPath);
+
+  // Dispose the stale panel for THIS viewType + project only. On page reload the
+  // browser's WS close message can be lost, leaving the map referencing a panel
+  // the browser no longer knows about.
+  panels.get(k)?.dispose(); // fires onDidDispose → clears map entry & timers
+
+  const panel = vscode.window.createWebviewPanel(
+    viewType,
+    title,
+    vscode.ViewColumn.Active,
+    { projectPath },
+  );
+  panels.set(k, panel);
+  panel.webview.html = html;
+
+  const msgDisposable = panel.webview.onDidReceiveMessage((raw: unknown) => {
+    void onMessage(raw, panel);
+  });
+
+  const disposeDisposable = panel.onDidDispose(() => {
+    // Only clear if the map still points at THIS panel — a newer panel for the
+    // same key must not be evicted by an older one's teardown.
+    if (panels.get(k) === panel) panels.delete(k);
+    msgDisposable.dispose();
+    disposeDisposable.dispose();
+    onDispose?.();
+  });
+
+  return panel;
+}
+
+/** Test seam: drop all registry state. */
+export function _resetPanelRegistry(): void {
+  panels.clear();
+}
+
+export function _panelCount(): number {
+  return panels.size;
+}

package/packages/ext-git-graph/src/ppm-api.ts

@@ -0,0 +1,48 @@
+/**
+ * Thin client for the PPM HTTP API, used to map a project path to the project
+ * name that `window.openTab` needs. Initialised once from `activate`.
+ */
+let baseUrl = "";
+let authToken = "";
+
+export function initPpmApi(): void {
+  baseUrl = (globalThis as any).__PPM_BASE_URL__ || "";
+  authToken = (globalThis as any).__PPM_AUTH_TOKEN__ || "";
+}
+
+/** Build fetch options with auth header when token is available */
+export function authHeaders(): RequestInit {
+  return authToken ? { headers: { Authorization: `Bearer ${authToken}` } } : {};
+}
+
+export function getBaseUrl(): string {
+  return baseUrl;
+}
+
+/** Resolve project path from PPM API as fallback */
+export async function resolveProjectPath(): Promise<string | null> {
+  try {
+    const res = await fetch(`${baseUrl}/api/projects`, authHeaders());
+    const json = await res.json() as { ok: boolean; data?: { name: string; path: string }[] };
+    if (!json.ok || !json.data || json.data.length === 0) return null;
+    // Single project — safe to auto-select
+    if (json.data.length === 1) return json.data[0]?.path ?? null;
+    // Multiple projects — cannot guess which is active, return null
+    return null;
+  } catch {}
+  return null;
+}
+
+/** Resolve project name from path via PPM API */
+export async function resolveProjectName(projectPath: string): Promise<string> {
+  try {
+    const res = await fetch(`${baseUrl}/api/projects`, authHeaders());
+    const json = await res.json() as { ok: boolean; data?: { name: string; path: string }[] };
+    if (json.ok && json.data) {
+      const match = json.data.find((p) => p.path === projectPath);
+      if (match) return match.name;
+    }
+  } catch {}
+  // Fallback to directory name
+  return projectPath.split(/[\\/]/).filter(Boolean).pop() || "project";
+}

package/packages/ext-git-graph/src/rebase-todo.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect } from "bun:test";
+import {
+  REWORD_ENV_PREFIX, SEQUENCE_EDITOR, TODO_ENV_VAR,
+  buildRebaseTodo, isNoopPlan, isRebaseAction,
+} from "./rebase-todo.ts";
+
+const A = "a".repeat(40);
+const B = "b".repeat(40);
+const C = "c".repeat(40);
+
+describe("buildRebaseTodo", () => {
+  it("writes one line per commit, oldest first", () => {
+    const { todo } = buildRebaseTodo([
+      { hash: A, action: "pick", subject: "first" },
+      { hash: B, action: "pick", subject: "second" },
+    ]);
+
+    expect(todo).toBe(`pick ${A} first\npick ${B} second\n`);
+  });
+
+  it("keeps squash and fixup actions", () => {
+    const { todo } = buildRebaseTodo([
+      { hash: A, action: "pick", subject: "base" },
+      { hash: B, action: "squash", subject: "fold in" },
+      { hash: C, action: "fixup", subject: "typo" },
+    ]);
+
+    expect(todo).toBe(`pick ${A} base\nsquash ${B} fold in\nfixup ${C} typo\n`);
+  });
+
+  it("omits a dropped commit rather than writing a drop line", () => {
+    const { todo } = buildRebaseTodo([
+      { hash: A, action: "pick", subject: "keep" },
+      { hash: B, action: "drop", subject: "remove" },
+    ]);
+
+    expect(todo).toBe(`pick ${A} keep\n`);
+    expect(todo).not.toContain("drop");
+  });
+
+  it("refuses a plan that drops everything", () => {
+    expect(() => buildRebaseTodo([{ hash: A, action: "drop" }]))
+      .toThrow(/nothing to rebase/);
+  });
+
+  it("refuses to squash the oldest kept commit", () => {
+    // There is no earlier commit for it to fold into; git would abort.
+    expect(() => buildRebaseTodo([
+      { hash: A, action: "squash", subject: "x" },
+      { hash: B, action: "pick", subject: "y" },
+    ])).toThrow(/oldest kept commit/);
+  });
+
+  it("looks past dropped commits when checking the oldest kept one", () => {
+    expect(() => buildRebaseTodo([
+      { hash: A, action: "drop" },
+      { hash: B, action: "fixup", subject: "y" },
+    ])).toThrow(/oldest kept commit/);
+  });
+
+  it("refuses a hash that is not a hash", () => {
+    expect(() => buildRebaseTodo([{ hash: "--exec=rm -rf /", action: "pick" }]))
+      .toThrow(/Invalid commit hash/);
+  });
+
+  it("collapses a multi-line subject so it cannot add a second command", () => {
+    const { todo } = buildRebaseTodo([
+      { hash: A, action: "pick", subject: "first line\nexec touch /tmp/pwned" },
+    ]);
+
+    expect(todo.trimEnd().split("\n")).toHaveLength(1);
+    expect(todo).toBe(`pick ${A} first line exec touch /tmp/pwned\n`);
+  });
+
+  it("writes a bare command when a commit has no subject", () => {
+    expect(buildRebaseTodo([{ hash: A, action: "pick" }]).todo).toBe(`pick ${A}\n`);
+  });
+
+  it("ends with a newline so git can parse the last command", () => {
+    expect(buildRebaseTodo([{ hash: A, action: "pick", subject: "x" }]).todo.endsWith("\n")).toBe(true);
+  });
+});
+
+describe("isRebaseAction", () => {
+  it("accepts every supported action", () => {
+    for (const action of ["pick", "reword", "edit", "squash", "fixup", "drop"]) {
+      expect(isRebaseAction(action)).toBe(true);
+    }
+  });
+
+  it("rejects anything else", () => {
+    expect(isRebaseAction("exec")).toBe(false);
+    expect(isRebaseAction(undefined)).toBe(false);
+  });
+});
+
+describe("buildRebaseTodo — reword", () => {
+  it("picks the commit and amends it from an environment variable", () => {
+    const { todo, env } = buildRebaseTodo([
+      { hash: A, action: "reword", subject: "old subject", message: "new subject" },
+    ]);
+
+    // The message never enters the todo text, so nothing in it can be read as a
+    // second command however it is punctuated.
+    expect(todo).toBe(
+      `pick ${A} old subject\nexec git commit --amend --allow-empty -m "$${REWORD_ENV_PREFIX}0"\n`,
+    );
+    expect(env).toEqual({ [`${REWORD_ENV_PREFIX}0`]: "new subject" });
+  });
+
+  it("numbers each reword separately", () => {
+    const { todo, env } = buildRebaseTodo([
+      { hash: A, action: "reword", subject: "one", message: "first" },
+      { hash: B, action: "pick", subject: "two" },
+      { hash: C, action: "reword", subject: "three", message: "third" },
+    ]);
+
+    expect(env).toEqual({
+      [`${REWORD_ENV_PREFIX}0`]: "first",
+      [`${REWORD_ENV_PREFIX}1`]: "third",
+    });
+    expect(todo).toContain(`$${REWORD_ENV_PREFIX}1`);
+  });
+
+  it("keeps a message that would be a shell disaster inline", () => {
+    const nasty = '"; rm -rf / #';
+    const { env } = buildRebaseTodo([
+      { hash: A, action: "reword", subject: "x", message: nasty },
+    ]);
+
+    expect(env[`${REWORD_ENV_PREFIX}0`]).toBe(nasty);
+  });
+
+  it("keeps a multi-line message whole, unlike a subject", () => {
+    const { env } = buildRebaseTodo([
+      { hash: A, action: "reword", subject: "x", message: "title\n\nbody line" },
+    ]);
+
+    expect(env[`${REWORD_ENV_PREFIX}0`]).toBe("title\n\nbody line");
+  });
+
+  it("refuses a reword with no message", () => {
+    expect(() => buildRebaseTodo([{ hash: A, action: "reword", subject: "x", message: "   " }]))
+      .toThrow(/Reword needs a new message/);
+    expect(() => buildRebaseTodo([{ hash: A, action: "reword", subject: "x" }]))
+      .toThrow(/Reword needs a new message/);
+  });
+
+  it("adds no environment when nothing is reworded", () => {
+    expect(buildRebaseTodo([{ hash: A, action: "pick" }]).env).toEqual({});
+  });
+});
+
+describe("buildRebaseTodo — edit", () => {
+  it("writes edit straight through, since git only stops there", () => {
+    const { todo, env } = buildRebaseTodo([
+      { hash: A, action: "pick", subject: "base" },
+      { hash: B, action: "edit", subject: "stop here" },
+    ]);
+
+    expect(todo).toBe(`pick ${A} base\nedit ${B} stop here\n`);
+    expect(env).toEqual({});
+  });
+});
+
+describe("isNoopPlan", () => {
+  it("recognises an unchanged plan", () => {
+    expect(isNoopPlan(
+      [{ hash: A, action: "pick" }, { hash: B, action: "pick" }],
+      [A, B],
+    )).toBe(true);
+  });
+
+  it("sees a reorder", () => {
+    expect(isNoopPlan(
+      [{ hash: B, action: "pick" }, { hash: A, action: "pick" }],
+      [A, B],
+    )).toBe(false);
+  });
+
+  it("sees a changed action", () => {
+    expect(isNoopPlan(
+      [{ hash: A, action: "pick" }, { hash: B, action: "squash" }],
+      [A, B],
+    )).toBe(false);
+  });
+});
+
+describe("sequence editor wiring", () => {
+  it("reads the todo from an environment variable, not from the command string", () => {
+    // Git pastes the editor string into a shell command; keeping the todo in an
+    // env var means no quoting of the todo or of the todo path can go wrong.
+    expect(SEQUENCE_EDITOR).toContain(`$${TODO_ENV_VAR}`);
+    expect(SEQUENCE_EDITOR.trimEnd().endsWith(">")).toBe(true);
+  });
+});

package/packages/ext-git-graph/src/rebase-todo.ts

@@ -0,0 +1,119 @@
+/**
+ * Todo-list generation for interactive rebase.
+ *
+ * `git rebase -i` opens its todo list in `$GIT_SEQUENCE_EDITOR`. Git invokes it
+ * as `sh -c "$GIT_SEQUENCE_EDITOR \"$@\"" <editor> <todo-path>`, so the editor
+ * string is pasted into a shell command while the todo path arrives as `$@`.
+ * Passing the replacement todo through an *environment variable* keeps it out of
+ * that command string entirely — no quoting to get wrong, no temp file to write
+ * or clean up, and a path containing spaces still works:
+ *
+ *     GIT_SEQUENCE_EDITOR='printf "%s" "$PPM_REBASE_TODO" >'
+ *     PPM_REBASE_TODO='pick abc1234 …'
+ *
+ * `reword` uses the same trick a second time. Git's own `reword` would open
+ * `$GIT_EDITOR` mid-rebase and block, which the extension API cannot answer, so
+ * the message is collected up front and applied by an `exec` line that reads it
+ * from the environment:
+ *
+ *     pick abc1234 old subject
+ *     exec git commit --amend --allow-empty -m "$PPM_REWORD_0"
+ *
+ * `edit` needs none of that. It only *stops* the rebase — git does not open an
+ * editor for it — and the panel already offers Continue/Skip/Abort for a rebase
+ * that is paused.
+ */
+
+export const REBASE_ACTIONS = ["pick", "reword", "edit", "squash", "fixup", "drop"] as const;
+export type RebaseAction = (typeof REBASE_ACTIONS)[number];
+
+export const TODO_ENV_VAR = "PPM_REBASE_TODO";
+export const SEQUENCE_EDITOR = `printf "%s" "$${TODO_ENV_VAR}" >`;
+/** Each reworded commit gets `${REWORD_ENV_PREFIX}<n>` holding its new message. */
+export const REWORD_ENV_PREFIX = "PPM_REWORD_";
+
+export interface RebaseTodoEntry {
+  hash: string;
+  action: RebaseAction;
+  /** Only used to comment the line, so a human reading `git status` can follow. */
+  subject?: string;
+  /** The replacement commit message. Required when `action` is "reword". */
+  message?: string;
+}
+
+export interface RebasePlan {
+  /** The todo body, for `TODO_ENV_VAR`. */
+  todo: string;
+  /** Reword messages, keyed by their environment variable name. */
+  env: Record<string, string>;
+}
+
+export function isRebaseAction(value: unknown): value is RebaseAction {
+  return typeof value === "string" && (REBASE_ACTIONS as readonly string[]).includes(value);
+}
+
+/**
+ * Build the todo body from entries in **oldest-first** order — the order git
+ * itself uses. The panel lists commits newest-first, so it reverses before
+ * calling this.
+ */
+export function buildRebaseTodo(entries: RebaseTodoEntry[]): RebasePlan {
+  const kept = entries.filter((e) => e.action !== "drop");
+  const oldest = kept[0];
+  if (!oldest) {
+    throw new Error("Dropping every commit would leave nothing to rebase.");
+  }
+  if (oldest.action === "squash" || oldest.action === "fixup") {
+    throw new Error(
+      `The oldest kept commit cannot be "${oldest.action}" — there is no earlier commit to fold it into.`,
+    );
+  }
+
+  const lines: string[] = [];
+  const env: Record<string, string> = {};
+  let rewordCount = 0;
+
+  for (const entry of entries) {
+    if (!/^[0-9a-f]{4,40}$/i.test(entry.hash)) {
+      throw new Error(`Invalid commit hash in rebase plan: "${entry.hash}"`);
+    }
+    if (!isRebaseAction(entry.action)) {
+      throw new Error(`Invalid rebase action: "${String(entry.action)}"`);
+    }
+    // A dropped commit is simply omitted rather than written as `drop`: both are
+    // valid to git, and omission keeps the todo readable if a conflict stops the
+    // rebase and the user inspects it.
+    if (entry.action === "drop") continue;
+
+    // Subjects are collapsed to one line — a newline here would inject an extra
+    // todo command.
+    const subject = (entry.subject ?? "").replace(/[\r\n]+/g, " ").trim();
+
+    if (entry.action === "reword") {
+      const message = (entry.message ?? "").trim();
+      if (!message) {
+        throw new Error(`Reword needs a new message for commit ${entry.hash.slice(0, 7)}.`);
+      }
+      const variable = `${REWORD_ENV_PREFIX}${rewordCount++}`;
+      env[variable] = message;
+      lines.push(`pick ${entry.hash}${subject ? ` ${subject}` : ""}`);
+      // `--allow-empty` because a commit that was already empty survives the
+      // rebase, and amending it without the flag would abort the whole run.
+      lines.push(`exec git commit --amend --allow-empty -m "$${variable}"`);
+      continue;
+    }
+
+    lines.push(`${entry.action} ${entry.hash}${subject ? ` ${subject}` : ""}`);
+  }
+
+  // Trailing newline: git's todo parser expects the final command to be
+  // terminated like any other line.
+  return { todo: `${lines.join("\n")}\n`, env };
+}
+
+/** Does this plan actually change anything, or is it the identity rebase? */
+export function isNoopPlan(entries: RebaseTodoEntry[], originalOrder: string[]): boolean {
+  if (entries.some((e) => e.action !== "pick")) return false;
+  if (entries.length !== originalOrder.length) return false;
+  return entries.every((e, i) => e.hash === originalOrder[i]);
+}