@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-1mc9vgcr.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  isString
+} from "./chunk-arvwar2c.js";
+
+// packages/core/src/question-recommendation.ts
+var optionValue = (option) => isString(option) ? option : option.value;
+var splitQuestionOptions = (options) => {
+  const descriptions = Object.fromEntries(options.flatMap((option) => isString(option) || option.description === undefined || option.description.trim() === "" ? [] : [[option.value, option.description]]));
+  return {
+    options: options.map(optionValue),
+    ...Object.keys(descriptions).length === 0 ? undefined : { optionDescriptions: descriptions }
+  };
+};
+var recommendationProblem = (question) => {
+  const options = question.options?.map(optionValue);
+  const reason = question.recommendationReason?.trim() ?? "";
+  const recommended = question.recommended?.trim() ?? "";
+  if (question.informationOnly === true) {
+    if (options !== undefined)
+      return "A Question with options always has one to recommend: set `recommended` to one of them, and drop `informationOnly`.";
+    if (recommended !== "")
+      return "A Question that recommends an answer is not `informationOnly`: drop `informationOnly`.";
+    return reason === "" ? "Say in `recommendationReason` why you cannot suggest an answer, such as that only the person knows the secret\u2019s name." : undefined;
+  }
+  if (recommended === "")
+    return `Add \`recommended\`: the answer you would pick${options === undefined ? ", as a suggested free-text answer" : `, one of: ${options.join(", ")}`}. Add \`recommendationReason\` too, in one or two sentences. Only a Question that purely asks for information you cannot guess, such as a secret's name, may set \`informationOnly\` instead and say why in \`recommendationReason\`.`;
+  if (options !== undefined && !options.includes(question.recommended ?? ""))
+    return `The recommended answer "${question.recommended}" is not one of the options: ${options.join(", ")}.`;
+  return reason === "" ? "Add `recommendationReason`: why you recommend that answer, in one or two sentences." : undefined;
+};
+var questionAdvice = (question) => ({
+  ...question.optionDescriptions === undefined ? undefined : { optionDescriptions: question.optionDescriptions },
+  ...question.recommended === undefined ? undefined : { recommended: question.recommended },
+  ...question.recommendationReason === undefined ? undefined : { recommendationReason: question.recommendationReason },
+  ...question.informationOnly === true ? { informationOnly: true } : undefined
+});
+
+export { splitQuestionOptions, recommendationProblem, questionAdvice };

package/dist/chunk-30397r95.js

@@ -0,0 +1,30 @@
+// @bun
+import {
+  HERDR_CORE_GENERATION2,
+  HERDR_CORE_INSTALL_COMMAND2,
+  HerdrCoreMissing2,
+  HerdrCoreIncompatible2,
+  HerdrCoreConnectionLost2,
+  HerdrCoreRpcError2,
+  HerdrCoreUpdateFailed2,
+  HerdrCore2,
+  herdrCoreLayer2,
+  herdrCoreTransportLayer2,
+  updateHerdrCore2
+} from "./chunk-wh1pa2aa.js";
+import"./chunk-3bj7sc3v.js";
+import"./chunk-11p4wf6n.js";
+import"./chunk-mbctzx7e.js";
+export {
+  HERDR_CORE_GENERATION2 as HERDR_CORE_GENERATION,
+  HERDR_CORE_INSTALL_COMMAND2 as HERDR_CORE_INSTALL_COMMAND,
+  HerdrCore2 as HerdrCore,
+  HerdrCoreConnectionLost2 as HerdrCoreConnectionLost,
+  HerdrCoreIncompatible2 as HerdrCoreIncompatible,
+  HerdrCoreMissing2 as HerdrCoreMissing,
+  HerdrCoreRpcError2 as HerdrCoreRpcError,
+  HerdrCoreUpdateFailed2 as HerdrCoreUpdateFailed,
+  herdrCoreLayer2 as herdrCoreLayer,
+  herdrCoreTransportLayer2 as herdrCoreTransportLayer,
+  updateHerdrCore2 as updateHerdrCore
+};

package/dist/chunk-3bj7sc3v.js

@@ -0,0 +1,389 @@
+// @bun
+import {
+  isString2,
+  hasProperty,
+  symbol,
+  hash,
+  symbol2,
+  equals,
+  BaseProto,
+  PipeInspectableProto,
+  Prototype,
+  some,
+  Service2,
+  getUnsafe,
+  succeed,
+  fail3,
+  getOrThrow,
+  TaggedError,
+  never,
+  flatMap3,
+  andThen2,
+  map8,
+  raceFirst,
+  scoped
+} from "./chunk-mbctzx7e.js";
+import {
+  unwrap,
+  drainFork,
+  decodeText,
+  splitLines,
+  runCollect,
+  runDrain,
+  mkString
+} from "./chunk-11p4wf6n.js";
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/redacted.js
+var redactedRegistry = /* @__PURE__ */ new WeakMap;
+var value2 = (self) => {
+  if (redactedRegistry.has(self)) {
+    return redactedRegistry.get(self);
+  } else {
+    throw new Error("Unable to get redacted value" + (self.label ? ` with label: "${self.label}"` : ""));
+  }
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Redacted.js
+var TypeId = "~effect/Redacted";
+var isRedacted = (u) => hasProperty(u, TypeId);
+var make5 = (value, options) => {
+  const self = Object.create(Proto);
+  if (options?.label) {
+    self.label = options.label;
+  }
+  redactedRegistry.set(self, value);
+  return self;
+};
+var Proto = {
+  [TypeId]: {
+    _A: (_) => _
+  },
+  label: undefined,
+  ...PipeInspectableProto,
+  toJSON() {
+    return this.toString();
+  },
+  toString() {
+    return `<redacted${isString2(this.label) ? ":" + this.label : ""}>`;
+  },
+  [symbol]() {
+    return hash(redactedRegistry.get(this));
+  },
+  [symbol2](that) {
+    return isRedacted(that) && equals(redactedRegistry.get(this), redactedRegistry.get(that));
+  }
+};
+var value = value2;
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Brand.js
+function nominal() {
+  return Object.assign((input) => input, {
+    option: (input) => some(input),
+    result: (input) => succeed(input),
+    is: (_) => true
+  });
+}
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/process/ChildProcessSpawner.js
+var ExitCode = /* @__PURE__ */ nominal();
+var ProcessId = /* @__PURE__ */ nominal();
+var HandleTypeId = "~effect/process/ChildProcessSpawner/ChildProcessHandle";
+var HandleProto = {
+  [HandleTypeId]: HandleTypeId,
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "ChildProcessHandle",
+      pid: this.pid
+    };
+  }
+};
+var makeHandle = (params) => Object.setPrototypeOf({
+  ...params
+}, HandleProto);
+var make6 = (spawn) => {
+  const streamString = (command, options) => spawn(command).pipe(map8((handle) => decodeText(options?.includeStderr === true ? handle.all : drainFork(handle.stdout, handle.stderr))), unwrap);
+  const streamLines = (command, options) => splitLines(streamString(command, options));
+  return ChildProcessSpawner.of({
+    spawn,
+    exitCode: (command) => scoped(flatMap3(spawn(command), (handle) => raceFirst(handle.exitCode, andThen2(runDrain(handle.all), never)))),
+    streamString,
+    streamLines,
+    lines: (command, options) => runCollect(streamLines(command, options)),
+    string: (command, options) => mkString(streamString(command, options))
+  });
+};
+
+class ChildProcessSpawner extends (/* @__PURE__ */ Service2()("effect/process/ChildProcessSpawner")) {
+}
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/process/CommandLine.js
+class CommandLineError extends (/* @__PURE__ */ TaggedError("CommandLineError")) {
+}
+var display = (words, options) => {
+  if (words.length === 0)
+    return "";
+  const format = options?.format ?? "posix";
+  return joinWords(format, words.map((word, i) => isRedacted(word) ? "<redacted>" : escapeControlCharacters(quoteWord(format, word, i === 0))));
+};
+var template = (strings, ...expressions) => {
+  const index = strings.findIndex((text) => text === undefined);
+  if (index !== -1) {
+    return fail3(new CommandLineError({
+      reason: "InvalidEscape",
+      message: `Template part ${index} contains an invalid escape sequence`
+    }));
+  }
+  return parseTemplate(strings, expressions);
+};
+var unwrap2 = (item) => isRedacted(item) ? value(item) : String(item);
+var toWord = (item) => isRedacted(item) ? item : String(item);
+var reservedWords = /* @__PURE__ */ new Set(["!", "{", "}", "and", "begin", "case", "coproc", "do", "done", "elif", "else", "end", "esac", "fi", "for", "foreach", "function", "if", "in", "nocorrect", "not", "or", "repeat", "select", "switch", "then", "time", "until", "while"]);
+var quoteWord = (format, value, program) => {
+  switch (format) {
+    case "posix":
+      return program && reservedWords.has(value) ? `'${value}'` : quotePosix(value);
+    case "powershell":
+      return quotePowerShell(value);
+    case "windows":
+      return program && !value.includes('"') ? quoteWindowsProgram(value) : quoteWindowsArgument(value);
+  }
+};
+var joinWords = (format, quoted) => format === "powershell" ? `& ${quoted.join(" ")}` : quoted.join(" ");
+var posixSafe = /^[A-Za-z0-9_@+:,./-]+$/;
+var quotePosix = (value) => posixSafe.test(value) ? value : `'${value.replace(/['\\]/g, (char) => `'\\${char}'`)}'`;
+var quotePowerShell = (value) => `'${value.replace(/['\u2018\u2019\u201A\u201B]/g, "$&$&")}'`;
+var windowsNeedsQuotes = /[ \t\n\v"]/;
+var quoteWindowsArgument = (value) => {
+  if (value.length > 0 && !windowsNeedsQuotes.test(value))
+    return value;
+  let out = '"';
+  let backslashes = 0;
+  for (const char of value) {
+    if (char === "\\") {
+      backslashes++;
+    } else if (char === '"') {
+      out += "\\".repeat(backslashes * 2 + 1) + '"';
+      backslashes = 0;
+    } else {
+      out += "\\".repeat(backslashes) + char;
+      backslashes = 0;
+    }
+  }
+  return out + "\\".repeat(backslashes * 2) + '"';
+};
+var quoteWindowsProgram = (value) => value.length > 0 && !/[ \t]/.test(value) ? value : `"${value}"`;
+var controlCharacters = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g;
+var controlEscapes = {
+  "\n": "\\n",
+  "\r": "\\r",
+  "\t": "\\t"
+};
+var escapeControlCharacters = (value) => value.replace(controlCharacters, (char) => controlEscapes[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+var operators = "|&;<>()";
+var globs = "*?[";
+var expansionStart = /[A-Za-z_0-9{(@*#?$!'"-]/;
+var quotedExpansionStart = /[A-Za-z_0-9{(@*#?$!-]/;
+var assignmentName = /^[A-Za-z_][A-Za-z0-9_]*\+?$/;
+var isBlank = (char) => char === " " || char === "\t" || char === `
+`;
+var unsupportedSyntax = (char, next, wordStart) => {
+  if (operators.includes(char))
+    return `The operator "${char}" needs a shell`;
+  if (char === "`")
+    return "Command substitution needs a shell";
+  if (char === "$" && next !== undefined && expansionStart.test(next))
+    return `The expansion "$${next}" needs a shell`;
+  if (globs.includes(char))
+    return `The glob character "${char}" needs a shell`;
+  if (!wordStart)
+    return;
+  if (char === "#")
+    return "A comment needs a shell";
+  if (char === "~")
+    return "Tilde expansion needs a shell";
+  if (char === "=" && next !== undefined && !isBlank(next))
+    return 'A leading "=" is expanded by zsh';
+  return;
+};
+var parseTemplate = (texts, values) => {
+  const words = [];
+  let word = [];
+  let plain = true;
+  let braceDepth = 0;
+  let quote = undefined;
+  let quotePart = 0;
+  let part = 0;
+  const error = (reason, message, at = part) => fail3(new CommandLineError({
+    reason,
+    message: `${message} in template part ${at}`
+  }));
+  const endWord = () => {
+    if (word.length === 0)
+      return;
+    const value = word.map(unwrap2).join("");
+    words.push(word.length === 1 && isRedacted(word[0]) ? word[0] : word.some(isRedacted) ? make5(value) : value);
+    word = [];
+    plain = true;
+    braceDepth = 0;
+  };
+  const scan = (text) => {
+    for (let i = 0;i < text.length; i++) {
+      const char = text[i];
+      const next = text[i + 1];
+      if (quote === "'") {
+        if (char === "'")
+          quote = undefined;
+        else
+          word.push(char);
+      } else if (quote === '"') {
+        if (char === '"') {
+          quote = undefined;
+        } else if (char === "\\" && next !== undefined && '$`"\\\n'.includes(next)) {
+          if (next !== `
+`)
+            word.push(next);
+          i++;
+        } else if (char === "`") {
+          return error("UnsupportedSyntax", "Command substitution needs a shell");
+        } else if (char === "$" && next !== undefined && quotedExpansionStart.test(next)) {
+          return error("UnsupportedSyntax", `The expansion "$${next}" needs a shell`);
+        } else {
+          word.push(char);
+        }
+      } else if (isBlank(char)) {
+        endWord();
+      } else if (char === "\\") {
+        if (next === undefined)
+          return error("InvalidEscape", "A trailing backslash escapes nothing");
+        if (next !== `
+`) {
+          word.push(next);
+          plain = false;
+        }
+        i++;
+      } else if (char === "'" || char === '"') {
+        quote = char;
+        quotePart = part;
+        word.push("");
+        plain = false;
+      } else {
+        const unsupported = unsupportedSyntax(char, next, word.length === 0);
+        if (unsupported !== undefined)
+          return error("UnsupportedSyntax", unsupported);
+        if (char === "{") {
+          braceDepth++;
+        } else if (char === "}") {
+          if (braceDepth > 0)
+            braceDepth--;
+        } else if (braceDepth > 0 && (char === "," || char === "." && next === ".")) {
+          return error("UnsupportedSyntax", "Brace expansion needs a shell");
+        } else if (char === "=" && words.length === 0 && plain && assignmentName.test(word.join(""))) {
+          return error("UnsupportedSyntax", "A variable assignment needs a shell");
+        }
+        word.push(char);
+      }
+    }
+    return;
+  };
+  for (;part < texts.length; part++) {
+    const failure = scan(texts[part]);
+    if (failure !== undefined)
+      return failure;
+    if (part === values.length)
+      break;
+    const expression = values[part];
+    if (Array.isArray(expression)) {
+      const after = texts[part + 1][0];
+      if (word.length > 0 || (after === undefined ? part + 1 < values.length : !isBlank(after))) {
+        return error("UnsupportedSyntax", "An interpolated array must be a separate argument");
+      }
+      for (const item of expression)
+        words.push(toWord(item));
+    } else {
+      word.push(toWord(expression));
+      plain = false;
+    }
+  }
+  if (quote !== undefined)
+    return error("UnterminatedQuote", "The quote is not closed", quotePart);
+  endWord();
+  return succeed(words);
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/process/ChildProcess.js
+var TypeId2 = "~effect/process/ChildProcess";
+var Proto2 = {
+  .../* @__PURE__ */ Prototype({
+    label: "Command",
+    evaluate(fiber) {
+      return getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);
+    }
+  }),
+  [TypeId2]: TypeId2
+};
+var makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto2), {
+  _tag: "StandardCommand",
+  command,
+  args,
+  options
+});
+var make7 = function make(...args) {
+  if (isTemplateString(args[0])) {
+    const [templates, ...expressions] = args;
+    const [command, cmdArgs] = parseTemplate2(templates, expressions);
+    return makeStandardCommand(command, cmdArgs, {});
+  }
+  if (typeof args[0] === "object" && !Array.isArray(args[0]) && !isTemplateString(args[0])) {
+    const options = args[0];
+    return function(templates, ...expressions) {
+      if (options.shell !== undefined && options.shell !== false) {
+        return makeStandardCommand(shellScript(templates, expressions), [], options);
+      }
+      const [command, cmdArgs] = parseTemplate2(templates, expressions);
+      return makeStandardCommand(command, cmdArgs, options);
+    };
+  }
+  if (typeof args[0] === "string" && !Array.isArray(args[1])) {
+    const [command, options = {}] = args;
+    return makeStandardCommand(command, [], options);
+  }
+  const [command, cmdArgs = [], options = {}] = args;
+  return makeStandardCommand(command, cmdArgs, options);
+};
+var isTemplateString = (u) => Array.isArray(u) && ("raw" in u) && Array.isArray(u.raw);
+var parseFdName = (name) => {
+  const match = /^fd(\d+)$/.exec(name);
+  if (match === null)
+    return;
+  const fd = parseInt(match[1], 10);
+  return fd >= 3 ? fd : undefined;
+};
+var fdName = (fd) => `fd${fd}`;
+var parseTemplate2 = (templates, expressions) => {
+  const [program = "", ...args] = getOrThrow(template(templates, ...expressions));
+  if (typeof program !== "string") {
+    throw new CommandLineError({
+      reason: "InvalidArgument",
+      message: "The program name of a command cannot be Redacted"
+    });
+  }
+  return [program, args];
+};
+var shellScript = (templates, expressions) => {
+  if (expressions.length > 0) {
+    throw new CommandLineError({
+      reason: "UnsupportedSyntax",
+      message: "A shell template cannot interpolate values; build the script with CommandLine.quote"
+    });
+  }
+  const script = templates[0];
+  if (script === undefined) {
+    throw new CommandLineError({
+      reason: "InvalidEscape",
+      message: "Template part 0 contains an invalid escape sequence"
+    });
+  }
+  return script;
+};
+export { isRedacted, make5, value, ExitCode, ProcessId, makeHandle, make6, ChildProcessSpawner, display, make7, parseFdName, fdName };

package/dist/chunk-6vns3ej0.js

@@ -0,0 +1,23 @@
+// @bun
+import {
+  sliceBytes2,
+  maxLineBytes2,
+  linesPerTurn2,
+  decodedOption2,
+  decoded2,
+  readOpencode2,
+  runOpencodeReader2
+} from "./chunk-x0b92bjb.js";
+import"./chunk-3bj7sc3v.js";
+import"./chunk-11p4wf6n.js";
+import"./chunk-arvwar2c.js";
+import"./chunk-mbctzx7e.js";
+export {
+  decoded2 as decoded,
+  decodedOption2 as decodedOption,
+  linesPerTurn2 as linesPerTurn,
+  maxLineBytes2 as maxLineBytes,
+  readOpencode2 as readOpencode,
+  runOpencodeReader2 as runOpencodeReader,
+  sliceBytes2 as sliceBytes
+};