@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.11

package/dist/chunk-TGEOLIAK.js

@@ -0,0 +1,149 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  readCatalog
+} from "./chunk-IILZ7J3L.js";
+import {
+  readDiagram,
+  reconcile
+} from "./chunk-5V5BJACL.js";
+import {
+  loadOrgPack,
+  orgPackDirOf,
+  parseRecord,
+  recordPath,
+  serializeRecord
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/reconcile-commands.js
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { dirname, join, relative, resolve, sep } from "node:path";
+var DEFAULT_DIR = "inputs/diagrams";
+async function findDiagrams(dir) {
+  const out = [];
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const full = join(d, e.name);
+      if (e.isDirectory())
+        await walk(full);
+      else if (/\.(drawio|drawio\.xml|vsdx|mmd|mermaid|csv)$/i.test(e.name))
+        out.push(full);
+    }
+  }
+  await walk(dir);
+  return out;
+}
+async function reconcileCommand(root, files, o, io) {
+  const paths = files.length > 0 ? files.map((f) => resolve(root, f)) : await findDiagrams(join(root, ...DEFAULT_DIR.split("/")));
+  if (paths.length === 0) {
+    io.err(`No diagrams to reconcile: name one, or put diagrams (.drawio, .vsdx, Lucid .csv, .mmd) under ${DEFAULT_DIR}/`);
+    return 2;
+  }
+  const texts = [];
+  for (const p of paths) {
+    try {
+      texts.push({ file: relative(root, p).split(sep).join("/"), bytes: await readFile(p) });
+    } catch {
+      io.err(`Can't read ${p}`);
+      return 2;
+    }
+  }
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const profile = op.profiles[0]?.profile;
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const curated = await readCatalog(join(catalogDir, "curated"), { cacheRoot: root });
+  for (const p of [...generated.problems, ...curated.problems])
+    io.err(`catalog ${p.file}: ${p.message}`);
+  const records = [...generated.records, ...curated.records];
+  if (generated.records.length === 0)
+    io.err("The catalog is empty: run atticus scan first, or every edge will be diagram-only.");
+  const results = [];
+  for (const t of texts) {
+    const diagram = readDiagram(t.file, t.bytes, profile?.legend);
+    if (!diagram) {
+      io.err(`${t.file}: not a diagram Atticus can read (draw.io, Visio .vsdx, Lucid CSV, Mermaid)`);
+      continue;
+    }
+    const r = reconcile({
+      diagram,
+      file: t.file,
+      records,
+      systems: profile?.systems ?? [],
+      patterns: op.patterns
+    });
+    results.push({ file: t.file, edges: diagram.edges.length, problems: diagram.problems, ...r });
+  }
+  if (o.json)
+    io.out(JSON.stringify({
+      diagrams: results.map(({ file, edges, matches, items, names, problems }) => ({
+        file,
+        edges,
+        matches,
+        items,
+        names,
+        problems
+      }))
+    }, null, 2));
+  else
+    for (const r of results) {
+      io.out(`${r.file}: ${r.edges} edges, ${r.matches.length} matched to code, ${r.items.length} item${r.items.length === 1 ? "" : "s"}`);
+      for (const p of r.problems)
+        io.out(`  ! cell ${p.cell}: ${p.message}`);
+      for (const i of r.items) {
+        io.out(`  ${i.type} ${i.diagram ? `[${i.diagram.cell}] ` : ""}${i.summary}`);
+        if (i.suggestion)
+          io.out(`    \u2192 ${i.suggestion.text}`);
+      }
+    }
+  return results.some((r) => r.items.length > 0) ? 1 : 0;
+}
+async function aliasCommand(root, name, target, o, io) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const systems = op.profiles.flatMap((p2) => p2.profile?.systems ?? []).map((s) => s.id);
+  if (!generated.records.some((r) => r.id === target) && !systems.includes(target)) {
+    io.err(`${target} isn't in the catalog. Find the id with: atticus query "${name.split(" ")[0]}"`);
+    return 1;
+  }
+  const slugName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const p = parseRecord({
+    schemaVersion: 1,
+    kind: "CuratedDecision",
+    id: `alias.${slugName}`,
+    status: "current",
+    confidence: "asserted",
+    target,
+    action: "alias",
+    value: name,
+    reason: o.reason ?? `"${name}" is ${target}`,
+    by: o.by ?? userInfo().username,
+    at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z")
+  });
+  if (!p.ok) {
+    io.err(p.issues.map((i) => `${i.path}: ${i.message}`).join("\n"));
+    return 1;
+  }
+  const rel = `${op.sources.layout.catalog}/curated/${recordPath(p.record)}`;
+  const full = join(root, ...rel.split("/"));
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, serializeRecord(p.record), "utf8");
+  io.out(`Wrote ${rel}: "${name}" is ${target}. Commit it so everyone's reconcile uses it.`);
+  return 0;
+}
+
+export {
+  reconcileCommand,
+  aliasCommand
+};

package/dist/chunk-TQYBXDVH.js

@@ -0,0 +1,133 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  AREAS,
+  commandCatalog
+} from "./chunk-NBQO75XT.js";
+import {
+  isLegacy,
+  topHelp
+} from "./chunk-BXBCMGIQ.js";
+import {
+  nearestCommand
+} from "./chunk-7EFILTCI.js";
+import "./chunk-4Q3NN7VF.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/help-commands.js
+function blocks(help) {
+  const out = [];
+  let current;
+  for (const l of help.split("\n")) {
+    if (/^ {2}atticus /.test(l)) {
+      current = { line: l.trim(), lines: [l] };
+      out.push(current);
+    } else if (current && /^ {6,}\S/.test(l))
+      current.lines.push(l);
+    else
+      current = void 0;
+  }
+  return out;
+}
+function commandOf(words, ids) {
+  let best;
+  for (const id of ids) {
+    const w = id.split(" ");
+    if (w.length <= words.length && w.every((x, i) => x === words[i])) {
+      if (!best || w.length > best.split(" ").length)
+        best = id;
+    }
+  }
+  return best;
+}
+function groupedHelp(help, o = {}) {
+  const lines = help.split("\n");
+  const first = lines.findIndex((l) => /^ {2}atticus /.test(l));
+  const head = lines.slice(0, first);
+  const areaOf = new Map(commandCatalog(help).map((c) => [c.usage, c.area]));
+  const byArea = /* @__PURE__ */ new Map();
+  const steps = [];
+  const general = [];
+  for (const b of blocks(help)) {
+    const usage = b.line.split(/ {2,}/)[0];
+    if (/^atticus (--help|--version)/.test(usage))
+      general.push(...b.lines);
+    else if (/^atticus <step>/.test(usage))
+      steps.push(...b.lines);
+    else {
+      const first2 = /^atticus ([a-z][a-z-]*)/.exec(usage)?.[1] ?? "";
+      if (o.only && !o.only(first2))
+        continue;
+      const area = areaOf.get(usage) ?? "start";
+      byArea.set(area, [...byArea.get(area) ?? [], ...b.lines]);
+    }
+  }
+  const globals = lines.filter((l) => /^ {2}--/.test(l));
+  const tail = lines.slice(lines.findLastIndex((l) => /^ {2}\S/.test(l)) + 1).filter((l) => l.trim());
+  const out = o.head ? [...o.head] : [...head.filter((l) => l.trim() !== "Usage:")];
+  while (out.length && !out.at(-1).trim())
+    out.pop();
+  out.push("");
+  for (const a of AREAS) {
+    if (a.id === "developer" && !o.all)
+      continue;
+    const body = byArea.get(a.id);
+    if (!body?.length)
+      continue;
+    out.push(`${a.title}:`, ...body, "");
+  }
+  if (steps.length)
+    out.push("Every AI step:", ...steps, "");
+  out.push("Every command:", ...globals, ...general, "");
+  if (!o.all)
+    out.push(o.more ?? "atticus help --all also lists the commands for Atticus's own quality.");
+  out.push(...tail);
+  return out.join("\n");
+}
+function legacyHelp(help, o = {}) {
+  return groupedHelp(help, {
+    ...o,
+    only: isLegacy,
+    head: [
+      "atticus legacy: every command outside the twelve atticus help shows.",
+      "Each runs as before, by its own name (atticus scan) or as atticus legacy scan."
+    ],
+    more: "atticus legacy --all also lists the commands for Atticus's own quality."
+  });
+}
+function helpCommand(words, help, io, o = {}) {
+  if (!words.length) {
+    io.out(o.all ? groupedHelp(help, o) : topHelp(help.split("\n")[0]));
+    return 0;
+  }
+  const asked = words.join(" ");
+  const ids = commandCatalog(help).map((c) => c.id);
+  const found = blocks(help).filter((b) => {
+    const line = b.line.slice("atticus ".length);
+    return line === asked || line.startsWith(`${asked} `);
+  });
+  if (!found.length) {
+    const near = nearestCommand(words, ids);
+    io.err(`atticus help has nothing for "${asked}".${near ? ` Did you mean atticus help ${near}?` : ""}`);
+    io.err("atticus help --all lists every command.");
+    return 2;
+  }
+  for (const b of found)
+    for (const l of b.lines)
+      io.out(l.replace(/^ {2}/, ""));
+  io.out("");
+  io.out("Every command also takes --root <dir> (the metarepo) and --by <handle> (who is acting).");
+  const id = commandOf(words, ids);
+  if (id)
+    io.out(`atticus explain ${id} says what it does in plain words.`);
+  return 0;
+}
+export {
+  commandOf,
+  groupedHelp,
+  helpCommand,
+  legacyHelp
+};

package/dist/chunk-TV45EUGM.js

@@ -0,0 +1,51 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunk-TZXHUDI6.js

@@ -0,0 +1,233 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  ExecutorError,
+  executorsCheck,
+  inputsSha256,
+  runStep
+} from "./chunk-7J7UY46S.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  StepError,
+  exportStep,
+  fileStepStore,
+  recordStep
+} from "./chunk-CAN3EBE5.js";
+
+// packages/cli/dist/todo-commands.js
+var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+function fail(io, e) {
+  if (e instanceof StepError || e instanceof ExecutorError || e instanceof Error && e.name === "StepFileError") {
+    io.err(e.message);
+    for (const p of e.problems ?? [])
+      io.err(`  ${p}`);
+    return e.code === "invalid" ? 2 : 1;
+  }
+  throw e;
+}
+async function findStep(root, ref) {
+  const [change, id] = ref.includes("/") ? ref.split("/", 2) : [void 0, ref];
+  const store = fileStepStore(root);
+  const all = await store.list(change ? { change } : {});
+  return all.find((s) => s.id === id);
+}
+async function todoList(root, o, io) {
+  let steps;
+  try {
+    steps = await fileStepStore(root).list(o.change ? { change: o.change } : {});
+  } catch (e) {
+    return fail(io, e);
+  }
+  const shown = o.all ? steps : steps.filter((s) => s.state === "open");
+  const blocked = (s) => s.dependsOn.filter((d) => steps.find((x) => x.id === d)?.state === "open");
+  if (o.json) {
+    io.out(JSON.stringify(shown.map((s) => ({
+      id: s.id,
+      change: s.change,
+      system: s.system,
+      action: s.action,
+      state: s.state,
+      title: s.title,
+      where: s.where,
+      waitsFor: blocked(s),
+      record: s.result.map((f) => ({
+        name: f.name,
+        label: f.label,
+        format: f.format,
+        required: f.required
+      })),
+      ...s.procedure ? { procedure: s.procedure } : {},
+      ...s.reason ? { reason: s.reason } : {},
+      createdAt: s.createdAt
+    })), null, 2));
+    return 0;
+  }
+  if (shown.length === 0) {
+    io.out(o.all ? "No manual steps yet." : "Nothing to do: every manual step is done.");
+    return 0;
+  }
+  io.out(`${shown.length} ${o.all ? "manual" : "open"} step${shown.length === 1 ? "" : "s"}:`);
+  for (const line of table(["STEP", "CHANGE", "STATE", "WHAT"], shown.map((s) => {
+    const w = blocked(s);
+    return [
+      s.id,
+      s.change ?? "-",
+      s.state,
+      `${s.title}${w.length ? ` (after ${w.join(", ")})` : ""}`
+    ];
+  })))
+    io.out(line);
+  io.out("Show a step with atticus todo show <step>; record it with atticus todo done <step> --result name=value.");
+  return 0;
+}
+async function todoShow(root, stepRef, o, io) {
+  if (!stepRef) {
+    io.err("Usage: atticus todo show <step> [--export text|csv|import]");
+    return 2;
+  }
+  const format = o.export ?? "text";
+  if (!["text", "csv", "import"].includes(format)) {
+    io.err(`Unknown export ${o.export}. Use text, csv or import.`);
+    return 2;
+  }
+  try {
+    const s = await findStep(root, stepRef);
+    if (!s) {
+      io.err(`There is no step ${stepRef}.`);
+      return 1;
+    }
+    for (const l of exportStep(s, format).text.replace(/\n$/, "").split("\n"))
+      io.out(l);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function results(raw) {
+  if (!raw)
+    return {};
+  if (!Array.isArray(raw))
+    return raw;
+  const out = {};
+  for (const r of raw) {
+    const i = r.indexOf("=");
+    if (i <= 0)
+      return `--result takes name=value, not ${r}`;
+    out[r.slice(0, i).trim()] = r.slice(i + 1).trim();
+  }
+  return out;
+}
+async function todoDone(root, stepRef, o, io, deps = {}) {
+  if (!stepRef || !o.by) {
+    io.err("Usage: atticus todo done <step> [--by <you>] [--result name=value]\u2026 [--skip --note <why>]");
+    return 2;
+  }
+  const values = results(o.result);
+  if (typeof values === "string") {
+    io.err(values);
+    return 2;
+  }
+  try {
+    const s = await findStep(root, stepRef);
+    if (!s) {
+      io.err(`There is no step ${stepRef}.`);
+      return 1;
+    }
+    const done = await recordStep(fileStepStore(root), s.id, {
+      by: o.by,
+      at: iso((deps.now ?? (() => /* @__PURE__ */ new Date()))()),
+      values,
+      ...o.skip ? { skip: true } : {},
+      ...o.note ? { note: o.note } : {}
+    });
+    io.out(done.state === "skipped" ? `Skipped step ${done.id}: ${o.note}` : `Recorded step ${done.id}${Object.keys(done.recorded?.values ?? {}).length ? `: ${Object.entries(done.recorded.values).map(([k, v]) => `${k} ${Array.isArray(v) ? v.join(", ") : String(v)}`).join(", ")}` : ""}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function todoRun(root, stepRef, o, io, deps = {}) {
+  if (!stepRef || !o.with) {
+    io.err("Usage: atticus todo run <step> --with <executor> [--approve <you> --inputs <sha-256>] [--fill-only]");
+    return 2;
+  }
+  try {
+    const s = await findStep(root, stepRef);
+    if (!s) {
+      io.err(`There is no step ${stepRef}.`);
+      return 1;
+    }
+    const sha = inputsSha256(s.inputs);
+    if (!o.approve) {
+      io.out(`Step ${s.id} would run with ${o.with} on these inputs:`);
+      for (const [k, v] of Object.entries(s.inputs))
+        io.out(`  ${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`);
+      io.out(`To approve exactly these inputs: atticus todo run ${s.id} --with ${o.with} --approve <you> --inputs ${sha}${o.fillOnly ? " --fill-only" : ""}`);
+      return 1;
+    }
+    const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+    const r = await runStep(root, s.id, {
+      executor: o.with,
+      approval: {
+        by: o.approve.replace(/^@/, ""),
+        at: iso(now()),
+        ref: s.id,
+        ...o.inputs ? { inputsSha256: o.inputs } : {}
+      },
+      ...o.fillOnly ? { fillOnly: true } : {},
+      ...deps.executors ? { executors: deps.executors } : {},
+      ...deps.client ? { client: deps.client } : {},
+      now: () => iso(now()),
+      onProgress: (p) => io.out(`  ${p.message}`)
+    });
+    io.out(r.message);
+    if (r.status === "done")
+      for (const [k, v] of Object.entries(r.step.recorded?.values ?? {}))
+        io.out(`  ${k}: ${Array.isArray(v) ? v.join(", ") : String(v)}`);
+    return r.status === "done" ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function executorsCheck2(root, o, io, deps = {}) {
+  const r = await executorsCheck(root, {
+    ...deps.executors ? { executors: deps.executors } : {},
+    ...deps.client ? { client: () => deps.client } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.executors.every((e) => e.reachable) && r.problems.length === 0 ? 0 : 1;
+  }
+  for (const p of r.problems)
+    io.err(p);
+  if (r.executors.length === 0) {
+    io.out("No executors are configured. A person declares theirs in .atticus/executors.yaml; the org pack allows them per procedure.");
+    return r.problems.length ? 1 : 0;
+  }
+  for (const line of table(["EXECUTOR", "TRANSPORT", "ANSWERS", "COVERS", "ALLOWED FOR"], r.executors.map((e) => [
+    e.name,
+    e.transport,
+    e.reachable ? `yes${e.version ? ` (${e.version})` : ""}` : "no",
+    e.covers.join(", ") || "-",
+    e.allowedFor.join(", ") || "nothing (off)"
+  ])))
+    io.out(line);
+  for (const e of r.executors.filter((x) => x.problem))
+    io.out(`  ${e.name}: ${e.problem}`);
+  for (const m of r.missing)
+    io.out(`  Procedure ${m.procedure} allows ${m.executor}, which isn't configured here.`);
+  return r.executors.every((e) => e.reachable) && r.problems.length === 0 ? 0 : 1;
+}
+
+export {
+  todoList,
+  todoShow,
+  todoDone,
+  todoRun,
+  executorsCheck2 as executorsCheck
+};

package/dist/chunk-U5PDQTLA.js

@@ -0,0 +1,50 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  runOpenSpecRaw
+} from "./chunk-L7I5PKGD.js";
+import {
+  changesDirOf
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/openspec-run-commands.js
+import { readdir } from "node:fs/promises";
+var CHANGE_FLAG = (a) => a === "--change" || a === "-c" || a.startsWith("--change=") || a.startsWith("-c=");
+async function openChanges(root) {
+  return (await readdir(changesDirOf(root), { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory() && d.name !== "archive").map((d) => d.name).sort();
+}
+var NEEDS_CHANGE = /* @__PURE__ */ new Set(["status", "instructions", "show"]);
+async function openspecRun(root, args, io) {
+  if (!args.length) {
+    io.err("Usage: atticus openspec <openspec arguments>, for example: atticus openspec status, atticus openspec instructions apply. atticus openspec setup and atticus openspec check are Atticus's own.");
+    return 2;
+  }
+  let full = [...args];
+  let note;
+  if (NEEDS_CHANGE.has(args[0]) && !args.some(CHANGE_FLAG)) {
+    const changes = await openChanges(root);
+    if (changes.length === 1) {
+      full = [...full, "--change", changes[0]];
+      note = `Only one change is open, so: openspec ${full.join(" ")}`;
+    } else if (changes.length > 1)
+      note = `${changes.length} changes are open (${changes.join(", ")}); add --change <id> to name one.`;
+  }
+  if (note)
+    io.out(note);
+  const r = await runOpenSpecRaw(full, { root });
+  for (const l of r.stdout.replace(/\n$/, "").split("\n"))
+    if (l !== "")
+      io.out(l);
+  for (const l of r.stderr.replace(/\n$/, "").split("\n"))
+    if (l !== "")
+      io.err(l);
+  return r.exitCode ?? 1;
+}
+export {
+  openspecRun
+};