next-issue 2.4.0 → 2.4.2

package/dist/exec.mjs

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn } from 'node:child_process';
 let observer;
 let defaultTimeoutMs = 10 * 60_000;
 const STDERR_TAIL = 200_000;
@@ -20,16 +20,16 @@ export function stopChildren(signal) {
         catch { }
     }
     groups.clear();
-    process.off("SIGTERM", onTerminate);
+    process.off('SIGTERM', onTerminate);
     process.kill(process.pid, signal);
 }
-const onTerminate = () => stopChildren("SIGTERM");
+const onTerminate = () => stopChildren('SIGTERM');
 function watch(pid) {
     if (pid === undefined) {
         return;
     }
     if (groups.size === 0) {
-        process.on("SIGTERM", onTerminate);
+        process.on('SIGTERM', onTerminate);
     }
     groups.add(pid);
 }
@@ -39,13 +39,13 @@ function unwatch(pid) {
     }
     groups.delete(pid);
     if (groups.size === 0) {
-        process.off("SIGTERM", onTerminate);
+        process.off('SIGTERM', onTerminate);
     }
 }
 export function track(child) {
     watch(child.pid);
-    child.on("close", () => unwatch(child.pid));
-    child.on("error", () => unwatch(child.pid));
+    child.on('close', () => unwatch(child.pid));
+    child.on('error', () => unwatch(child.pid));
 }
 export function setCommandObserver(next) {
     observer = next;
@@ -61,19 +61,19 @@ export function run(command, args, options = {}) {
             cwd: options.cwd,
             detached: true,
             stdio: [
-                options.input === undefined ? "ignore" : "pipe",
-                options.show === true ? 2 : "pipe",
-                "pipe",
+                options.input === undefined ? 'ignore' : 'pipe',
+                options.show === true ? 2 : 'pipe',
+                'pipe',
             ],
         });
         const pid = child.pid;
         watch(pid);
-        let stdout = "";
-        let stderr = "";
+        let stdout = '';
+        let stderr = '';
         let timedOut = false;
-        child.stdout?.setEncoding("utf8");
-        child.stderr?.setEncoding("utf8");
-        child.stdout?.on("data", (chunk) => {
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
             options.onStdout?.(chunk);
             stdout += chunk;
             if (options.tailChars !== undefined && stdout.length > options.tailChars) {
@@ -81,7 +81,7 @@ export function run(command, args, options = {}) {
             }
         });
         const stderrLimit = options.tailChars ?? STDERR_TAIL;
-        child.stderr?.on("data", (chunk) => {
+        child.stderr?.on('data', (chunk) => {
             stderr += chunk;
             if (stderr.length > stderrLimit) {
                 stderr = stderr.slice(-stderrLimit);
@@ -90,14 +90,14 @@ export function run(command, args, options = {}) {
         const timer = setTimeout(() => {
             timedOut = true;
             if (pid === undefined) {
-                child.kill("SIGKILL");
+                child.kill('SIGKILL');
                 return;
             }
             try {
-                process.kill(-pid, "SIGKILL");
+                process.kill(-pid, 'SIGKILL');
             }
             catch {
-                child.kill("SIGKILL");
+                child.kill('SIGKILL');
             }
         }, limit);
         let done = false;
@@ -115,18 +115,18 @@ export function run(command, args, options = {}) {
                 cwd: options.cwd,
                 code: result.code,
                 ms: Date.now() - started,
-                stderr: result.code === 0 ? "" : stderr.trim(),
+                stderr: result.code === 0 ? '' : stderr.trim(),
                 timedOut,
             });
             resolve(result);
         };
-        child.on("error", (error) => {
+        child.on('error', (error) => {
             clearTimeout(timer);
             unwatch(pid);
             done = true;
             reject(error);
         });
-        child.on("exit", (code) => {
+        child.on('exit', (code) => {
             if (!timedOut) {
                 return;
             }
@@ -134,9 +134,9 @@ export function run(command, args, options = {}) {
             child.stderr?.destroy();
             settle(code);
         });
-        child.on("close", settle);
+        child.on('close', settle);
         if (options.input !== undefined) {
-            child.stdin?.on("error", () => undefined);
+            child.stdin?.on('error', () => undefined);
             child.stdin?.end(options.input);
         }
     });
@@ -144,10 +144,10 @@ export function run(command, args, options = {}) {
 export async function must(command, args, options = {}) {
     const result = await run(command, args, options);
     if (result.timedOut) {
-        throw new Error(`${command} ${args.join(" ")} did not finish in time.`);
+        throw new Error(`${command} ${args.join(' ')} did not finish in time.`);
     }
     if (result.code !== 0) {
-        throw new Error(`${command} ${args.join(" ")} failed with code ${result.code}: ${result.stderr.trim()}`);
+        throw new Error(`${command} ${args.join(' ')} failed with code ${result.code}: ${result.stderr.trim()}`);
     }
     return result.stdout.trim();
 }

package/dist/git.mjs

@@ -1,6 +1,6 @@
-import { appendFile, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { must, run } from "./exec.mjs";
+import { appendFile, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { must, run } from './exec.mjs';
 const REMOTE_PATTERNS = [
     /^git@[^:]+:(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?$/,
     /^ssh:\/\/[^/]+\/(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?$/,
@@ -16,74 +16,74 @@ export function parseRemote(url) {
     throw new Error(`Cannot parse the git remote URL: ${url}`);
 }
 export async function repoRoot(cwd) {
-    return must("git", ["rev-parse", "--show-toplevel"], { cwd });
+    return must('git', ['rev-parse', '--show-toplevel'], { cwd });
 }
 export async function detectRepo(cwd, remote) {
     const root = await repoRoot(cwd);
-    const url = await must("git", ["remote", "get-url", remote], { cwd });
+    const url = await must('git', ['remote', 'get-url', remote], { cwd });
     const { owner, name } = parseRemote(url);
     return { owner, name, root };
 }
-export const WORKTREE_DIR = ".worktrees";
+export const WORKTREE_DIR = '.worktrees';
 export function worktreePath(repo, issue) {
     return join(repo.root, WORKTREE_DIR, String(issue));
 }
 export async function addWorktree(repo, issue, branch, base, remote) {
     const upstream = `${remote}/${branch}`;
-    await must("git", ["fetch", remote], { cwd: repo.root });
+    await must('git', ['fetch', remote], { cwd: repo.root });
     const baseUpdated = await updateBase(repo, base, remote);
-    await must("git", ["worktree", "prune"], { cwd: repo.root });
-    const pushed = await hasBranch(repo, upstream, "--remotes");
+    await must('git', ['worktree', 'prune'], { cwd: repo.root });
+    const pushed = await hasBranch(repo, upstream, '--remotes');
     const existing = await findWorktree(repo, branch);
     const path = existing ?? worktreePath(repo, issue);
     if (existing === undefined) {
         const args = (await hasBranch(repo, branch))
-            ? ["worktree", "add", path, branch]
-            : ["worktree", "add", "-b", branch, path, pushed ? upstream : `${remote}/${base}`];
-        await must("git", args, { cwd: repo.root });
+            ? ['worktree', 'add', path, branch]
+            : ['worktree', 'add', '-b', branch, path, pushed ? upstream : `${remote}/${base}`];
+        await must('git', args, { cwd: repo.root });
     }
     if (pushed) {
-        await run("git", ["merge", "--ff-only", upstream], { cwd: path });
+        await run('git', ['merge', '--ff-only', upstream], { cwd: path });
     }
     return { path, baseUpdated };
 }
 async function hasBranch(repo, name, ...flags) {
-    const list = await must("git", ["branch", "--list", ...flags, name], { cwd: repo.root });
+    const list = await must('git', ['branch', '--list', ...flags, name], { cwd: repo.root });
     return list.length > 0;
 }
 export async function updateBase(repo, base, remote) {
-    const head = await run("git", ["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd: repo.root });
+    const head = await run('git', ['symbolic-ref', '--quiet', '--short', 'HEAD'], { cwd: repo.root });
     const args = head.code === 0 && head.stdout.trim() === base
-        ? ["merge", "--ff-only", `${remote}/${base}`]
-        : ["fetch", ".", `${remote}/${base}:${base}`];
-    const result = await run("git", args, { cwd: repo.root });
+        ? ['merge', '--ff-only', `${remote}/${base}`]
+        : ['fetch', '.', `${remote}/${base}:${base}`];
+    const result = await run('git', args, { cwd: repo.root });
     return result.code === 0;
 }
 export async function findWorktree(repo, branch) {
-    const list = await must("git", ["worktree", "list", "--porcelain"], { cwd: repo.root });
+    const list = await must('git', ['worktree', 'list', '--porcelain'], { cwd: repo.root });
     const entry = list
-        .split("\n\n")
-        .map((block) => block.split("\n"))
+        .split('\n\n')
+        .map((block) => block.split('\n'))
         .find((lines) => lines.includes(`branch refs/heads/${branch}`));
-    return entry?.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
+    return entry?.find((line) => line.startsWith('worktree '))?.slice('worktree '.length);
 }
 export async function removeWorktree(repo, path) {
-    const result = await run("git", ["worktree", "remove", path], { cwd: repo.root });
+    const result = await run('git', ['worktree', 'remove', path], { cwd: repo.root });
     return result.code === 0;
 }
 export async function ensureIgnored(root, entry) {
-    const path = join(root, ".gitignore");
-    let current = "";
+    const path = join(root, '.gitignore');
+    let current = '';
     try {
-        current = await readFile(path, "utf8");
+        current = await readFile(path, 'utf8');
     }
     catch {
-        current = "";
+        current = '';
     }
-    if (current.split("\n").some((line) => line.trim() === entry)) {
+    if (current.split('\n').some((line) => line.trim() === entry)) {
         return false;
     }
-    const gap = current.length === 0 || current.endsWith("\n") ? "" : "\n";
+    const gap = current.length === 0 || current.endsWith('\n') ? '' : '\n';
     await appendFile(path, `${gap}${entry}\n`);
     return true;
 }
@@ -91,39 +91,39 @@ export function branchName(issue) {
     return String(issue);
 }
 export async function isDirty(cwd) {
-    const status = await must("git", ["status", "--porcelain"], { cwd });
+    const status = await must('git', ['status', '--porcelain'], { cwd });
     return status.length > 0;
 }
 export async function diff(cwd, base, remote) {
-    return must("git", ["diff", `${remote}/${base}...HEAD`], { cwd });
+    return must('git', ['diff', `${remote}/${base}...HEAD`], { cwd });
 }
 export async function commitAll(cwd, message) {
     if (!(await isDirty(cwd))) {
         return false;
     }
-    await must("git", ["add", "-A"], { cwd });
-    await must("git", ["commit", "-m", message], { cwd });
+    await must('git', ['add', '-A'], { cwd });
+    await must('git', ['commit', '-m', message], { cwd });
     return true;
 }
 export async function discardChanges(cwd, target) {
     if (!(await isDirty(cwd)) && (await revision(cwd)) === target) {
         return false;
     }
-    await must("git", ["reset", "--hard", target], { cwd });
-    await must("git", ["clean", "-fd"], { cwd });
+    await must('git', ['reset', '--hard', target], { cwd });
+    await must('git', ['clean', '-fd'], { cwd });
     return true;
 }
 export async function push(cwd, remote, branch, force = false) {
-    await must("git", ["push", "-u", ...(force ? ["--force"] : []), remote, branch], { cwd });
+    await must('git', ['push', '-u', ...(force ? ['--force'] : []), remote, branch], { cwd });
 }
 export async function resetToBase(cwd, base, remote) {
-    await must("git", ["fetch", remote, base], { cwd });
-    await must("git", ["reset", "--hard", `${remote}/${base}`], { cwd });
+    await must('git', ['fetch', remote, base], { cwd });
+    await must('git', ['reset', '--hard', `${remote}/${base}`], { cwd });
 }
 export async function revision(cwd) {
-    return must("git", ["rev-parse", "HEAD"], { cwd });
+    return must('git', ['rev-parse', 'HEAD'], { cwd });
 }
 export async function deleteBranch(repo, branch) {
-    const result = await run("git", ["branch", "-D", branch], { cwd: repo.root });
+    const result = await run('git', ['branch', '-D', branch], { cwd: repo.root });
     return result.code === 0;
 }