@hienlh/ppm 0.19.12 → 0.20.0

package/packages/ext-git-graph/src/commit-search.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "bun:test";
+import {
+  SEARCH_FIELD_SEP, SEARCH_RECORD_SEP, buildSearchArgs, isSearchMode, parseSearchResults,
+} from "./commit-search.ts";
+
+const REPO = "/tmp/repo";
+const A = "a".repeat(40);
+
+describe("buildSearchArgs", () => {
+  it("searches messages across all refs", () => {
+    const args = buildSearchArgs({ mode: "message", text: "fix login" }, 50, REPO);
+
+    expect(args).toContain("--all");
+    expect(args).toContain("--grep=fix login");
+    expect(args).toContain("--max-count=50");
+  });
+
+  it("searches authors", () => {
+    expect(buildSearchArgs({ mode: "author", text: "Mai" }, 10, REPO)).toContain("--author=Mai");
+  });
+
+  it("uses the pickaxe for a code change", () => {
+    expect(buildSearchArgs({ mode: "content", text: "getUser(" }, 10, REPO)).toContain("-SgetUser(");
+  });
+
+  it("puts a path after -- so it cannot be read as an option", () => {
+    const args = buildSearchArgs({ mode: "file", text: "src/app.ts" }, 10, REPO);
+
+    expect(args[args.length - 2]).toBe("--");
+    expect(args[args.length - 1]).toBe("src/app.ts");
+  });
+
+  it("attaches the query to its flag so a leading dash stays data", () => {
+    // As a separate argv element, "--output=x" would be read as an option.
+    const args = buildSearchArgs({ mode: "message", text: "--output=/tmp/x" }, 10, REPO);
+
+    expect(args).toContain("--grep=--output=/tmp/x");
+    expect(args).not.toContain("--output=/tmp/x");
+  });
+
+  it("refuses a path that escapes the repository", () => {
+    expect(() => buildSearchArgs({ mode: "file", text: "../../etc/passwd" }, 10, REPO))
+      .toThrow(/escapes project root/);
+  });
+
+  it("refuses an absolute path", () => {
+    expect(() => buildSearchArgs({ mode: "file", text: "/etc/passwd" }, 10, REPO))
+      .toThrow(/Invalid file path/);
+  });
+
+  it("refuses control characters, which would break the record framing", () => {
+    expect(() => buildSearchArgs({ mode: "message", text: `a${SEARCH_RECORD_SEP}b` }, 10, REPO))
+      .toThrow(/control characters/);
+  });
+
+  it("refuses an empty query", () => {
+    expect(() => buildSearchArgs({ mode: "message", text: "   " }, 10, REPO))
+      .toThrow(/Enter something to search/);
+  });
+
+  it("refuses an unknown mode", () => {
+    expect(() => buildSearchArgs({ mode: "exec" as never, text: "x" }, 10, REPO))
+      .toThrow(/Unknown search mode/);
+  });
+
+  it("falls back to a sane limit when given a bad one", () => {
+    expect(buildSearchArgs({ mode: "message", text: "x" }, -5, REPO)).toContain("--max-count=200");
+  });
+});
+
+describe("parseSearchResults", () => {
+  function record(fields: string[]): string {
+    return SEARCH_RECORD_SEP + fields.join(SEARCH_FIELD_SEP);
+  }
+
+  it("reads a hit with its refs", () => {
+    const stdout = record([A, "Mai", "mai@example.com", "1700000000", "HEAD -> main, origin/main", "fix login"]);
+
+    expect(parseSearchResults(stdout)).toEqual([{
+      hash: A,
+      author: "Mai",
+      authorEmail: "mai@example.com",
+      authorDate: 1700000000,
+      refs: ["HEAD -> main", "origin/main"],
+      subject: "fix login",
+    }]);
+  });
+
+  it("reads a hit with no refs", () => {
+    const stdout = record([A, "Mai", "m@e.com", "1", "", "subject"]);
+
+    expect(parseSearchResults(stdout)[0]!.refs).toEqual([]);
+  });
+
+  it("reads several hits", () => {
+    const stdout = record([A, "Mai", "m@e.com", "2", "", "second"])
+      + record(["b".repeat(40), "Nam", "n@e.com", "1", "", "first"]);
+
+    expect(parseSearchResults(stdout).map((h) => h.subject)).toEqual(["second", "first"]);
+  });
+
+  it("returns nothing when no commit matched", () => {
+    expect(parseSearchResults("")).toEqual([]);
+  });
+});
+
+describe("isSearchMode", () => {
+  it("accepts the supported modes", () => {
+    for (const mode of ["message", "author", "content", "file"]) {
+      expect(isSearchMode(mode)).toBe(true);
+    }
+  });
+
+  it("rejects anything else", () => {
+    expect(isSearchMode("loaded")).toBe(false);
+    expect(isSearchMode(null)).toBe(false);
+  });
+});

package/packages/ext-git-graph/src/commit-search.ts

@@ -0,0 +1,102 @@
+/**
+ * Server-side commit search.
+ *
+ * The graph's find bar previously filtered only the commit rows already loaded,
+ * so a match older than the current page simply did not exist as far as the user
+ * could tell. These searches run in git itself, over the whole history.
+ *
+ * Every query value is passed as an *attached* argument (`--grep=<text>`), so a
+ * value that begins with a dash cannot be re-read as an option. Control
+ * characters are rejected outright — they have no place in any of these fields
+ * and would corrupt the record framing on the way back.
+ */
+import { assertSafeFilePaths } from "./git-exec.ts";
+
+export const SEARCH_RECORD_SEP = "\x1e";
+export const SEARCH_FIELD_SEP = "\x1f";
+export const SEARCH_FORMAT =
+  `${SEARCH_RECORD_SEP}%H${SEARCH_FIELD_SEP}%an${SEARCH_FIELD_SEP}%ae${SEARCH_FIELD_SEP}%at${SEARCH_FIELD_SEP}%D${SEARCH_FIELD_SEP}%s`;
+
+export const SEARCH_MODES = ["message", "author", "content", "file"] as const;
+export type SearchMode = (typeof SEARCH_MODES)[number];
+
+export interface SearchQuery {
+  mode: SearchMode;
+  text: string;
+}
+
+export interface SearchHit {
+  hash: string;
+  author: string;
+  authorEmail: string;
+  authorDate: number;
+  refs: string[];
+  subject: string;
+}
+
+export function isSearchMode(value: unknown): value is SearchMode {
+  return typeof value === "string" && (SEARCH_MODES as readonly string[]).includes(value);
+}
+
+function assertSearchText(text: unknown): string {
+  const s = String(text ?? "");
+  if (!s.trim()) throw new Error("Enter something to search for.");
+  if (/[\x00-\x1f\x7f]/.test(s)) throw new Error("Search text cannot contain control characters.");
+  return s;
+}
+
+/**
+ * Build the `git log` arguments for one search.
+ * `projectPath` is only needed for `mode: "file"`, to keep the path inside the
+ * repository.
+ */
+export function buildSearchArgs(
+  query: SearchQuery,
+  maxCount: number,
+  projectPath: string,
+): string[] {
+  if (!isSearchMode(query.mode)) throw new Error(`Unknown search mode: "${String(query.mode)}"`);
+  const text = assertSearchText(query.text);
+  const limit = Number.isInteger(maxCount) && maxCount > 0 ? maxCount : 200;
+
+  const args = ["log", "--all", `--format=${SEARCH_FORMAT}`, `--max-count=${limit}`];
+
+  switch (query.mode) {
+    case "message":
+      args.push("--regexp-ignore-case", `--grep=${text}`);
+      break;
+    case "author":
+      args.push("--regexp-ignore-case", `--author=${text}`);
+      break;
+    case "content":
+      // -S counts occurrences, so it reports the commits that introduced or
+      // removed the string rather than every commit whose diff mentions it.
+      args.push(`-S${text}`);
+      break;
+    case "file":
+      assertSafeFilePaths([text], projectPath);
+      args.push("--", text);
+      break;
+  }
+
+  return args;
+}
+
+export function parseSearchResults(stdout: string): SearchHit[] {
+  const hits: SearchHit[] = [];
+  for (const record of stdout.split(SEARCH_RECORD_SEP)) {
+    if (!record.trim()) continue;
+    const fields = record.split("\n")[0]?.split(SEARCH_FIELD_SEP);
+    if (!fields || fields.length < 6) continue;
+    const refs = fields[4] ?? "";
+    hits.push({
+      hash: fields[0] ?? "",
+      author: fields[1] ?? "",
+      authorEmail: fields[2] ?? "",
+      authorDate: Number(fields[3]) || 0,
+      refs: refs ? refs.split(",").map((r) => r.trim()).filter(Boolean) : [],
+      subject: fields[5] ?? "",
+    });
+  }
+  return hits;
+}

package/packages/ext-git-graph/src/compare-args.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "bun:test";
+import {
+  buildRangeSpec, parseAheadBehind, parseNumstatZ, parseRefList,
+} from "./compare-args.ts";
+
+describe("buildRangeSpec", () => {
+  it("joins two refs with two dots for a commit range", () => {
+    expect(buildRangeSpec("main", "feature", "two-dot")).toBe("main..feature");
+  });
+
+  it("joins two refs with three dots for a merge-base diff", () => {
+    expect(buildRangeSpec("main", "feature", "three-dot")).toBe("main...feature");
+  });
+
+  it("refuses a ref that already contains a range", () => {
+    // Otherwise one field could smuggle a whole range past validation.
+    expect(() => buildRangeSpec("main..evil", "feature", "two-dot")).toThrow(/Invalid git ref/);
+  });
+
+  it("refuses a ref that starts with a dash", () => {
+    expect(() => buildRangeSpec("--output=/tmp/x", "main", "two-dot")).toThrow(/Invalid git ref/);
+  });
+
+  it("refuses an empty ref", () => {
+    expect(() => buildRangeSpec("", "main", "two-dot")).toThrow(/Invalid git ref/);
+  });
+
+  it("names which side was invalid", () => {
+    expect(() => buildRangeSpec("main", "bad..ref", "two-dot")).toThrow(/ref2/);
+  });
+});
+
+describe("parseNumstatZ", () => {
+  it("reads additions and deletions per file", () => {
+    const stdout = "3\t1\tsrc/app.ts\0" + "0\t7\tsrc/old.ts\0";
+
+    expect(parseNumstatZ(stdout)).toEqual([
+      { path: "src/app.ts", additions: 3, deletions: 1, binary: false },
+      { path: "src/old.ts", additions: 0, deletions: 7, binary: false },
+    ]);
+  });
+
+  it("marks a binary file instead of reporting it as zero changes", () => {
+    const stdout = "-\t-\tassets/logo.png\0";
+
+    expect(parseNumstatZ(stdout)).toEqual([
+      { path: "assets/logo.png", additions: 0, deletions: 0, binary: true },
+    ]);
+  });
+
+  it("reads a rename, whose paths arrive as two extra records", () => {
+    const stdout = "2\t2\t\0src/old.ts\0src/new.ts\0";
+
+    expect(parseNumstatZ(stdout)).toEqual([
+      { path: "src/new.ts", oldPath: "src/old.ts", additions: 2, deletions: 2, binary: false },
+    ]);
+  });
+
+  it("keeps reading files after a rename", () => {
+    const stdout = "2\t2\t\0src/old.ts\0src/new.ts\0" + "1\t0\tREADME.md\0";
+
+    const changes = parseNumstatZ(stdout);
+
+    expect(changes).toHaveLength(2);
+    expect(changes[1]).toEqual({ path: "README.md", additions: 1, deletions: 0, binary: false });
+  });
+
+  it("handles a path containing a space", () => {
+    const stdout = "1\t1\tsrc/my file.ts\0";
+
+    expect(parseNumstatZ(stdout)[0]!.path).toBe("src/my file.ts");
+  });
+
+  it("returns nothing for identical trees", () => {
+    expect(parseNumstatZ("")).toEqual([]);
+  });
+});
+
+describe("parseAheadBehind", () => {
+  it("reads the left/right counts", () => {
+    expect(parseAheadBehind("3\t7\n")).toEqual({ behind: 3, ahead: 7 });
+  });
+
+  it("reads zeros for identical refs", () => {
+    expect(parseAheadBehind("0\t0\n")).toEqual({ behind: 0, ahead: 0 });
+  });
+
+  it("falls back to zeros on unexpected output", () => {
+    expect(parseAheadBehind("")).toEqual({ behind: 0, ahead: 0 });
+  });
+});
+
+describe("parseRefList", () => {
+  it("classifies branches, remotes and tags", () => {
+    const stdout = [
+      `refs/heads/main\x1faaa\x1fmain`,
+      `refs/remotes/origin/main\x1fbbb\x1forigin/main`,
+      `refs/tags/v1.0.0\x1fccc\x1fv1.0.0`,
+    ].join("\n");
+
+    expect(parseRefList(stdout)).toEqual([
+      { name: "main", hash: "aaa", kind: "head" },
+      { name: "origin/main", hash: "bbb", kind: "remote" },
+      { name: "v1.0.0", hash: "ccc", kind: "tag" },
+    ]);
+  });
+
+  it("skips malformed lines", () => {
+    expect(parseRefList("refs/heads/main\n\n")).toEqual([]);
+  });
+});

package/packages/ext-git-graph/src/compare-args.ts

@@ -0,0 +1,109 @@
+/**
+ * Range building and output parsing for the compare panel.
+ *
+ * The two refs are always validated separately and joined here. Accepting an
+ * already-joined `a..b` string from the webview would defeat `assertValidRef`,
+ * which rejects `..` precisely so that a single field cannot smuggle a range (or
+ * an option) into a git argument.
+ */
+import { assertValidRef } from "./git-exec.ts";
+
+export type CompareMode = "two-dot" | "three-dot";
+
+/**
+ * `a..b` lists commits reachable from b but not a.
+ * `a...b` (for diff) compares b against the merge base — "what changed on b
+ * since the branches diverged", which is what a review wants to see.
+ */
+export function buildRangeSpec(ref1: unknown, ref2: unknown, mode: CompareMode): string {
+  const a = assertValidRef(ref1, "ref1");
+  const b = assertValidRef(ref2, "ref2");
+  return `${a}${mode === "three-dot" ? "..." : ".."}${b}`;
+}
+
+export interface CompareFileChange {
+  path: string;
+  oldPath?: string;
+  additions: number;
+  deletions: number;
+  /** true when git reported `-` for both counts, i.e. a binary file. */
+  binary: boolean;
+}
+
+/**
+ * Parse `git diff --numstat -z`.
+ *
+ * With `-z`, records are NUL-terminated and a rename is three records in a row:
+ * the counts line, then the old path, then the new path. Without `-z` a path
+ * containing a tab or a quote would be escaped and ambiguous.
+ */
+export function parseNumstatZ(stdout: string): CompareFileChange[] {
+  const parts = stdout.split("\0");
+  const changes: CompareFileChange[] = [];
+
+  for (let i = 0; i < parts.length; i++) {
+    const record = parts[i];
+    if (!record) continue;
+    const tab1 = record.indexOf("\t");
+    if (tab1 === -1) continue;
+    const tab2 = record.indexOf("\t", tab1 + 1);
+    if (tab2 === -1) continue;
+
+    const addedRaw = record.slice(0, tab1);
+    const deletedRaw = record.slice(tab1 + 1, tab2);
+    const pathPart = record.slice(tab2 + 1);
+    const binary = addedRaw === "-" && deletedRaw === "-";
+
+    if (pathPart === "") {
+      // Rename/copy: the two paths follow as separate NUL-terminated records.
+      const oldPath = parts[++i] ?? "";
+      const newPath = parts[++i] ?? "";
+      changes.push({
+        path: newPath,
+        oldPath,
+        additions: binary ? 0 : Number(addedRaw) || 0,
+        deletions: binary ? 0 : Number(deletedRaw) || 0,
+        binary,
+      });
+      continue;
+    }
+
+    changes.push({
+      path: pathPart,
+      additions: binary ? 0 : Number(addedRaw) || 0,
+      deletions: binary ? 0 : Number(deletedRaw) || 0,
+      binary,
+    });
+  }
+
+  return changes;
+}
+
+/** Parse `git rev-list --left-right --count a...b` → "3\t7". */
+export function parseAheadBehind(stdout: string): { behind: number; ahead: number } {
+  const [left, right] = stdout.trim().split(/\s+/);
+  return { behind: Number(left) || 0, ahead: Number(right) || 0 };
+}
+
+export interface RefEntry {
+  name: string;
+  hash: string;
+  kind: "head" | "remote" | "tag";
+}
+
+/** Parse `git for-each-ref --format=%(refname)%1f%(objectname)%1f%(refname:short)`. */
+export function parseRefList(stdout: string): RefEntry[] {
+  const refs: RefEntry[] = [];
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const [fullName, hash, shortName] = line.split("\x1f");
+    if (!fullName || !hash || !shortName) continue;
+    const kind = fullName.startsWith("refs/tags/")
+      ? "tag"
+      : fullName.startsWith("refs/remotes/")
+        ? "remote"
+        : "head";
+    refs.push({ name: shortName, hash, kind });
+  }
+  return refs;
+}