@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-P4GNZPXO.js

@@ -0,0 +1,1156 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  artifactDefaultPath
+} from "./chunk-NTTS3O53.js";
+import {
+  canonicalizeExistingPath,
+  canonicalizeRawPath
+} from "./chunk-MGLRTOCK.js";
+import {
+  isVerificationScriptName
+} from "./chunk-M4KFUXS7.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/safety/protected-artifacts.ts
+init_esm_shims();
+import path from "node:path";
+var COMMAND_SEPARATORS = /* @__PURE__ */ new Set([";", "&", "&&", "||", "|", "(", ")"]);
+var SHELL_WRAPPERS = /* @__PURE__ */ new Set(["command", "builtin", "sudo", "doas"]);
+var SHELL_REDIRECTIONS = /* @__PURE__ */ new Set([">", ">>", "<", "<<", "<<<", "<&", ">&", "<>", ">|", "&>", "&>>"]);
+var SHELL_WRITE_REDIRECTIONS = /* @__PURE__ */ new Set([">", ">>", ">&", "<>", ">|", "&>", "&>>"]);
+function toolMutationPaths(toolName, args) {
+  if (toolName === ToolNames.Artifact) {
+    return [mutationPathArg(args) ?? artifactDefaultPath(args?.kind)];
+  }
+  if (toolName === ToolNames.Write || toolName === ToolNames.Edit) {
+    const candidate = mutationPathArg(args);
+    return candidate === null ? [] : [candidate];
+  }
+  return [];
+}
+function protectedArtifactMutationBlockReason(state, toolName, args) {
+  if (state.artifacts.length === 0) return null;
+  for (const candidate of toolMutationPaths(toolName, args)) {
+    if (isProtectedPath(state, candidate)) {
+      return `protected artifact blocked: ${toolName} would modify protected path ${candidate}`;
+    }
+  }
+  if (toolName !== ToolNames.Bash) return null;
+  const command = typeof args?.command === "string" && args.command.length > 0 ? args.command : null;
+  if (command === null) return null;
+  const classification = classifyDestructiveCommand(command, state.artifacts);
+  if (classification.kind === "benign") return null;
+  const affected = classification.matches.map((match) => match.artifactPath).join(", ");
+  return `protected artifact blocked: ${classification.operation} would affect ${affected}`;
+}
+function mutationPathArg(args) {
+  if (!args) return null;
+  const candidate = args.path ?? args.file_path ?? args.filePath;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : null;
+}
+function protectArtifact(state, artifact) {
+  const artifacts = artifactMap(state.artifacts);
+  const key = normalizePathKey(artifact.path);
+  if (key !== null) artifacts.set(key, cloneArtifact(artifact));
+  return stateFromMap(artifacts);
+}
+function isProtectedPath(state, artifactPath) {
+  const candidate = normalizePathKey(artifactPath);
+  if (candidate === null) return false;
+  for (const artifact of normalizedArtifacts(state.artifacts)) {
+    if (isSameOrDescendant(candidate, artifact.key)) return true;
+  }
+  return false;
+}
+function classifyDestructiveCommand(command, protectedArtifacts) {
+  const artifacts = normalizedArtifacts(protectedArtifacts);
+  if (artifacts.length === 0) return { kind: "benign", matches: [] };
+  const segments = splitSegments(scanShellLike(command)).flatMap((tokens) => [
+    tokens,
+    ...substitutionSegments(tokens, 0)
+  ]);
+  for (const tokens of segments) {
+    const segment = shellCommandArguments(tokens);
+    const redirect = classifyRedirect(tokens, artifacts);
+    if (redirect.kind === "destructive") return redirect;
+    const commandIndex = commandTokenIndex(segment);
+    if (commandIndex === null) continue;
+    const executable = basenameToken(segment[commandIndex]);
+    if (executable === "rm") {
+      const result = classifyPathOperation(
+        "rm",
+        "rm can remove protected artifacts",
+        pathArgs(segment, commandIndex),
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "mv") {
+      const result = classifyPathOperation(
+        "mv",
+        "mv can move or overwrite protected artifacts",
+        pathArgs(segment, commandIndex),
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "truncate") {
+      const result = classifyPathOperation(
+        "truncate",
+        "truncate can overwrite protected artifacts",
+        pathArgs(segment, commandIndex),
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "cp") {
+      const args = pathArgs(segment, commandIndex);
+      const destination = args.at(-1);
+      const result = classifyPathOperation(
+        "cp",
+        "cp can overwrite protected artifacts",
+        destination === void 0 ? [] : [destination],
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "git") {
+      const result = classifyGitOperation(segment.slice(commandIndex + 1), artifacts);
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "find") {
+      const result = classifyFindDelete(segment.slice(commandIndex + 1), artifacts);
+      if (result.kind === "destructive") return result;
+    }
+  }
+  return { kind: "benign", matches: [] };
+}
+function detectValidationCommand(command, scope = "finish-contract") {
+  for (const tokens of splitSegments(scanShellLike(command))) {
+    const segment = shellCommandArguments(tokens);
+    const commandIndex = commandTokenIndex(segment);
+    if (commandIndex === null) continue;
+    const executable = basenameToken(segment[commandIndex]);
+    const args = segment.slice(commandIndex + 1);
+    const matched = validationMatch(executable, args) ?? (scope === "grounding" ? groundingMatch(executable, args) : null);
+    if (matched !== null) return { kind: "validation", matched };
+  }
+  return { kind: "none" };
+}
+function extractCommandWriteTargets(command) {
+  const targets = [];
+  for (const segment of expandedShellSegments(command)) {
+    collectRedirectTargets(segment, targets);
+    const argv = shellCommandArguments(segment);
+    collectInvokedWriteTargets(argv, targets);
+    collectInPlaceEditTargets(argv, targets);
+  }
+  return targets.filter(isInterestingWriteTarget);
+}
+var INNER_SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var INNER_SHELL_MAX_DEPTH = 3;
+function segmentShellScript(segment) {
+  const commandIndex = commandTokenIndex(segment);
+  if (commandIndex === null) return null;
+  if (!INNER_SHELLS.has(basenameToken(segment[commandIndex]))) return null;
+  for (let index = commandIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (token.startsWith("-") && token.length > 1) {
+      if (!token.slice(1).includes("c")) continue;
+      const script = segment[index + 1];
+      return script !== void 0 && script.length > 0 ? script : null;
+    }
+    return null;
+  }
+  return null;
+}
+function expandedShellSegments(command, depth = 0) {
+  const segments = splitSegments(scanShellLike(command));
+  if (depth >= INNER_SHELL_MAX_DEPTH) return segments;
+  const out = [];
+  for (const segment of segments) {
+    out.push(segment, ...substitutionSegments(segment, depth));
+    const script = segmentShellScript(shellCommandArguments(segment));
+    if (script !== null) out.push(...expandedShellSegments(script, depth + 1));
+  }
+  return out;
+}
+function inlineShellScript(command) {
+  const segments = splitSegments(scanShellLike(command));
+  if (segments.length !== 1) return null;
+  const segment = segments[0];
+  if (segment === void 0) return null;
+  return segmentShellScript(shellCommandArguments(segment));
+}
+function extractCommandCdTargets(command) {
+  const targets = [];
+  for (const tokens of expandedShellSegments(command)) {
+    const target = cdTarget(shellCommandArguments(tokens));
+    if (target !== null) targets.push(target);
+  }
+  return targets;
+}
+function cdTarget(segment) {
+  const commandIndex = commandTokenIndex(segment);
+  if (commandIndex === null) return null;
+  const executable = basenameToken(segment[commandIndex]);
+  if (executable !== "cd" && executable !== "pushd") return null;
+  return pathArgs(segment, commandIndex).at(0) ?? "~";
+}
+var LOOP_WORDS = /* @__PURE__ */ new Set(["for", "while", "until", "select"]);
+function leadingShellWords(argv) {
+  const words = [];
+  for (const word of argv) {
+    if (SHELL_RESERVED_PREFIXES.has(word)) {
+      words.push(word);
+      continue;
+    }
+    if (word === "for" || word === "case" || word === "select") words.push(word);
+    break;
+  }
+  return words;
+}
+function extractCommandPathWalk(command, topLevelHeredocs = true) {
+  const walk = {
+    events: [],
+    loopDepth: 0,
+    functionSeen: false,
+    cdpath: /\bCDPATH\b/u.test(command),
+    caseSeen: false,
+    heredocSeen: false,
+    topLevelHeredocs
+  };
+  collectPathWalk(command, 0, walk);
+  return walk.caseSeen ? walk.events.filter((event) => event.kind !== "subshell") : walk.events;
+}
+function extractCommandPathWalks(command) {
+  const withoutBodies = withoutHeredocBodies(command);
+  if (withoutBodies === command) return [extractCommandPathWalk(command)];
+  const removedAll = !scanShellLike(withoutBodies).some((token) => token.operator && token.value === "<<");
+  return [extractCommandPathWalk(command, !removedAll), extractCommandPathWalk(withoutBodies)];
+}
+var MAX_HEREDOCS = 64;
+function withoutHeredocBodies(command) {
+  let text = command;
+  for (let pass = 0; pass < MAX_HEREDOCS; pass += 1) {
+    const tokens = scanShellLike(text);
+    const first = tokens.findIndex((token) => token.operator && token.value === "<<");
+    if (first === -1) return text;
+    const lineEnd = tokens.findIndex(
+      (token, index) => index > first && token.operator && token.value === ";" && text[token.start] === "\n"
+    );
+    const docs = [];
+    for (let index = first; index < (lineEnd === -1 ? tokens.length : lineEnd); index += 1) {
+      const operator = tokens[index];
+      if (operator === void 0 || !operator.operator || operator.value !== "<<") continue;
+      let word = tokens[index + 1];
+      let stripTabs = false;
+      if (word !== void 0 && !word.operator && word.start === operator.end && text[word.start] === "-") {
+        stripTabs = true;
+        if (word.value === "-") word = tokens[index + 2];
+      }
+      if (word === void 0 || word.operator) return text;
+      const delimiter = stripTabs && text[word.start] === "-" ? word.value.slice(1) : word.value;
+      docs.push({ start: operator.start, end: word.end, word: delimiter, stripTabs });
+    }
+    let head = text;
+    for (const doc of [...docs].reverse()) {
+      head = `${head.slice(0, doc.start)}${" ".repeat(doc.end - doc.start)}${head.slice(doc.end)}`;
+    }
+    if (lineEnd === -1) {
+      text = head;
+      continue;
+    }
+    const bodyStart = (tokens[lineEnd]?.start ?? text.length) + 1;
+    let cursor = bodyStart;
+    for (const doc of docs) {
+      while (cursor < text.length) {
+        const newline = text.indexOf("\n", cursor);
+        const line = text.slice(cursor, newline === -1 ? text.length : newline);
+        cursor = newline === -1 ? text.length : newline + 1;
+        if ((doc.stripTabs ? line.replace(/^\t+/u, "") : line) === doc.word) break;
+      }
+    }
+    text = `${head.slice(0, bodyStart)}${text.slice(cursor)}`;
+  }
+  return text;
+}
+function collectPathWalk(command, depth, walk) {
+  const tokens = scanShellLike(command);
+  let segment = [];
+  for (const [index, token] of tokens.entries()) {
+    if (token.operator && COMMAND_SEPARATORS.has(token.value)) {
+      collectSegmentPathEvents(segment, depth, walk);
+      segment = [];
+      const next = tokens[index + 1];
+      if (token.value === "(" && next?.operator === true && next.value === ")") walk.functionSeen = true;
+      if ((token.value === "(" || token.value === ")") && !walk.heredocSeen)
+        walk.events.push({ kind: "subshell", open: token.value === "(" });
+      continue;
+    }
+    segment.push(token);
+  }
+  collectSegmentPathEvents(segment, depth, walk);
+}
+function collectChildScript(script, depth, walk) {
+  if (depth >= INNER_SHELL_MAX_DEPTH) return;
+  walk.events.push({ kind: "subshell", open: true });
+  collectPathWalk(script, depth + 1, walk);
+  const withoutBodies = withoutHeredocBodies(script);
+  if (withoutBodies !== script) collectPathWalk(withoutBodies, depth + 1, walk);
+  if (!walk.heredocSeen) walk.events.push({ kind: "subshell", open: false });
+}
+function collectSegmentPathEvents(segment, depth, walk) {
+  if (segment.length === 0) return;
+  for (const token of segment) {
+    for (const script2 of token.substitutions ?? []) collectChildScript(script2, depth, walk);
+  }
+  const argv = shellCommandArguments(segment);
+  if (argv[0] === "done" && walk.loopDepth > 0) walk.loopDepth -= 1;
+  if (argv[0] === "function") walk.functionSeen = true;
+  for (const word of leadingShellWords(argv)) {
+    if (LOOP_WORDS.has(word)) walk.loopDepth += 1;
+    if (word === "case") walk.caseSeen = true;
+  }
+  const writes = [];
+  collectRedirectTargets(segment, writes);
+  collectInvokedWriteTargets(argv, writes);
+  collectInPlaceEditTargets(argv, writes);
+  for (const target of writes.filter(isInterestingWriteTarget)) walk.events.push({ kind: "write", target });
+  collectLinkEvents(argv, walk.events);
+  const cd = cdTarget(argv);
+  if (cd !== null) {
+    walk.events.push({
+      kind: "cd",
+      target: cd,
+      unmodeled: walk.loopDepth > 0 || walk.functionSeen || walk.cdpath || walk.heredocSeen
+    });
+  }
+  const script = segmentShellScript(argv);
+  if (script !== null) collectChildScript(script, depth, walk);
+  if ((depth > 0 || walk.topLevelHeredocs) && segment.some((token) => token.operator && token.value === "<<"))
+    walk.heredocSeen = true;
+}
+var LINK_WRAPPERS = /* @__PURE__ */ new Set([
+  "nice",
+  "nohup",
+  "timeout",
+  "stdbuf",
+  "ionice",
+  "chrt",
+  "xargs",
+  "busybox",
+  "setsid",
+  "taskset",
+  "flock",
+  "exec",
+  "find"
+]);
+var LINK_COMMANDS = /* @__PURE__ */ new Set(["ln", "link", "cp", "mv"]);
+function linkCommandIndex(argv) {
+  let index = commandTokenIndex(argv);
+  let fromInput = false;
+  while (index !== null && LINK_WRAPPERS.has(basenameToken(argv[index]))) {
+    const wrapper = basenameToken(argv[index]);
+    if (wrapper === "xargs" || wrapper === "find") fromInput = true;
+    const from = index;
+    const next = wrapper === "find" ? argv.findIndex((word, at) => at > from && /^-(?:exec|execdir|ok|okdir)$/u.test(word)) + 1 : argv.findIndex(
+      (word, at) => at > from && (LINK_COMMANDS.has(basenameToken(word)) || LINK_WRAPPERS.has(basenameToken(word)))
+    );
+    index = next > from ? next : null;
+  }
+  return index === null ? null : { index, fromInput };
+}
+function collectLinkEvents(argv, out) {
+  const found = linkCommandIndex(argv);
+  if (found === null) return;
+  const cmdIndex = found.index;
+  const executable = basenameToken(argv[cmdIndex]);
+  if (!LINK_COMMANDS.has(executable)) return;
+  let symbolic = false;
+  let hard = executable === "ln" || executable === "link";
+  let keepsLinks = executable === "mv";
+  let dereferences = false;
+  let targetDirectory = null;
+  let noTargetDirectory = false;
+  let endOfOptions = false;
+  const operands = [];
+  for (let index = cmdIndex + 1; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (found.fromInput && (token === ";" || token === "+")) break;
+    if (endOfOptions || !token.startsWith("-") || token === "-") {
+      operands.push(token);
+      continue;
+    }
+    if (token === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const eq = token.indexOf("=");
+      const name = eq === -1 ? token : token.slice(0, eq);
+      const value = eq === -1 ? void 0 : token.slice(eq + 1);
+      if (executable === "mv") {
+        if (name === "--target-directory") {
+          targetDirectory = value ?? argv[index + 1] ?? null;
+          if (value === void 0) index += 1;
+        } else if (name === "--no-target-directory") noTargetDirectory = true;
+        else if (name === "--suffix" && value === void 0) index += 1;
+        continue;
+      }
+      if (name === "--symbolic" || name === "--symbolic-link") symbolic = true;
+      else if (name === "--link") hard = true;
+      else if (name === "--archive" || name === "--no-dereference" || name === "--recursive") keepsLinks = true;
+      else if (name === "--dereference") dereferences = true;
+      else if (name === "--no-target-directory") noTargetDirectory = true;
+      else if (name === "--target-directory") {
+        targetDirectory = value ?? argv[index + 1] ?? null;
+        if (value === void 0) index += 1;
+      } else if (name === "--suffix" && value === void 0) index += 1;
+      continue;
+    }
+    for (let at = 1; at < token.length; at += 1) {
+      const flag = token[at];
+      if (flag === "s" && executable !== "mv") symbolic = true;
+      else if (flag === "l" && executable === "cp") hard = true;
+      else if (executable === "cp" && flag !== void 0 && "aPdrR".includes(flag)) keepsLinks = true;
+      else if (executable === "cp" && (flag === "L" || flag === "H")) dereferences = true;
+      else if (flag === "T") noTargetDirectory = true;
+      else if (flag === "t" || flag === "S") {
+        const rest = token.slice(at + 1);
+        const value = rest.length > 0 ? rest : argv[index + 1];
+        if (rest.length === 0) index += 1;
+        if (flag === "t") targetDirectory = value ?? null;
+        break;
+      }
+    }
+  }
+  const copied = !symbolic && !hard && keepsLinks && !dereferences;
+  if (!symbolic && !hard && !copied) return;
+  let sources = operands;
+  let linkDirs = ["."];
+  if (targetDirectory !== null) {
+    linkDirs = [targetDirectory];
+    out.push({ kind: "write", target: targetDirectory });
+  } else if (operands.length > 1) {
+    const destination = operands.at(-1);
+    sources = operands.slice(0, -1);
+    const parent = path.posix.dirname(destination);
+    linkDirs = noTargetDirectory ? [parent] : [parent, destination];
+  }
+  const origin = found.fromInput ? "input" : copied ? "copied" : "text";
+  if (origin === "input") {
+    out.push({
+      kind: "link",
+      symbolic: symbolic || copied,
+      sources: operands.length > 0 ? operands : ["<input>"],
+      linkDirs,
+      origin
+    });
+    return;
+  }
+  if (sources.length > 0) out.push({ kind: "link", symbolic: symbolic || copied, sources, linkDirs, origin });
+}
+function extractCommandDeleteTargets(command) {
+  const targets = [];
+  for (const tokens of expandedShellSegments(command)) {
+    const segment = shellCommandArguments(tokens);
+    const commandIndex = commandTokenIndex(segment);
+    if (commandIndex === null) continue;
+    const executable = basenameToken(segment[commandIndex]);
+    if (executable === "rm") {
+      targets.push(...pathArgs(segment, commandIndex));
+      continue;
+    }
+    if (executable === "mv") {
+      const args = pathArgs(segment, commandIndex);
+      if (args.length >= 2) targets.push(...args.slice(0, -1));
+      continue;
+    }
+    if (executable === "find" && segment.includes("-delete")) {
+      targets.push(...findRoots(segment.slice(commandIndex + 1)));
+    }
+  }
+  return targets.filter(isInterestingWriteTarget);
+}
+function invokesClioSkillMutation(command, excludeLibrary = false) {
+  for (const segment of expandedShellSegments(command)) {
+    const argv = shellCommandArguments(segment);
+    const index = commandTokenIndex(argv);
+    if (index === null) continue;
+    let args = argv.slice(index);
+    const executable = basenameToken(args[0]);
+    if (executable === "npx" || executable === "npm" && args[1] === "exec") {
+      args = args.slice(executable === "npm" ? 2 : 1);
+      while (args[0]?.startsWith("-")) args = args.slice(1);
+    }
+    const program = args[0] ?? "";
+    if (basenameToken(program) === "node" || basenameToken(program) === "tsx") {
+      if (!/(?:^|\/)(?:src|dist)\/cli\/index\.(?:js|ts)$/.test(args[1] ?? "")) continue;
+      args = args.slice(2);
+    } else if (/^(?:@iowarp\/)?clio-coder(?:@[^/]+)?$/.test(program) || basenameToken(program) === "clio-coder") {
+      args = args.slice(1);
+    } else continue;
+    if (args.includes("--version") || args.includes("-v")) continue;
+    let rootHelp = false;
+    let firstRootFlag;
+    while (args[0]?.startsWith("-")) {
+      const flag = args[0];
+      if (flag === "--all" || flag === "--help" || flag === "-h") firstRootFlag ??= flag;
+      rootHelp = firstRootFlag === "--help" || firstRootFlag === "-h";
+      args = args.slice(flag === "--skill" || flag === "--api-key" ? 2 : 1);
+    }
+    if (rootHelp) continue;
+    if (args[0] !== "skills" && args[0] !== "library" && args[0] !== "plugins" && args[0] !== "extensions" && args[0] !== "interop")
+      continue;
+    if (excludeLibrary && args[0] === "library") continue;
+    if (resourceCliMutatesSkills(args[0], args.slice(1))) return true;
+  }
+  return false;
+}
+function shellCommandArguments(segment) {
+  const args = [];
+  for (let index = 0; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (token.operator && SHELL_REDIRECTIONS.has(token.value)) {
+      const previous = args.at(-1);
+      if (previous && previous.end === token.start && !previous.quoted && /^\d+$/.test(previous.value)) args.pop();
+      if (segment[index + 1]?.operator === false) index += 1;
+      continue;
+    }
+    args.push(token);
+  }
+  return args.map((token) => token.value);
+}
+function resourceCliMutatesSkills(resource, args) {
+  const valueOptions = resource === "skills" ? ["--name", "--category", "--scenario", "--target", "--workspace", "--timeout"] : ["--kind", "--from"];
+  let verb;
+  let confirmed = false;
+  let dryRun = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (valueOptions.includes(arg)) {
+      index += 1;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") return false;
+    if (arg === "--yes") confirmed = true;
+    if (arg === "--dry-run") dryRun = true;
+    if (!arg.startsWith("-")) verb ??= arg;
+  }
+  if (resource === "skills") return verb === "install" || verb === "update" || verb === "sync";
+  if (resource === "plugins" || resource === "extensions")
+    return ["install", "update", "remove", "enable", "disable", "pin"].includes(verb ?? "");
+  if (resource === "interop") return verb === "adopt" && confirmed && !dryRun;
+  if ((verb === "install" || verb === "update") && dryRun) return false;
+  return ["install", "update", "remove", "enable", "disable", "pin", "register", "sync"].includes(verb ?? "");
+}
+var STANDARD_DEV_TARGETS = /* @__PURE__ */ new Set(["/dev/null", "/dev/stdout", "/dev/stderr", "/dev/tty", "/dev/zero"]);
+function collectRedirectTargets(segment, out) {
+  for (let index = 0; index < segment.length - 1; index += 1) {
+    const target = redirectWriteTarget(segment[index], segment[index + 1]);
+    if (target !== null) out.push(target);
+  }
+}
+function redirectWriteTarget(operator, target) {
+  if (!operator?.operator || target === void 0 || target.operator || !SHELL_WRITE_REDIRECTIONS.has(operator.value))
+    return null;
+  if (operator.value === ">&" && /^(?:\d+-?|-)$/u.test(target.value)) return null;
+  return target.value;
+}
+function collectInvokedWriteTargets(segment, out) {
+  const cmdIndex = commandTokenIndex(segment);
+  if (cmdIndex === null) return;
+  const executable = basenameToken(segment[cmdIndex]);
+  if (executable === "tee") {
+    for (const arg of pathArgs(segment, cmdIndex)) out.push(arg);
+    return;
+  }
+  if (executable === "mkdir" || executable === "touch") {
+    for (const arg of pathArgs(segment, cmdIndex)) out.push(arg);
+    return;
+  }
+  if (executable === "ln") {
+    const args = pathArgs(segment, cmdIndex);
+    const destination = args.at(-1);
+    if (args.length >= 2 && destination !== void 0) out.push(destination);
+    return;
+  }
+  if (executable === "cp" || executable === "mv") {
+    const args = pathArgs(segment, cmdIndex);
+    const destination = args.at(-1);
+    if (args.length >= 2 && destination !== void 0) out.push(destination);
+  }
+}
+function collectInPlaceEditTargets(segment, out) {
+  const cmdIndex = commandTokenIndex(segment);
+  if (cmdIndex === null) return;
+  if (basenameToken(segment[cmdIndex]) !== "sed") return;
+  if (!hasSedInPlaceFlag(segment, cmdIndex)) return;
+  for (const operand of sedFileOperands(segment, cmdIndex)) out.push(operand);
+}
+function hasSedInPlaceFlag(segment, cmdIndex) {
+  for (let index = cmdIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (token === "--") break;
+    if (token === "--in-place" || token.startsWith("--in-place=")) return true;
+    if (token.startsWith("--")) continue;
+    if (token.startsWith("-") && token.length > 1 && token.slice(1).includes("i")) return true;
+  }
+  return false;
+}
+function sedFileOperands(segment, cmdIndex) {
+  const operands = [];
+  let sawScriptFlag = false;
+  let endOfOptions = false;
+  for (let index = cmdIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (!endOfOptions && token === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (!endOfOptions && token.startsWith("-") && token.length > 1) {
+      if (token === "-e" || token === "-f") {
+        sawScriptFlag = true;
+        index += 1;
+        continue;
+      }
+      if (token === "-l") {
+        index += 1;
+        continue;
+      }
+      if (token === "--expression" || token === "--file") {
+        sawScriptFlag = true;
+        index += 1;
+        continue;
+      }
+      if (token.startsWith("--expression=") || token.startsWith("--file=")) {
+        sawScriptFlag = true;
+        continue;
+      }
+      continue;
+    }
+    operands.push(token);
+  }
+  if (!sawScriptFlag && operands.length > 0) operands.shift();
+  return operands;
+}
+function isInterestingWriteTarget(target) {
+  if (target.length === 0) return false;
+  if (STANDARD_DEV_TARGETS.has(target)) return false;
+  if (target.startsWith("/dev/fd/")) return false;
+  return true;
+}
+function classifyRedirect(segment, artifacts) {
+  for (let index = 0; index < segment.length; index += 1) {
+    if (segment[index]?.value === ">>" || segment[index]?.value === "&>>") continue;
+    const target = redirectWriteTarget(segment[index], segment[index + 1]);
+    if (target === null) continue;
+    const matches = matchesForPaths([target], artifacts, "target", "redirect can overwrite protected artifacts");
+    if (matches.length > 0) {
+      return {
+        kind: "destructive",
+        operation: "redirect",
+        matches
+      };
+    }
+  }
+  return { kind: "benign", matches: [] };
+}
+function classifyGitOperation(args, artifacts) {
+  const subcommand = args[0];
+  if (subcommand === "reset" && args.includes("--hard")) {
+    return {
+      kind: "destructive",
+      operation: "git_reset_hard",
+      matches: artifacts.map(({ artifact }) => ({
+        artifactPath: artifact.path,
+        commandPath: ".",
+        reason: "git reset --hard can overwrite protected artifacts"
+      }))
+    };
+  }
+  if (subcommand === "checkout" && args.includes("--")) {
+    const paths = args.slice(args.indexOf("--") + 1);
+    const matches = matchesForPaths(paths, artifacts, "intersects", "git checkout -- can overwrite protected artifacts");
+    if (matches.length > 0) {
+      return {
+        kind: "destructive",
+        operation: "git_checkout",
+        matches
+      };
+    }
+    return { kind: "benign", matches: [] };
+  }
+  if (subcommand === "restore") {
+    const matches = matchesForPaths(
+      pathArgs(args.slice(1), -1),
+      artifacts,
+      "intersects",
+      "git restore can overwrite protected artifacts"
+    );
+    if (matches.length > 0) {
+      return {
+        kind: "destructive",
+        operation: "git_restore",
+        matches
+      };
+    }
+  }
+  return { kind: "benign", matches: [] };
+}
+function classifyFindDelete(args, artifacts) {
+  if (!args.includes("-delete")) return { kind: "benign", matches: [] };
+  const roots = findRoots(args);
+  const matches = matchesForPaths(
+    roots.length === 0 ? ["."] : roots,
+    artifacts,
+    "intersects",
+    "find -delete can remove protected artifacts"
+  );
+  if (matches.length > 0) {
+    return {
+      kind: "destructive",
+      operation: "find_delete",
+      matches
+    };
+  }
+  return { kind: "benign", matches: [] };
+}
+function findRoots(args) {
+  const roots = [];
+  for (const token of args) {
+    if (token === "-delete" || token.startsWith("-") || token === "(" || token === "!" || token === "not") break;
+    if (token === "--") continue;
+    roots.push(token);
+  }
+  return roots.length === 0 ? ["."] : roots;
+}
+function classifyPathOperation(operation, reason, paths, artifacts) {
+  const matches = matchesForPaths(paths, artifacts, "intersects", reason);
+  if (matches.length === 0) return { kind: "benign", matches: [] };
+  return {
+    kind: "destructive",
+    operation,
+    matches
+  };
+}
+function matchesForPaths(commandPaths, artifacts, mode, reason) {
+  const matches = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const commandPath of commandPaths) {
+    for (const artifact of artifacts) {
+      if (!pathMatchesArtifact(commandPath, artifact.key, mode)) continue;
+      const key = `${artifact.key}\0${commandPath}\0${reason}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      matches.push({
+        artifactPath: artifact.artifact.path,
+        commandPath,
+        reason
+      });
+    }
+  }
+  matches.sort(compareMatches);
+  return matches;
+}
+function pathMatchesArtifact(commandPath, artifactKey, mode) {
+  const wildcardRoot = wildcardRootKey(commandPath);
+  if (wildcardRoot !== null) {
+    return isSameOrDescendant(artifactKey, wildcardRoot);
+  }
+  const commandKey = normalizePathKey(commandPath);
+  if (commandKey === null) return false;
+  if (mode === "target") return isSameOrDescendant(commandKey, artifactKey);
+  return isSameOrDescendant(commandKey, artifactKey) || isSameOrDescendant(artifactKey, commandKey);
+}
+function validationMatch(executable, args) {
+  if (executable === "node" && args[0] === "--test") return "node --test";
+  if (executable === "npm") {
+    if (args[0] === "test") return "npm test";
+    const script = args[0] === "run" && typeof args[1] === "string" ? args[1] : null;
+    if (script !== null && isVerificationScriptName(script)) return `npm run ${script}`;
+  }
+  if (executable === "pytest") return "pytest";
+  if (isPythonExecutable(executable) && moduleArg(args) === "pytest") return "python -m pytest";
+  if (isPythonExecutable(executable) && moduleArg(args) === "unittest") return "python -m unittest";
+  if (executable === "cargo" && args[0] === "test") return "cargo test";
+  if (executable === "go" && args[0] === "test") return "go test";
+  if (executable === "ctest") return "ctest";
+  if (executable === "make" && args[0] === "test") return "make test";
+  if (executable === "make" && args[0] === "check") return "make check";
+  if (executable === "ninja" && args[0] === "test") return "ninja test";
+  if (executable === "meson" && args[0] === "test") return "meson test";
+  if (executable === "mvn" && args[0] === "test") return "mvn test";
+  if ((executable === "gradle" || executable === "gradlew") && args[0] === "test") return "gradle test";
+  return null;
+}
+function groundingMatch(executable, args) {
+  if (executable === "git") {
+    if (args[0] === "diff") return "git diff";
+    if (args[0] === "status") return "git status";
+    return null;
+  }
+  if (executable === "node") {
+    if (args.includes("--test")) return "node --test";
+    if (args.includes("-e") || args.includes("--eval")) return "node -e";
+    return null;
+  }
+  if (executable === "tsc") return typescriptCheckMatch(args);
+  if (executable === "npx") {
+    const inner = npxInvocation(args);
+    return inner === null ? null : npxRunnerMatch(inner.executable, inner.args);
+  }
+  return null;
+}
+var NPX_TEST_RUNNERS = /* @__PURE__ */ new Set(["vitest", "jest", "mocha"]);
+function npxRunnerMatch(executable, args) {
+  if (NPX_TEST_RUNNERS.has(executable)) return `npx ${executable}`;
+  if (executable === "tsx" && args.includes("--test")) return "npx tsx --test";
+  if (executable === "tsc") return typescriptCheckMatch(args);
+  return null;
+}
+function typescriptCheckMatch(args) {
+  return args.some((arg) => arg.toLowerCase() === "--noemit") ? "tsc --noEmit" : "tsc";
+}
+function npxInvocation(args) {
+  const VALUE_FLAGS = /* @__PURE__ */ new Set(["-p", "--package", "-c", "--call", "--shell"]);
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === void 0) return null;
+    if (VALUE_FLAGS.has(token)) {
+      index += 2;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      index += 1;
+      continue;
+    }
+    return { executable: basenameToken(token), args: args.slice(index + 1) };
+  }
+  return null;
+}
+function moduleArg(args) {
+  for (let index = 0; index < args.length - 1; index += 1) {
+    if (args[index] === "-m") return args[index + 1] ?? null;
+  }
+  return null;
+}
+function isPythonExecutable(executable) {
+  return executable === "python" || executable === "python3" || /^python3\.\d+$/.test(executable);
+}
+function pathArgs(segment, commandIndex) {
+  const args = [];
+  let endOfOptions = false;
+  for (let index = commandIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (!endOfOptions && token === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (!endOfOptions && token.startsWith("-")) continue;
+    args.push(token);
+  }
+  return args;
+}
+function commandArgumentSegments(command) {
+  return splitSegments(scanShellLike(command)).map(shellCommandArguments);
+}
+function scanShellLike(command) {
+  const tokens = [];
+  let current = "";
+  let wordStart = null;
+  let quoted = false;
+  let quote = null;
+  let substitutions = [];
+  const pushCurrent = (end) => {
+    if (wordStart === null) return;
+    const token = { value: current, operator: false, quoted, start: wordStart, end };
+    if (substitutions.length > 0) token.substitutions = substitutions;
+    tokens.push(token);
+    current = "";
+    wordStart = null;
+    quoted = false;
+    substitutions = [];
+  };
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (char === void 0) continue;
+    if (quote !== null) {
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+      if (quote === '"' && char === "\\" && index + 1 < command.length) {
+        const next = command[index + 1] ?? "";
+        if (next === "\n" || '$`"\\'.includes(next)) {
+          index += 1;
+          if (next !== "\n") current += next;
+          continue;
+        }
+      }
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      wordStart ??= index;
+      quoted = true;
+      quote = char;
+      continue;
+    }
+    if (char === "\\" && index + 1 < command.length) {
+      if (command[index + 1] !== "\n") {
+        wordStart ??= index;
+        quoted = true;
+        current += command[index + 1] ?? "";
+      }
+      index += 1;
+      continue;
+    }
+    if (char === "#" && wordStart === null) {
+      while (index + 1 < command.length && command[index + 1] !== "\n") index += 1;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      pushCurrent(index);
+      if (char === "\n") tokens.push({ value: ";", operator: true, quoted: false, start: index, end: index + 1 });
+      continue;
+    }
+    if (char === "(") {
+      const previous = tokens.at(-1);
+      const dollar = wordStart !== null && command[index - 1] === "$" && current.endsWith("$");
+      const processSubstitution = wordStart === null && previous?.operator === true && previous.end === index && (previous.value === "<" || previous.value === ">");
+      if (dollar || processSubstitution) {
+        const close = matchingParen(command, index);
+        if (processSubstitution) {
+          tokens.pop();
+          wordStart = index - 1;
+          current = previous.value;
+        }
+        current += command.slice(index, close + 1);
+        substitutions.push(command.slice(index + 1, close));
+        index = close;
+        continue;
+      }
+    }
+    if (";&|><()".includes(char)) {
+      pushCurrent(index);
+      const three = command.slice(index, index + 3);
+      const two = command.slice(index, index + 2);
+      const value = SHELL_REDIRECTIONS.has(three) || COMMAND_SEPARATORS.has(three) ? three : SHELL_REDIRECTIONS.has(two) || COMMAND_SEPARATORS.has(two) ? two : char;
+      tokens.push({ value, operator: true, quoted: false, start: index, end: index + value.length });
+      index += value.length - 1;
+      continue;
+    }
+    wordStart ??= index;
+    current += char;
+  }
+  pushCurrent(command.length);
+  return tokens;
+}
+function matchingParen(command, open) {
+  let depth = 0;
+  let quote = null;
+  for (let index = open; index < command.length; index += 1) {
+    const char = command[index];
+    if (quote !== null) {
+      if (char === "\\" && quote === '"') index += 1;
+      else if (char === quote) quote = null;
+      continue;
+    }
+    if (char === "\\") index += 1;
+    else if (char === "'" || char === '"') quote = char;
+    else if (char === "(") depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return command.length - 1;
+}
+function substitutionSegments(tokens, depth) {
+  if (depth >= INNER_SHELL_MAX_DEPTH) return [];
+  return tokens.flatMap(
+    (token) => (token.substitutions ?? []).flatMap((script) => expandedShellSegments(script, depth + 1))
+  );
+}
+function scanShellLikeDeep(command, depth = 0) {
+  const tokens = scanShellLike(command);
+  if (depth >= INNER_SHELL_MAX_DEPTH) return tokens;
+  const inner = tokens.flatMap(
+    (token) => (token.substitutions ?? []).flatMap((script) => [
+      { value: ";", operator: true, quoted: false, start: token.start, end: token.start },
+      ...scanShellLikeDeep(script, depth + 1)
+    ])
+  );
+  return [...tokens, ...inner];
+}
+function splitSegments(tokens) {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (token.operator && COMMAND_SEPARATORS.has(token.value)) {
+      if (current.length > 0) segments.push(current);
+      current = [];
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) segments.push(current);
+  return segments;
+}
+var SHELL_RESERVED_PREFIXES = /* @__PURE__ */ new Set([
+  "{",
+  "!",
+  "if",
+  "then",
+  "elif",
+  "else",
+  "while",
+  "until",
+  "do",
+  "time"
+]);
+function commandTokenIndex(segment) {
+  let index = 0;
+  while (index < segment.length) {
+    const token = segment[index];
+    if (token === void 0) return null;
+    if (SHELL_RESERVED_PREFIXES.has(token)) {
+      index += 1;
+      continue;
+    }
+    if (isEnvAssignment(token)) {
+      index += 1;
+      continue;
+    }
+    if (token === "env") {
+      index += 1;
+      while (index < segment.length && (segment[index]?.startsWith("-") === true || isEnvAssignment(segment[index] ?? ""))) {
+        index += 1;
+      }
+      continue;
+    }
+    if (SHELL_WRAPPERS.has(token)) {
+      index += 1;
+      while (index < segment.length && segment[index]?.startsWith("-") === true) index += 1;
+      continue;
+    }
+    return index;
+  }
+  return null;
+}
+function isEnvAssignment(token) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+}
+function basenameToken(token) {
+  if (token === void 0) return "";
+  const normalized = token.replace(/\\/g, "/");
+  const basename = normalized.slice(normalized.lastIndexOf("/") + 1);
+  return basename.toLowerCase();
+}
+function artifactMap(artifacts) {
+  const out = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    const key = normalizePathKey(artifact.path);
+    if (key !== null) out.set(key, cloneArtifact(artifact));
+  }
+  return out;
+}
+function stateFromMap(artifacts) {
+  return {
+    artifacts: Array.from(artifacts.entries()).sort(([left], [right]) => compareStrings(left, right)).map(([, artifact]) => cloneArtifact(artifact))
+  };
+}
+function normalizedArtifacts(artifacts) {
+  const out = Array.from(artifactMap(artifacts).entries()).map(([key, artifact]) => ({ key, artifact }));
+  out.sort((left, right) => compareStrings(left.key, right.key));
+  return out;
+}
+function cloneArtifact(artifact) {
+  const cloned = {
+    path: artifact.path,
+    protectedAt: artifact.protectedAt,
+    reason: artifact.reason,
+    source: artifact.source
+  };
+  if (artifact.validationCommand !== void 0) cloned.validationCommand = artifact.validationCommand;
+  if (artifact.validationExitCode !== void 0) cloned.validationExitCode = artifact.validationExitCode;
+  return cloned;
+}
+function normalizePathKey(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return null;
+  if (isWindowsAbsolutePath(trimmed) && path.sep !== "\\") {
+    return toSlashKey(path.win32.normalize(trimmed));
+  }
+  const resolved = path.isAbsolute(trimmed) ? trimmed : path.resolve(trimmed);
+  return toSlashKey(canonicalizeRawPath(trimmed, process.cwd()) ?? canonicalizeExistingPath(resolved));
+}
+function wildcardRootKey(input) {
+  const normalizedInput = toSlashKey(input.trim());
+  const firstWildcard = firstWildcardIndex(normalizedInput);
+  if (firstWildcard === null) return null;
+  const prefix = normalizedInput.slice(0, firstWildcard);
+  const slash = prefix.lastIndexOf("/");
+  const root = slash >= 0 ? prefix.slice(0, slash + 1) : ".";
+  return normalizePathKey(root);
+}
+function firstWildcardIndex(input) {
+  const indexes = ["*", "?", "["].map((char) => input.indexOf(char)).filter((index) => index >= 0);
+  if (indexes.length === 0) return null;
+  return Math.min(...indexes);
+}
+function isWindowsAbsolutePath(input) {
+  return /^[A-Za-z]:[\\/]/.test(input);
+}
+function toSlashKey(input) {
+  return input.replace(/\\/g, "/");
+}
+function isSameOrDescendant(candidate, parent) {
+  if (candidate === parent) return true;
+  const relative = path.posix.relative(parent, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path.posix.isAbsolute(relative);
+}
+function compareMatches(left, right) {
+  return compareStrings(left.artifactPath, right.artifactPath) || compareStrings(left.commandPath, right.commandPath) || compareStrings(left.reason, right.reason);
+}
+function compareStrings(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+export {
+  toolMutationPaths,
+  protectedArtifactMutationBlockReason,
+  protectArtifact,
+  detectValidationCommand,
+  extractCommandWriteTargets,
+  inlineShellScript,
+  extractCommandCdTargets,
+  extractCommandPathWalks,
+  extractCommandDeleteTargets,
+  invokesClioSkillMutation,
+  commandArgumentSegments,
+  scanShellLike,
+  scanShellLikeDeep
+};
+//# sourceMappingURL=chunk-P4GNZPXO.js.map