@poetic-ai/poetic 1.42.1-bootstrap.0

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-OKBTRSZI.js

@@ -0,0 +1,205 @@
+import {
+  extractAcceptanceCriteria
+} from "./chunk-G2PTLLEL.js";
+import {
+  parseTaskBody
+} from "./chunk-SNLBO4BF.js";
+
+// src/core/build/parse-instruction.ts
+var FENCED_BLOCK_RE = /```(\w+)?\s*\n([\s\S]*?)```/g;
+var ALLOWED_FENCE_LANGS = /* @__PURE__ */ new Set(["bash", "sh"]);
+var VERIFY_SECTION_RE = /(?:^|\n)(?:##\s*)?(?:How\s+to\s+Verify|Verification)\s*:?\s*\n+([\s\S]*?)(?=\n##|\n---|$)/i;
+function extractVerifyCommands(text) {
+  if (!text) return [];
+  const commands = [];
+  for (const match of text.matchAll(FENCED_BLOCK_RE)) {
+    const lang = (match[1] ?? "").toLowerCase();
+    if (!ALLOWED_FENCE_LANGS.has(lang)) continue;
+    const body = match[2] ?? "";
+    for (const rawLine of body.split("\n")) {
+      const line = rawLine.replace(/^\s*\$\s+/, "").trim();
+      if (line.length === 0) continue;
+      if (line.startsWith("#")) continue;
+      commands.push(line);
+    }
+  }
+  const textOutsideFences = text.replace(FENCED_BLOCK_RE, "");
+  for (const rawLine of textOutsideFences.split("\n")) {
+    const dollarMatch = rawLine.match(/^\s*\$\s+(.+)$/);
+    if (dollarMatch?.[1]) {
+      const line = dollarMatch[1].trim();
+      if (line.length > 0 && !commands.includes(line)) {
+        commands.push(line);
+      }
+    }
+  }
+  return commands;
+}
+function parseBuildInstruction(input) {
+  const trimmed = input.trim();
+  const spec = parseTaskBody(trimmed);
+  const acceptanceCriteria = extractAcceptanceCriteria(trimmed);
+  if (acceptanceCriteria.length > 0) {
+    spec.acceptanceCriteria = acceptanceCriteria;
+  }
+  const verificationText = spec.verification ?? trimmed.match(VERIFY_SECTION_RE)?.[1]?.trim();
+  const verifyCommands = extractVerifyCommands(verificationText);
+  return { spec, acceptanceCriteria, verifyCommands };
+}
+function mergeVerifyCommands(parsed, cliOverrides) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const cmd of [...parsed, ...cliOverrides ?? []]) {
+    const trimmed = cmd.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    merged.push(trimmed);
+  }
+  return merged;
+}
+
+// src/core/loop/explicit-verification-intent.ts
+var FORWARDED_ARG_TOKEN = String.raw`-[-\w:@./=]*`;
+var FORWARDED_ARGS = String.raw`(?:\s+--\s+${FORWARDED_ARG_TOKEN}(?:\s+${FORWARDED_ARG_TOKEN})*)?`;
+var DIRECT_FLAGS = String.raw`(?:\s+-[-\w:@./=]+)*`;
+var PACKAGE_RUN_TARGET = String.raw`(?:-[\w-]+\s+)*[A-Za-z0-9_:@./][\w:@./-]*`;
+var VERIFY_SCRIPT = String.raw`(?:[\w-]*(?:test|type|check|lint|verify|validate|build|e2e|coverage|smoke|integration)[\w-]*(?::[\w:-]+)?)`;
+var PACKAGE_COMMAND = String.raw`(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?${PACKAGE_RUN_TARGET}${DIRECT_FLAGS}${FORWARDED_ARGS}`;
+var PYTHON_MODULE_ARG_TOKEN = String.raw`(?!(?:and|after|before|confirm|finish(?:ing)?|then|to|verify|passes?)\b)[-\w:@./=]+`;
+var PYTHONPATH_VALUE = String.raw`[-\w:@./]+`;
+var PYTHONPATH_ENV_PREFIX = String.raw`(?:env\s+)?PYTHONPATH=${PYTHONPATH_VALUE}`;
+var PYTHON_MODULE_VERIFY_COMMAND = String.raw`(?:${PYTHONPATH_ENV_PREFIX}\s+)?(?:python3?|py)\s+-m\s+(?:pytest|unittest)(?:\s+${PYTHON_MODULE_ARG_TOKEN})*`;
+var BARE_PYTHON_MODULE_VERIFY_COMMAND = String.raw`(?:python3?|py)\s+-m\s+(?:pytest|unittest)(?:\s+${PYTHON_MODULE_ARG_TOKEN})*`;
+var PACKAGE_RUN_PREFIXED_COMMAND = new RegExp(String.raw`\brun\s+(${PACKAGE_COMMAND})`, "gi");
+var PACKAGE_BARE_COMMAND = new RegExp(String.raw`\b(${PACKAGE_COMMAND})`, "gi");
+var PYTHONPATH_ENV_COMMAND = new RegExp(
+  String.raw`^(?:env\s+)?(PYTHONPATH=${PYTHONPATH_VALUE})\s+(${BARE_PYTHON_MODULE_VERIFY_COMMAND})$`,
+  "i"
+);
+var BARE_PYTHON_MODULE_VERIFY_COMMAND_PATTERN = new RegExp(
+  `^${BARE_PYTHON_MODULE_VERIFY_COMMAND}$`,
+  "i"
+);
+var NPM_STYLE_RUN_COMMAND = new RegExp(
+  String.raw`^(?:npm|pnpm|bun)\s+run\s+(?:-[\w-]+\s+)*${VERIFY_SCRIPT}${FORWARDED_ARGS}$`,
+  "i"
+);
+var PACKAGE_SCRIPT_SHORTCUT_COMMAND = new RegExp(
+  String.raw`^(?:pnpm|bun|yarn)\s+(?:run\s+)?(?:-[\w-]+\s+)*${VERIFY_SCRIPT}${DIRECT_FLAGS}${FORWARDED_ARGS}$`,
+  "i"
+);
+function extractExplicitVerificationCommands(prompt) {
+  const commands = /* @__PURE__ */ new Set();
+  for (const cmd of extractVerifyCommands(prompt)) {
+    if (cmd.length > 0) commands.add(cmd);
+  }
+  for (const match of prompt.matchAll(/`([^`\n]+)`/g)) {
+    for (const part of splitCompoundVerificationCommand(match[1] ?? "")) {
+      const cmd = normalizeVerificationCommand(part);
+      if (cmd) commands.add(cmd);
+    }
+  }
+  const patterns = [
+    PACKAGE_RUN_PREFIXED_COMMAND,
+    /\brun\s+(make\s+[\w:@./-]+)/gi,
+    /\brun\s+((?:cargo|go|pytest|bundle)\s+[\w:@./-]+)/gi,
+    new RegExp(String.raw`\brun\s+(${PYTHON_MODULE_VERIFY_COMMAND})`, "gi"),
+    PACKAGE_BARE_COMMAND,
+    /\b(make\s+(?:test|check|lint|verify|typecheck)\b)/gi,
+    /\b(cargo\s+(?:test|check|clippy|fmt)(?:\s+-[-\w:@./=]+)?)/gi,
+    /\b(go\s+(?:test|vet|build)(?:\s+[\w./-]+)?(?:\s+-[-\w:@./=]+)?)/gi,
+    /\b(pytest(?:\s+[\w./-]+)?)/gi,
+    new RegExp(String.raw`\b(${PYTHON_MODULE_VERIFY_COMMAND})`, "gi")
+  ];
+  for (const pattern of patterns) {
+    for (const match of prompt.matchAll(pattern)) {
+      const candidate = match[1] ?? match[0];
+      if (isBarePythonMatchInsideEnvAssignment(prompt, match.index ?? -1, candidate)) {
+        continue;
+      }
+      const cmd = normalizeVerificationCommand(candidate);
+      if (cmd) commands.add(cmd);
+    }
+  }
+  return removeBarePythonCommandsCoveredByEnv(Array.from(commands));
+}
+function splitCompoundVerificationCommand(command) {
+  return command.split(/\s*(?:&&|;)\s*/).filter((part) => part.trim().length > 0);
+}
+function normalizeVerificationCommand(command) {
+  const normalized = command.trim().replace(/(?<![./])[.,;:]+$/g, "").replace(/\s+/g, " ");
+  const normalizedEnvCommand = normalizePythonPathEnvCommand(normalized);
+  if (normalizedEnvCommand.length === 0) return void 0;
+  if (!isVerificationCommand(normalizedEnvCommand)) return void 0;
+  return normalizedEnvCommand;
+}
+function normalizePythonPathEnvCommand(command) {
+  return command.replace(
+    PYTHONPATH_ENV_COMMAND,
+    (_match, assignment, pythonCommand) => `env ${assignment} ${pythonCommand}`
+  );
+}
+function isBarePythonMatchInsideEnvAssignment(prompt, matchIndex, candidate) {
+  if (matchIndex < 0 || !BARE_PYTHON_MODULE_VERIFY_COMMAND_PATTERN.test(candidate)) {
+    return false;
+  }
+  const prefix = prompt.slice(Math.max(0, matchIndex - 120), matchIndex);
+  return /(?:^|[\s`])(?:env\s+)?[A-Za-z_][A-Za-z0-9_]*=\S+\s+$/i.test(prefix);
+}
+function removeBarePythonCommandsCoveredByEnv(commands) {
+  const envWrappedPythonCommands = /* @__PURE__ */ new Set();
+  const envWrappedDirectAliases = /* @__PURE__ */ new Set();
+  for (const command of commands) {
+    const match = command.match(PYTHONPATH_ENV_COMMAND);
+    if (match?.[2]) {
+      const pythonCommand = match[2];
+      envWrappedPythonCommands.add(pythonCommand);
+      const pytestMatch = pythonCommand.match(/^(?:python3?|py)\s+-m\s+pytest(?:\s+(.+))?$/i);
+      if (pytestMatch) {
+        envWrappedDirectAliases.add(`pytest${pytestMatch[1] ? ` ${pytestMatch[1]}` : ""}`);
+      }
+    }
+  }
+  return commands.filter((command) => {
+    if (!BARE_PYTHON_MODULE_VERIFY_COMMAND_PATTERN.test(command)) return true;
+    return !envWrappedPythonCommands.has(command);
+  }).filter((command) => !envWrappedDirectAliases.has(command));
+}
+function isVerificationCommand(command) {
+  if (/^(?:npm|pnpm|bun)\s+test(?:\s+[\w:@./=-]+)*$/i.test(command)) return true;
+  if (NPM_STYLE_RUN_COMMAND.test(command)) return true;
+  if (PACKAGE_SCRIPT_SHORTCUT_COMMAND.test(command)) return true;
+  if (/^make\s+[\w:@./-]+$/i.test(command)) return true;
+  if (/^cargo\s+(?:test|check|clippy|fmt)(?:\s+-[-\w:@./=]+)*$/i.test(command)) return true;
+  if (/^go\s+(?:test|vet|build)(?:\s+[\w./-]+)?(?:\s+-[-\w:@./=]+)*$/i.test(command)) {
+    return true;
+  }
+  if (/^pytest(?:\s+[\w./-]+)?$/i.test(command)) return true;
+  if (new RegExp(
+    String.raw`^env\s+PYTHONPATH=${PYTHONPATH_VALUE}\s+${BARE_PYTHON_MODULE_VERIFY_COMMAND}$`,
+    "i"
+  ).test(command)) {
+    return true;
+  }
+  if (/^(?:python3?|py)\s+-m\s+(?:pytest|unittest)(?:\s+[-\w:@./=]+)*$/i.test(command)) {
+    return true;
+  }
+  if (/^bundle\s+[\w:@./-]+$/i.test(command)) return true;
+  return false;
+}
+function hasExplicitVerificationIntent(prompt) {
+  if (extractExplicitVerificationCommands(prompt).length > 0) {
+    return true;
+  }
+  return /\b(?:run|execute)\b[\s\S]{0,160}\b(?:confirm|verify)\b[\s\S]{0,80}\bpass(?:es)?\b/i.test(
+    prompt
+  );
+}
+
+export {
+  parseBuildInstruction,
+  mergeVerifyCommands,
+  extractExplicitVerificationCommands,
+  hasExplicitVerificationIntent
+};
+//# sourceMappingURL=chunk-OKBTRSZI.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