@primitive.ai/prim 0.1.0-alpha.9 → 0.1.0-alpha.90

package/dist/chunk-PPQYQEIR.js

@@ -0,0 +1,815 @@
+// src/hooks/pre-tool-use-scoring.ts
+import { isAbsolute, relative, sep } from "path";
+function anyUnverified(results) {
+  return results.some((r) => r.verdict === "unavailable" || r.truncated);
+}
+function unverifiedNote(results) {
+  const causes = [];
+  const unavailable = results.find((r) => r.verdict === "unavailable");
+  if (unavailable) {
+    causes.push(
+      unavailable.unavailable ? `decision check skipped \u2014 ${unavailable.unavailable}` : "decision check skipped \u2014 not verified"
+    );
+  }
+  if (results.some((r) => r.truncated)) {
+    causes.push("decision check partial \u2014 conflict set truncated (per-file cap hit)");
+  }
+  return causes.map((c) => `[primitive] ${c}`).join("\n");
+}
+function blockingReason(results) {
+  const parts = results.filter((result) => result.verdict === "ask" || result.verdict === "deny").flatMap((result) => [result.reason, result.additionalContext]).filter((value) => value.length > 0);
+  return [...new Set(parts)].join("\n\n") || "[primitive] conflict detected (no detail available)";
+}
+function advisoryNote(aggregate, results) {
+  const details = results.flatMap((result) => [
+    ...aggregate === "warn" ? [result.reason] : [],
+    result.additionalContext
+  ]);
+  if (anyUnverified(results)) details.push(unverifiedNote(results));
+  return [...new Set(details.filter((value) => value.length > 0))].join("\n\n");
+}
+function buildHookOutput(aggregate, results) {
+  if (aggregate === "deny" || aggregate === "ask") {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: aggregate,
+        permissionDecisionReason: blockingReason(results)
+      }
+    };
+  }
+  const notes = advisoryNote(aggregate, results);
+  if (notes.length > 0) {
+    return {
+      systemMessage: notes,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        additionalContext: notes
+      }
+    };
+  }
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  };
+}
+function buildCodexOutput(aggregate, results) {
+  if (aggregate === "deny" || aggregate === "ask") {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: blockingReason(results)
+      }
+    };
+  }
+  const notes = advisoryNote(aggregate, results);
+  return notes ? {
+    systemMessage: notes,
+    hookSpecificOutput: { hookEventName: "PreToolUse", additionalContext: notes }
+  } : {};
+}
+function failOpenOutput() {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  };
+}
+function failOpenCodex() {
+  return {};
+}
+function buildHermesOutput(aggregate, results) {
+  if (aggregate !== "deny" && aggregate !== "ask") {
+    return {};
+  }
+  const reason = results.filter((r) => r.verdict === "deny" || r.verdict === "ask").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n");
+  const directive = results.map((r) => r.additionalContext).filter((s) => s.length > 0 && s !== reason).join("\n");
+  const message = [reason, directive].filter((s) => s.length > 0).join("\n\n") || "[primitive] conflict detected (no detail available)";
+  return { action: "block", message };
+}
+function failOpenHermes() {
+  return {};
+}
+var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var APPLY_PATCH_FILE_RE = /^\*\*\* (?:Update|Add|Delete) File: (?<path>.+)$/;
+var MOVE_FILE_RE = /^\*\*\* Move File:\s*(?<src>.+?)\s*->\s*(?<dst>.+?)\s*$/;
+var MOVE_TO_RE = /^\*\*\* Move to: (?<dst>.+)$/;
+var LINE_SPLIT_RE = /\r?\n/;
+function parseApplyPatchTargets(command) {
+  const paths = /* @__PURE__ */ new Set();
+  let activeUpdate = false;
+  let complete = true;
+  for (const line of command.split(LINE_SPLIT_RE)) {
+    const path = APPLY_PATCH_FILE_RE.exec(line)?.groups?.path;
+    if (path) {
+      paths.add(path);
+      activeUpdate = line.startsWith("*** Update File:");
+      continue;
+    }
+    const moveTo = MOVE_TO_RE.exec(line)?.groups?.dst;
+    if (moveTo) {
+      if (activeUpdate) paths.add(moveTo);
+      else complete = false;
+      activeUpdate = false;
+      continue;
+    }
+    const move = MOVE_FILE_RE.exec(line)?.groups;
+    if (move?.src) {
+      paths.add(move.src);
+      if (move.dst) {
+        paths.add(move.dst);
+      }
+      activeUpdate = false;
+      continue;
+    }
+    if (line === "*** Begin Patch" || line === "*** End Patch") activeUpdate = false;
+    else if (line.startsWith("*** ")) complete = false;
+  }
+  return { paths: [...paths], complete: complete && paths.size > 0 };
+}
+function extractCodexFileTargets(toolName, toolInput) {
+  if (toolName !== "apply_patch") {
+    return null;
+  }
+  const text = codexPatchText(toolInput);
+  return text !== null ? parseApplyPatchTargets(text) : { paths: [], complete: false };
+}
+function codexPatchText(toolInput) {
+  if (typeof toolInput === "string") return toolInput;
+  if (!toolInput || typeof toolInput !== "object") return null;
+  const input = toolInput;
+  for (const key of ["command", "input", "patch"]) {
+    const value = input[key];
+    if (typeof value === "string") return value;
+  }
+  return null;
+}
+var HERMES_EDITING_TOOLS = /* @__PURE__ */ new Set(["write_file", "patch"]);
+function extractHermesFileTargets(toolName, toolInput) {
+  if (!HERMES_EDITING_TOOLS.has(toolName)) {
+    return null;
+  }
+  if (!toolInput || typeof toolInput !== "object") {
+    return { paths: [], complete: false };
+  }
+  const input = toolInput;
+  if (toolName === "patch" && input.mode === "patch") {
+    return typeof input.patch === "string" ? parseApplyPatchTargets(input.patch) : { paths: [], complete: false };
+  }
+  const paths = typeof input.path === "string" && input.path.length > 0 ? [input.path] : [];
+  const mode = input.mode;
+  return { paths, complete: paths.length > 0 && (mode === void 0 || mode === "replace") };
+}
+function extractFileTargets(toolName, toolInput, agent = "claude_code") {
+  if (agent === "codex") {
+    return extractCodexFileTargets(toolName, toolInput);
+  }
+  if (agent === "hermes") {
+    return extractHermesFileTargets(toolName, toolInput);
+  }
+  if (!SUPPORTED_TOOLS.has(toolName)) {
+    return null;
+  }
+  if (!toolInput || typeof toolInput !== "object") {
+    return { paths: [], complete: false };
+  }
+  const input = toolInput;
+  if (toolName === "NotebookEdit") {
+    const paths2 = typeof input.notebook_path === "string" && input.notebook_path.length > 0 ? [input.notebook_path] : [];
+    return { paths: paths2, complete: paths2.length > 0 };
+  }
+  const paths = typeof input.file_path === "string" && input.file_path.length > 0 ? [input.file_path] : [];
+  return { paths, complete: paths.length > 0 };
+}
+function readHookMode(env) {
+  if (env.PRIM_BYPASS === "1" || env.PRIM_BYPASS === "true") {
+    return "off";
+  }
+  const mode = env.PRIM_HOOK_MODE;
+  if (mode === "off" || mode === "warn") {
+    return mode;
+  }
+  return "block";
+}
+function demoteForMode(verdict, mode) {
+  if (mode === "off") {
+    return "allow";
+  }
+  if (mode === "warn" && (verdict === "ask" || verdict === "deny")) {
+    return "warn";
+  }
+  return verdict;
+}
+
+// src/hooks/shell-targets.ts
+import { parse } from "unbash";
+var OUTPUT_REDIRECTS = /* @__PURE__ */ new Set([">", ">>", ">|", "&>", "&>>"]);
+var READ_ONLY_COMMANDS = new Set(": cat echo false printf pwd test true [".split(" "));
+var SINKS = /* @__PURE__ */ new Set(["/dev/null", "/dev/stdout", "/dev/stderr"]);
+var STATIC_PARTS = /* @__PURE__ */ new Set(["Literal", "SingleQuoted", "AnsiCQuoted"]);
+var set = (values) => new Set(values.split(" ").filter(Boolean));
+var INFO_OPTIONS = set("--help --version");
+var COMMAND_OPTIONS = {
+  rg: {
+    shortFlags: "0FHILNPSUabchilnopqsvwx",
+    shortValues: "ABCEgjMmrtTef",
+    longFlags: set(
+      "--binary --case-sensitive --column --count --count-matches --crlf --debug --files --files-with-matches --files-without-match --fixed-strings --follow --heading --hidden --ignore-case --invert-match --json --line-number --line-regexp --multiline --multiline-dotall --no-filename --no-heading --no-hidden --no-ignore --no-ignore-parent --no-ignore-vcs --no-line-number --null --null-data --one-file-system --only-matching --passthru --pcre2 --pretty --quiet --smart-case --stats --text --trim --unrestricted --with-filename --word-regexp"
+    ),
+    longValues: set(
+      "--after-context --before-context --context --dfa-size-limit --encoding --engine --file --glob --iglob --max-columns --max-count --max-depth --path-separator --regexp --regex-size-limit --replace --sort --sortr --threads --type --type-add --type-clear --type-not"
+    ),
+    longOptionalValues: set("--color")
+  },
+  grep: {
+    shortFlags: "EFGHIPRTUVabcdhLlnqrsuvwxyZz",
+    shortValues: "ABCDefm",
+    longFlags: set(
+      "--basic-regexp --binary-files-without-match --byte-offset --count --extended-regexp --files-with-matches --files-without-match --fixed-regexp --fixed-strings --help --ignore-case --initial-tab --invert-match --line-buffered --line-number --line-regexp --null --null-data --only-matching --perl-regexp --quiet --recursive --silent --unix-byte-offsets --version --with-filename --word-regexp"
+    ),
+    longValues: set(
+      "--after-context --before-context --binary-files --context --devices --directories --exclude --exclude-dir --exclude-from --file --include --label --max-count --regexp"
+    ),
+    longOptionalValues: set("--color")
+  },
+  head: {
+    shortFlags: "qvz",
+    shortValues: "cn",
+    longFlags: set("--help --quiet --verbose --version --zero-terminated"),
+    longValues: set("--bytes --lines")
+  },
+  tail: {
+    shortFlags: "Fqsvz",
+    shortValues: "cn",
+    longFlags: set("--help --quiet --retry --silent --verbose --version --zero-terminated"),
+    longValues: set("--bytes --lines --max-unchanged-stats --pid --sleep-interval"),
+    longOptionalValues: set("--follow")
+  },
+  wc: {
+    shortFlags: "cLlmw",
+    longFlags: set("--bytes --chars --help --lines --max-line-length --version --words"),
+    longValues: set("--files0-from")
+  },
+  ls: {
+    shortFlags: "ABCDFGHILNQRSTUXZabcdfghiklmnopqrstuvwxy",
+    shortValues: "ITw",
+    longFlags: set(
+      "--all --almost-all --author --classify --dereference --directory --dired --file-type --group-directories-first --help --hide-control-chars --human-readable --ignore-backups --inode --kibibytes --literal --no-group --numeric-uid-gid --quote-name --recursive --reverse --show-control-chars --size --version"
+    ),
+    longValues: set(
+      "--block-size --format --hide --ignore --indicator-style --quoting-style --sort --tabsize --time --time-style --width"
+    ),
+    longOptionalValues: set("--color --hyperlink")
+  }
+};
+var GIT_INSPECTION_OPTIONS = {
+  shortFlags: "abcdfhiklmnprstuvwz",
+  shortValues: "ABCGLMSU",
+  longFlags: set(
+    "--abbrev-commit --all --binary --branches --cached --check --children --date-order --deduplicate --deleted --error-unmatch --exclude-standard --exit-code --files-with-matches --full-history --full-index --full-name --graph --heading --ignore-all-space --ignore-blank-lines --ignore-space-at-eol --ignore-space-change --ignored --is-bare-repository --is-inside-git-dir --is-inside-work-tree --killed --left-only --line-number --merge-base --merges --modified --name-only --name-status --no-abbrev-commit --no-color --no-decorate --no-ext-diff --no-renames --no-textconv --numstat --objects --oneline --others --patch --quiet --remotes --right-only --root --short --shortstat --show-current --show-toplevel --stage --staged --stat --summary --symbolic-full-name --tags --topo-order --unmerged --verify --zero-commit"
+  ),
+  longValues: set(
+    "--after --author --before --committer --date --decorate-refs-exclude --diff-filter --exclude --format --git-path --grep --max-count --max-depth --max-parents --min-parents --object-format --path-format --pretty --since --skip --sort --until"
+  ),
+  longOptionalValues: set(
+    "--abbrev --batch --batch-check --color --decorate --relative --word-diff"
+  )
+};
+var GIT_METADATA_OPTIONS = {
+  add: {
+    shortFlags: "Afnpuv",
+    longFlags: set(
+      "--all --dry-run --force --ignore-errors --ignore-missing --intent-to-add --no-all --no-ignore-removal --pathspec-file-nul --refresh --renormalize --sparse --update --verbose"
+    ),
+    longValues: set("--chmod --pathspec-from-file")
+  },
+  commit: {
+    shortFlags: "anqsu",
+    shortValues: "CFm",
+    longFlags: set(
+      "--all --allow-empty --allow-empty-message --amend --branch --dry-run --include --long --no-edit --no-post-rewrite --no-status --no-verify --null --only --pathspec-file-nul --porcelain --reset-author --short --signoff --status"
+    ),
+    longValues: set(
+      "--author --cleanup --date --file --fixup --message --pathspec-from-file --reuse-message --squash --trailer --untracked-files"
+    )
+  },
+  push: {
+    shortFlags: "fquv",
+    longFlags: set(
+      "--all --atomic --delete --dry-run --follow-tags --force --force-if-includes --mirror --no-verify --porcelain --prune --quiet --set-upstream --tags --verbose"
+    ),
+    longValues: set("--push-option --recurse-submodules"),
+    longOptionalValues: set("--force-with-lease")
+  },
+  branch: {
+    shortFlags: "adfMmrqv",
+    longFlags: set(
+      "--all --copy --delete --force --ignore-case --list --merged --move --no-color --no-contains --no-merged --remotes --show-current --verbose"
+    ),
+    longValues: set("--contains --format --points-at --sort"),
+    longOptionalValues: set("--color --column --track")
+  },
+  "update-index": {
+    shortFlags: "q",
+    longFlags: set(
+      "--add --again --assume-unchanged --force-remove --fsmonitor-valid --ignore-missing --index-info --info-only --no-assume-unchanged --no-fsmonitor-valid --refresh --remove --replace --skip-worktree --unresolve"
+    ),
+    longValues: set("--cacheinfo --chmod --index-version")
+  }
+};
+var GH_PR_OPTIONS = {
+  view: {
+    longFlags: set("--comments"),
+    longValues: set("--jq --json --template")
+  },
+  list: {
+    longFlags: set("--draft"),
+    longValues: set(
+      "--app --assignee --author --base --head --jq --json --label --limit --search --state --template"
+    )
+  },
+  status: {},
+  checks: {
+    longFlags: set("--fail-fast --required --watch"),
+    longValues: set("--interval --jq --json --template")
+  },
+  diff: {
+    longFlags: set("--name-only --patch"),
+    longValues: set("--color")
+  },
+  create: {
+    longFlags: set("--draft --fill --fill-first --fill-verbose --no-maintainer-edit"),
+    longValues: set(
+      "--assignee --base --body --body-file --head --label --milestone --project --recover --reviewer --template --title"
+    )
+  },
+  edit: {
+    longValues: set(
+      "--add-assignee --add-label --add-project --add-reviewer --base --body --body-file --milestone --remove-assignee --remove-label --remove-milestone --remove-project --remove-reviewer --title"
+    )
+  },
+  close: {
+    longValues: set("--comment")
+  },
+  reopen: {
+    longValues: set("--comment")
+  },
+  ready: {
+    longFlags: set("--undo")
+  },
+  review: {
+    longFlags: set("--approve --comment --request-changes"),
+    longValues: set("--body --body-file")
+  },
+  merge: {
+    shortFlags: "mdrs",
+    longFlags: set("--admin --auto --disable-auto --merge --rebase --squash"),
+    longValues: set("--author-email --body --body-file --match-head-commit --subject")
+  },
+  comment: {
+    longFlags: set("--delete-last --edit-last"),
+    longValues: set("--body --body-file")
+  },
+  lock: {
+    longValues: set("--reason")
+  },
+  unlock: {}
+};
+function staticPart(part) {
+  return STATIC_PARTS.has(part.type) || part.type === "DoubleQuoted" && part.parts.every(staticPart);
+}
+function staticWord(word) {
+  if (!word || !word.value || word.value.includes("\0") || word.value.includes("\n")) return;
+  if (word.parts ? !word.parts.every(staticPart) : word.value.startsWith("~") || /[*?\[$`]/.test(word.text))
+    return;
+  return word.value;
+}
+function parseOptions(args, spec) {
+  const result = {
+    operands: [],
+    seen: /* @__PURE__ */ new Set(),
+    values: /* @__PURE__ */ new Map()
+  };
+  let optionsEnded = false;
+  const recordValue = (option, value) => {
+    result.seen.add(option);
+    result.values.set(option, [...result.values.get(option) ?? [], value]);
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (optionsEnded || arg === "-" || !arg.startsWith("-")) {
+      result.operands.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      optionsEnded = true;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const separator = arg.indexOf("=");
+      const option = separator === -1 ? arg : arg.slice(0, separator);
+      const attached = separator === -1 ? void 0 : arg.slice(separator + 1);
+      if (spec.longValues?.has(option)) {
+        const value = attached ?? args[++index];
+        if (!value) return;
+        recordValue(option, value);
+      } else if (spec.longOptionalValues?.has(option)) {
+        result.seen.add(option);
+        if (attached !== void 0) recordValue(option, attached);
+      } else if (spec.longFlags?.has(option) && attached === void 0) {
+        result.seen.add(option);
+      } else {
+        return;
+      }
+      continue;
+    }
+    for (let offset = 1; offset < arg.length; offset += 1) {
+      const option = `-${arg[offset]}`;
+      if (spec.shortValues?.includes(arg[offset])) {
+        const attached = arg.slice(offset + 1);
+        const value = attached || args[++index];
+        if (!value) return;
+        recordValue(option, value);
+        break;
+      }
+      if (!spec.shortFlags?.includes(arg[offset])) return;
+      result.seen.add(option);
+    }
+  }
+  return result;
+}
+function staticArgs(words) {
+  const args = [];
+  for (const word of words) {
+    const value = staticWord(word);
+    if (value === void 0) return;
+    args.push(value);
+  }
+  return args;
+}
+function safeSedProgram(program) {
+  if (/^(?:(?:\d+|\$)(?:,(?:\d+|\$))?)?[dDpPqQnN=]$/.test(program) || /^\/(?:\\.|[^/])*\/[dDpPqQnN=]$/.test(program))
+    return true;
+  const match = /^(?:(?:\d+|\$)(?:,(?:\d+|\$))?)?s(.)(.*)$/s.exec(program);
+  if (!match || /[\\\nA-Za-z0-9]/.test(match[1])) return false;
+  const delimiter = match[1];
+  const tail = match[2];
+  let offset = 0;
+  for (let section = 0; section < 2; section += 1) {
+    let closed = false;
+    while (offset < tail.length) {
+      if (tail[offset] === "\\") {
+        offset += 2;
+      } else if (tail[offset] === delimiter) {
+        offset += 1;
+        closed = true;
+        break;
+      } else {
+        offset += 1;
+      }
+    }
+    if (!closed) return false;
+  }
+  return /^[0-9gIpMm]*$/.test(tail.slice(offset));
+}
+function safeSed(args) {
+  if (args.length === 1 && INFO_OPTIONS.has(args[0])) return true;
+  const parsed = parseOptions(args, {
+    shortFlags: "Enrsu",
+    shortValues: "e",
+    longFlags: set("--quiet --regexp-extended --separate --silent --unbuffered"),
+    longValues: set("--expression")
+  });
+  if (!parsed) return false;
+  const optionPrograms = [
+    ...parsed.values.get("-e") ?? [],
+    ...parsed.values.get("--expression") ?? []
+  ];
+  const programs = optionPrograms.length > 0 ? optionPrograms : parsed.operands.length > 0 ? [parsed.operands.shift()] : [];
+  return programs.length > 0 && programs.every(safeSedProgram);
+}
+function safeFind(args) {
+  if (args.length === 1 && INFO_OPTIONS.has(args[0])) return true;
+  const noValue = set(
+    "! ( ) -a -and -daystart -empty -executable -false -follow -ignore_readdir_race -ls -mount -noignore_readdir_race -not -o -or -print -print0 -prune -readable -true -writable -xdev"
+  );
+  const oneValue = set(
+    "-amin -anewer -atime -cmin -cnewer -ctime -fstype -gid -group -ilname -iname -inum -ipath -iregex -iwholename -links -lname -maxdepth -mindepth -mmin -mtime -name -newer -path -perm -printf -regex -regextype -samefile -size -type -uid -used -user -wholename -xtype"
+  );
+  let expressionStarted = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!expressionStarted && (arg === "-H" || arg === "-L" || arg === "-P" || /^-O\d+$/.test(arg)))
+      continue;
+    if (!expressionStarted && !arg.startsWith("-") && arg !== "!" && arg !== "(") continue;
+    expressionStarted = true;
+    if (noValue.has(arg)) continue;
+    if (/^-newer(?:a|B|c|m)t$/.test(arg) || /^-newer[acm][acm]$/.test(arg) || oneValue.has(arg)) {
+      if (!args[++index]) return false;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+function withLongOptions(spec, flags, values) {
+  return {
+    ...spec,
+    longFlags: /* @__PURE__ */ new Set([...spec.longFlags ?? [], ...flags.split(" ").filter(Boolean)]),
+    longValues: /* @__PURE__ */ new Set([...spec.longValues ?? [], ...values.split(" ").filter(Boolean)])
+  };
+}
+function safeGit(args) {
+  let index = 0;
+  while (index < args.length) {
+    const arg = args[index];
+    if (arg === "--no-pager" || arg === "--paginate") {
+      index += 1;
+    } else if (arg === "-C" || arg === "--git-dir" || arg === "--work-tree") {
+      if (!args[index + 1]) return false;
+      index += 2;
+    } else if (arg.startsWith("--git-dir=") || arg.startsWith("--work-tree=")) {
+      if (!arg.slice(arg.indexOf("=") + 1)) return false;
+      index += 1;
+    } else {
+      break;
+    }
+  }
+  const subcommand = args[index++];
+  if (!subcommand) return args.length === 1 && INFO_OPTIONS.has(args[0]);
+  const rest = args.slice(index);
+  if ((/* @__PURE__ */ new Set([
+    "blame",
+    "cat-file",
+    "describe",
+    "diff",
+    "for-each-ref",
+    "grep",
+    "log",
+    "ls-files",
+    "ls-tree",
+    "merge-base",
+    "name-rev",
+    "rev-list",
+    "rev-parse",
+    "shortlog",
+    "show",
+    "status"
+  ])).has(subcommand))
+    return parseOptions(rest, GIT_INSPECTION_OPTIONS) !== void 0;
+  const metadata = GIT_METADATA_OPTIONS[subcommand];
+  if (metadata) {
+    const parsed = parseOptions(rest, metadata);
+    if (!parsed) return false;
+    if (subcommand !== "commit") return true;
+    return [
+      "-C",
+      "-F",
+      "-m",
+      "--dry-run",
+      "--file",
+      "--message",
+      "--no-edit",
+      "--reuse-message"
+    ].some((option) => parsed.seen.has(option));
+  }
+  if (subcommand === "reset") {
+    const parsed = parseOptions(rest, {
+      shortFlags: "Npq",
+      longFlags: set("--intent-to-add --mixed --no-refresh --pathspec-file-nul --quiet --soft"),
+      longValues: set("--pathspec-from-file")
+    });
+    return parsed !== void 0;
+  }
+  if (subcommand === "restore") {
+    const parsed = parseOptions(rest, {
+      shortFlags: "pq",
+      longFlags: set(
+        "--ignore-skip-worktree-bits --no-overlay --overlay --pathspec-file-nul --staged"
+      ),
+      longValues: set("--pathspec-from-file --source")
+    });
+    return parsed?.seen.has("--staged") === true;
+  }
+  if (subcommand === "rm") {
+    const parsed = parseOptions(rest, {
+      shortFlags: "fnqr",
+      longFlags: set(
+        "--cached --dry-run --force --ignore-unmatch --pathspec-file-nul --quiet --recursive"
+      ),
+      longValues: set("--pathspec-from-file")
+    });
+    return parsed?.seen.has("--cached") === true;
+  }
+  if (subcommand === "update-ref")
+    return parseOptions(rest, {
+      shortFlags: "d",
+      longFlags: set("--create-reflog --delete --no-deref --stdin"),
+      longValues: set("--reason")
+    }) !== void 0;
+  return false;
+}
+function safeGh(args) {
+  let index = 0;
+  while (index < args.length) {
+    const arg = args[index];
+    if (arg === "-R" || arg === "--repo" || arg === "--hostname") {
+      if (!args[index + 1]) return false;
+      index += 2;
+    } else if (arg.startsWith("--repo=") || arg.startsWith("--hostname=")) {
+      if (!arg.slice(arg.indexOf("=") + 1)) return false;
+      index += 1;
+    } else {
+      break;
+    }
+  }
+  if (args[index++] !== "pr") return false;
+  const subcommand = args[index++];
+  if (!subcommand) return args.length === index && args.at(-1) === "--help";
+  const spec = GH_PR_OPTIONS[subcommand];
+  if (!spec) return false;
+  const common = withLongOptions(spec, "--help", "--hostname --repo");
+  const parsed = parseOptions(args.slice(index), {
+    ...common,
+    shortValues: `${common.shortValues ?? ""}R`
+  });
+  if (!parsed) return false;
+  if (subcommand === "create") {
+    const filled = ["--fill", "--fill-first", "--fill-verbose", "--recover"].some(
+      (option) => parsed.seen.has(option)
+    );
+    return filled || parsed.seen.has("--title") && (parsed.seen.has("--body") || parsed.seen.has("--body-file"));
+  }
+  if (subcommand === "comment" && parsed.seen.has("--edit-last"))
+    return parsed.seen.has("--body") || parsed.seen.has("--body-file");
+  if (subcommand === "merge")
+    return ["--disable-auto", "--merge", "--rebase", "--squash", "-m", "-r", "-s"].some(
+      (option) => parsed.seen.has(option)
+    );
+  return true;
+}
+function knownNoWorktreeMutation(name, args) {
+  const options = COMMAND_OPTIONS[name];
+  if (options)
+    return args.length === 1 && INFO_OPTIONS.has(args[0]) || parseOptions(args, options) !== void 0;
+  if (name === "sed") return safeSed(args);
+  if (name === "find") return safeFind(args);
+  if (name === "git") return safeGit(args);
+  if (name === "gh") return safeGh(args);
+  return false;
+}
+function unknown(state) {
+  state.complete = false;
+  state.mutation = true;
+}
+function recordTarget(word, state) {
+  const path = staticWord(word);
+  if (path === "-" || path && (SINKS.has(path) || path.startsWith("/dev/fd/"))) return;
+  state.mutation = true;
+  if (path) state.paths.add(path);
+  else state.complete = false;
+}
+function visitRedirect(redirect, state) {
+  const target = staticWord(redirect.target);
+  if (redirect.operator === ">&" && (target === "-" || /^\d+$/.test(target ?? ""))) return;
+  if (OUTPUT_REDIRECTS.has(redirect.operator) || redirect.operator === ">&")
+    recordTarget(redirect.target, state);
+  else unknown(state);
+}
+function visitApplyPatch(command, state) {
+  state.mutation = true;
+  state.definiteEdit = true;
+  let hasBody = false;
+  if (command.suffix.length > 0) state.complete = false;
+  for (const redirect of command.redirects) {
+    if (redirect.operator !== "<<") {
+      visitRedirect(redirect, state);
+      continue;
+    }
+    if (typeof redirect.content !== "string") {
+      state.complete = false;
+      continue;
+    }
+    hasBody = true;
+    if (redirect.heredocQuoted !== true && redirect.body !== void 0) {
+      state.complete = false;
+      continue;
+    }
+    const targets = parseApplyPatchTargets(redirect.content);
+    for (const path of targets.paths) state.paths.add(path);
+    if (!targets.complete) state.complete = false;
+  }
+  if (!hasBody) state.complete = false;
+}
+function operands(words, short = "", long = /* @__PURE__ */ new Set()) {
+  const result = [];
+  let optionsEnded = false;
+  for (const word of words) {
+    const value = staticWord(word);
+    if (value === void 0) return;
+    if (optionsEnded || value === "-" || !value.startsWith("-")) result.push(value);
+    else if (value === "--") optionsEnded = true;
+    else if (value.startsWith("--") ? !long.has(value) : [...value.slice(1)].some((c) => !short.includes(c)))
+      return;
+  }
+  return result;
+}
+function visitCommand(command, state) {
+  const name = staticWord(command.name);
+  const literalApplyPatch = name === "apply_patch" && !command.redirects.some((redirect) => redirect.operator === "<<-");
+  if (literalApplyPatch) {
+    visitApplyPatch(command, state);
+  } else {
+    for (const redirect of command.redirects) visitRedirect(redirect, state);
+  }
+  if (!name || name.includes("/") || !literalApplyPatch && command.suffix.some((word) => !staticWord(word))) {
+    unknown(state);
+  } else if (literalApplyPatch) {
+  } else if (!READ_ONLY_COMMANDS.has(name) && !knownNoWorktreeMutation(name, staticArgs(command.suffix))) {
+    state.mutation = true;
+    let targets;
+    if (name === "tee") {
+      targets = operands(command.suffix, "ai", /* @__PURE__ */ new Set(["--append", "--ignore-interrupts"]));
+    } else if (name === "touch") {
+      targets = operands(command.suffix);
+    } else if (name === "rm") {
+      targets = operands(
+        command.suffix,
+        "fivI",
+        /* @__PURE__ */ new Set(["--force", "--interactive", "--interactive=once", "--verbose"])
+      );
+    } else if (name === "cp" || name === "mv") {
+      const pair = operands(command.suffix);
+      if (pair?.length === 2) targets = name === "cp" ? [pair[1]] : pair;
+    }
+    if (!targets?.length) state.complete = false;
+    else for (const target of targets) state.paths.add(target);
+  }
+  visitNested([command.name, command.prefix, command.suffix, command.redirects], state);
+}
+var CONTAINERS = /* @__PURE__ */ new Set(["Script", "Pipeline", "AndOr", "CompoundList"]);
+function visitNested(value, state) {
+  if (Array.isArray(value)) {
+    for (const child of value) visitNested(child, state);
+  } else if (value && typeof value === "object") {
+    const child = value;
+    if (child.type === "Command") {
+      visitCommand(child, state);
+    } else if (child.type === "Statement") {
+      visitStatement(child, state);
+    } else if ("parts" in child) {
+      for (const part of value.parts ?? []) visitNested(part, state);
+    } else {
+      const node = typeof child.type === "string" && "pos" in child && "end" in child;
+      if (node && !CONTAINERS.has(child.type)) unknown(state);
+      if (child.type === "Function") return;
+      for (const nested of Object.values(child)) visitNested(nested, state);
+    }
+  }
+}
+function visitStatement(statement, state) {
+  if (statement.background) unknown(state);
+  for (const redirect of statement.redirects) visitRedirect(redirect, state);
+  visitNested([statement.redirects, statement.command], state);
+}
+function analyzeShellTargets(source) {
+  if (!source.trim())
+    return { paths: [], coverage: "complete", mutation: "none" };
+  try {
+    const script = parse(source);
+    const state = {
+      paths: /* @__PURE__ */ new Set(),
+      complete: !script.errors?.length,
+      mutation: false,
+      definiteEdit: false
+    };
+    for (const statement of script.commands) visitStatement(statement, state);
+    if (script.errors?.length) state.mutation = true;
+    return {
+      paths: [...state.paths],
+      coverage: state.complete ? "complete" : "unverified",
+      mutation: state.mutation ? "present" : "none",
+      ...state.definiteEdit ? { definiteEdit: true } : {}
+    };
+  } catch {
+    return { paths: [], coverage: "unverified", mutation: "present" };
+  }
+}
+
+export {
+  buildHookOutput,
+  buildCodexOutput,
+  failOpenOutput,
+  failOpenCodex,
+  buildHermesOutput,
+  failOpenHermes,
+  extractFileTargets,
+  readHookMode,
+  demoteForMode,
+  analyzeShellTargets
+};