@poetic-ai/poetic 1.42.0

package/dist/chunk-OGMSYL6J.js

@@ -0,0 +1,227 @@
+import {
+  classifyRepoPath
+} from "./chunk-H2AYQIHW.js";
+
+// src/core/loop/simple-artifact-goal.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var SIMPLE_ARTIFACT_GOAL_BOUNDARY = /\s+(?:(?:and|then)\s+)?(?:stop when|stop as soon as|stop after|do not modify|do not edit|do not change|only modify|no other files)\b[\s\S]*$/i;
+var SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD = String.raw`(?=(?:\s+(?:and|then))?\s*\b(?:stop when|stop as soon as|stop after|do not modify|do not edit|do not change|only modify|no other files)\b|$)`;
+var SIMPLE_ARTIFACT_INSTRUCTION_BOUNDARY = /\.\s+(?:Use\s+(?:normal\s+)?(?:text[- ]?file\s+)?formatting(?:;\s*a\s+final\s+newline\s+is\s+acceptable)?|A\s+final\s+newline\s+is\s+acceptable)\b[\s\S]*$/i;
+var SIMPLE_ARTIFACT_SAFE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".csv",
+  ".json",
+  ".log",
+  ".md",
+  ".txt",
+  ".tsv",
+  ".yaml",
+  ".yml"
+]);
+var SIMPLE_ARTIFACT_CODE_ROOTS = /* @__PURE__ */ new Set([
+  "src",
+  "test",
+  "tests",
+  "__tests__",
+  "scripts",
+  "bin",
+  "lib",
+  "packages"
+]);
+function normalizeSimpleArtifactPath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function classifyArtifactPath(filePath) {
+  const targetPath = normalizeSimpleArtifactPath(filePath);
+  if (targetPath.length === 0 || path.isAbsolute(targetPath) || targetPath.includes("\0") || targetPath.split("/").includes("..")) {
+    return null;
+  }
+  const pathParts = targetPath.split("/").filter(Boolean);
+  return {
+    topLevel: pathParts[0] ?? "",
+    extension: path.extname(targetPath).toLowerCase(),
+    artifactNamedPath: pathParts.some((part) => /artifacts?/i.test(part))
+  };
+}
+function isSafeArtifactRelativePath(filePath) {
+  const parts = classifyArtifactPath(filePath);
+  if (parts === null) return false;
+  return !SIMPLE_ARTIFACT_CODE_ROOTS.has(parts.topLevel) && (parts.artifactNamedPath || SIMPLE_ARTIFACT_SAFE_EXTENSIONS.has(parts.extension));
+}
+function isNonCodeArtifactDiffPath(filePath) {
+  const parts = classifyArtifactPath(filePath);
+  if (parts === null) return false;
+  return !SIMPLE_ARTIFACT_CODE_ROOTS.has(parts.topLevel) && SIMPLE_ARTIFACT_SAFE_EXTENSIONS.has(parts.extension);
+}
+var SIMPLE_ARTIFACT_QUOTE_PAIRS = [
+  ["```", "```"],
+  ["`", "`"],
+  ['"', '"'],
+  ["'", "'"]
+];
+function unwrapQuotedExactContent(value) {
+  for (const [open, close] of SIMPLE_ARTIFACT_QUOTE_PAIRS) {
+    if (value.startsWith(open) && value.endsWith(close) && value.length >= open.length + close.length) {
+      return {
+        value: value.slice(open.length, value.length - close.length),
+        wasQuoted: true
+      };
+    }
+  }
+  return { value, wasQuoted: false };
+}
+function trimQuotedExactContent(raw, options) {
+  let value = raw.replace(SIMPLE_ARTIFACT_GOAL_BOUNDARY, "").trim();
+  const quoted = unwrapQuotedExactContent(value);
+  const wasQuoted = quoted.wasQuoted;
+  value = quoted.value;
+  if (!wasQuoted) {
+    value = value.replace(SIMPLE_ARTIFACT_INSTRUCTION_BOUNDARY, "").trim();
+  }
+  if (options?.stripSentenceTerminatorBeforeBoundary === true && !wasQuoted && /[.!?]$/.test(value)) {
+    value = value.slice(0, -1).trimEnd();
+  }
+  if (!wasQuoted && /[.!?]$/.test(value) && !/\s/u.test(value.slice(0, -1))) {
+    value = value.slice(0, -1).trimEnd();
+  }
+  return value;
+}
+function hasSimpleArtifactGoalBoundary(prompt) {
+  return /\b(?:stop when|stop as soon as|stop after|do not modify|do not edit|do not change|only modify|no other files)\b/i.test(
+    prompt
+  );
+}
+function buildSimpleArtifactGoalFromMatch(match, options) {
+  const targetPath = normalizeSimpleArtifactPath(
+    options?.stripTrailingPathTerminator === true ? (match[1] ?? "").replace(/[.!?]$/, "") : match[1] ?? ""
+  );
+  if (!isNonCodeArtifactDiffPath(targetPath)) {
+    return void 0;
+  }
+  const separator = match[2] ?? "";
+  const expectedContent = trimQuotedExactContent(match[3] ?? "", {
+    stripSentenceTerminatorBeforeBoundary: options?.stripTrailingSentenceTerminator === true || !separator.includes(":")
+  });
+  if (expectedContent.length === 0) return void 0;
+  return { path: targetPath, expectedContent };
+}
+function parseCreateSimpleArtifactGoal(prompt) {
+  if (!/\b(?:create(?:\s+or\s+update)?|ensure|set|write|add)\b/i.test(prompt)) return void 0;
+  if (!/\b(?:(?:contains?|containing|with)\s+exactly)\b/i.test(prompt)) return void 0;
+  if (!hasSimpleArtifactGoalBoundary(prompt)) return void 0;
+  const repoRelative = parseRepoRelativePathSimpleArtifactGoal(prompt);
+  if (repoRelative) return repoRelative;
+  const matches = Array.from(
+    prompt.matchAll(
+      new RegExp(
+        String.raw`\b(?:create(?:\s+or\s+update)?|ensure|set|write|add)\s+(?:the\s+)?(?:file\s+)?[` + `\`'"]?([^\`'"\\s:]+)[\`'"]?` + String.raw`\s+(?:contains?\s+exactly|containing\s+exactly|with\s+exactly(?:\s+one\s+line)?)(\s*:|\s+)([\s\S]*?)` + SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD,
+        "gi"
+      )
+    )
+  );
+  const match = matches.at(-1);
+  if (!match) return void 0;
+  const stripTrailingSentenceTerminator = /\bwith\s+exactly\s+one\s+line\b/i.test(match[0] ?? "");
+  return buildSimpleArtifactGoalFromMatch(match, {
+    stripTrailingSentenceTerminator
+  });
+}
+function parseRepoRelativePathSimpleArtifactGoal(prompt) {
+  const matches = Array.from(
+    prompt.matchAll(
+      new RegExp(
+        String.raw`\b(?:create(?:\s+or\s+update)?|ensure|set|write|add)\s+(?:a\s+|the\s+)?file\s+at\s+the\s+repo-relative\s+path\s+[` + `\`'"]?([^\`'"\\s:]+)[\`'"]?` + String.raw`[\s\S]*?\b(?:must|should)?\s*contains?\s+exactly(\s*:|\s+)([\s\S]*?)` + SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD,
+        "gi"
+      )
+    )
+  );
+  const match = matches.at(-1);
+  if (!match) return void 0;
+  return buildSimpleArtifactGoalFromMatch(match, { stripTrailingPathTerminator: true });
+}
+function parseEditSimpleArtifactGoal(prompt) {
+  if (!/\bEdit only\b/i.test(prompt)) return void 0;
+  if (!/\bso it contains exactly\b/i.test(prompt)) return void 0;
+  if (!hasSimpleArtifactGoalBoundary(prompt)) return void 0;
+  const matches = Array.from(
+    prompt.matchAll(
+      new RegExp(
+        String.raw`\bEdit only\s+(?:the\s+)?(?:file\s+)?[` + `\`'"]?([^\`'"\\s:]+)[\`'"]?` + String.raw`\s+so it contains exactly(\s+)([\s\S]*?)` + SIMPLE_ARTIFACT_GOAL_BOUNDARY_LOOKAHEAD,
+        "gi"
+      )
+    )
+  );
+  const match = matches.at(-1);
+  if (!match) return void 0;
+  return buildSimpleArtifactGoalFromMatch(match);
+}
+function parseSimpleArtifactGoal(prompt) {
+  return parseCreateSimpleArtifactGoal(prompt) ?? parseEditSimpleArtifactGoal(prompt);
+}
+async function applyExactArtifactGoalSuccessGate(input) {
+  if (!input.success) {
+    return { success: false };
+  }
+  const goal = parseSimpleArtifactGoal(input.prompt);
+  if (!goal) {
+    return { success: true };
+  }
+  const satisfied = await isSimpleArtifactGoalSatisfied(input.worktreePath, goal);
+  if (satisfied) {
+    return { success: true, goal };
+  }
+  return {
+    success: false,
+    goal,
+    failureReason: `Exact artifact content mismatch for ${goal.path}`
+  };
+}
+function isValidationArtifactPath(filePath) {
+  const normalized = normalizeSimpleArtifactPath(filePath);
+  return normalized.startsWith("dogfood-validation-artifacts/") || normalized.startsWith(".poetic/validation/");
+}
+function artifactContentMatchesExpected(actualContent, expectedContent, filePath) {
+  if (actualContent === expectedContent) {
+    return true;
+  }
+  const extension = path.extname(normalizeSimpleArtifactPath(filePath)).toLowerCase();
+  if ((isValidationArtifactPath(filePath) || SIMPLE_ARTIFACT_SAFE_EXTENSIONS.has(extension)) && actualContent === `${expectedContent}
+`) {
+    return true;
+  }
+  return false;
+}
+async function isSimpleArtifactGoalSatisfied(workspaceRoot, goal) {
+  try {
+    const actualContent = await fs.readFile(path.join(workspaceRoot, goal.path), "utf8");
+    return artifactContentMatchesExpected(actualContent, goal.expectedContent, goal.path);
+  } catch {
+    return false;
+  }
+}
+function getUnexpectedSimpleArtifactTaskChanges(goal, changedFiles) {
+  return changedFiles.map(normalizeSimpleArtifactPath).filter((file) => classifyRepoPath(file) !== "runtime-artifact").filter((file) => file !== goal.path);
+}
+async function isSimpleArtifactGoalSatisfiedForChanges(workspaceRoot, goal, changedFiles) {
+  const normalizedChangedFiles = changedFiles.map(normalizeSimpleArtifactPath);
+  if (!normalizedChangedFiles.includes(goal.path)) {
+    return false;
+  }
+  if (getUnexpectedSimpleArtifactTaskChanges(goal, normalizedChangedFiles).length > 0) {
+    return false;
+  }
+  return isSimpleArtifactGoalSatisfied(workspaceRoot, goal);
+}
+
+export {
+  normalizeSimpleArtifactPath,
+  isSafeArtifactRelativePath,
+  isNonCodeArtifactDiffPath,
+  parseSimpleArtifactGoal,
+  applyExactArtifactGoalSuccessGate,
+  artifactContentMatchesExpected,
+  isSimpleArtifactGoalSatisfied,
+  getUnexpectedSimpleArtifactTaskChanges,
+  isSimpleArtifactGoalSatisfiedForChanges
+};
+//# sourceMappingURL=chunk-OGMSYL6J.js.map

package/dist/chunk-OIS7J26S.js

@@ -0,0 +1,319 @@
+import {
+  assertContainedPath
+} from "./chunk-WMPU2UOV.js";
+
+// src/planning/file-utils.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as yaml from "js-yaml";
+var CONVENTION_FILES = /* @__PURE__ */ new Set(["AGENTS.md", "CLAUDE.md", "GEMINI.md", "README.md"]);
+var VALID_KINDS = /* @__PURE__ */ new Set([
+  "task",
+  "sprint",
+  "backlog",
+  "tech-debt",
+  "parking-lot",
+  "finding",
+  "issue",
+  "suppression"
+]);
+var VALID_PRIORITIES = /* @__PURE__ */ new Set(["P0", "P1", "P2", "P3"]);
+var WORK_EDGE_TYPES = ["depends_on", "supersedes"];
+var WORK_ITEM_KINDS = [
+  "task",
+  "sprint",
+  "backlog",
+  "tech-debt",
+  "parking-lot",
+  "finding",
+  "issue",
+  "suppression"
+];
+var RAW_RELATIONSHIPS = [
+  "blocks",
+  "blocked-by",
+  "supersedes",
+  "superseded_by"
+];
+function isRawRelationship(value) {
+  return RAW_RELATIONSHIPS.includes(value);
+}
+var NEUTRAL_RELATIONSHIPS = ["related"];
+function isNeutralRelationship(value) {
+  return NEUTRAL_RELATIONSHIPS.includes(value);
+}
+function isWorkEdgeType(value) {
+  return typeof value === "string" && WORK_EDGE_TYPES.includes(value);
+}
+function isWorkItemKind(value) {
+  return typeof value === "string" && WORK_ITEM_KINDS.includes(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function assertSafePlanningFileId(id, label) {
+  if (typeof id !== "string") {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+  if (id.includes("\0")) {
+    throw new Error(`${label} must not contain a NUL byte`);
+  }
+  const trimmed = id.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  if (path.isAbsolute(trimmed)) {
+    throw new Error(`${label} must not be an absolute path`);
+  }
+  if (trimmed === "." || trimmed === "..") {
+    throw new Error(`${label} must not be "." or ".."`);
+  }
+  if (trimmed.includes("/") || trimmed.includes("\\") || path.basename(trimmed) !== trimmed) {
+    throw new Error(`${label} must be a single path segment`);
+  }
+  return trimmed;
+}
+function resolvePlanningItemPath(bucketDir, id, options = {}) {
+  const label = options.label ?? "id";
+  const safeId = assertSafePlanningFileId(id, label);
+  const extra = (options.extraSegments ?? []).map(
+    (segment, index) => assertSafePlanningFileId(segment, `${label} path segment ${index + 1}`)
+  );
+  const relativeFile = path.join(...extra, `${safeId}.md`);
+  assertContainedPath(bucketDir, relativeFile, label);
+  return path.join(bucketDir, relativeFile);
+}
+function isPersistedWorkEdge(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return isNonEmptyString(candidate.from) && isNonEmptyString(candidate.to) && isWorkEdgeType(candidate.type) && isWorkItemKind(candidate.fromKind) && isWorkItemKind(candidate.toKind) && isNonEmptyString(candidate.declaredOn) && typeof candidate.declaredBy === "string" && isRawRelationship(candidate.declaredBy) && isNonEmptyString(candidate.declaredTarget);
+}
+function normalizeMarkdownContent(content) {
+  return content.replace(/\r\n/g, "\n");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function validateBaseFrontMatter(value, source) {
+  if (!isRecord(value)) {
+    throw new Error(`Invalid YAML front matter in ${source}: expected an object`);
+  }
+  const hasBaseShape = "kind" in value || "title" in value || "id" in value && "kind" in value;
+  if (!hasBaseShape) {
+    return value;
+  }
+  if (typeof value.id !== "string" || value.id.trim().length === 0) {
+    throw new Error(`Invalid YAML front matter in ${source}: id must be a non-empty string`);
+  }
+  if (typeof value.title !== "string" || value.title.trim().length === 0) {
+    throw new Error(`Invalid YAML front matter in ${source}: title must be a non-empty string`);
+  }
+  if (typeof value.kind !== "string" || !VALID_KINDS.has(value.kind)) {
+    throw new Error(`Invalid YAML front matter in ${source}: kind must be a known planning kind`);
+  }
+  if ("priority" in value && value.priority !== null && value.priority !== void 0) {
+    if (typeof value.priority !== "string" || !VALID_PRIORITIES.has(value.priority)) {
+      throw new Error(`Invalid YAML front matter in ${source}: priority must be P0, P1, P2, or P3`);
+    }
+  }
+  return value;
+}
+async function atomicWriteFile(filePath, content) {
+  const dirPath = path.dirname(filePath);
+  await ensureDirectoryExists(dirPath);
+  const tempPath = path.join(
+    dirPath,
+    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`
+  );
+  const handle = await fs.open(tempPath, "w");
+  try {
+    await handle.writeFile(content, "utf-8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    await fs.rename(tempPath, filePath);
+  } catch (error) {
+    await fs.rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function readMarkdownFile(filePath) {
+  const content = normalizeMarkdownContent(await fs.readFile(filePath, "utf-8"));
+  const frontMatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+  const match = content.match(frontMatterRegex);
+  if (!match) {
+    throw new Error(`No YAML front matter found in ${filePath}`);
+  }
+  const [, yamlContent, body] = match;
+  const frontMatter = validateBaseFrontMatter(
+    yaml.load(yamlContent ?? "", { schema: yaml.JSON_SCHEMA }),
+    filePath
+  );
+  const trimmedBody = (body ?? "").trim();
+  return {
+    frontMatter,
+    body: trimmedBody,
+    content: trimmedBody
+    // Alias for body for backward compatibility
+  };
+}
+async function parseMarkdownFile(filePath) {
+  const content = normalizeMarkdownContent(await fs.readFile(filePath, "utf-8"));
+  const match = content.match(/^---\n([\s\S]+?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    throw new Error(`Invalid markdown format in ${filePath}: Missing YAML front matter`);
+  }
+  const yamlContent = match[1];
+  const body = match[2] || "";
+  const parsed = validateBaseFrontMatter(
+    yaml.load(yamlContent ?? "", { schema: yaml.JSON_SCHEMA }),
+    filePath
+  );
+  return { yaml: parsed, body };
+}
+async function writeMarkdownFile(filePath, frontMatter, body) {
+  const yamlContent = yaml.dump(frontMatter, {
+    indent: 2,
+    lineWidth: -1,
+    // Disable line wrapping
+    noRefs: true
+    // Don't use anchors/aliases
+  });
+  const content = `---
+${yamlContent}---
+
+${body.trim()}
+`;
+  await atomicWriteFile(filePath, content);
+}
+function extractYAML(yamlString) {
+  try {
+    return validateBaseFrontMatter(
+      yaml.load(yamlString, { schema: yaml.JSON_SCHEMA }),
+      "YAML input"
+    );
+  } catch (error) {
+    throw new Error(`Invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function serializeYAML(obj) {
+  return yaml.dump(obj, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true
+  });
+}
+async function ensureDirectoryExists(dirPath) {
+  try {
+    await fs.access(dirPath);
+  } catch {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+}
+async function getSequentialId(directory, prefix) {
+  try {
+    await fs.access(directory);
+  } catch {
+    return `${prefix}-001`;
+  }
+  const files = await fs.readdir(directory);
+  const pattern = new RegExp(`^${prefix}-(\\d+)(?:-|\\.|$)`);
+  let maxNum = 0;
+  for (const file of files) {
+    const match = file.match(pattern);
+    if (match?.[1]) {
+      const num = Number.parseInt(match[1], 10);
+      if (num > maxNum) {
+        maxNum = num;
+      }
+    }
+  }
+  const nextNum = maxNum + 1;
+  return `${prefix}-${String(nextNum).padStart(3, "0")}`;
+}
+async function listMarkdownFiles(directory) {
+  try {
+    const files = await fs.readdir(directory);
+    return files.filter((f) => f.endsWith(".md") && !CONVENTION_FILES.has(f)).sort((a, b) => a.localeCompare(b)).map((f) => path.join(directory, f));
+  } catch {
+    return [];
+  }
+}
+async function listMarkdownFilesRecursive(directory) {
+  const results = [];
+  let entries;
+  try {
+    entries = await fs.readdir(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await listMarkdownFilesRecursive(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md") && !CONVENTION_FILES.has(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function listMarkdownFilesRecursiveStrict(directory) {
+  const results = [];
+  let entries;
+  try {
+    entries = await fs.readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await listMarkdownFilesRecursiveStrict(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md") && !CONVENTION_FILES.has(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  WORK_EDGE_TYPES,
+  WORK_ITEM_KINDS,
+  RAW_RELATIONSHIPS,
+  isRawRelationship,
+  isNeutralRelationship,
+  assertSafePlanningFileId,
+  resolvePlanningItemPath,
+  isPersistedWorkEdge,
+  atomicWriteFile,
+  readMarkdownFile,
+  parseMarkdownFile,
+  writeMarkdownFile,
+  extractYAML,
+  serializeYAML,
+  ensureDirectoryExists,
+  getSequentialId,
+  listMarkdownFiles,
+  listMarkdownFilesRecursive,
+  listMarkdownFilesRecursiveStrict,
+  fileExists
+};
+//# sourceMappingURL=chunk-OIS7J26S.js.map

package/dist/chunk-OMX5VL43.js

@@ -0,0 +1,79 @@
+// src/utils/git-lock-recovery.ts
+import { rm, stat } from "fs/promises";
+import path from "path";
+import { execa } from "execa";
+var DEFAULT_STALE_LOCK_AGE_MS = 3e4;
+async function hasAnyActiveGitProcess() {
+  const result = await execa("ps", ["-axo", "pid=,command="], {
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    return true;
+  }
+  return result.stdout.split("\n").map((line) => line.trim()).some((line) => {
+    if (!line) return false;
+    const [pidText, ...commandParts] = line.split(/\s+/);
+    if (!pidText) return false;
+    const pid = Number.parseInt(pidText, 10);
+    if (!Number.isFinite(pid) || pid === process.pid) {
+      return false;
+    }
+    const command = commandParts.join(" ");
+    return /\bgit(\s|$)/.test(command);
+  });
+}
+async function resolveGitDir(cwd) {
+  const result = await execa("git", ["rev-parse", "--path-format=absolute", "--git-dir"], {
+    cwd,
+    stdio: "pipe",
+    reject: false
+  });
+  if (result.exitCode !== 0) {
+    return null;
+  }
+  const gitDir = result.stdout.trim();
+  return gitDir.length > 0 ? gitDir : null;
+}
+async function cleanupStaleGitIndexLock(cwd, options = {}) {
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_LOCK_AGE_MS;
+  const gitDir = await resolveGitDir(cwd);
+  if (!gitDir) {
+    return false;
+  }
+  const lockPath = path.join(gitDir, "index.lock");
+  let lockStats;
+  try {
+    lockStats = await stat(lockPath);
+  } catch {
+    return false;
+  }
+  if (Date.now() - lockStats.mtimeMs < staleAfterMs) {
+    return false;
+  }
+  if (await hasAnyActiveGitProcess()) {
+    return false;
+  }
+  let latestLockStats;
+  try {
+    latestLockStats = await stat(lockPath);
+  } catch {
+    return false;
+  }
+  if (latestLockStats.mtimeMs !== lockStats.mtimeMs || Date.now() - latestLockStats.mtimeMs < staleAfterMs) {
+    return false;
+  }
+  await rm(lockPath, { force: true }).catch(() => {
+  });
+  try {
+    await stat(lockPath);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+export {
+  cleanupStaleGitIndexLock
+};
+//# sourceMappingURL=chunk-OMX5VL43.js.map