@garygentry/system1 0.1.0

package/dist/bundle/chunks/chunk-A7ODZFMY.mjs

@@ -0,0 +1,197 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  parseFileRef,
+  parseQuestionSet
+} from "./chunk-V7OTO67I.mjs";
+import {
+  DecisionsError
+} from "./chunk-7LVHD6A5.mjs";
+
+// src/args.ts
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+var DECIDE_OPTIONS = {
+  spec: { type: "string" },
+  question: { type: "string", multiple: true },
+  questions: { type: "string" },
+  input: { type: "string" },
+  glob: { type: "string", multiple: true },
+  file: { type: "string", multiple: true },
+  jsonl: { type: "string" },
+  diff: { type: "string" },
+  staged: { type: "boolean" },
+  text: { type: "string" },
+  stdin: { type: "boolean" },
+  "allow-outside": { type: "boolean" },
+  split: { type: "string" },
+  keep: { type: "string", multiple: true },
+  sort: { type: "string" },
+  limit: { type: "string" },
+  fields: { type: "string" },
+  "dry-run": { type: "boolean" },
+  confirm: { type: "boolean" },
+  record: { type: "boolean" },
+  replay: { type: "boolean" },
+  live: { type: "boolean" },
+  model: { type: "string" },
+  concurrency: { type: "string" },
+  help: { type: "boolean", short: "h" }
+};
+function parseDecideFlags(argv) {
+  try {
+    return parseArgs({ args: argv, options: DECIDE_OPTIONS, allowPositionals: true, strict: true });
+  } catch (error) {
+    throw new DecisionsError("invalid-request", error.message);
+  }
+}
+function typedParse(config) {
+  try {
+    return parseArgs(config);
+  } catch (error) {
+    throw new DecisionsError("invalid-request", error.message);
+  }
+}
+function buildInput(values, readStdin, cwd = process.cwd()) {
+  if (values.stdin && values.input === "-") {
+    throw new DecisionsError("invalid-request", "--stdin and --input - both want stdin; use one");
+  }
+  if (values.questions !== void 0) {
+    const clash = values.spec ? "--spec" : values.question?.length ? "--question" : void 0;
+    if (clash) {
+      throw new DecisionsError(
+        "invalid-request",
+        `--questions and ${clash} both give questions; use one`
+      );
+    }
+    if (values.questions === "-" && (values.stdin || values.input === "-")) {
+      throw new DecisionsError(
+        "invalid-request",
+        `--questions - and ${values.stdin ? "--stdin" : "--input -"} both want stdin; put the questions in a file instead`
+      );
+    }
+  }
+  const base = values.input ? readJson(resolve(cwd, values.input), values.input, readStdin) : {};
+  const sources = [
+    ...values.glob?.length ? [{ kind: "glob", patterns: values.glob }] : [],
+    ...(values.file ?? []).map((ref) => ({ kind: "file", ...parseFileRef(ref) })),
+    ...values.jsonl ? [{ kind: "jsonl", path: values.jsonl }] : [],
+    ...values.diff !== void 0 || values.staged ? [
+      {
+        kind: "diff",
+        ...values.diff ? { range: values.diff } : {},
+        ...values.staged ? { staged: true } : {}
+      }
+    ] : [],
+    ...values.text !== void 0 ? [{ kind: "text", text: values.text }] : [],
+    ...values.stdin ? [{ kind: "stdin", text: readStdin() }] : []
+  ];
+  const modes = ["record", "replay", "live"].filter((m) => values[m]);
+  if (modes.length > 1)
+    throw new DecisionsError("invalid-request", `Pick one of --${modes.join(", --")}`);
+  const input = { ...base };
+  const set = (key, value) => {
+    if (value !== void 0) input[key] = value;
+  };
+  set("spec", values.spec);
+  if (values.question?.length) input.questions = parseQuestions(values.question);
+  if (values.questions !== void 0) {
+    const ref = values.questions;
+    const inline = ref.includes("\n") || ref.trimStart().startsWith("{");
+    input.questions = parseQuestionSet(
+      inline ? ref : ref === "-" ? readStdin() : readText(resolve(cwd, ref), ref, "--questions"),
+      inline ? "--questions (inline)" : `--questions ${ref}`
+    );
+  }
+  if (sources.length) input.sources = sources;
+  set("split", values.split);
+  set("keep", values.keep?.length ? values.keep : void 0);
+  set("sort", values.sort);
+  set("limit", int(values.limit, "--limit"));
+  set(
+    "fields",
+    values.fields ? values.fields.split(",").map((f) => f.trim()).filter(Boolean) : void 0
+  );
+  set("allowOutside", values["allow-outside"]);
+  set("dryRun", values["dry-run"]);
+  set("confirm", values.confirm);
+  set("mode", modes[0]);
+  set("model", values.model);
+  set("concurrency", int(values.concurrency, "--concurrency"));
+  return input;
+}
+function parseQuestions(texts) {
+  const questions = {};
+  for (const text of texts) {
+    const m = /^([A-Za-z_][\w-]*):(noul|choice|score):([^:]+?)(?::(.+))?$/s.exec(text);
+    if (!m?.[1] || !m[2] || !m[3]) {
+      throw new DecisionsError(
+        "invalid-request",
+        `Cannot parse --question "${text}". Use name:noul:<text>, name:choice:<text>:a=..|b=.., or name:score:<text>:l0|l1|l2`
+      );
+    }
+    const [, name, type, instructions, rest] = m;
+    if (name in questions)
+      throw new DecisionsError("invalid-request", `Question "${name}" given twice`);
+    if (type === "noul") {
+      if (rest)
+        throw new DecisionsError("invalid-request", `--question "${text}": a noul takes no options`);
+      questions[name] = { type, instructions: instructions.trim() };
+    } else if (type === "choice") {
+      const options = (rest ?? "").split("|").map((o) => o.trim()).filter(Boolean);
+      const criteria = Object.fromEntries(
+        options.map((o) => {
+          const eq = o.indexOf("=");
+          if (eq <= 0)
+            throw new DecisionsError(
+              "invalid-request",
+              `--question "${text}": choice options are key=description`
+            );
+          return [o.slice(0, eq).trim(), o.slice(eq + 1).trim()];
+        })
+      );
+      questions[name] = { type, instructions: instructions.trim(), criteria };
+    } else {
+      questions[name] = {
+        type,
+        instructions: instructions.trim(),
+        criteria: (rest ?? "").split("|").map((l) => l.trim()).filter(Boolean)
+      };
+    }
+  }
+  return questions;
+}
+function readJson(path, ref, readStdin) {
+  const text = ref === "-" ? readStdin() : readText(path, ref);
+  try {
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      throw new Error("not an object");
+    return value;
+  } catch (error) {
+    throw new DecisionsError(
+      "invalid-request",
+      `--input ${ref}: not a JSON object (${error.message})`
+    );
+  }
+}
+function readText(path, ref, flag = "--input") {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    const hint = flag === "--questions" && /:\s/.test(ref) ? " (inline questions must be JSON, or YAML spanning several lines)" : "";
+    throw new DecisionsError("invalid-request", `${flag}: cannot read ${ref}${hint}`);
+  }
+}
+function int(value, flag) {
+  if (value === void 0) return void 0;
+  if (!/^\d+$/.test(value))
+    throw new DecisionsError("invalid-request", `${flag} must be a whole number`);
+  return Number(value);
+}
+
+export {
+  parseDecideFlags,
+  typedParse,
+  buildInput
+};