@smthrs/std 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/SearchContract.js

@@ -0,0 +1,339 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SearchContract_exports = {};
+__export(SearchContract_exports, {
+  canonicalGlob: () => canonicalGlob,
+  expression: () => expression,
+  includedByGlobs: () => includedByGlobs,
+  isContractRejection: () => isContractRejection,
+  matchesGlob: () => matchesGlob,
+  unsatisfiableNotice: () => unsatisfiableNotice,
+  validateGlob: () => validateGlob,
+  validatePattern: () => validatePattern
+});
+module.exports = __toCommonJS(SearchContract_exports);
+var import_effect = require("effect");
+var LinearRegex = __toESM(require("./internal/LinearRegex.js"), 1);
+var import_SearchContract = require("./internal/SearchContract.js");
+var Walk = __toESM(require("./internal/Walk.js"), 1);
+const validatePattern = (pattern, fixedStrings) => {
+  if (pattern.length > 4096) return (0, import_SearchContract.invalidPattern)(pattern, "patterns must not exceed 4096 bytes");
+  if (!/^[\x20-\x7e]*$/.test(pattern)) return (0, import_SearchContract.invalidPattern)(pattern, "patterns must contain printable ASCII only");
+  if (fixedStrings) return void 0;
+  if (pattern.includes("(?")) return (0, import_SearchContract.invalidPattern)(pattern, "special groups and lookaround are not supported");
+  let inClass = false;
+  let classCharacters = 0;
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    if (character === "\\") {
+      const escaped = pattern[index + 1];
+      if (escaped === void 0 || /[A-Za-z0-9]/.test(escaped)) {
+        return (0, import_SearchContract.invalidPattern)(pattern, "backreferences, shorthand classes and encoded escapes are not supported");
+      }
+      index++;
+      if (inClass) classCharacters++;
+      continue;
+    }
+    if (character === "[" && inClass) {
+      return (0, import_SearchContract.invalidPattern)(pattern, "nested and named character classes are not supported");
+    }
+    if (character === "[") {
+      inClass = true;
+      classCharacters = 0;
+      continue;
+    }
+    if (character === "{" && !inClass) {
+      const closing = pattern.indexOf("}", index + 1);
+      if (closing >= 0) {
+        const counts = pattern.slice(index + 1, closing).split(",").filter((value) => value.length > 0);
+        if (counts.some((value) => /^\d+$/.test(value) && Number(value) > 1e3)) {
+          return (0, import_SearchContract.invalidPattern)(pattern, "repetition counts above 1000 are not supported");
+        }
+      }
+    }
+    if (character === "]" && inClass) {
+      if (classCharacters === 0 || classCharacters === 1 && pattern[index - 1] === "^") {
+        return (0, import_SearchContract.invalidPattern)(pattern, "empty character classes are not supported");
+      }
+      inClass = false;
+      continue;
+    }
+    if (inClass) {
+      if (character === "&" && pattern[index + 1] === "&" || character === "-" && pattern[index + 1] === "-" || character === "~" && pattern[index + 1] === "~") {
+        return (0, import_SearchContract.invalidPattern)(pattern, "character-class set operations are not supported");
+      }
+      classCharacters++;
+    }
+  }
+  try {
+    new RegExp(pattern, "u");
+  } catch (error) {
+    return (0, import_SearchContract.invalidPattern)(pattern, malformed(pattern) ?? engineReason(error));
+  }
+  try {
+    LinearRegex.compile(pattern, false);
+    return void 0;
+  } catch (error) {
+    return (0, import_SearchContract.invalidPattern)(pattern, error.message);
+  }
+};
+const countedRepetition = /^\{\d+(,\d*)?\}/;
+const malformed = (pattern) => {
+  const open = [];
+  let repeatable = false;
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    const at = `"${character}" at column ${index + 1}`;
+    if (character === "\\") {
+      index++;
+      repeatable = true;
+      continue;
+    }
+    if (character === "[") {
+      let end = index + 1;
+      if (pattern[end] === "^") end++;
+      while (end < pattern.length && pattern[end] !== "]") end += pattern[end] === "\\" ? 2 : 1;
+      if (end >= pattern.length) return `${at} is never closed; write \\[ for a literal bracket`;
+      index = end;
+      repeatable = true;
+      continue;
+    }
+    if (character === "(") {
+      open.push(index);
+      repeatable = false;
+      continue;
+    }
+    if (character === ")") {
+      if (open.pop() === void 0) return `${at} closes nothing; write \\) for a literal parenthesis`;
+      repeatable = true;
+      continue;
+    }
+    if (character === "{") {
+      const count = countedRepetition.exec(pattern.slice(index));
+      if (count === null) return `${at} is not a repetition count; write \\{ for a literal brace`;
+      if (!repeatable) return `${at} repeats nothing; write \\{ for a literal brace`;
+      index += count[0].length - 1;
+      continue;
+    }
+    if (character === "}" || character === "]") {
+      return `${at} closes nothing; write \\${character} for a literal ${character === "}" ? "brace" : "bracket"}`;
+    }
+    if (character === "*" || character === "+" || character === "?") {
+      if (!repeatable) return `${at} repeats nothing; write \\${character} for a literal ${character}`;
+      continue;
+    }
+    repeatable = character !== "|" && character !== "^" && character !== "$";
+  }
+  const unclosed = open.at(-1);
+  return unclosed === void 0 ? void 0 : `"(" at column ${unclosed + 1} is never closed; write \\( for a literal parenthesis`;
+};
+const engineReason = (error) => {
+  const reason = error.message.replace(/^Invalid regular expression: (\/.*\/[a-z]*: )?/, "").trim();
+  return `invalid expression: ${reason}`;
+};
+const isContractRejection = (error) => error.code === "invalid_pattern" && error.message.startsWith(`${import_SearchContract.rejectionPrefix}"`);
+const validateGlob = (glob) => {
+  const pattern = glob.startsWith("!") ? glob.slice(1) : glob;
+  if (pattern.replace(/ +$/, "").length === 0) return (0, import_SearchContract.invalidPattern)(glob, "glob patterns must not be empty");
+  if (!/^[\x20-\x7e]*$/.test(pattern)) return (0, import_SearchContract.invalidPattern)(glob, "globs must contain printable ASCII only");
+  if (pattern.includes("\\") || pattern.includes("[") || pattern.includes("]")) {
+    return (0, import_SearchContract.invalidPattern)(glob, "glob escapes and character classes are not supported");
+  }
+  let inBrace = false;
+  let alternatives = 1;
+  let expansionCount = 1;
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    if (character === "{") {
+      if (inBrace) return (0, import_SearchContract.invalidPattern)(glob, "nested brace alternatives are not supported");
+      inBrace = true;
+      alternatives = 1;
+    } else if (character === "," && inBrace) {
+      alternatives++;
+    } else if (character === "}") {
+      if (!inBrace || alternatives < 2) return (0, import_SearchContract.invalidPattern)(glob, "braces must contain alternatives");
+      inBrace = false;
+      expansionCount *= alternatives;
+      if (expansionCount > 256) return (0, import_SearchContract.invalidPattern)(glob, "glob brace expansion exceeds 256 patterns");
+    }
+  }
+  if (inBrace) return (0, import_SearchContract.invalidPattern)(glob, "glob braces must be balanced");
+  return void 0;
+};
+const expression = (pattern, fixedStrings, insensitive) => {
+  const input = fixedStrings ? (0, import_SearchContract.escapeRegex)(pattern) : pattern;
+  let source = "";
+  let inClass = false;
+  for (let index = 0; index < input.length; index++) {
+    const character = input[index];
+    if (character === "\\") {
+      source += `${character}${input[index + 1] ?? ""}`;
+      index++;
+    } else if (character === "[") {
+      inClass = true;
+      source += character;
+    } else if (character === "]" && inClass) {
+      inClass = false;
+      source += character;
+    } else if (!inClass && character === ".") {
+      source += "[^\\n]";
+    } else if (!inClass && character === "$") {
+      source += "(?![\\s\\S])";
+    } else {
+      source += character;
+    }
+  }
+  return new RegExp(source, insensitive ? "iu" : "u");
+};
+const expandBraces = (pattern) => {
+  const opening = pattern.indexOf("{");
+  if (opening < 0) return [pattern];
+  const closing = pattern.indexOf("}", opening + 1);
+  if (closing < 0) return [pattern];
+  const alternatives = pattern.slice(opening + 1, closing).split(",");
+  if (alternatives.length < 2) return [pattern];
+  return alternatives.flatMap(
+    (alternative) => expandBraces(
+      `${pattern.slice(0, opening)}${alternative}${pattern.slice(closing + 1)}`
+    )
+  );
+};
+const globExpression = (pattern) => {
+  let source = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const character = pattern[index];
+    const next = pattern[index + 1];
+    if (character === "*" && next === "*" && (index === 0 || pattern[index - 1] === "/") && (pattern[index + 2] === void 0 || pattern[index + 2] === "/")) {
+      source += pattern[index + 2] === "/" ? "(?:.*/)?" : ".*";
+      index += pattern[index + 2] === "/" ? 2 : 1;
+    } else if (character === "*") source += "[^/]*";
+    else if (character === "?") source += "[^/]";
+    else source += character.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  }
+  return new RegExp(`^${source}$`);
+};
+const outsidePrintableAscii = /[^\x20-\x7e]/;
+const utf8ByteString = (value) => outsidePrintableAscii.test(value) ? Array.from(new TextEncoder().encode(value), (byte) => String.fromCharCode(byte)).join("") : value;
+const canonicalGlob = (glob) => {
+  const excluded = glob.startsWith("!");
+  const pattern = excluded ? glob.slice(1) : glob;
+  const canonical = pattern.replace(/ +$/, "").replace(/\/\.(?=\/)/g, "").replace(/^\.\//, "/");
+  return excluded ? `!${canonical}` : canonical;
+};
+const compiled = /* @__PURE__ */ new Map();
+const compileGlob = (pattern) => {
+  const cached = compiled.get(pattern);
+  if (cached !== void 0) return cached;
+  const matchers = expandBraces(canonicalGlob(pattern)).map((expanded) => {
+    const rooted = expanded.startsWith("/");
+    const normalized = rooted ? expanded.slice(1) : expanded;
+    return { byPath: rooted || normalized.includes("/"), expression: globExpression(normalized) };
+  });
+  if (compiled.size >= 256) compiled.clear();
+  compiled.set(pattern, matchers);
+  return matchers;
+};
+const matchesGlob = (pattern, relative, basename) => compileGlob(pattern).some((matcher) => matcher.expression.test(utf8ByteString(matcher.byPath ? relative : basename)));
+const includedByGlobs = (globs, relative, basename) => {
+  const positives = globs.filter((glob) => !glob.startsWith("!"));
+  let included = positives.length === 0;
+  for (const glob of globs) {
+    const excluded = glob.startsWith("!");
+    if (matchesGlob(excluded ? glob.slice(1) : glob, relative, basename)) included = !excluded;
+  }
+  return included;
+};
+const wildcard = /[*?{}]/;
+const literalDirectory = (pattern) => {
+  if (!pattern.includes("/")) return [];
+  const segments = pattern.replace(/^\//, "").split("/").filter((segment) => segment.length > 0);
+  const wildcardAt = segments.findIndex((segment) => wildcard.test(segment));
+  return wildcardAt < 0 ? segments.slice(0, -1) : segments.slice(0, wildcardAt);
+};
+const rootRelativeSuffix = (pattern, root, path) => {
+  const anchored = pattern.replace(/^\/+/, "");
+  const patternRoot = path.sep === "\\" ? root.replaceAll("\\", "/") : root;
+  const stem = patternRoot.replace(/^\/+/, "").replace(/\/+$/, "");
+  return stem.length > 0 && anchored.startsWith(`${stem}/`) ? anchored.slice(stem.length + 1) : void 0;
+};
+const unsatisfiedReason = (options, pattern) => import_effect.Effect.gen(function* () {
+  const reasons = [];
+  for (const alternative of expandBraces(pattern)) {
+    const segments = literalDirectory(alternative);
+    if (segments.length === 0) return void 0;
+    const skipped = segments.find((segment) => Walk.skippedDirectories.has(segment));
+    if (skipped !== void 0) {
+      reasons.push(`${skipped} is never descended into; name it as the search root to look inside it`);
+      continue;
+    }
+    if (!options.hidden && segments.some((segment) => segment.startsWith("."))) {
+      reasons.push("hidden paths are excluded unless hidden is true");
+      continue;
+    }
+    const directory = segments.join("/");
+    const present = yield* options.fileSystem.stat(options.path.join(options.root, directory)).pipe(
+      import_effect.Effect.map((info) => info.type === "Directory"),
+      import_effect.Effect.orElseSucceed(() => false)
+    );
+    if (present) return void 0;
+    reasons.push(`there is no ${directory} directory there`);
+  }
+  return reasons[0];
+});
+const unsatisfiableNotice = (options) => import_effect.Effect.gen(function* () {
+  const walkable = yield* options.fileSystem.stat(options.root).pipe(
+    import_effect.Effect.map((info) => info.type === "Directory"),
+    import_effect.Effect.orElseSucceed(() => false)
+  );
+  if (!walkable) return void 0;
+  const sentences = [];
+  for (const glob of options.globs) {
+    if (glob.startsWith("!")) continue;
+    const canonical = canonicalGlob(glob);
+    const reason = yield* unsatisfiedReason(options, canonical);
+    if (reason === void 0) continue;
+    const suffix = rootRelativeSuffix(canonical, options.root, options.path);
+    sentences.push(
+      `No file under ${options.root} can match "${glob}": ${suffix === void 0 ? reason : `glob patterns are relative to the search root, so use "${suffix}" instead`}.`
+    );
+  }
+  if (sentences.length > 0 && sentences.length === options.globs.filter((glob) => !glob.startsWith("!")).length) {
+    return sentences.join(" ");
+  }
+  const included = (relative, basename) => includedByGlobs(options.globs, relative, basename);
+  const ignored = options.noIgnore ? false : options.ignored ?? (yield* Walk.files(options.fileSystem, options.path, options.root, options.hidden, false, included).pipe(
+    import_effect.Effect.map((walked) => walked.ignored),
+    import_effect.Effect.orElseSucceed(() => false)
+  ));
+  if (ignored) {
+    sentences.push("No results; ignore files excluded paths. Retry with noIgnore: true to include them.");
+  }
+  return sentences.length === 0 ? void 0 : sentences.join(" ");
+});
+//# sourceMappingURL=SearchContract.js.map

package/dist/cjs/SearchContract.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/SearchContract.ts"],
+  "sourcesContent": ["/**\n * The validation and matching rules every Search implementation shares.\n *\n * Both peers shipped here match globs through {@link includedByGlobs} and\n * canonicalize them through {@link canonicalGlob}, so the two implementations\n * cannot drift on what a pattern means, and an external peer binding its own\n * `Search` builds on the same functions. {@link unsatisfiableNotice} is the\n * shared explanation for empty answers caused by impossible globs or ignore\n * exclusions.\n *\n * @since 1.0.0\n */\n\nimport type * as Path from \"@smthrs/kernel/Path\"\nimport { Effect } from \"effect\"\nimport type * as FileSystem from \"effect/FileSystem\"\nimport * as LinearRegex from \"./internal/LinearRegex.ts\"\nimport { escapeRegex, invalidPattern, rejectionPrefix } from \"./internal/SearchContract.ts\"\nimport * as Walk from \"./internal/Walk.ts\"\nimport type * as StdError from \"./StdError.ts\"\n\n/**\n * Validates Smithers Ripgrep ASCII v1. It is deliberately the intersection of\n * Rust regex and JavaScript RegExp: ASCII patterns, captures, alternation,\n * ASCII character classes and ordinary quantifiers. Lookaround,\n * backreferences, named/inline groups, Unicode/shorthand classes and control\n * escapes are rejected before either implementation runs. Patterns are\n * limited to 4096 bytes, counted repetitions to 1000, group nesting to 128\n * and expanded state machines to 8192 states. Both peers share this\n * compilation boundary; portable matching never backtracks over input.\n *\n * @category validation\n * @since 1.0.0\n */\nexport const validatePattern = (pattern: string, fixedStrings: boolean): StdError.StdError | undefined => {\n  if (pattern.length > 4096) return invalidPattern(pattern, \"patterns must not exceed 4096 bytes\")\n  if (!/^[\\x20-\\x7e]*$/.test(pattern)) return invalidPattern(pattern, \"patterns must contain printable ASCII only\")\n  if (fixedStrings) return undefined\n  if (pattern.includes(\"(?\")) return invalidPattern(pattern, \"special groups and lookaround are not supported\")\n  let inClass = false\n  let classCharacters = 0\n  for (let index = 0; index < pattern.length; index++) {\n    const character = pattern[index]\n    if (character === \"\\\\\") {\n      const escaped = pattern[index + 1]\n      if (escaped === undefined || /[A-Za-z0-9]/.test(escaped)) {\n        return invalidPattern(pattern, \"backreferences, shorthand classes and encoded escapes are not supported\")\n      }\n      index++\n      if (inClass) classCharacters++\n      continue\n    }\n    if (character === \"[\" && inClass) {\n      return invalidPattern(pattern, \"nested and named character classes are not supported\")\n    }\n    if (character === \"[\") {\n      inClass = true\n      classCharacters = 0\n      continue\n    }\n    if (character === \"{\" && !inClass) {\n      const closing = pattern.indexOf(\"}\", index + 1)\n      if (closing >= 0) {\n        const counts = pattern.slice(index + 1, closing).split(\",\").filter((value) => value.length > 0)\n        if (counts.some((value) => /^\\d+$/.test(value) && Number(value) > 1000)) {\n          return invalidPattern(pattern, \"repetition counts above 1000 are not supported\")\n        }\n      }\n    }\n    if (character === \"]\" && inClass) {\n      if (classCharacters === 0 || (classCharacters === 1 && pattern[index - 1] === \"^\")) {\n        return invalidPattern(pattern, \"empty character classes are not supported\")\n      }\n      inClass = false\n      continue\n    }\n    if (inClass) {\n      if (\n        (character === \"&\" && pattern[index + 1] === \"&\") ||\n        (character === \"-\" && pattern[index + 1] === \"-\") ||\n        (character === \"~\" && pattern[index + 1] === \"~\")\n      ) {\n        return invalidPattern(pattern, \"character-class set operations are not supported\")\n      }\n      classCharacters++\n    }\n  }\n  try {\n    new RegExp(pattern, \"u\")\n  } catch (error) {\n    return invalidPattern(pattern, malformed(pattern) ?? engineReason(error as Error))\n  }\n  try {\n    LinearRegex.compile(pattern, false)\n    return undefined\n  } catch (error) {\n    // LinearRegex.compile throws Error for its nesting and state budgets.\n    return invalidPattern(pattern, (error as Error).message)\n  }\n}\n\nconst countedRepetition = /^\\{\\d+(,\\d*)?\\}/\n\n/**\n * Names the first construct that keeps `pattern` from parsing, with its\n * 1-based column and the escape that makes it literal.\n *\n * A caller told only that a pattern is unsupported guesses at which character\n * broke it; `Rule({` reads as a literal search to its author and as an unclosed\n * group plus a count with no digits to the parser. Only the syntax errors a\n * search author commonly makes are named here; anything else falls back to the\n * engine's own reason.\n */\nconst malformed = (pattern: string): string | undefined => {\n  const open: Array<number> = []\n  let repeatable = false\n  for (let index = 0; index < pattern.length; index++) {\n    const character = pattern[index]!\n    const at = `\"${character}\" at column ${index + 1}`\n    if (character === \"\\\\\") {\n      index++\n      repeatable = true\n      continue\n    }\n    if (character === \"[\") {\n      let end = index + 1\n      if (pattern[end] === \"^\") end++\n      while (end < pattern.length && pattern[end] !== \"]\") end += pattern[end] === \"\\\\\" ? 2 : 1\n      if (end >= pattern.length) return `${at} is never closed; write \\\\[ for a literal bracket`\n      index = end\n      repeatable = true\n      continue\n    }\n    if (character === \"(\") {\n      open.push(index)\n      repeatable = false\n      continue\n    }\n    if (character === \")\") {\n      if (open.pop() === undefined) return `${at} closes nothing; write \\\\) for a literal parenthesis`\n      repeatable = true\n      continue\n    }\n    if (character === \"{\") {\n      const count = countedRepetition.exec(pattern.slice(index))\n      if (count === null) return `${at} is not a repetition count; write \\\\{ for a literal brace`\n      if (!repeatable) return `${at} repeats nothing; write \\\\{ for a literal brace`\n      index += count[0].length - 1\n      continue\n    }\n    if (character === \"}\" || character === \"]\") {\n      return `${at} closes nothing; write \\\\${character} for a literal ${character === \"}\" ? \"brace\" : \"bracket\"}`\n    }\n    if (character === \"*\" || character === \"+\" || character === \"?\") {\n      if (!repeatable) return `${at} repeats nothing; write \\\\${character} for a literal ${character}`\n      continue\n    }\n    repeatable = character !== \"|\" && character !== \"^\" && character !== \"$\"\n  }\n  const unclosed = open.at(-1)\n  return unclosed === undefined\n    ? undefined\n    : `\"(\" at column ${unclosed + 1} is never closed; write \\\\( for a literal parenthesis`\n}\n\n/** The JavaScript engine's reason, without its prefix or its echo of the pattern. */\nconst engineReason = (error: Error): string => {\n  const reason = error.message.replace(/^Invalid regular expression: (\\/.*\\/[a-z]*: )?/, \"\").trim()\n  return `invalid expression: ${reason}`\n}\n\n/**\n * Whether `error` is a pattern or glob rejection this contract wrote.\n *\n * Those messages are host-authored and name the construct that broke, so a\n * caller may show them to a model. A peer's `invalid_pattern` built from\n * `rg`'s stderr is not one of them and stays private.\n *\n * @category validation\n * @since 1.0.0\n */\nexport const isContractRejection = (error: StdError.StdError): boolean =>\n  error.code === \"invalid_pattern\" && error.message.startsWith(`${rejectionPrefix}\"`)\n\n/**\n * Validates the portable `-g` grammar before either peer sees it.\n *\n * @category validation\n * @since 1.0.0\n */\nexport const validateGlob = (glob: string): StdError.StdError | undefined => {\n  const pattern = glob.startsWith(\"!\") ? glob.slice(1) : glob\n  // `rg` drops the trailing spaces and then ignores a glob that is left blank,\n  // which filters nothing at all. Rejecting it keeps a typo from silently\n  // widening the search instead of narrowing it.\n  if (pattern.replace(/ +$/, \"\").length === 0) return invalidPattern(glob, \"glob patterns must not be empty\")\n  if (!/^[\\x20-\\x7e]*$/.test(pattern)) return invalidPattern(glob, \"globs must contain printable ASCII only\")\n  if (pattern.includes(\"\\\\\") || pattern.includes(\"[\") || pattern.includes(\"]\")) {\n    return invalidPattern(glob, \"glob escapes and character classes are not supported\")\n  }\n  let inBrace = false\n  let alternatives = 1\n  let expansionCount = 1\n  for (let index = 0; index < pattern.length; index++) {\n    const character = pattern[index]\n    if (character === \"{\") {\n      if (inBrace) return invalidPattern(glob, \"nested brace alternatives are not supported\")\n      inBrace = true\n      alternatives = 1\n    } else if (character === \",\" && inBrace) {\n      alternatives++\n    } else if (character === \"}\") {\n      if (!inBrace || alternatives < 2) return invalidPattern(glob, \"braces must contain alternatives\")\n      inBrace = false\n      expansionCount *= alternatives\n      if (expansionCount > 256) return invalidPattern(glob, \"glob brace expansion exceeds 256 patterns\")\n    }\n  }\n  if (inBrace) return invalidPattern(glob, \"glob braces must be balanced\")\n  return undefined\n}\n\n/**\n * Compiles a pattern after common validation.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const expression = (pattern: string, fixedStrings: boolean, insensitive: boolean): RegExp => {\n  const input = fixedStrings ? escapeRegex(pattern) : pattern\n  let source = \"\"\n  let inClass = false\n  for (let index = 0; index < input.length; index++) {\n    const character = input[index]\n    if (character === \"\\\\\") {\n      source += `${character}${input[index + 1] ?? \"\"}`\n      index++\n    } else if (character === \"[\") {\n      inClass = true\n      source += character\n    } else if (character === \"]\" && inClass) {\n      inClass = false\n      source += character\n    } else if (!inClass && character === \".\") {\n      source += \"[^\\\\n]\"\n    } else if (!inClass && character === \"$\") {\n      source += \"(?![\\\\s\\\\S])\"\n    } else {\n      source += character\n    }\n  }\n  return new RegExp(source, insensitive ? \"iu\" : \"u\")\n}\n\nconst expandBraces = (pattern: string): ReadonlyArray<string> => {\n  const opening = pattern.indexOf(\"{\")\n  if (opening < 0) return [pattern]\n  const closing = pattern.indexOf(\"}\", opening + 1)\n  if (closing < 0) return [pattern]\n  const alternatives = pattern.slice(opening + 1, closing).split(\",\")\n  if (alternatives.length < 2) return [pattern]\n  return alternatives.flatMap((alternative) =>\n    expandBraces(\n      `${pattern.slice(0, opening)}${alternative}${pattern.slice(closing + 1)}`\n    )\n  )\n}\n\nconst globExpression = (pattern: string): RegExp => {\n  let source = \"\"\n  for (let index = 0; index < pattern.length; index++) {\n    const character = pattern[index]!\n    const next = pattern[index + 1]\n    if (\n      character === \"*\" && next === \"*\" &&\n      (index === 0 || pattern[index - 1] === \"/\") &&\n      (pattern[index + 2] === undefined || pattern[index + 2] === \"/\")\n    ) {\n      source += pattern[index + 2] === \"/\" ? \"(?:.*/)?\" : \".*\"\n      index += pattern[index + 2] === \"/\" ? 2 : 1\n    } else if (character === \"*\") source += \"[^/]*\"\n    else if (character === \"?\") source += \"[^/]\"\n    else source += character.replace(/[\\\\^$.*+?()[\\]{}|]/g, \"\\\\$&\")\n  }\n  return new RegExp(`^${source}$`)\n}\n\nconst outsidePrintableAscii = /[^\\x20-\\x7e]/\n\n// Printable ASCII is its own UTF-8 encoding, and paths are overwhelmingly\n// printable ASCII, so the encoder only runs for the paths that need it.\nconst utf8ByteString = (value: string): string =>\n  outsidePrintableAscii.test(value)\n    ? Array.from(new TextEncoder().encode(value), (byte) => String.fromCharCode(byte)).join(\"\")\n    : value\n\n/**\n * Rewrites a glob into the one spelling both peers match against.\n *\n * `.` is never a path component either peer can produce, so a leading `./` and\n * every interior `/./` would silently make a pattern unmatchable. Both are\n * folded into the root anchor, which is what a caller writing `./src/**` means.\n * Trailing spaces are dropped because `rg` reads `-g` by gitignore's rules and\n * drops them too, so `\"a.ts \"` finds `a.ts` in the native peer and has to find\n * it in the in-process one. A leading `!` is preserved so exclusion globs\n * canonicalize the same way.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const canonicalGlob = (glob: string): string => {\n  const excluded = glob.startsWith(\"!\")\n  const pattern = excluded ? glob.slice(1) : glob\n  const canonical = pattern.replace(/ +$/, \"\").replace(/\\/\\.(?=\\/)/g, \"\").replace(/^\\.\\//, \"/\")\n  return excluded ? `!${canonical}` : canonical\n}\n\ninterface CompiledGlob {\n  readonly byPath: boolean\n  readonly expression: RegExp\n}\n\nconst compiled = new Map<string, ReadonlyArray<CompiledGlob>>()\n\n/**\n * Compiles one glob into its alternatives, once per distinct pattern.\n *\n * The in-process peer asks whether a pattern matches for every candidate file\n * in the walk, so canonicalizing, brace expanding and compiling the pattern\n * inside that loop makes the work quadratic in the tree. A pattern compiles to\n * the same matchers every time, so the compilation is cached; the cache is\n * bounded because callers, not the tree, supply the patterns.\n */\nconst compileGlob = (pattern: string): ReadonlyArray<CompiledGlob> => {\n  const cached = compiled.get(pattern)\n  if (cached !== undefined) return cached\n  const matchers = expandBraces(canonicalGlob(pattern)).map((expanded) => {\n    const rooted = expanded.startsWith(\"/\")\n    const normalized = rooted ? expanded.slice(1) : expanded\n    return { byPath: rooted || normalized.includes(\"/\"), expression: globExpression(normalized) }\n  })\n  if (compiled.size >= 256) compiled.clear()\n  compiled.set(pattern, matchers)\n  return matchers\n}\n\n/**\n * Matches the supported `-g` subset against a root-relative candidate path.\n *\n * A pattern without `/` matches the basename at any depth. Every other pattern\n * is matched against the candidate's path relative to the search root, anchored\n * at the root, whether or not it carries the optional leading `/`.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const matchesGlob = (pattern: string, relative: string, basename: string): boolean =>\n  compileGlob(pattern).some((matcher) => matcher.expression.test(utf8ByteString(matcher.byPath ? relative : basename)))\n\n/**\n * Applies ripgrep `-g` ordering: positive globs include and `!` globs exclude.\n *\n * @category matching\n * @since 1.0.0\n */\nexport const includedByGlobs = (globs: ReadonlyArray<string>, relative: string, basename: string): boolean => {\n  const positives = globs.filter((glob) => !glob.startsWith(\"!\"))\n  let included = positives.length === 0\n  for (const glob of globs) {\n    const excluded = glob.startsWith(\"!\")\n    if (matchesGlob(excluded ? glob.slice(1) : glob, relative, basename)) included = !excluded\n  }\n  return included\n}\n\nconst wildcard = /[*?{}]/\n\nconst literalDirectory = (pattern: string): ReadonlyArray<string> => {\n  if (!pattern.includes(\"/\")) return []\n  const segments = pattern.replace(/^\\//, \"\").split(\"/\").filter((segment) => segment.length > 0)\n  const wildcardAt = segments.findIndex((segment) => wildcard.test(segment))\n  return wildcardAt < 0 ? segments.slice(0, -1) : segments.slice(0, wildcardAt)\n}\n\nconst rootRelativeSuffix = (pattern: string, root: string, path: Path.Path): string | undefined => {\n  const anchored = pattern.replace(/^\\/+/, \"\")\n  const patternRoot = path.sep === \"\\\\\" ? root.replaceAll(\"\\\\\", \"/\") : root\n  const stem = patternRoot.replace(/^\\/+/, \"\").replace(/\\/+$/, \"\")\n  return stem.length > 0 && anchored.startsWith(`${stem}/`) ? anchored.slice(stem.length + 1) : undefined\n}\n\nconst unsatisfiedReason = (\n  options: {\n    readonly fileSystem: FileSystem.FileSystem\n    readonly path: Path.Path\n    readonly root: string\n    readonly hidden: boolean\n  },\n  pattern: string\n): Effect.Effect<string | undefined> =>\n  Effect.gen(function*() {\n    const reasons: Array<string> = []\n    for (const alternative of expandBraces(pattern)) {\n      const segments = literalDirectory(alternative)\n      if (segments.length === 0) return undefined\n      const skipped = segments.find((segment) => Walk.skippedDirectories.has(segment))\n      if (skipped !== undefined) {\n        reasons.push(`${skipped} is never descended into; name it as the search root to look inside it`)\n        continue\n      }\n      if (!options.hidden && segments.some((segment) => segment.startsWith(\".\"))) {\n        reasons.push(\"hidden paths are excluded unless hidden is true\")\n        continue\n      }\n      const directory = segments.join(\"/\")\n      const present = yield* options.fileSystem.stat(options.path.join(options.root, directory)).pipe(\n        Effect.map((info) => info.type === \"Directory\"),\n        Effect.orElseSucceed(() => false)\n      )\n      if (present) return undefined\n      reasons.push(`there is no ${directory} directory there`)\n    }\n    return reasons[0]\n  })\n\n/**\n * Explains the positive globs that no file under the root could ever match.\n *\n * A search that returns nothing is ambiguous: the tree may hold no match, or\n * the pattern may be unsatisfiable \u2014 an absolute path written where a\n * root-relative one belongs, a directory that does not exist, a skipped\n * directory, a hidden path with `hidden` left false. Callers attach the result\n * to `notice` when they produced no entries. Ignore exclusions name the\n * `noIgnore: true` escape hatch, while impossible globs explain the correction.\n * This keeps the cases\n * distinguishable. Exclusion globs are ignored: excluding what is not there\n * changes nothing.\n *\n * @category diagnostics\n * @since 1.0.0\n */\nexport const unsatisfiableNotice = (options: {\n  readonly fileSystem: FileSystem.FileSystem\n  readonly path: Path.Path\n  readonly root: string\n  readonly globs: ReadonlyArray<string>\n  readonly noIgnore?: boolean | undefined\n  readonly ignored?: boolean | undefined\n  readonly hidden: boolean\n}): Effect.Effect<string | undefined> =>\n  Effect.gen(function*() {\n    // Globs filter a walk. A root that names one file is searched whatever the\n    // globs say \u2014 `rg` always searches a path given on the command line \u2014 so\n    // there is no unsatisfiable pattern to report and no directory to stat.\n    const walkable = yield* options.fileSystem.stat(options.root).pipe(\n      Effect.map((info) => info.type === \"Directory\"),\n      Effect.orElseSucceed(() => false)\n    )\n    if (!walkable) return undefined\n    const sentences: Array<string> = []\n    for (const glob of options.globs) {\n      if (glob.startsWith(\"!\")) continue\n      const canonical = canonicalGlob(glob)\n      const reason = yield* unsatisfiedReason(options, canonical)\n      if (reason === undefined) continue\n      const suffix = rootRelativeSuffix(canonical, options.root, options.path)\n      sentences.push(\n        `No file under ${options.root} can match \"${glob}\": ${\n          suffix === undefined\n            ? reason\n            : `glob patterns are relative to the search root, so use \"${suffix}\" instead`\n        }.`\n      )\n    }\n    // An impossible glob cannot be repaired by opting out of ignores.\n    if (sentences.length > 0 && sentences.length === options.globs.filter((glob) => !glob.startsWith(\"!\")).length) {\n      return sentences.join(\" \")\n    }\n    const included = (relative: string, basename: string) => includedByGlobs(options.globs, relative, basename)\n    const ignored = options.noIgnore ? false : options.ignored ??\n      (yield* Walk.files(options.fileSystem, options.path, options.root, options.hidden, false, included).pipe(\n        Effect.map((walked) => walked.ignored),\n        Effect.orElseSucceed(() => false)\n      ))\n    if (ignored) {\n      sentences.push(\"No results; ignore files excluded paths. Retry with noIgnore: true to include them.\")\n    }\n    return sentences.length === 0 ? undefined : sentences.join(\" \")\n  })\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/ShellCommand.d.ts

@@ -0,0 +1,164 @@
+/**
+ * shell_command flow declaration and portable handler.
+ *
+ * A Codex CLI clone of the `shell_command` tool: string command, `workdir`,
+ * `timeout_ms`, and the Codex output format (`Exit code:` / `Wall time:` /
+ * `Output:` with middle token-budget truncation).
+ *
+ * Codex's `sandbox_permissions` / `justification` / `prefix_rule` approval
+ * parameters are deliberately absent: the permission kernel owns
+ * sandboxing and escalation in this harness.
+ *
+ * @since 1.0.0
+ */
+import type * as ChildProcessSpawner from "@smthrs/kernel/ChildProcessSpawner";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type * as StdError from "./StdError.ts";
+/**
+ * Registry name for the shell_command flow. Matches the Codex CLI tool name.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "shell_command";
+/**
+ * Model-facing description of the shell_command flow. Matches the Codex CLI
+ * (non-Windows) description.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const description: string;
+/**
+ * Default command timeout in milliseconds, matching Codex.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const DEFAULT_TIMEOUT_MS = 10000;
+/**
+ * Maximum bytes retained from each stream while a shell command executes.
+ *
+ * This is far above the 10,000-token model budget because
+ * `formatExecOutputForModel` keeps the head and tail while the capture bound
+ * keeps only the tail. Commands below this bound therefore render byte for
+ * byte as before, while larger output costs the bound instead of its full size.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const MAX_CAPTURE_BYTES = 8000000;
+/**
+ * Default output token budget, matching Codex.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const DEFAULT_MAX_OUTPUT_TOKENS = 10000;
+/**
+ * Timeout exit code reported to the model, matching Codex exec.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const TIMEOUT_EXIT_CODE = 124;
+/**
+ * Input schema for the shell_command flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly command: Schema.String;
+    readonly workdir: Schema.optional<Schema.String>;
+    readonly timeout_ms: Schema.optional<Schema.Number>;
+}>;
+/**
+ * Decoded input accepted by the `shell_command` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output schema for the shell_command flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Output: Schema.Struct<{
+    readonly output: Schema.String;
+    readonly exitCode: Schema.Number;
+}>;
+/**
+ * Decoded output returned by the `shell_command` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Static conservative effect envelope for the shell_command flow.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the effect envelope for a decoded invocation.
+ *
+ * A command line carries no declared envelope, so an invocation says nothing
+ * the registry-time worst case does not already say.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (_input: typeof Input.Type) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Capabilities required by the shell_command flow.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * Declaration-only shell_command flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    readonly name: "shell_command";
+    readonly description: string;
+    readonly input: Schema.Struct<{
+        readonly command: Schema.String;
+        readonly workdir: Schema.optional<Schema.String>;
+        readonly timeout_ms: Schema.optional<Schema.Number>;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly output: Schema.String;
+        readonly exitCode: Schema.Number;
+    }>;
+    readonly capabilities: string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+/**
+ * Executes a shell command through the permission-aware kernel service and
+ * renders the Codex model-facing output format.
+ *
+ * Non-zero exit codes and timeouts remain successful values, exactly as in
+ * Codex; only host and permission failures use the typed error channel.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly command: string;
+    readonly workdir?: string | undefined;
+    readonly timeout_ms?: number | undefined;
+}) => Effect.Effect<{
+    readonly output: string;
+    readonly exitCode: number;
+}, StdError.StdError, ChildProcessSpawner.ChildProcessSpawner>;
+//# sourceMappingURL=ShellCommand.d.ts.map

package/dist/cjs/ShellCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShellCommand.d.ts","sourceRoot":"","sources":["../../src/ShellCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,KAAK,mBAAmB,MAAM,oCAAoC,CAAA;AAC9E,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,IAAI,kBAAkB,CAAA;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QACgG,CAAA;AAExH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AAExC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,UAAY,CAAA;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAA;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;EAQhB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;EAKjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAA8E,CAAA;AAElG;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,OAAO,KAAK,CAAC,IAAI,+CAAY,CAAA;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAkC,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG;;;;;;;8DAiCd,CAAA"}