@poetic-ai/poetic 1.42.0

package/dist/chunk-BXI4NXL3.js

@@ -0,0 +1,507 @@
+import {
+  withFileMutationLock
+} from "./chunk-TGON4N4O.js";
+import {
+  atomicWriteText
+} from "./chunk-A3YGID55.js";
+import {
+  isEphemeralPoeticBranchDeletionCandidate,
+  isProtectedPipelineBranch
+} from "./chunk-XQD2B6BB.js";
+
+// src/core/cleanup/remote-branch-cleanup-queue.ts
+import { access, readFile, rm } from "fs/promises";
+import { isAbsolute, resolve } from "path";
+import { execa } from "execa";
+var DEFAULT_QUEUE_RELATIVE_PATH = ".poetic/tmp/remote-branch-cleanup-queue.jsonl";
+var ALLOWED_REMOTE = "origin";
+var queueMutationLocks = /* @__PURE__ */ new Map();
+function isValidQueuedRemote(remote) {
+  return remote === ALLOWED_REMOTE;
+}
+function isValidQueuedBranch(branch) {
+  if (!branch || branch === "HEAD") return false;
+  if (branch.startsWith("-") || branch.startsWith("/") || branch.endsWith("/")) return false;
+  if (branch.includes("..") || branch.includes("//") || branch.includes("@{")) return false;
+  if (/[\\\s~^:?*[\]]/.test(branch)) return false;
+  if (branch.split("/").some((segment) => segment.length === 0 || segment.endsWith(".lock"))) {
+    return false;
+  }
+  if (isProtectedPipelineBranch(branch)) return false;
+  return true;
+}
+function isValidQueueEntry(entry) {
+  return isValidQueuedRemote(entry.remote) && isValidQueuedBranch(entry.branch);
+}
+function getRemoteBranchCleanupQueueLockPath(queuePath) {
+  return `${queuePath}.lock`;
+}
+function getQueueEntryKey(entry) {
+  return `${entry.remote}\0${entry.branch}`;
+}
+function normalizeQueueEntryCwd(cwd) {
+  const trimmed = cwd?.trim();
+  return trimmed ? resolve(trimmed) : void 0;
+}
+function readQueueEntryCwd(cwd) {
+  if (typeof cwd !== "string") return void 0;
+  const trimmed = cwd.trim();
+  return trimmed && isAbsolute(trimmed) ? trimmed : void 0;
+}
+function toTimestamp(value) {
+  if (!value) return Number.NEGATIVE_INFINITY;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : Number.NEGATIVE_INFINITY;
+}
+function isAbortError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const maybeCode = error.code;
+  return error.name === "AbortError" || maybeCode === "ABORT_ERR";
+}
+async function resolveDrainCwd(entryCwd, processorCwd) {
+  if (!entryCwd) {
+    return processorCwd;
+  }
+  try {
+    await access(entryCwd);
+    return entryCwd;
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? processorCwd : entryCwd;
+  }
+}
+function mergeQueueEntries(existing, incoming) {
+  if (existing.expectedRemoteSha && incoming.expectedRemoteSha && existing.expectedRemoteSha !== incoming.expectedRemoteSha) {
+    return {
+      version: 1,
+      remote: existing.remote,
+      branch: existing.branch,
+      cwd: incoming.cwd ?? existing.cwd,
+      expectedRemoteSha: incoming.expectedRemoteSha,
+      createdAt: incoming.createdAt,
+      attemptCount: incoming.attemptCount ?? 0,
+      lastAttemptAt: incoming.lastAttemptAt,
+      lastError: incoming.lastError,
+      reason: incoming.reason ?? existing.reason
+    };
+  }
+  const createdAt = toTimestamp(existing.createdAt) <= toTimestamp(incoming.createdAt) ? existing.createdAt : incoming.createdAt;
+  const latestAttemptAt = toTimestamp(existing.lastAttemptAt) >= toTimestamp(incoming.lastAttemptAt) ? existing.lastAttemptAt : incoming.lastAttemptAt;
+  const attemptCount = Math.max(existing.attemptCount ?? 0, incoming.attemptCount ?? 0);
+  const latestError = toTimestamp(existing.lastAttemptAt) >= toTimestamp(incoming.lastAttemptAt) ? existing.lastError ?? incoming.lastError : incoming.lastError ?? existing.lastError;
+  return {
+    version: 1,
+    remote: existing.remote,
+    branch: existing.branch,
+    cwd: existing.cwd ?? incoming.cwd,
+    expectedRemoteSha: existing.expectedRemoteSha ?? incoming.expectedRemoteSha,
+    createdAt,
+    attemptCount,
+    lastAttemptAt: latestAttemptAt,
+    lastError: latestError,
+    reason: existing.reason ?? incoming.reason
+  };
+}
+function dedupeQueueEntries(entries) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = getQueueEntryKey(entry);
+    const existing = deduped.get(key);
+    deduped.set(key, existing ? mergeQueueEntries(existing, entry) : entry);
+  }
+  return Array.from(deduped.values());
+}
+async function writeRemoteBranchCleanupQueue(entries, queuePath) {
+  if (entries.length === 0) {
+    await rm(queuePath, { force: true }).catch(() => {
+    });
+    return;
+  }
+  const serialized = `${entries.map((entry) => JSON.stringify(entry)).join("\n")}
+`;
+  await atomicWriteText(queuePath, serialized);
+}
+async function withQueueMutationLock(queuePath, mutate) {
+  const previous = (queueMutationLocks.get(queuePath) ?? Promise.resolve()).catch(() => {
+  });
+  let releaseLock;
+  const nextLock = new Promise((resolve2) => {
+    releaseLock = resolve2;
+  });
+  const lockTail = previous.then(() => nextLock);
+  queueMutationLocks.set(queuePath, lockTail);
+  await previous;
+  try {
+    return await withFileMutationLock(getRemoteBranchCleanupQueueLockPath(queuePath), mutate);
+  } finally {
+    releaseLock?.();
+    if (queueMutationLocks.get(queuePath) === lockTail) {
+      queueMutationLocks.delete(queuePath);
+    }
+  }
+}
+function getRemoteBranchCleanupQueuePath(cwd = process.cwd()) {
+  return resolve(cwd, DEFAULT_QUEUE_RELATIVE_PATH);
+}
+function isRemoteBranchMissingError(message) {
+  const text = message.toLowerCase();
+  return text.includes("remote ref does not exist") || text.includes("couldn't find remote ref");
+}
+async function remoteBranchHeadOnRemote(remote, branch, cwd, abortSignal) {
+  const result = await execa("git", ["ls-remote", "--heads", remote, branch], {
+    reject: false,
+    ...abortSignal ? { cancelSignal: abortSignal } : {},
+    ...cwd ? { cwd } : {}
+  });
+  if (result.exitCode !== 0) {
+    const message = `${result.stderr ?? ""}
+${result.stdout ?? ""}`.trim();
+    return {
+      state: "unknown",
+      reason: message || `git ls-remote --heads ${remote} ${branch} failed`
+    };
+  }
+  const sha = result.stdout.trim().split(/\s+/)[0];
+  return sha ? { state: "exists", sha } : { state: "missing" };
+}
+async function getOpenPRForBranch(branch, options = {}) {
+  try {
+    const result = await execa(
+      "gh",
+      ["pr", "list", "--head", branch, "--state", "open", "--json", "number", "--limit", "1"],
+      {
+        stdio: "pipe",
+        ...options.abortSignal ? { cancelSignal: options.abortSignal } : {},
+        ...options.cwd ? { cwd: options.cwd } : {}
+      }
+    );
+    const prs = JSON.parse(result.stdout.trim() || "[]");
+    return prs.length > 0 && prs[0] ? prs[0].number : null;
+  } catch (error) {
+    if (options.abortSignal?.aborted || isAbortError(error)) {
+      throw error;
+    }
+    return "unknown";
+  }
+}
+async function resolveExpectedRemoteShaForQueuedBranch(branch, options = {}) {
+  const remote = options.remote ?? "origin";
+  const remoteState = await remoteBranchHeadOnRemote(
+    remote,
+    branch,
+    options.cwd,
+    options.abortSignal
+  );
+  return remoteState.state === "exists" ? remoteState.sha : void 0;
+}
+async function validateRemoteBranchCleanupDrain(entry, options = {}) {
+  if (!isEphemeralPoeticBranchDeletionCandidate(entry.branch)) {
+    return {
+      action: "skip-unsafe",
+      reason: `Refusing remote delete for ${entry.branch}: not an ephemeral Poetic-owned branch`
+    };
+  }
+  const remoteState = await remoteBranchHeadOnRemote(
+    entry.remote,
+    entry.branch,
+    options.cwd,
+    options.abortSignal
+  );
+  if (remoteState.state === "missing") {
+    return { action: "skip-missing" };
+  }
+  if (remoteState.state === "unknown") {
+    return {
+      action: "retry",
+      reason: `Remote state for ${entry.remote}/${entry.branch} could not be verified: ${remoteState.reason}`
+    };
+  }
+  if (!entry.expectedRemoteSha) {
+    return {
+      action: "skip-unsafe",
+      reason: `Refusing remote delete for ${entry.branch}: missing expected remote tip`
+    };
+  }
+  if (remoteState.sha !== entry.expectedRemoteSha) {
+    return {
+      action: "skip-unsafe",
+      reason: `Refusing remote delete for ${entry.branch}: remote tip changed since enqueue`
+    };
+  }
+  const openPRNumber = await getOpenPRForBranch(entry.branch, {
+    cwd: options.cwd,
+    abortSignal: options.abortSignal
+  });
+  if (openPRNumber === "unknown") {
+    return {
+      action: "retry",
+      reason: `Open PR status for ${entry.branch} could not be verified`
+    };
+  }
+  if (openPRNumber !== null) {
+    return {
+      action: "skip-unsafe",
+      reason: `Refusing remote delete for ${entry.branch}: open PR #${openPRNumber}`
+    };
+  }
+  return { action: "delete" };
+}
+function isRetryableRemoteDeleteError(message) {
+  const text = message.toLowerCase();
+  if (isRemoteBranchMissingError(text)) return false;
+  return text.includes("authentication failed") || text.includes("permission denied") || text.includes("could not read from remote repository") || text.includes("could not resolve host") || text.includes("connection timed out") || text.includes("connection reset") || text.includes("failed to connect") || text.includes("network is unreachable") || text.includes("fatal: the remote end hung up unexpectedly") || text.includes("http 401") || text.includes("http 403") || text.includes("ssh") || text.includes("denied");
+}
+async function enqueueRemoteBranchCleanup(branch, options = {}) {
+  const entryCwd = normalizeQueueEntryCwd(options.cwd);
+  const queuePath = options.queuePath ?? getRemoteBranchCleanupQueuePath(entryCwd);
+  const remote = options.remote ?? "origin";
+  if (!isValidQueueEntry({ remote, branch })) {
+    throw new Error(`Invalid remote branch cleanup entry: ${remote}/${branch}`);
+  }
+  const entry = {
+    version: 1,
+    remote,
+    branch,
+    cwd: entryCwd,
+    expectedRemoteSha: options.expectedRemoteSha,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    attemptCount: 0,
+    reason: options.reason
+  };
+  await withQueueMutationLock(queuePath, async () => {
+    const existingEntries = await readRemoteBranchCleanupQueue(queuePath);
+    const existingKey = getQueueEntryKey(entry);
+    const existingIndex = existingEntries.findIndex(
+      (existingEntry) => getQueueEntryKey(existingEntry) === existingKey
+    );
+    if (existingIndex >= 0) {
+      const merged = mergeQueueEntries(existingEntries[existingIndex], entry);
+      const updatedEntries = [...existingEntries];
+      updatedEntries[existingIndex] = merged;
+      await writeRemoteBranchCleanupQueue(updatedEntries, queuePath);
+      return;
+    }
+    await writeRemoteBranchCleanupQueue([...existingEntries, entry], queuePath);
+  });
+}
+async function readRemoteBranchCleanupQueue(queuePath = getRemoteBranchCleanupQueuePath()) {
+  try {
+    const raw = await readFile(queuePath, "utf8");
+    const lines = raw.split("\n").filter(Boolean);
+    const entries = [];
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.version !== 1) continue;
+        if (!parsed.branch || !parsed.remote || !parsed.createdAt) continue;
+        if (!isValidQueueEntry({ branch: parsed.branch, remote: parsed.remote })) continue;
+        entries.push({
+          version: 1,
+          branch: parsed.branch,
+          remote: parsed.remote,
+          cwd: readQueueEntryCwd(parsed.cwd),
+          expectedRemoteSha: typeof parsed.expectedRemoteSha === "string" && parsed.expectedRemoteSha.length > 0 ? parsed.expectedRemoteSha : void 0,
+          createdAt: parsed.createdAt,
+          attemptCount: typeof parsed.attemptCount === "number" ? parsed.attemptCount : 0,
+          lastAttemptAt: parsed.lastAttemptAt,
+          lastError: parsed.lastError,
+          reason: parsed.reason
+        });
+      } catch {
+      }
+    }
+    return dedupeQueueEntries(entries);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function processRemoteBranchCleanupQueue(options) {
+  const queuePath = options.queuePath ?? getRemoteBranchCleanupQueuePath(options.cwd);
+  return withQueueMutationLock(queuePath, async () => {
+    options.abortSignal?.throwIfAborted();
+    const entries = await readRemoteBranchCleanupQueue(queuePath);
+    const nowMs = Date.now();
+    const MAX_ENTRY_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+    const MAX_ATTEMPTS = 14;
+    let purgedOld = 0;
+    let purgedRetries = 0;
+    const errors = [];
+    const actionableEntries = [];
+    for (const entry of entries) {
+      const ageMs = nowMs - new Date(entry.createdAt).getTime();
+      if (entry.attemptCount > MAX_ATTEMPTS) {
+        errors.push(
+          `Purged remote branch cleanup entry for ${entry.branch}: exceeded retry budget (${entry.attemptCount} attempts)`
+        );
+        purgedRetries++;
+        continue;
+      }
+      if (Number.isNaN(ageMs) || ageMs > MAX_ENTRY_AGE_MS) {
+        errors.push(
+          `Purged remote branch cleanup entry for ${entry.branch}: exceeded max age (${entry.createdAt})`
+        );
+        purgedOld++;
+        continue;
+      }
+      actionableEntries.push(entry);
+    }
+    if (options.dryRun) {
+      let wouldDelete = 0;
+      let wouldSkipMissing = 0;
+      let wouldRemain = 0;
+      const previewErrors = [];
+      for (const entry of actionableEntries) {
+        options.abortSignal?.throwIfAborted();
+        const entryCwd = await resolveDrainCwd(entry.cwd, options.cwd);
+        try {
+          const validation = await validateRemoteBranchCleanupDrain(entry, {
+            cwd: entryCwd,
+            abortSignal: options.abortSignal
+          });
+          if (validation.action === "delete") {
+            wouldDelete++;
+            continue;
+          }
+          if (validation.action === "skip-missing") {
+            wouldSkipMissing++;
+            continue;
+          }
+          wouldRemain++;
+          previewErrors.push(validation.reason);
+        } catch (error) {
+          if (options.abortSignal?.aborted || isAbortError(error)) {
+            throw error;
+          }
+          wouldRemain++;
+          previewErrors.push(error instanceof Error ? error.message : String(error));
+        }
+      }
+      return {
+        mode: "dry-run",
+        found: entries.length,
+        deleted: 0,
+        skippedMissing: 0,
+        remaining: actionableEntries.length,
+        wouldDelete,
+        wouldSkipMissing,
+        wouldRemain,
+        previewErrors,
+        errors,
+        purgedOld,
+        purgedRetries
+      };
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const remaining = [];
+    let deleted = 0;
+    let skippedMissing = 0;
+    for (const entry of actionableEntries) {
+      options.abortSignal?.throwIfAborted();
+      const entryCwd = await resolveDrainCwd(entry.cwd, options.cwd);
+      try {
+        const validation = await validateRemoteBranchCleanupDrain(entry, {
+          cwd: entryCwd,
+          abortSignal: options.abortSignal
+        });
+        if (validation.action === "skip-missing") {
+          skippedMissing++;
+          continue;
+        }
+        if (validation.action === "skip-unsafe") {
+          const updated2 = {
+            ...entry,
+            lastAttemptAt: now,
+            lastError: validation.reason
+          };
+          remaining.push(updated2);
+          errors.push(validation.reason);
+          continue;
+        }
+        if (validation.action === "retry") {
+          const updated2 = {
+            ...entry,
+            attemptCount: (entry.attemptCount ?? 0) + 1,
+            lastAttemptAt: now,
+            lastError: validation.reason
+          };
+          remaining.push(updated2);
+          errors.push(validation.reason);
+          continue;
+        }
+        const result = await execa(
+          "git",
+          [
+            "push",
+            entry.remote,
+            `--force-with-lease=refs/heads/${entry.branch}:${entry.expectedRemoteSha}`,
+            `:refs/heads/${entry.branch}`
+          ],
+          {
+            reject: false,
+            ...options.abortSignal ? { cancelSignal: options.abortSignal } : {},
+            ...entryCwd ? { cwd: entryCwd } : {}
+          }
+        );
+        if (result.exitCode === 0) {
+          deleted++;
+          continue;
+        }
+        const message = `${result.stderr ?? ""}
+${result.stdout ?? ""}`.trim();
+        if (isRemoteBranchMissingError(message)) {
+          skippedMissing++;
+          continue;
+        }
+        const updated = {
+          ...entry,
+          attemptCount: (entry.attemptCount ?? 0) + 1,
+          lastAttemptAt: now,
+          lastError: message || `git push ${entry.remote} with lease delete for ${entry.branch} failed`
+        };
+        remaining.push(updated);
+        errors.push(updated.lastError ?? "unknown error");
+      } catch (error) {
+        if (options.abortSignal?.aborted || isAbortError(error)) {
+          throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const updated = {
+          ...entry,
+          attemptCount: (entry.attemptCount ?? 0) + 1,
+          lastAttemptAt: now,
+          lastError: message
+        };
+        remaining.push(updated);
+        errors.push(message);
+      }
+    }
+    await writeRemoteBranchCleanupQueue(dedupeQueueEntries(remaining), queuePath);
+    if (options.verbose && (deleted > 0 || skippedMissing > 0)) {
+    }
+    return {
+      mode: "executed",
+      found: entries.length,
+      deleted,
+      skippedMissing,
+      remaining: remaining.length,
+      errors,
+      purgedOld,
+      purgedRetries
+    };
+  });
+}
+
+export {
+  getRemoteBranchCleanupQueuePath,
+  isRemoteBranchMissingError,
+  resolveExpectedRemoteShaForQueuedBranch,
+  isRetryableRemoteDeleteError,
+  enqueueRemoteBranchCleanup,
+  processRemoteBranchCleanupQueue
+};
+//# sourceMappingURL=chunk-BXI4NXL3.js.map