@procedures/git 0.2.3 → 0.3.0

package/src/procedures/git/tag/list.ts

@@ -0,0 +1,36 @@
+/**
+ * git.tag.list procedure
+ *
+ * List the tags (roadmap R40).
+ */
+
+import { gitArg } from "../args.js";
+import { git, type GitContext } from "../run.js";
+import type { GitTagInfo, GitTagListInput, GitTagListOutput } from "../../../types.js";
+
+/**
+ * The fields of each tag, separated by NUL: the name, the type of the object, the commit of an
+ * annotated tag, the object, and the subject of the message.
+ */
+const FORMAT = "--format=%(refname:strip=2)%00%(objecttype)%00%(*objectname)%00%(objectname)%00%(contents:subject)";
+
+/**
+ * List the tags
+ */
+export async function gitTagList(input: GitTagListInput, ctx: GitContext = {}): Promise<GitTagListOutput> {
+  const args = ["tag", "--list", FORMAT];
+  if (input.pattern) args.push(gitArg("pattern", input.pattern));
+
+  const output = await git(args, { cwd: input.cwd, signal: ctx.signal });
+  const tags: GitTagInfo[] = output
+    .split("\n")
+    .filter((line) => line.length > 0)
+    .map((line) => {
+      const [name = "", type = "", peeled = "", object = "", subject = ""] = line.split("\0");
+      const annotated = type === "tag";
+      const tag: GitTagInfo = { name, hash: annotated && peeled ? peeled : object, annotated };
+      if (annotated) tag.message = subject;
+      return tag;
+    });
+  return { tags };
+}

package/src/procedures/git/worktree/add.ts

@@ -0,0 +1,35 @@
+/**
+ * git.worktree.add procedure
+ *
+ * Add a working tree (roadmap R40). Git refuses a folder that exists and is not empty. Without
+ * `ref`, `branch` and `detach`, git makes a branch with the name of the folder.
+ */
+
+import { resolve } from "node:path";
+import { gitArg } from "../args.js";
+import { git, type GitContext } from "../run.js";
+import { currentBranch, headHash } from "../refs.js";
+import type { GitWorktreeAddInput, GitWorktreeAddOutput } from "../../../types.js";
+
+/**
+ * Add a working tree
+ */
+export async function gitWorktreeAdd(input: GitWorktreeAddInput, ctx: GitContext = {}): Promise<GitWorktreeAddOutput> {
+  const { ref, branch, detach, cwd } = input;
+  const path = resolve(cwd ?? process.cwd(), input.path);
+
+  const args = ["worktree", "add"];
+  if (branch) args.push("-b", gitArg("branch", branch));
+  if (detach) args.push("--detach");
+  // After "--", a path that starts with "-" stays a path
+  args.push("--", path);
+  if (ref) args.push(gitArg("ref", ref));
+  await git(args, { cwd, signal: ctx.signal });
+
+  // The new working tree gives its own HEAD
+  const inTree = { cwd: path, signal: ctx.signal };
+  const result: GitWorktreeAddOutput = { path, head: await headHash(inTree) };
+  const checkedOut = await currentBranch(inTree);
+  if (checkedOut !== "HEAD") result.branch = checkedOut;
+  return result;
+}

package/src/procedures/git/worktree/list.ts

@@ -0,0 +1,48 @@
+/**
+ * git.worktree.list procedure
+ *
+ * List the working trees of the repository (roadmap R40). The main working tree is first.
+ */
+
+import { resolve } from "node:path";
+import { git, zFields, type GitContext } from "../run.js";
+import type { GitWorktreeInfo, GitWorktreeListInput, GitWorktreeListOutput } from "../../../types.js";
+
+/**
+ * This function reads the output of `git worktree list --porcelain -z`: the fields of one working
+ * tree, then an empty field.
+ */
+export function parseWorktrees(output: string): GitWorktreeInfo[] {
+  const worktrees: GitWorktreeInfo[] = [];
+  let current: GitWorktreeInfo | undefined;
+  for (const field of zFields(output)) {
+    if (field === "") {
+      current = undefined;
+      continue;
+    }
+    const space = field.indexOf(" ");
+    const key = space < 0 ? field : field.slice(0, space);
+    const value = space < 0 ? "" : field.slice(space + 1);
+    if (key === "worktree") {
+      // Git gives "/" on Windows too: resolve gives the path of the platform
+      current = { path: resolve(value), detached: false, bare: false, locked: false, prunable: false };
+      worktrees.push(current);
+    } else if (current) {
+      if (key === "HEAD") current.head = value;
+      else if (key === "branch") current.branch = value.replace(/^refs\/heads\//, "");
+      else if (key === "detached") current.detached = true;
+      else if (key === "bare") current.bare = true;
+      else if (key === "locked") current.locked = true;
+      else if (key === "prunable") current.prunable = true;
+    }
+  }
+  return worktrees;
+}
+
+/**
+ * List the working trees of the repository
+ */
+export async function gitWorktreeList(input: GitWorktreeListInput, ctx: GitContext = {}): Promise<GitWorktreeListOutput> {
+  const output = await git(["worktree", "list", "--porcelain", "-z"], { cwd: input.cwd, signal: ctx.signal });
+  return { worktrees: parseWorktrees(output) };
+}

package/src/procedures/git/worktree/remove.ts

@@ -0,0 +1,21 @@
+/**
+ * git.worktree.remove procedure
+ *
+ * Remove a working tree and its folder (roadmap R40). Git refuses a working tree with changes
+ * that are not committed, unless `force` is true. Then the changes are lost.
+ */
+
+import { git, type GitContext } from "../run.js";
+import type { GitWorktreeRemoveInput, GitWorktreeRemoveOutput } from "../../../types.js";
+
+/**
+ * Remove a working tree
+ */
+export async function gitWorktreeRemove(input: GitWorktreeRemoveInput, ctx: GitContext = {}): Promise<GitWorktreeRemoveOutput> {
+  const args = ["worktree", "remove"];
+  if (input.force) args.push("--force");
+  // After "--", a path that starts with "-" stays a path
+  args.push("--", input.path);
+  await git(args, { cwd: input.cwd, signal: ctx.signal });
+  return { path: input.path };
+}