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

package/dist/chunk-EPTBZ3GP.js

@@ -0,0 +1,101 @@
+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 {
+  parseFactLine
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/memory-room.js
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { freemem } from "node:os";
+import { getHeapStatistics } from "node:v8";
+var NoRoomError = class extends Error {
+  usedMB;
+  ceilingMB;
+  constructor(what, usedMB, ceilingMB) {
+    super(`${what} need more memory than Node was given: ${usedMB} MB of the ${ceilingMB} MB ceiling is in use. Run it again with ATTICUS_MAX_OLD_SPACE=${Math.max(4096, ceilingMB * 2)} (megabytes Node may use for the heap), or in parts, a repo at a time. Closing an IDE frees the memory this needs.`);
+    this.name = "NoRoomError";
+    this.usedMB = usedMB;
+    this.ceilingMB = ceilingMB;
+  }
+};
+var MB = 1024 * 1024;
+var SHARE = 0.8;
+function ceilingOf(env = process.env) {
+  const heap = getHeapStatistics().heap_size_limit;
+  const asked = Number(env.ATTICUS_MAX_OLD_SPACE);
+  const limit = Number.isFinite(asked) && asked > 0 ? Math.min(heap, asked * MB) : heap;
+  const free = freemem();
+  return free > 0 ? Math.min(limit, free + process.memoryUsage.rss()) : limit;
+}
+function roomGuard(o) {
+  const ceiling = o.ceilingBytes ?? ceilingOf();
+  const every = o.every ?? 32;
+  const used = o.used ?? (() => process.memoryUsage.rss());
+  const bar = ceiling * SHARE;
+  let n = 0;
+  return () => {
+    if (n++ % every !== 0)
+      return;
+    const now = used();
+    if (now <= bar)
+      return;
+    throw new NoRoomError(o.what, Math.round(now / MB), Math.max(1, Math.round(ceiling / MB)));
+  };
+}
+function maxOldSpaceIn(args) {
+  for (const a of args) {
+    const m = /^--max[-_]old[-_]space[-_]size[= ](\d+)$/.exec(a.trim());
+    if (m)
+      return Number(m[1]);
+  }
+  return void 0;
+}
+function reExecForMemory(env, execArgv) {
+  if (env.ATTICUS_RESTARTED_FOR_MEMORY)
+    return void 0;
+  const mb = Number(env.ATTICUS_MAX_OLD_SPACE);
+  if (!Number.isInteger(mb) || mb < 256 || mb > 1048576)
+    return void 0;
+  const already = [
+    maxOldSpaceIn(execArgv),
+    maxOldSpaceIn((env.NODE_OPTIONS ?? "").split(/\s+/))
+  ].filter((n) => n !== void 0);
+  if (already.length && Math.max(...already) >= mb)
+    return void 0;
+  return { maxOldSpaceMB: mb };
+}
+async function streamFacts(file, room) {
+  const facts = [];
+  const bad = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = createInterface({
+    input: createReadStream(file, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let line = 0;
+  try {
+    for await (const raw of lines) {
+      room?.();
+      const r = parseFactLine(raw, ++line, seen);
+      if (r.fact)
+        facts.push(r.fact);
+      else if (r.bad)
+        bad.push(r.bad);
+    }
+  } finally {
+    lines.close();
+  }
+  return { facts, bad };
+}
+
+export {
+  NoRoomError,
+  ceilingOf,
+  roomGuard,
+  reExecForMemory,
+  streamFacts
+};

package/dist/chunk-EYWIDJFU.js

@@ -0,0 +1,130 @@
+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 {
+  metarepoToolBox
+} from "./chunk-ZVM6AKKM.js";
+import {
+  CONTEXT_TOOLS
+} from "./chunk-T6AIP7H5.js";
+import {
+  TOOL_LIMITS,
+  ToolSession,
+  readToolCalls,
+  recordToolCalls
+} from "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/context-commands.js
+var box = (root) => metarepoToolBox(root);
+async function runFor(root, name, input, io) {
+  try {
+    io.out(await box(root).call(name, input));
+    return 0;
+  } catch (e) {
+    io.err(e.message);
+    return e.name === "ToolError" ? 2 : 1;
+  }
+}
+function contextShow(root, id, io) {
+  return runFor(root, "show", { id }, io);
+}
+function contextWalk(root, id, o, io) {
+  return runFor(root, "walk", {
+    id,
+    ...o.hops ? { hops: o.hops } : {},
+    ...o.kinds?.length ? { kinds: o.kinds } : {},
+    ...o.limit ? { limit: o.limit } : {}
+  }, io);
+}
+function contextCode(root, o, io) {
+  return runFor(root, "show_code", {
+    ...o.id ? { id: o.id } : {},
+    ...o.repo ? { repo: o.repo } : {},
+    ...o.path ? { path: o.path } : {},
+    ...o.line ? { line: o.line } : {},
+    ...o.around !== void 0 ? { context: o.around } : {}
+  }, io);
+}
+function contextGrep(root, pattern, o, io) {
+  return runFor(root, "grep", {
+    pattern,
+    ...o.regex ? { regex: true } : {},
+    ...o.ignoreCase ? { ignoreCase: true } : {},
+    ...o.repo ? { repo: o.repo } : {},
+    ...o.paths ? { paths: o.paths } : {},
+    ...o.limit ? { limit: o.limit } : {}
+  }, io);
+}
+function contextFiles(root, glob, o, io) {
+  return runFor(root, "files", { glob, ...o.repo ? { repo: o.repo } : {}, ...o.limit ? { limit: o.limit } : {} }, io);
+}
+function contextOutline(root, repo, path, io) {
+  return runFor(root, "outline", { repo, path }, io);
+}
+function contextSimilar(root, id, o, io) {
+  return runFor(root, "similar", { id, ...o.kinds?.length ? { kinds: o.kinds } : {}, ...o.limit ? { limit: o.limit } : {} }, io);
+}
+function contextTools(o, io) {
+  if (o.json) {
+    io.out(JSON.stringify({ tools: CONTEXT_TOOLS, limits: TOOL_LIMITS }, null, 2));
+    return 0;
+  }
+  for (const t of CONTEXT_TOOLS)
+    io.out(`${t.name}: ${t.description}`);
+  io.out(`At most ${TOOL_LIMITS.rounds} rounds of tool calls in a run, ${TOOL_LIMITS.tokens} tokens from tools in all, ${TOOL_LIMITS.perCall} from one call.`);
+  return 0;
+}
+async function contextCall(root, name, o, io) {
+  let input = {};
+  if (o.input !== void 0) {
+    try {
+      const v = JSON.parse(o.input);
+      if (typeof v !== "object" || v === null || Array.isArray(v))
+        throw new Error("not an object");
+      input = v;
+    } catch {
+      io.err(`--input is the tool's input as a JSON object, for example --input '{"id":"forge-ledger"}'.`);
+      return 2;
+    }
+  }
+  const existing = o.run ? await readToolCalls(root, o.run) : void 0;
+  if (o.run && !existing) {
+    io.err(`There is no run ${o.run}. atticus runs lists them.`);
+    return 2;
+  }
+  const session = new ToolSession(metarepoToolBox(root, existing?.tools?.calls), {}, existing?.tools);
+  const before = session.calls.length;
+  const call = await session.run(o.round ?? 1, { name, input });
+  if (o.run)
+    await recordToolCalls(root, o.run, (t) => ({
+      offered: CONTEXT_TOOLS.map((d) => d.name),
+      calls: [...t?.calls ?? [], ...session.calls.slice(before)],
+      ...session.stopped ? { stopped: session.stopped } : {}
+    }));
+  if (o.json)
+    io.out(JSON.stringify({
+      output: call.output,
+      tokens: call.tokens,
+      ...call.error ? { error: true } : {},
+      ...session.stopped ? { stopped: session.stopped } : {}
+    }, null, 2));
+  else
+    io.out(call.output);
+  return 0;
+}
+export {
+  contextCall,
+  contextCode,
+  contextFiles,
+  contextGrep,
+  contextOutline,
+  contextShow,
+  contextSimilar,
+  contextTools,
+  contextWalk
+};

package/dist/chunk-F7HYOUFF.js

@@ -0,0 +1,287 @@
+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 {
+  aliasArgv,
+  isLegacy
+} from "./chunk-ZDPAS56H.js";
+import {
+  isHandoffStep
+} from "./chunk-4Q3NN7VF.js";
+
+// packages/cli/dist/command-catalog.js
+var AREAS = [
+  { id: "start", title: "Set up and keep healthy" },
+  { id: "repos", title: "Repos, scans and specs" },
+  { id: "knowledge", title: "Knowledge and documents" },
+  { id: "catalog", title: "The catalog" },
+  { id: "changes", title: "Changes, findings and questions" },
+  { id: "plan", title: "Plans, tasks and work items" },
+  { id: "release", title: "Release" },
+  { id: "developer", title: "For Atticus's own quality" }
+];
+var AREA_BY_WORD = {
+  init: "start",
+  adopt: "start",
+  unadopt: "start",
+  setup: "start",
+  doctor: "start",
+  probe: "start",
+  secret: "start",
+  upgrade: "start",
+  support: "start",
+  sandbox: "start",
+  learn: "start",
+  explain: "start",
+  executors: "start",
+  openspec: "start",
+  "assistant-files": "start",
+  ui: "start",
+  mcp: "start",
+  index: "start",
+  schema: "start",
+  orgpack: "start",
+  templates: "start",
+  commands: "start",
+  legacy: "start",
+  next: "changes",
+  scan: "repos",
+  verify: "repos",
+  join: "repos",
+  map: "repos",
+  spec: "repos",
+  estate: "repos",
+  "repo-type": "repos",
+  repo: "repos",
+  repos: "repos",
+  workspace: "repos",
+  frameworks: "repos",
+  dialect: "repos",
+  onboard: "repos",
+  baseline: "repos",
+  drift: "repos",
+  stub: "repos",
+  ci: "repos",
+  sources: "knowledge",
+  standards: "knowledge",
+  knowledge: "knowledge",
+  patterns: "knowledge",
+  absorb: "knowledge",
+  intake: "knowledge",
+  triage: "knowledge",
+  glossary: "knowledge",
+  domain: "knowledge",
+  catalog: "catalog",
+  query: "catalog",
+  context: "catalog",
+  cites: "catalog",
+  impact: "catalog",
+  ask: "catalog",
+  guide: "catalog",
+  diagram: "catalog",
+  reconcile: "catalog",
+  coverage: "catalog",
+  feature: "catalog",
+  alias: "catalog",
+  site: "catalog",
+  digest: "changes",
+  change: "changes",
+  finding: "changes",
+  findings: "changes",
+  stage: "changes",
+  critic: "changes",
+  handoff: "changes",
+  questions: "changes",
+  plan: "plan",
+  task: "plan",
+  stories: "plan",
+  todo: "plan",
+  needs: "changes",
+  waiting: "changes",
+  watch: "changes",
+  runs: "changes",
+  history: "changes",
+  ado: "plan",
+  tests: "plan",
+  trace: "plan",
+  initiative: "plan",
+  outcome: "plan",
+  release: "release",
+  bench: "developer",
+  eval: "developer",
+  defences: "developer",
+  plugin: "developer",
+  conformance: "developer"
+};
+var AREA_BY_ID = {
+  "spec hand-down": "changes",
+  "spec hand-up": "changes",
+  "ci archive-gate": "release"
+};
+var KIND_BY_NAME = {
+  repo: "repo",
+  repos: "repo",
+  change: "change",
+  flow: "flow",
+  system: "system",
+  file: "path",
+  files: "path",
+  dir: "path",
+  path: "path",
+  a: "path",
+  b: "path"
+};
+var KIND_BY_COMMAND = {
+  "questions answer": ["question"],
+  "change status": ["change"],
+  "change handoff": ["change"],
+  "change sync": ["change"],
+  "change return": ["change"],
+  "change archive": ["change"],
+  finding: ["change", "finding"],
+  findings: ["change"],
+  impact: ["record"],
+  drift: ["change"],
+  trace: ["change"]
+};
+var SERVES = /* @__PURE__ */ new Set(["ui", "stub serve", "mcp"]);
+var APPROVE_FLAGS = ["--approve", "--send"];
+var isWord = (t) => /^[a-z][a-z-]*$/.test(t);
+function parseArgs(id, usage) {
+  const out = [];
+  const kinds = KIND_BY_COMMAND[id];
+  const re = /(\[|"?<)([a-z][a-z|-]*?)(\.\.\.)?(>"?|\])(\.\.\.)?/g;
+  for (const m of usage.matchAll(re)) {
+    const before = usage.slice(0, m.index).trimEnd();
+    if (/--[a-z-]+$/.test(before) || /--[a-z-]+ ?\|?$/.test(before))
+      continue;
+    if (m[1] === "[" && !/^[a-z]+$/.test(m[2]))
+      continue;
+    const raw = m[2];
+    const parts = raw.split("|");
+    const isChoice = parts.length >= 3;
+    const name = isChoice ? "choice" : parts[0];
+    const kind = kinds?.[out.length] ?? (isChoice ? "choice" : KIND_BY_NAME[name] ?? "text");
+    out.push({
+      name,
+      kind,
+      optional: m[1] === "[",
+      many: !!(m[3] || m[5]),
+      ...isChoice ? { choices: parts } : {}
+    });
+  }
+  return out;
+}
+function parseFlags(text, summaries) {
+  const out = /* @__PURE__ */ new Map();
+  const re = /(--[a-z][a-z-]*)(?:[ =]("[^"]*"|<[^>]+>|[A-Za-z0-9][\w.,=-]*(?:\|[\w.-]+)*))?/g;
+  for (const m of text.matchAll(re)) {
+    const name = m[1];
+    if (out.has(name))
+      continue;
+    const before = text.slice(0, m.index);
+    const opened = (before.match(/\[/g) ?? []).length - (before.match(/\]/g) ?? []).length;
+    let value = m[2]?.replace(/^<|>$/g, "");
+    if (value?.startsWith("--") || value && /^[a-z]+$/.test(value) && !m[2].startsWith("<"))
+      value = /^(m|n|t|s|k|f|c|d|o|p|file|dir|id)$/.test(value) ? value : void 0;
+    const summary = summaries.get(name);
+    out.set(name, {
+      name,
+      ...value ? { value } : {},
+      // `<folder> | --org <org>`: the option is given instead of the argument, not as well.
+      required: opened <= 0 && !/<[^>]+>\s*\|\s*$/.test(before),
+      ...summary ? { summary } : {}
+    });
+  }
+  return [...out.values()];
+}
+function parseHelp(help) {
+  const out = [];
+  let current;
+  const blocks = [];
+  for (const l of help.split("\n")) {
+    if (/^ {2}atticus /.test(l)) {
+      current = { line: l.trim(), more: [] };
+      blocks.push(current);
+    } else if (current && /^ {6,}\[?--|^ {6,}\(/.test(l))
+      current.more.push(l.trim());
+    else if (current && !current.more.length && current.below === void 0 && /^ {6,}\S/.test(l))
+      current.below = l.trim();
+    else if (!/^ {6,}/.test(l))
+      current = void 0;
+  }
+  for (const b of blocks) {
+    if (/^atticus (--help|--version|<step>)/.test(b.line))
+      continue;
+    const cut = b.line.search(/ {2,}/);
+    const usage = cut > 0 ? b.line.slice(0, cut) : b.line;
+    const written = cut > 0 ? b.line.slice(cut).trim() : b.below ?? "";
+    const summary = written.replace(/(\s*\[[^\]]*--[^\]]*\](\.\.\.)?)+\s*$/, "");
+    const tokens = usage.split(" ").slice(1);
+    const words = [];
+    for (const t of tokens) {
+      if (!isWord(t))
+        break;
+      words.push(t);
+    }
+    const id = words.join(" ");
+    const summaries = /* @__PURE__ */ new Map();
+    for (const m of b.more) {
+      const c = m.search(/ {2,}/);
+      const opt = c > 0 ? m.slice(0, c) : m;
+      const what = c > 0 ? m.slice(c).trim() : "";
+      for (const f of opt.matchAll(/--[a-z][a-z-]*/g))
+        if (what)
+          summaries.set(f[0], what);
+    }
+    const optionText = [
+      usage,
+      written,
+      // Each option line's option part only: its description may hold brackets of its own.
+      ...b.more.map((m) => {
+        const c = m.search(/ {2,}/);
+        return `[${(c > 0 ? m.slice(0, c) : m).replace(/^\[|\]$/g, "")}]`;
+      })
+    ].join(" ");
+    out.push({
+      id,
+      words,
+      usage,
+      summary,
+      args: parseArgs(id, usage.slice(`atticus ${id}`.length)),
+      flags: parseFlags(optionText, summaries)
+    });
+  }
+  return out;
+}
+function commandCatalog(help) {
+  const seen = /* @__PURE__ */ new Set();
+  return parseHelp(help).map((parsed) => {
+    let c = parsed;
+    if (seen.has(c.id)) {
+      const mark = c.flags.find((f) => f.required) ?? c.flags[0];
+      if (mark)
+        c = { ...c, id: `${c.id} ${mark.name}` };
+    }
+    seen.add(c.id);
+    const area = AREA_BY_ID[c.id] ?? AREA_BY_WORD[c.words[0] ?? ""] ?? "";
+    const approve = APPROVE_FLAGS.find((f) => c.flags.some((x) => x.name === f));
+    const [w0, w1] = aliasArgv(c.words, c.words.map((_, i) => i));
+    const runs = isHandoffStep(w0, w1) || c.id === "critic" || c.id === "map" ? "ai" : SERVES.has(c.id) ? "serve" : approve ? "shared" : "local";
+    return {
+      ...c,
+      area,
+      runs,
+      ...approve && runs === "shared" ? { approve } : {},
+      legacy: isLegacy(c.words[0])
+    };
+  });
+}
+
+export {
+  AREAS,
+  parseHelp,
+  commandCatalog
+};

package/dist/chunk-FHH4I4ZV.js

@@ -0,0 +1,128 @@
+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 {
+  targetFlowsOf
+} from "./chunk-TDD55CJH.js";
+import {
+  estimateChange,
+  loadRelease,
+  releaseForecast
+} from "./chunk-BOHJZTEQ.js";
+import {
+  gateStatus,
+  reviewedGates
+} from "./chunk-3HI6Z55Y.js";
+import {
+  detectConflicts
+} from "./chunk-XY3P7JW7.js";
+import {
+  loadEstimates,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/change-estimate.js
+import { relative, sep } from "node:path";
+async function estimateOf(root, change, o = {}) {
+  const t = await targetFlowsOf(root, change);
+  if (!t)
+    return void 0;
+  const problems = [...t.problems];
+  const { estimates, problem } = await loadEstimates(orgPackDirOf(root));
+  if (problem)
+    problems.push(problem);
+  const systems = /* @__PURE__ */ new Map();
+  const systemOf = /* @__PURE__ */ new Map();
+  for (const r of t.records) {
+    if (r.kind === "System")
+      systems.set(r.id, r.boundary);
+    if (r.kind === "Component")
+      systemOf.set(r.id, r.system);
+  }
+  const boundaryOf = (c) => systems.get(systemOf.get(c) ?? c);
+  let openBlocking = 0;
+  for (const gate of await reviewedGates(root, change).catch(() => []))
+    openBlocking += await gateStatus(root, change, gate).then((s) => s.open.blocking, () => 0);
+  const conflicts = (await detectConflicts(root).catch(() => [])).filter((p) => p.changes.includes(change)).length;
+  let waitDays;
+  try {
+    const f = await releaseForecast(await loadRelease(root, change, o.now ? { now: o.now } : {}));
+    if (f.status !== "released")
+      waitDays = f.waitDays;
+  } catch (e2) {
+    problems.push(`The release forecast couldn't be worked out: ${e2.message.split("\n")[0]}`);
+  }
+  const flows = t.merged.map((m) => ({
+    flow: m.flow,
+    repo: m.repo,
+    change: m.change,
+    trigger: m.trigger.kind,
+    file: `${t.source}/${m.flow}.yaml`,
+    steps: m.steps.map((s) => ({
+      mark: s.mark,
+      kind: s.kind,
+      ...s.today !== void 0 ? { today: s.today } : {},
+      ...s.target !== void 0 ? { target: s.target } : {},
+      ...s.what ? { what: s.what } : {},
+      ...s.to ? { to: s.to } : {},
+      ...s.store ? { store: s.store } : {},
+      ...s.confirmedBy ? { confirmedBy: s.confirmedBy } : {}
+    }))
+  }));
+  const e = estimateChange({
+    change,
+    flows,
+    ...estimates ? { table: estimates } : {},
+    boundaryOf,
+    openBlocking,
+    conflicts,
+    ...waitDays !== void 0 ? { waitDays } : {}
+  });
+  return {
+    ...e,
+    title: t.title,
+    source: t.source,
+    ...estimates ? { table: `${relative(root, orgPackDirOf(root)).split(sep).join("/")}/estimates.yaml` } : {},
+    problems
+  };
+}
+var units = (n) => `${n} unit${n === 1 ? "" : "s"} of work`;
+var range = (d) => `${d.p20}-${d.p80} days (p50 ${d.p50})`;
+async function changeEstimateCommand(root, change, o, io) {
+  const e = await estimateOf(root, change, o.now ? { now: o.now } : {});
+  if (!e) {
+    io.err(`There is no change ${change}.`);
+    return 2;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(e, null, 2));
+    return 0;
+  }
+  for (const p of e.problems)
+    io.err(p);
+  if (!e.units.length) {
+    io.err(`${change} has no target flows yet, so there is nothing to size: the architecture stage writes them (atticus change architecture ${change}).`);
+    return 1;
+  }
+  io.out(`Estimate for ${change}: ${e.title}`);
+  io.out(e.effort ? `Effort: ${range(e.effort)}, from ${e.units.length - e.needsClass} of ${units(e.units.length)}.` : `Size: ${units(e.units.length)}. No days: ${e.table ? "no class in the org pack's estimates.yaml matches them" : "the org pack has no estimates.yaml"}.`);
+  if (e.calendar.waitDays !== void 0)
+    io.out(`Waiting (the release forecast): ${e.calendar.waitDays} working days${e.calendar.longer ? `; the ${e.calendar.longer} is longer` : ""}.`);
+  io.out(e.calibration.source ? `Not calibrated yet: the ranges are ${e.calibration.source}'s, from ${e.table}.` : "Not calibrated yet.");
+  if (e.drivers.length) {
+    io.out("Drivers:");
+    for (const d of e.drivers)
+      io.out(`  ${d.what}: ${d.count}${d.widens ? ` (widens the upper end by ${d.widens}x)` : ""}${d.source ? `  ${d.source}` : ""}`);
+  }
+  io.out("Work:");
+  for (const u of e.units)
+    io.out(`  ${u.repo}  ${u.flow}${u.step !== void 0 ? ` step ${u.step}` : ""}  ${u.class}  ${u.days ? range(u.days) : "needs a class"}  ${u.what}`);
+  return 0;
+}
+
+export {
+  estimateOf,
+  changeEstimateCommand
+};