pi-agent-flow 2.0.0 → 2.0.2

package/dist/batch/execute.js

@@ -7,8 +7,10 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { execFile } from "node:child_process";
-import { MAX_LINES, MAX_BYTES, SAFE_FULL_READ_LIMIT, TARGETED_READ_LINE_LIMIT, MAX_TOTAL_RESULT_LINES, BATCH_READ_MAX_TOTAL_BYTES, } from "./constants.js";
+import { withFileMutationQueue } from "@mariozechner/pi-coding-agent";
+import { MAX_LINES, MAX_BYTES, SAFE_FULL_READ_LIMIT, TARGETED_READ_LINE_LIMIT, MAX_TOTAL_RESULT_LINES, BATCH_READ_MAX_TOTAL_BYTES, RG_SIGNATURES_MAX_FILES, } from "./constants.js";
 import { normalizeToLF, restoreLineEndings, detectLineEnding, stripBom, applyEdits, levenshtein, validatePath, } from "./fuzzy-edit.js";
+import { applyPatch } from "./apply-patch.js";
 import { buildFileContextMap } from "./symbols.js";
 // ---------------------------------------------------------------------------
 // Read helpers
@@ -123,9 +125,6 @@ export async function suggestSimilarFiles(inputPath, cwd) {
         return [];
     }
 }
-// ---------------------------------------------------------------------------
-// Error hints
-// ---------------------------------------------------------------------------
 function getErrorHint(error) {
     if (error.includes("File not found") || error.includes("file not found"))
         return "Verify the path exists.";
@@ -143,15 +142,27 @@ function getErrorHint(error) {
         return "Verify the path exists.";
     if (error.includes("is beyond end of file"))
         return "Use a smaller offset within the file length.";
+    if (error.includes("ripgrep failed"))
+        return "Ripgrep crashed or was killed. Try narrowing the search path or adding max-count to limit output.";
     return "";
 }
+function isRetryable(error) {
+    const transient = [
+        "File not found",
+        "file not found",
+        "ENOENT",
+        "no such file",
+        "Could not find",
+        "occurrences",
+    ];
+    return transient.some((p) => error.includes(p));
+}
 // ---------------------------------------------------------------------------
 // Main execute function
 // ---------------------------------------------------------------------------
-export async function executeOperations(operations, cwd, signal, options = {}) {
+export async function executeOperations(operations, cwd, signal, options = {}, onUpdate) {
     const results = [];
-    let failed = false;
-    const counts = { read: 0, write: 0, edit: 0, delete: 0, rg: 0, error: 0, skipped: 0 };
+    const counts = { read: 0, write: 0, edit: 0, delete: 0, rg: 0, patch: 0, bash: 0, error: 0, skipped: 0 };
     const errors = [];
     const truncatedFiles = [];
     const aggregateLimitSkipped = [];
@@ -159,38 +170,72 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
     let aggregateLinesRead = 0;
     let aggregateBytesRead = 0;
     const includeLimitWarnings = options.includeLimitWarnings ?? true;
-    for (const op of operations) {
+    let lastUpdateTime = 0;
+    let finalUpdateEmitted = false;
+    function emitPartialUpdate() {
+        if (!onUpdate)
+            return;
+        const now = Date.now();
+        const isFinal = results.length === operations.length;
+        if (!isFinal && now - lastUpdateTime < 100)
+            return;
+        if (isFinal && finalUpdateEmitted)
+            return;
+        finalUpdateEmitted = isFinal;
+        lastUpdateTime = now;
+        const partialSummary = buildSummary(counts, errors, truncatedFiles, aggregateLimitSkipped, aggregateByteLimitSkipped);
+        const partialContentText = buildContentText(partialSummary, results);
+        onUpdate({
+            content: [{ type: "text", text: partialContentText }],
+            details: { results: [...results] },
+        });
+    }
+    for (let i = 0; i < operations.length; i++) {
+        const op = operations[i];
         if (signal?.aborted) {
-            results.push({ op: op.o, path: op.p, status: "skipped", error: "Operation aborted." });
-            counts.skipped++;
-            continue;
-        }
-        if (failed) {
-            results.push({ op: op.o, path: op.p, status: "skipped" });
-            counts.skipped++;
-            continue;
+            for (let j = i; j < operations.length; j++) {
+                const r = operations[j];
+                results.push({ op: r.o, path: r.p, status: "skipped", error: "Operation aborted.", s: r.s, l: r.l, q: r.q });
+                counts.skipped++;
+            }
+            emitPartialUpdate();
+            break;
         }
         try {
-            const resolvedPath = await validatePath(op.p, cwd);
+            const { path: resolvedPath, warning: pathWarning } = await validatePath(op.p, cwd);
             switch (op.o) {
                 case "read": {
                     if (aggregateLinesRead >= MAX_TOTAL_RESULT_LINES) {
+                        const remainingOps = operations.length - i - 1;
                         results.push({
                             op: "read",
                             path: op.p,
                             status: "skipped",
-                            error: `Skipped: aggregate line limit of ${MAX_TOTAL_RESULT_LINES} already reached. Use separate batch/batch_read calls.`,
+                            skipped: true,
+                            reason: "aggregate_line_limit",
+                            consumed: { lines: aggregateLinesRead, bytes: aggregateBytesRead },
+                            remainingOps,
+                            error: `Skipped: aggregate line limit of ${MAX_TOTAL_RESULT_LINES} reached (${aggregateLinesRead} lines consumed). ${remainingOps} remaining operation(s) will still execute. Use separate batch/batch_read calls.`,
+                            s: op.s,
+                            l: op.l,
                         });
                         counts.skipped++;
                         aggregateLimitSkipped.push({ path: op.p });
                         break;
                     }
                     if (aggregateBytesRead >= BATCH_READ_MAX_TOTAL_BYTES) {
+                        const remainingOps = operations.length - i - 1;
                         results.push({
                             op: "read",
                             path: op.p,
                             status: "skipped",
-                            error: `Skipped: aggregate byte limit of ${BATCH_READ_MAX_TOTAL_BYTES} already reached. Use separate batch/batch_read calls.`,
+                            skipped: true,
+                            reason: "aggregate_byte_limit",
+                            consumed: { lines: aggregateLinesRead, bytes: aggregateBytesRead },
+                            remainingOps,
+                            error: `Skipped: aggregate byte limit of ${BATCH_READ_MAX_TOTAL_BYTES} reached (${aggregateBytesRead} bytes consumed). ${remainingOps} remaining operation(s) will still execute. Use separate batch/batch_read calls.`,
+                            s: op.s,
+                            l: op.l,
                         });
                         counts.skipped++;
                         aggregateByteLimitSkipped.push({ path: op.p });
@@ -260,9 +305,11 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
                         status: "ok",
                         content: finalContent,
                         totalLines: totalFileLines,
-                        warning: safetyWarning,
+                        warning: [pathWarning, safetyWarning].filter(Boolean).join("\n") || undefined,
                         truncated: finalTruncated || undefined,
                         nextOffset,
+                        s: op.s,
+                        l: op.l,
                     });
                     counts.read++;
                     break;
@@ -271,13 +318,16 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
                     if (!op.c && op.c !== "") {
                         throw new Error("c (content) is required for write operations.");
                     }
-                    await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
-                    await fs.writeFile(resolvedPath, op.c, "utf-8");
+                    await withFileMutationQueue(resolvedPath, async () => {
+                        await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+                        await fs.writeFile(resolvedPath, op.c, "utf-8");
+                    });
                     results.push({
                         op: "write",
                         path: op.p,
                         status: "ok",
                         bytes: Buffer.byteLength(op.c, "utf-8"),
+                        warning: pathWarning,
                     });
                     counts.write++;
                     break;
@@ -286,38 +336,45 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
                     if (!op.e || op.e.length === 0) {
                         throw new Error("e (edits) array is required for edit operations.");
                     }
-                    const rawContent = await fs.readFile(resolvedPath, "utf-8");
-                    const { bom, text: contentWithoutBom } = stripBom(rawContent);
-                    const originalEnding = detectLineEnding(contentWithoutBom);
-                    const normalizedContent = normalizeToLF(contentWithoutBom);
-                    const { newContent, blocksChanged } = applyEdits(normalizedContent, op.e, op.p);
-                    const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-                    await fs.writeFile(resolvedPath, finalContent, "utf-8");
+                    const edits = op.e;
+                    const blocksChanged = await withFileMutationQueue(resolvedPath, async () => {
+                        const rawContent = await fs.readFile(resolvedPath, "utf-8");
+                        const { bom, text: contentWithoutBom } = stripBom(rawContent);
+                        const originalEnding = detectLineEnding(contentWithoutBom);
+                        const normalizedContent = normalizeToLF(contentWithoutBom);
+                        const { newContent, blocksChanged: changed } = applyEdits(normalizedContent, edits, op.p);
+                        const finalContent = bom + restoreLineEndings(newContent, originalEnding);
+                        await fs.writeFile(resolvedPath, finalContent, "utf-8");
+                        return changed;
+                    });
                     results.push({
                         op: "edit",
                         path: op.p,
                         status: "ok",
                         blocksChanged,
+                        warning: pathWarning,
                     });
                     counts.edit++;
                     break;
                 }
                 case "delete": {
-                    let stat;
-                    try {
-                        stat = await fs.lstat(resolvedPath);
-                    }
-                    catch (err) {
-                        if (err.code === "ENOENT") {
-                            throw new Error(`File not found: ${op.p}`);
+                    await withFileMutationQueue(resolvedPath, async () => {
+                        let stat;
+                        try {
+                            stat = await fs.lstat(resolvedPath);
                         }
-                        throw err;
-                    }
-                    if (stat.isDirectory()) {
-                        throw new Error(`Cannot delete directory: ${op.p}. Use a recursive removal tool or delete files individually.`);
-                    }
-                    await fs.unlink(resolvedPath);
-                    results.push({ op: "delete", path: op.p, status: "ok" });
+                        catch (err) {
+                            if (err.code === "ENOENT") {
+                                throw new Error(`File not found: ${op.p}`);
+                            }
+                            throw err;
+                        }
+                        if (stat.isDirectory()) {
+                            throw new Error(`Cannot delete directory: ${op.p}. Use a recursive removal tool or delete files individually.`);
+                        }
+                        await fs.unlink(resolvedPath);
+                    });
+                    results.push({ op: "delete", path: op.p, status: "ok", warning: pathWarning });
                     counts.delete++;
                     break;
                 }
@@ -328,26 +385,61 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
                     }
                     const searchPath = (rgOp.p.startsWith("~") || path.isAbsolute(rgOp.p)) ? resolvedPath : rgOp.p;
                     const args = buildRgArgs({ ...rgOp, p: searchPath });
-                    const matches = await execRg(args, cwd);
+                    const matches = await execRg(args, cwd, signal);
                     const content = matches.join("\n");
+                    // Try to attach enclosing signatures (only when we have line numbers)
+                    let enclosingSignatures;
+                    const uniqueFiles = extractUniqueFilesFromRg(matches);
+                    if (uniqueFiles.size > 0 && uniqueFiles.size <= RG_SIGNATURES_MAX_FILES && !isFilesOnlyRg(matches)) {
+                        enclosingSignatures = await buildEnclosingSignatures(uniqueFiles, matches, cwd);
+                    }
                     results.push({
                         op: "rg",
                         path: rgOp.p,
                         status: "ok",
                         content,
                         totalLines: matches.length,
+                        enclosingSignatures,
+                        warning: pathWarning,
+                        q: rgOp.q,
                     });
                     counts.rg++;
                     break;
                 }
+                case "patch": {
+                    if (!op.c && op.c !== "") {
+                        throw new Error("c (patch text) is required for patch operations.");
+                    }
+                    const { affected, exact } = await applyPatch(op.c, cwd);
+                    results.push({
+                        op: "patch",
+                        path: op.p,
+                        status: "ok",
+                        affected,
+                        exact,
+                        warning: pathWarning,
+                    });
+                    counts.patch++;
+                    break;
+                }
                 default:
                     throw new Error(`Unknown operation type: ${op.o}`);
             }
         }
         catch (err) {
-            failed = true;
-            counts.error++;
             const message = err instanceof Error ? err.message : String(err);
+            // Treat mid-flight rg abort as skipped rather than error
+            if (message === "Aborted" && signal?.aborted) {
+                counts.skipped++;
+                results.push({
+                    op: op.o,
+                    path: op.p,
+                    status: "skipped",
+                    error: "Operation aborted.",
+                });
+                continue;
+            }
+            counts.error++;
             // Enrich file-not-found errors with fuzzy filename suggestions
             let hint = getErrorHint(message);
             if (message.includes("File not found") ||
@@ -359,6 +451,8 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
                     hint += ` Did you mean: ${suggestions.join(", ")}?`;
                 }
             }
+            const retryable = isRetryable(message);
+            const suggestedFix = hint || undefined;
             errors.push({ path: op.p, op: op.o, message, hint });
             results.push({
                 op: op.o,
@@ -366,9 +460,16 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
                 status: "error",
                 error: message,
                 hint,
+                retryable,
+                suggestedFix,
+                s: op.s,
+                l: op.l,
+                q: op.q,
             });
         }
+        emitPartialUpdate();
     }
+    emitPartialUpdate();
     // Build the enhanced summary and content text
     const summary = buildSummary(counts, errors, truncatedFiles, aggregateLimitSkipped, aggregateByteLimitSkipped);
     const contentText = buildContentText(summary, results);
@@ -378,36 +479,70 @@ export async function executeOperations(operations, cwd, signal, options = {}) {
 // Summary / content rendering
 // ---------------------------------------------------------------------------
 function buildSummary(counts, errors, truncatedFiles, aggregateLimitSkipped = [], aggregateByteLimitSkipped = []) {
-    const totalSuccess = counts.read + counts.write + counts.edit + counts.delete + counts.rg;
-    const totalOps = totalSuccess + counts.error + counts.skipped;
     const parts = [];
-    // Build the success breakdown
+    // Build success parts from counts
     const successParts = [];
     if (counts.read > 0)
-        successParts.push(`${counts.read} read${counts.read > 1 ? "s" : ""}`);
+        successParts.push(`${counts.read} read`);
     if (counts.write > 0)
-        successParts.push(`${counts.write} write${counts.write > 1 ? "s" : ""}`);
+        successParts.push(`${counts.write} write`);
     if (counts.edit > 0)
-        successParts.push(`${counts.edit} edit${counts.edit > 1 ? "s" : ""}`);
+        successParts.push(`${counts.edit} edit`);
     if (counts.delete > 0)
-        successParts.push(`${counts.delete} delete${counts.delete > 1 ? "s" : ""}`);
+        successParts.push(`${counts.delete} delete`);
     if (counts.rg > 0)
-        successParts.push(`${counts.rg} rg${counts.rg > 1 ? "s" : ""}`);
-    if (counts.error === 0) {
-        // All success
-        parts.push(`${totalOps} operations: ${successParts.join(", ")}`);
+        successParts.push(`${counts.rg} rg`);
+    if (counts.patch > 0)
+        successParts.push(`${counts.patch} patch`);
+    if (counts.bash > 0)
+        successParts.push(`${counts.bash} bash`);
+    // Build failure parts from errors
+    const failedCounts = {};
+    for (const err of errors) {
+        failedCounts[err.op] = (failedCounts[err.op] || 0) + 1;
+    }
+    const failedParts = [];
+    if (failedCounts.read > 0)
+        failedParts.push(`${failedCounts.read} read`);
+    if (failedCounts.write > 0)
+        failedParts.push(`${failedCounts.write} write`);
+    if (failedCounts.edit > 0)
+        failedParts.push(`${failedCounts.edit} edit`);
+    if (failedCounts.delete > 0)
+        failedParts.push(`${failedCounts.delete} delete`);
+    if (failedCounts.rg > 0)
+        failedParts.push(`${failedCounts.rg} rg`);
+    if (failedCounts.patch > 0)
+        failedParts.push(`${failedCounts.patch} patch`);
+    if (failedCounts.bash > 0)
+        failedParts.push(`${failedCounts.bash} bash`);
+    const hasSuccess = successParts.length > 0;
+    const hasFailure = failedParts.length > 0;
+    const hasSkipped = counts.skipped > 0;
+    if (!hasFailure) {
+        // All success (or skipped)
+        const summaryParts = [...successParts];
+        if (hasSkipped)
+            summaryParts.push(`${counts.skipped} skipped`);
+        parts.push(`✔ ${summaryParts.join(", ")}`);
     }
     else {
-        // Mixed success/failure
-        parts.push(`${counts.error} failed${counts.skipped > 0 ? `, ${counts.skipped} skipped` : ""}`);
-        if (totalSuccess > 0) {
-            parts.push(`  ${successParts.join(", ")} ok`);
+        // Mixed or all failed
+        if (hasSuccess) {
+            parts.push(`✔ ${successParts.join(", ")} | ✗ ${failedParts.join(", ")}`);
         }
-        for (const err of errors) {
-            const hint = err.hint ?? "";
-            const hintSuffix = hint ? ` — ${hint}` : "";
-            parts.push(`  ${err.op} ${err.path}: ${err.message}${hintSuffix}`);
+        else {
+            parts.push(`✗ ${failedParts.join(", ")}`);
         }
+        if (hasSkipped) {
+            parts.push(`${counts.skipped} skipped`);
+        }
+    }
+    // Error details
+    for (const err of errors) {
+        const hint = err.hint ?? "";
+        const hintSuffix = hint ? ` — ${hint}` : "";
+        parts.push(`  ${err.op} ${err.path}: ${err.message}${hintSuffix}`);
     }
     // Truncation warnings
     for (const tf of truncatedFiles) {
@@ -472,11 +607,30 @@ function buildContentText(summary, results) {
             sections.push(`\n--- delete: ${r.path} ---`);
         }
         else if (r.op === "rg" && r.status === "ok") {
-            sections.push(`\n--- rg: ${r.path} ---\n${r.content}`);
+            if (r.enclosingSignatures && Object.keys(r.enclosingSignatures).length > 0) {
+                const grouped = groupRgMatchesByFile(r.content ?? "", r.enclosingSignatures);
+                sections.push(`\n--- rg: ${r.path} ---\n${grouped}`);
+            }
+            else {
+                sections.push(`\n--- rg: ${r.path} ---\n${r.content}`);
+            }
         }
         else if (r.status === "error") {
             sections.push(`\n--- ${r.op}: ${r.path} ---\nError: ${r.error}`);
         }
+        else if (r.op === "patch" && r.status === "ok") {
+            const parts = [];
+            if (r.affected?.added.length)
+                parts.push(`A ${r.affected.added.join(', ')}`);
+            if (r.affected?.modified.length)
+                parts.push(`M ${r.affected.modified.join(', ')}`);
+            if (r.affected?.deleted.length)
+                parts.push(`D ${r.affected.deleted.join(', ')}`);
+            sections.push(`\n--- patch: ${r.path} ---\n${parts.join('\n')}`);
+        }
+        else if (r.status === "skipped") {
+            sections.push(`\n--- ${r.op}: ${r.path} ---\n${r.error ?? "Skipped"}`);
+        }
     }
     return sections.join("");
 }
@@ -485,6 +639,7 @@ function buildContentText(summary, results) {
 // ---------------------------------------------------------------------------
 function buildRgArgs(op) {
     const args = [];
+    args.push("-n");
     if (op.l === true || op.l === undefined)
         args.push("-l");
     if (op.i === true)
@@ -502,16 +657,111 @@ function buildRgArgs(op) {
     args.push(op.p);
     return args;
 }
-function execRg(args, cwd) {
+function isFilesOnlyRg(matches) {
+    // When rg runs with -l, matches are just filenames with no line numbers
+    return matches.length > 0 && !matches.some((m) => m.includes(":"));
+}
+function extractUniqueFilesFromRg(matches) {
+    const files = new Set();
+    for (const m of matches) {
+        const colonIdx = m.indexOf(":");
+        if (colonIdx > 0)
+            files.add(m.substring(0, colonIdx));
+    }
+    return files;
+}
+function parseRgLineNumber(match) {
+    // format: path:line:content
+    const parts = match.split(":");
+    if (parts.length < 3)
+        return null;
+    const lineNum = parseInt(parts[1], 10);
+    return Number.isFinite(lineNum) ? lineNum : null;
+}
+function parseRgFilePath(match) {
+    const colonIdx = match.indexOf(":");
+    return colonIdx > 0 ? match.substring(0, colonIdx) : null;
+}
+async function buildEnclosingSignatures(files, matches, cwd) {
+    const sigMap = {};
+    for (const filePath of files) {
+        try {
+            const abs = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+            const raw = await fs.readFile(abs, "utf-8");
+            const lines = raw.split("\n");
+            const ctxMap = buildFileContextMap(filePath, lines);
+            if (!ctxMap.symbols || ctxMap.symbols.length === 0)
+                continue;
+            // For each match line in this file, find enclosing symbol
+            for (const match of matches) {
+                const lineNum = parseRgLineNumber(match);
+                if (lineNum === null)
+                    continue;
+                const matchPath = parseRgFilePath(match);
+                if (matchPath !== filePath)
+                    continue;
+                const enclosing = ctxMap.symbols
+                    .filter((s) => lineNum >= s.startLine && lineNum <= s.endLine)
+                    .sort((a, b) => (a.endLine - a.startLine) - (b.endLine - b.startLine))[0];
+                if (enclosing?.signature) {
+                    sigMap[match] = enclosing.signature;
+                }
+            }
+        }
+        catch {
+            // File not readable, skip
+        }
+    }
+    return sigMap;
+}
+function groupRgMatchesByFile(content, sigMap) {
+    // Group matches by file, deduplicate signatures per file
+    const fileGroups = new Map();
+    for (const match of content.split("\n").filter(Boolean)) {
+        const filePath = parseRgFilePath(match);
+        if (!filePath) {
+            // Fallback: keep bare match as-is
+            const fallbackKey = "";
+            const group = fileGroups.get(fallbackKey) ?? { sigs: new Set(), lines: [] };
+            group.lines.push(match);
+            fileGroups.set(fallbackKey, group);
+            continue;
+        }
+        const group = fileGroups.get(filePath) ?? { sigs: new Set(), lines: [] };
+        const sig = sigMap[match];
+        if (sig)
+            group.sigs.add(sig);
+        group.lines.push(match);
+        fileGroups.set(filePath, group);
+    }
+    const out = [];
+    for (const [filePath, { sigs, lines }] of fileGroups) {
+        if (!filePath) {
+            out.push(...lines);
+            continue;
+        }
+        out.push(filePath);
+        for (const sig of sigs) {
+            out.push(`  ${sig}`);
+        }
+        for (const line of lines) {
+            const colonIdx = line.indexOf(":");
+            const afterPath = colonIdx > 0 ? line.substring(colonIdx + 1) : line;
+            out.push(`  → ${afterPath}`);
+        }
+    }
+    return out.join("\n");
+}
+function execRg(args, cwd, signal) {
     return new Promise((resolve, reject) => {
-        execFile("rg", args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        const child = execFile("rg", args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
             if (err) {
                 // ripgrep exits with code 1 when no matches are found
                 if (err.code === 1) {
                     resolve([]);
                     return;
                 }
-                if (err.code === "ENOBUFS") {
+                if (err.code === "ENOBUFS" || err.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
                     reject(new Error("ripgrep output exceeded 10MB buffer limit. Use a more specific pattern or add max-count."));
                     return;
                 }
@@ -520,12 +770,30 @@ function execRg(args, cwd) {
                     return;
                 }
                 const stderrMsg = stderr?.trim() ? ` — ${stderr.trim()}` : "";
-                reject(new Error(`ripgrep failed${stderrMsg}`));
+                const codeInfo = err.code ? ` (code: ${err.code})` : "";
+                const msgInfo = err.message ? `: ${err.message}` : "";
+                reject(new Error(`ripgrep failed${codeInfo}${msgInfo}${stderrMsg}`));
                 return;
             }
             const lines = stdout.split("\n").filter((line) => line.length > 0);
             resolve(lines);
         });
+        if (signal) {
+            const onAbort = () => {
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch { /* already dead */ }
+                reject(new Error("Aborted"));
+            };
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener("abort", onAbort, { once: true });
+                child.on("close", () => signal.removeEventListener("abort", onAbort));
+            }
+        }
     });
 }
 //# sourceMappingURL=execute.js.map