@garygentry/system1 0.1.0

package/dist/bundle/chunks/config-QR35VKVT.mjs

@@ -0,0 +1,116 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  typedParse
+} from "./chunk-A7ODZFMY.mjs";
+import {
+  DEFAULT_EXCLUDES,
+  createContext,
+  loadConfig,
+  repoConfigPath,
+  setConsent
+} from "./chunk-V7OTO67I.mjs";
+import {
+  DecisionsError,
+  emit
+} from "./chunk-7LVHD6A5.mjs";
+
+// src/commands/config.ts
+function runConfigCommand(argv, io, format) {
+  return emit(
+    io,
+    "config",
+    format,
+    () => body(argv, io),
+    (r, f) => f === "brief" ? brief(r) : void 0
+  );
+}
+function body(argv, io) {
+  const { values, positionals } = typedParse({
+    args: argv,
+    allowPositionals: true,
+    options: { confirm: { type: "boolean" }, by: { type: "string" } }
+  });
+  const [section = "show", action = "status"] = positionals;
+  const cwd = io.cwd ?? process.cwd();
+  if (section === "show") return show(io, cwd);
+  if (section !== "egress") {
+    throw new DecisionsError(
+      "invalid-request",
+      `Unknown config section "${section}". Use: show, egress`
+    );
+  }
+  const config = loadConfig({ cwd, env: io.env, ...io.home ? { home: io.home } : {} });
+  const file = repoConfigPath(config.repoRoot);
+  switch (action) {
+    case "status":
+      return { egress: { consent: config.egress.consent, file } };
+    case "allow":
+      if (!io.interactive && !values.confirm) {
+        throw new DecisionsError(
+          "egress-refused",
+          "Egress consent is the user's decision. Ask the user to run `decide config egress allow` themselves (in Claude Code: `! decide config egress allow`)."
+        );
+      }
+      return {
+        egress: {
+          consent: setConsent(config.repoRoot, true, values.by ?? "decide config"),
+          file,
+          changed: true
+        }
+      };
+    case "deny":
+      return {
+        egress: {
+          consent: setConsent(config.repoRoot, false, values.by ?? "decide config"),
+          file,
+          changed: true
+        }
+      };
+    default:
+      throw new DecisionsError(
+        "invalid-request",
+        `Unknown egress action "${action}". Use: status, allow, deny`
+      );
+  }
+}
+function show(io, cwd) {
+  const ctx = createContext({ ...io, cwd, env: io.env });
+  const { config } = ctx;
+  return {
+    repoRoot: config.repoRoot,
+    model: config.model,
+    endpoint: config.endpoint,
+    concurrency: config.concurrency,
+    budget: config.budget,
+    egress: {
+      consent: config.egress.consent,
+      exclude: config.egress.exclude,
+      defaultExcludes: DEFAULT_EXCLUDES.length
+    },
+    apiKey: config.apiKey ? `present (${config.apiKeySource})` : "absent (replay only)",
+    replay: config.replay,
+    session: config.session ?? null,
+    sessionOrigin: config.sessionOrigin ?? null,
+    files: config.layers,
+    specDirs: ctx.specDirs
+  };
+}
+function brief(r) {
+  if (!("repoRoot" in r)) {
+    const c2 = r.egress.consent;
+    return `egress consent: ${c2.granted ? `granted${c2.at ? ` ${c2.at}` : ""}` : "not granted"} (${r.egress.file})`;
+  }
+  const c = r.egress.consent;
+  return [
+    `repo: ${r.repoRoot}`,
+    `model: ${r.model} via ${r.endpoint}`,
+    `key: ${r.apiKey}${r.replay ? " \xB7 SYSTEM1_REPLAY forces replay" : ""}`,
+    `egress consent: ${c.granted ? `granted ${c.at ?? ""}`.trim() : "not granted \u2014 run `decide config egress allow`"}`,
+    `excludes: ${r.egress.defaultExcludes} default${r.egress.exclude.length ? ` + ${r.egress.exclude.join(", ")}` : ""}`,
+    `budget: ${r.budget.maxCalls} calls / $${r.budget.maxUsd} per request \xB7 concurrency ${r.concurrency}`,
+    `session: ${r.session ? `${r.session} (${r.sessionOrigin === "env" ? "SYSTEM1_SESSION" : `detected from ${r.sessionOrigin}`})` : "none"}`
+  ].join("\n");
+}
+export {
+  runConfigCommand
+};

package/dist/bundle/chunks/decide-PW7REJ6Y.mjs

@@ -0,0 +1,77 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  briefAsk,
+  briefMany
+} from "./chunk-5LVOFZF3.mjs";
+import {
+  buildInput,
+  parseDecideFlags
+} from "./chunk-A7ODZFMY.mjs";
+import {
+  createContext,
+  runAsk,
+  runMany
+} from "./chunk-V7OTO67I.mjs";
+import {
+  DecisionsError,
+  ENVELOPE_VERSION,
+  emit
+} from "./chunk-7LVHD6A5.mjs";
+
+// src/commands/decide.ts
+import { readFileSync } from "node:fs";
+var MANY_ONLY = ["dry-run", "confirm", "sort", "limit", "fields", "concurrency"];
+function runAskCommand(argv, io, format) {
+  return emit(
+    io,
+    "ask",
+    format,
+    () => runAsk(context(io), input(argv, io, true)),
+    (r, f) => f === "brief" ? briefAsk(r) : void 0
+  );
+}
+function runManyCommand(argv, io, format) {
+  return emit(
+    io,
+    "many",
+    format,
+    () => runMany(context(io), input(argv, io)),
+    (r, f) => f === "brief" ? briefMany(r) : f === "jsonl" ? jsonlMany(r) : void 0
+  );
+}
+function jsonlMany(r) {
+  const lines = [
+    ...r.kept.map((row) => ({ status: "kept", ...row })),
+    ...r.undecided.map((row) => ({ status: "undecided", ...row })),
+    ...r.failed.map((f) => ({ status: "failed", ...f }))
+  ].map((l) => JSON.stringify(l));
+  const { kept: _k, undecided: _u, failed: _f, ...summary } = r;
+  lines.push(JSON.stringify({ v: ENVELOPE_VERSION, status: "summary", ...summary }));
+  return lines.join("\n");
+}
+function context(io) {
+  return createContext({ ...io, cwd: io.cwd ?? process.cwd(), env: io.env });
+}
+function input(argv, io, ask = false) {
+  const { values, positionals } = parseDecideFlags(argv);
+  if (ask) {
+    const given = MANY_ONLY.filter((flag) => values[flag] !== void 0);
+    if (given.length > 0) {
+      throw new DecisionsError(
+        "invalid-request",
+        `--${given.join(", --")} ${given.length > 1 ? "apply" : "applies"} to \`decide many\`, not \`ask\` (one state, one call).`
+      );
+    }
+  }
+  if (positionals.length > 0) {
+    throw new DecisionsError(
+      "invalid-request",
+      `Unexpected argument "${positionals[0]}". Did you mean --text "${positionals[0]}"?`
+    );
+  }
+  return buildInput(values, io.readStdin ?? (() => readFileSync(0, "utf8")), io.cwd);
+}
+export {
+  runAskCommand,
+  runManyCommand
+};

package/dist/bundle/chunks/doctor-HAT6XVTW.mjs

@@ -0,0 +1,61 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  runDoctor
+} from "./chunk-V7OTO67I.mjs";
+import {
+  emit
+} from "./chunk-7LVHD6A5.mjs";
+
+// src/commands/doctor.ts
+import { execFile } from "node:child_process";
+function runDoctorCommand(io, format) {
+  return emit(
+    io,
+    "doctor",
+    format,
+    () => runDoctor({
+      ...io,
+      cwd: io.cwd ?? process.cwd(),
+      env: io.env,
+      ...process.argv[1] ? { cliPath: process.argv[1] } : {},
+      probeVersion: (path) => probeVersion(path, io.env)
+    }),
+    (r, f) => f === "brief" ? brief(r) : void 0
+  );
+}
+function brief(r) {
+  const lines = [
+    `decide doctor: ${r.healthy ? "healthy" : "PROBLEMS FOUND"} \xB7 ${r.live ? "live ready" : "replay only"} \xB7 harness ${r.harness ?? "none"} \xB7 session ${r.session ?? "none"}`
+  ];
+  for (const c of r.checks) {
+    lines.push(`  ${c.status.padEnd(4)} ${c.name}: ${c.detail}`);
+    if (c.fix && c.status !== "ok") lines.push(`       fix: ${c.fix}`);
+  }
+  return lines.join("\n");
+}
+function probeVersion(path, env, timeoutMs = 2e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const child = execFile(
+      path,
+      ["version"],
+      { env: { ...env, SYSTEM1_NO_NPX: "1" }, timeout: timeoutMs, killSignal: "SIGKILL" },
+      // Empty output is passed on as "": doctor tells it apart from a failure.
+      (error, stdout) => done(error ? void 0 : stdout.trim().split("\n")[0] ?? "")
+    );
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      done(void 0);
+    }, timeoutMs + 200);
+  });
+}
+export {
+  probeVersion,
+  runDoctorCommand
+};

package/dist/bundle/chunks/misc-6VZKJEN4.mjs

@@ -0,0 +1,78 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  typedParse
+} from "./chunk-A7ODZFMY.mjs";
+import {
+  TOOL_SCHEMAS,
+  createContext,
+  ping,
+  resolveConnection,
+  runUsage
+} from "./chunk-V7OTO67I.mjs";
+import {
+  DecisionsError,
+  EXIT,
+  emit
+} from "./chunk-7LVHD6A5.mjs";
+
+// src/commands/misc.ts
+function runSchemaCommand(argv, io, format) {
+  return emit(io, "schema", format, () => {
+    const [tool] = argv;
+    if (!tool || !(tool in TOOL_SCHEMAS)) {
+      throw new DecisionsError(
+        "invalid-request",
+        `Usage: decide schema <${Object.keys(TOOL_SCHEMAS).join("|")}>`
+      );
+    }
+    return TOOL_SCHEMAS[tool];
+  });
+}
+function runUsageCommand(argv, io, format) {
+  return emit(
+    io,
+    "usage",
+    format,
+    () => {
+      const { values } = typedParse({
+        args: argv,
+        options: { session: { type: "string" }, since: { type: "string" } }
+      });
+      const ctx = createContext({ ...io, cwd: io.cwd ?? process.cwd(), env: io.env });
+      return runUsage(ctx, {
+        ...values.session ? { session: values.session } : {},
+        ...values.since ? { since: values.since } : {}
+      });
+    },
+    (r, f) => f === "brief" ? `usage (measured): ${r.calls} call(s) \u2014 ${r.liveCalls} live, ${r.replayCalls} replayed \xB7 $${r.cost.toFixed(6)} \xB7 ${r.input_tokens} input tokens${r.session ? ` \xB7 session ${r.session}` : ""}` : void 0
+  );
+}
+async function runPingCommand(io, format) {
+  let failed = false;
+  const code = await emit(
+    io,
+    "ping",
+    format,
+    async () => {
+      const result = await ping(resolveConnection(io.env), io.fetch ? { fetch: io.fetch } : {});
+      failed = !result.ok;
+      if (!result.ok && format !== "brief") {
+        throw new DecisionsError("provider-unreachable", result.error ?? "unreachable", {
+          ...result
+        });
+      }
+      return result;
+    },
+    (r, f) => {
+      if (f !== "brief") return void 0;
+      const key = r.keyPresent ? "key: present" : "key: absent (replay only)";
+      return r.ok ? `decide ping: ok \u2014 ${r.model} reachable in ${r.latencyMs} ms (${key})` : `decide ping: FAILED \u2014 ${r.probe}: ${r.error} (${key})`;
+    }
+  );
+  return failed ? EXIT.providerError : code;
+}
+export {
+  runPingCommand,
+  runSchemaCommand,
+  runUsageCommand
+};

package/dist/bundle/chunks/spec-Z2LZJ5EZ.mjs

@@ -0,0 +1,123 @@
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+import {
+  briefSpecCheck
+} from "./chunk-5LVOFZF3.mjs";
+import {
+  typedParse
+} from "./chunk-A7ODZFMY.mjs";
+import {
+  assertExamples,
+  createContext,
+  exampleProblems,
+  listSpecs,
+  loadSpec,
+  runSpecCheck
+} from "./chunk-V7OTO67I.mjs";
+import {
+  DecisionsError,
+  emit
+} from "./chunk-7LVHD6A5.mjs";
+
+// src/commands/spec.ts
+function runSpecCommand(argv, io, format) {
+  const [action = "list", ref] = argv;
+  const ctx = () => createContext({ ...io, cwd: io.cwd ?? process.cwd(), env: io.env });
+  switch (action) {
+    case "list":
+      return emit(
+        io,
+        "spec",
+        format,
+        () => ({ specs: listSpecs(ctx().specDirs) }),
+        (r, f) => f === "brief" ? r.specs.length ? r.specs.map(
+          (s) => `${s.name}  [${s.origin}${s.shadowed ? ", shadowed" : ""}]  ${s.error ? `INVALID: ${s.error.split("\n")[0]}` : s.description}`
+        ).join("\n") : "no specs found" : void 0
+      );
+    case "show":
+      return emit(io, "spec", format, () => {
+        if (!ref) throw new DecisionsError("invalid-request", "Usage: decide spec show <name|path>");
+        const c = ctx();
+        return loadSpec(ref, c.specDirs, c.cwd);
+      });
+    case "validate":
+      return emit(
+        io,
+        "spec",
+        format,
+        () => {
+          const c = ctx();
+          const root = c.config.repoRoot;
+          if (ref) {
+            const spec = loadSpec(ref, c.specDirs, c.cwd);
+            assertExamples(spec, root);
+            return { valid: [spec.name], invalid: [] };
+          }
+          const all = listSpecs(c.specDirs);
+          const invalid = all.flatMap((s) => {
+            if (s.error) return [{ name: s.name, error: s.error }];
+            const problems = exampleProblems(loadSpec(s.file, c.specDirs, c.cwd), root);
+            return problems.length ? [{ name: s.name, error: problems.join("\n") }] : [];
+          });
+          if (invalid.length) {
+            throw new DecisionsError(
+              "invalid-request",
+              `${invalid.length} invalid spec(s): ${invalid.map((i) => i.name).join(", ")}`,
+              { invalid }
+            );
+          }
+          return { valid: all.map((s) => s.name), invalid };
+        },
+        (r, f) => f === "brief" ? `valid: ${r.valid.join(", ") || "(none)"}` : void 0
+      );
+    case "check":
+      return emit(
+        io,
+        "spec",
+        format,
+        () => runSpecCheck(ctx(), checkInput(argv.slice(1))),
+        (r, f) => f === "brief" ? briefSpecCheck(r) : void 0
+      );
+    default:
+      return emit(io, "spec", format, () => {
+        throw new DecisionsError(
+          "invalid-request",
+          `Unknown spec action "${action}". Use: list, show, validate, check`
+        );
+      });
+  }
+}
+function checkInput(argv) {
+  const { values, positionals } = parse(argv);
+  const [spec, extra] = positionals;
+  if (!spec || extra !== void 0) {
+    throw new DecisionsError(
+      "invalid-request",
+      "Usage: decide spec check <name|path> [--live] [--confirm] [--model <id>]"
+    );
+  }
+  if (values.live && values.replay) {
+    throw new DecisionsError("invalid-request", "Pick one of --live, --replay");
+  }
+  return {
+    spec,
+    mode: values.live ? "record" : "replay",
+    ...values.confirm ? { confirm: true } : {},
+    ...values.model ? { model: values.model } : {}
+  };
+}
+function parse(argv) {
+  return typedParse({
+    args: argv,
+    allowPositionals: true,
+    strict: true,
+    options: {
+      live: { type: "boolean" },
+      replay: { type: "boolean" },
+      confirm: { type: "boolean" },
+      model: { type: "string" }
+    }
+  });
+}
+export {
+  runSpecCommand
+};

package/dist/bundle/decide.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { createRequire as __decideRequire } from "node:module"; const require = __decideRequire(import.meta.url);
+
+// src/entry.ts
+import module from "node:module";
+module.enableCompileCache?.();
+await import("./chunks/bin-IIUCANF7.mjs");

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@garygentry/system1",
+  "version": "0.1.0",
+  "description": "The `decide` CLI: typed, calibrated decisions for coding agents, hooks and CI.",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "Gary Gentry",
+    "email": "gary@garygentry.net"
+  },
+  "homepage": "https://github.com/garygentry/system1",
+  "keywords": [
+    "decisions",
+    "decision-model",
+    "jev",
+    "cli",
+    "agents",
+    "triage",
+    "classification"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/garygentry/system1",
+    "directory": "packages/cli"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "decide": "./dist/bundle/decide.mjs"
+  },
+  "files": [
+    "dist/bundle",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  "scripts": {
+    "build": "tsc -b && node bundle.mjs && node ../../tools/notices.mjs",
+    "prepublishOnly": "node ../../tools/prepublish-check.mjs"
+  },
+  "devDependencies": {
+    "@garygentry/system1-core": "workspace:*",
+    "esbuild": "^0.28.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}