intentdocs 0.11.0 → 0.12.1

package/dist/pull-MDI63WI7.js

@@ -0,0 +1,476 @@
+import {
+  listStories
+} from "./chunk-KTGQO3AE.js";
+import {
+  classify,
+  featureFiles,
+  findIntentDir,
+  newFeature,
+  parseFeature,
+  readIntentFolder,
+  readSyncBase,
+  renderFeature,
+  requireConfig,
+  slug,
+  specOfPushStory,
+  specOfStory,
+  writeSyncBase
+} from "./chunk-RGFGTIIH.js";
+import {
+  choose,
+  closePrompt,
+  confirm,
+  isInteractive
+} from "./chunk-WRRUCCVZ.js";
+import "./chunk-XZE2XP6O.js";
+import "./chunk-UYTVTYNB.js";
+
+// src/commands/pull.ts
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join, relative } from "path";
+import { parse } from "yaml";
+
+// src/lib/pull-files.ts
+import { isMap, isScalar, isSeq, parseDocument, stringify } from "yaml";
+var YAML_OUT = { lineWidth: 0, flowCollectionPadding: false };
+function edit(text, change) {
+  const doc = parseDocument(text);
+  change(doc);
+  return doc.toString(YAML_OUT);
+}
+var seqOf = (doc, key) => {
+  const node = doc.get(key, true);
+  if (isSeq(node)) return node;
+  const seq = doc.createNode([]);
+  doc.set(key, seq);
+  return seq;
+};
+var itemsOf = (seq) => seq.items.filter((i) => isMap(i));
+function releaseItem(doc, number, title) {
+  const releases = seqOf(doc, "releases");
+  const found = itemsOf(releases).find((r) => r.get("number") === number);
+  if (found) return found;
+  const created = doc.createNode({ number, title, stories: [] });
+  created.get("stories", true).flow = true;
+  const after = itemsOf(releases).findIndex((r) => Number(r.get("number")) > number);
+  if (after < 0) releases.items.push(created);
+  else releases.items.splice(releases.items.indexOf(itemsOf(releases)[after]), 0, created);
+  return created;
+}
+function setReleaseTitle(text, number, title) {
+  return edit(text, (doc) => releaseItem(doc, number, title).set("title", title));
+}
+function setActivityTitle(text, id, title) {
+  return edit(text, (doc) => {
+    const activities = seqOf(doc, "activities");
+    const found = itemsOf(activities).find((a) => a.get("id") === id);
+    if (found) found.set("title", title);
+    else activities.items.push(doc.createNode({ id, title }));
+  });
+}
+function ensureActivity(text, id, title) {
+  const has = itemsOf(seqOf(parseDocument(text), "activities")).some((a) => a.get("id") === id);
+  return has ? text : setActivityTitle(text, id, title);
+}
+function placeStory(text, key, number, releaseTitle) {
+  return edit(text, (doc) => {
+    const target = releaseItem(doc, number, releaseTitle);
+    for (const release of itemsOf(seqOf(doc, "releases"))) {
+      const stories = release.get("stories", true);
+      if (!isSeq(stories)) continue;
+      const at = stories.items.findIndex((s) => isScalar(s) && s.value === key);
+      if (at >= 0 && release !== target) stories.items.splice(at, 1);
+    }
+    const existing = target.get("stories", true);
+    let seq;
+    if (isSeq(existing)) {
+      seq = existing;
+    } else {
+      seq = doc.createNode([]);
+      seq.flow = true;
+      target.set("stories", seq);
+    }
+    if (!seq.items.some((s) => isScalar(s) && s.value === key)) seq.items.push(doc.createNode(key));
+  });
+}
+function setState(text, key, fields) {
+  return edit(text, (doc) => {
+    for (const [field, value] of Object.entries(fields)) if (value !== void 0) doc.setIn(["stories", key, field], value);
+  });
+}
+function planVersions(names, key) {
+  const re = new RegExp(`^${key.replace(/[-]/g, "\\-")}\\.v(\\d+)\\.md$`);
+  return names.map((n) => re.exec(n)?.[1]).filter((v) => !!v).map(Number).sort((a, b) => a - b);
+}
+function planBody(text) {
+  return text.replace(/^---\n[\s\S]*?\n---\n?/, "").trim();
+}
+function renderPlan(key, version, plan, labelOf, today) {
+  const meta = { story: key, version, created: today };
+  if (version > 1) meta.supersedes = version - 1;
+  if (plan.summary) meta.summary = plan.summary;
+  const steps = plan.steps.map((step, i) => {
+    const title = step.title ?? step.text.split("\n")[0] ?? `Step ${i + 1}`;
+    const lines = [`## ${i + 1}. ${title}`];
+    if (step.why) lines.push(`**Why:** ${step.why}`);
+    const criteria = step.criteria.map((id) => labelOf(id) ?? id);
+    if (criteria.length) lines.push(`**Criteria:** ${criteria.join(", ")}`);
+    if (step.files.length) lines.push(`**Files:** ${step.files.join(", ")}`);
+    if (step.tests.length) lines.push(`**Tests:** ${step.tests.join(", ")}`);
+    if (step.needs_you) lines.push(`**Needs you:** ${step.needs_you}`);
+    const notes = step.title ? step.agent_notes : step.text;
+    if (notes) lines.push("", notes.trim());
+    return lines.join("\n");
+  });
+  return `---
+${stringify(meta, YAML_OUT)}---
+
+${steps.join("\n\n")}
+`;
+}
+
+// src/lib/text-diff.ts
+function ops(a, b) {
+  const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) {
+      out.push({ kind: " ", line: a[i], a: i++, b: j++ });
+    } else if (i < a.length && (j >= b.length || lcs[i + 1][j] >= lcs[i][j + 1])) {
+      out.push({ kind: "-", line: a[i], a: i++, b: j });
+    } else {
+      out.push({ kind: "+", line: b[j], a: i, b: j++ });
+    }
+  }
+  return out;
+}
+function unifiedDiff(before, after, label, context = 3) {
+  if (before === after) return "";
+  const all = ops(before.split("\n"), after.split("\n"));
+  const changed = all.map((o, n) => o.kind === " " ? -1 : n).filter((n) => n >= 0);
+  const hunks = [];
+  for (const n of changed) {
+    const start = Math.max(0, n - context);
+    const end = Math.min(all.length - 1, n + context);
+    const last = hunks[hunks.length - 1];
+    if (last && start <= last[1] + 1) last[1] = end;
+    else hunks.push([start, end]);
+  }
+  const lines = [`--- ${label} (in the repo)`, `+++ ${label} (from intentdocs)`];
+  for (const [start, end] of hunks) {
+    const slice = all.slice(start, end + 1);
+    const aLen = slice.filter((o) => o.kind !== "+").length;
+    const bLen = slice.filter((o) => o.kind !== "-").length;
+    lines.push(`@@ -${slice[0].a + 1},${aLen} +${slice[0].b + 1},${bLen} @@`);
+    for (const o of slice) lines.push(`${o.kind}${o.line}`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/pull.ts
+var Files = class _Files {
+  constructor(read) {
+    this.read = read;
+  }
+  changed = /* @__PURE__ */ new Map();
+  get(path) {
+    return this.changed.has(path) ? this.changed.get(path) : this.read(path);
+  }
+  set(path, text) {
+    this.changed.set(path, text);
+  }
+  clone() {
+    const copy = new _Files(this.read);
+    for (const [p, t] of this.changed) copy.set(p, t);
+    return copy;
+  }
+  /** Paths whose text differs from the file on disk. */
+  edits() {
+    return [...this.changed].filter(([p, t]) => this.read(p) !== t);
+  }
+};
+var PullError = class extends Error {
+  constructor(message, details = []) {
+    super(message);
+    this.details = details;
+    this.name = "PullError";
+  }
+};
+var KIND_LABEL = {
+  web: "From intentdocs",
+  clash: "Changed in intentdocs AND in the repo since the last sync",
+  unrecorded: "Differs from intentdocs, with no sync record to say which side changed"
+};
+var STATUSES = /* @__PURE__ */ new Set(["todo", "in_progress", "needs_rework", "done"]);
+function planUnits(deps, response, base, nextBase, outcome) {
+  const intentDir = findIntentDir(deps.cwd);
+  const read = readIntentFolder(deps.cwd);
+  if (!read.ok) throw new PullError(`intent/ needs fixing before a pull (${read.dir}):`, read.errors);
+  const storymapPath = join(intentDir, "storymap.yaml");
+  const statePath = join(intentDir, "state.yaml");
+  const plansDir = join(intentDir, "plans");
+  const today = deps.now().toISOString().slice(0, 10);
+  const files = featureFiles(intentDir);
+  const local = new Map(read.payload.stories.map((s) => [s.key, s]));
+  const storymap = parse(deps.readFile(storymapPath) ?? "");
+  const state = parse(deps.readFile(statePath) ?? "") ?? {};
+  const remoteReleases = new Map((response.releases ?? []).map((r) => [r.number, r.title]));
+  const releaseTitle = (n) => remoteReleases.get(n) ?? storymap.releases?.find((r) => r.number === n)?.title ?? `Release ${n}`;
+  const units = [];
+  for (const [number, title] of remoteReleases) {
+    const mine = storymap.releases?.find((r) => r.number === number)?.title;
+    const was = base.releases[String(number)];
+    const kind = mine === void 0 && was === void 0 ? "web" : classify(mine, title, was);
+    if (kind === null) nextBase.releases[String(number)] = title;
+    else if (kind !== "local") {
+      units.push({
+        title: mine === void 0 ? `New release ${number}: ${title}` : `Release ${number} renamed to "${title}"`,
+        kind,
+        apply: (f) => f.set(storymapPath, setReleaseTitle(f.get(storymapPath), number, title)),
+        record: (b) => b.releases[String(number)] = title
+      });
+    }
+  }
+  for (const activity of response.activities ?? []) {
+    if (!activity.ref?.startsWith("nikos:")) continue;
+    const id = activity.ref.slice("nikos:".length);
+    const mine = storymap.activities?.find((a) => a.id === id)?.title;
+    if (mine === void 0) continue;
+    const kind = classify(mine, activity.title, base.activities[id]);
+    if (kind === null) nextBase.activities[id] = activity.title;
+    else if (kind !== "local") {
+      units.push({
+        title: `Activity ${id} renamed to "${activity.title}"`,
+        kind,
+        apply: (f) => f.set(storymapPath, setActivityTitle(f.get(storymapPath), id, activity.title)),
+        record: (b) => b.activities[id] = activity.title
+      });
+    }
+  }
+  const live = response.stories.filter((s) => s.key);
+  outcome.cancelled = live.filter((s) => s.cancelled_at && files.has(s.key)).map((s) => s.key);
+  for (const story of live.filter((s) => !s.cancelled_at)) {
+    const key = story.key;
+    const theirs = specOfStory(story, storymap.activities ?? []);
+    const mine = local.get(key);
+    const path = files.get(key);
+    if (mine && path) {
+      const kind = classify(specOfPushStory(mine), theirs, base.stories[key]);
+      if (kind === null) nextBase.stories[key] = theirs;
+      else if (kind === "local") outcome.localOnly.push(key);
+      else units.push(storyUnit(key, path, mine, theirs, story, kind));
+    } else if (!mine) {
+      units.push(newStoryUnit(key, theirs, story));
+    }
+  }
+  function placeIn(f, key, theirs, story) {
+    let map = f.get(storymapPath);
+    map = ensureActivity(map, theirs.activity, story.activity);
+    map = placeStory(map, key, theirs.release, releaseTitle(theirs.release));
+    f.set(storymapPath, map);
+  }
+  function storyUnit(key, path, mine, theirs, story, kind) {
+    return {
+      title: `${key} ${theirs.title}`,
+      kind,
+      apply: (f) => {
+        f.set(path, renderFeature(f.get(path), theirs));
+        if (mine.release !== theirs.release || mine.activity_id !== theirs.activity) placeIn(f, key, theirs, story);
+      },
+      record: (b) => b.stories[key] = theirs
+    };
+  }
+  function newStoryUnit(key, theirs, story) {
+    const dir = join(intentDir, "features", theirs.activity);
+    const name = slug(theirs.title);
+    const path = deps.readFile(join(dir, `${name}.feature`)) === null ? join(dir, `${name}.feature`) : join(dir, `${name}-${key.toLowerCase()}.feature`);
+    const status = STATUSES.has(story.status) ? story.status : "todo";
+    return {
+      title: `New story ${key} ${theirs.title}`,
+      kind: "web",
+      apply: (f) => {
+        f.set(path, newFeature(key, theirs));
+        placeIn(f, key, theirs, story);
+        f.set(statePath, setState(f.get(statePath), key, { status, updated: today }));
+        if (story.agent_plan) writePlan(f, key, path, story, story.agent_plan);
+      },
+      record: (b) => {
+        b.stories[key] = theirs;
+        b.statuses[key] = status;
+        if (story.agent_plan) b.plans[key] = story.agent_plan.version;
+      }
+    };
+  }
+  function writePlan(f, key, featurePath, story, plan) {
+    const existing = planVersions(deps.listDir(plansDir), key);
+    let next = (existing[existing.length - 1] ?? 0) + 1;
+    while (f.get(join(plansDir, `${key}.v${next}.md`)) !== null) next++;
+    const criteria = parseFeature(f.get(featurePath) ?? "")?.criteria ?? [];
+    const textOf = new Map(story.acceptance_criteria.map((c) => [c.id, c.text.trim()]));
+    const labelOf = (id) => criteria.find((c) => c.text.trim() === textOf.get(id))?.label || void 0;
+    f.set(join(plansDir, `${key}.v${next}.md`), renderPlan(key, next, plan, labelOf, today));
+    f.set(statePath, setState(f.get(statePath), key, { plan_version: next }));
+  }
+  const statusChanges = [];
+  const notMoved = [];
+  for (const s of live.filter((s2) => !s2.cancelled_at && STATUSES.has(s2.status) && state.stories?.[s2.key])) {
+    const key = s.key;
+    const mine = state.stories[key].status ?? "todo";
+    const was = base.statuses[key];
+    if (mine === s.status) nextBase.statuses[key] = s.status;
+    else if (was === s.status || was === void 0 && s.status === "todo") {
+      nextBase.statuses[key] = s.status;
+      notMoved.push(`${key} (${mine} here)`);
+    } else statusChanges.push({ key, from: mine, to: s.status });
+  }
+  outcome.statusNotMoved = notMoved;
+  if (statusChanges.length) {
+    units.push({
+      title: `Statuses: ${statusChanges.map((c) => `${c.key} ${c.from} \u2192 ${c.to}`).join(", ")}`,
+      kind: "web",
+      apply: (f) => {
+        let text = f.get(statePath);
+        for (const c of statusChanges) text = setState(text, c.key, { status: c.to, updated: today });
+        f.set(statePath, text);
+      },
+      record: (b) => {
+        for (const c of statusChanges) b.statuses[c.key] = c.to;
+      }
+    });
+  }
+  for (const story of live.filter((s) => !s.cancelled_at && s.agent_plan && files.has(s.key) && local.has(s.key))) {
+    const key = story.key;
+    const plan = story.agent_plan;
+    if ((base.plans[key] ?? 0) >= plan.version) continue;
+    const versions = planVersions(deps.listDir(plansDir), key);
+    const latest = versions[versions.length - 1];
+    const path = files.get(key);
+    const preview = new Files(deps.readFile);
+    writePlan(preview, key, path, story, plan);
+    const drafted = preview.edits().find(([p]) => p.startsWith(plansDir))?.[1] ?? "";
+    const current = latest ? deps.readFile(join(plansDir, `${key}.v${latest}.md`)) : null;
+    if (current && planBody(current) === planBody(drafted)) {
+      nextBase.plans[key] = plan.version;
+      continue;
+    }
+    units.push({
+      title: `Plan for ${key}: intentdocs plan v${plan.version} as ${key}.v${(latest ?? 0) + 1}.md`,
+      kind: "web",
+      apply: (f) => writePlan(f, key, path, story, plan),
+      record: (b) => b.plans[key] = plan.version
+    });
+  }
+  return units;
+}
+async function runPull(deps) {
+  const response = await deps.listStories();
+  const base = deps.readSyncBase();
+  const nextBase = structuredClone(base);
+  const outcome = { units: [], written: [], localOnly: [], cancelled: [], statusNotMoved: [] };
+  outcome.units = planUnits(deps, response, base, nextBase, outcome);
+  const disk = new Files(deps.readFile);
+  for (const unit of outcome.units) {
+    deps.log(`
+${KIND_LABEL[unit.kind]}: ${unit.title}`);
+    const preview = disk.clone();
+    unit.apply(preview);
+    for (const [path, after] of preview.edits()) {
+      const rel = relative(deps.cwd, path);
+      const before = deps.readFile(path);
+      deps.log(before === null ? `+++ ${rel} (new file)
+${after.trimEnd().split("\n").map((l) => `+${l}`).join("\n")}` : unifiedDiff(before, after, rel));
+    }
+  }
+  if (outcome.localOnly.length) deps.log(`
+Changed only in the repo, so nothing to pull: ${outcome.localOnly.join(", ")}. \`intentdocs push\` sends them.`);
+  if (outcome.statusNotMoved.length)
+    deps.log(`
+intentdocs hasn't moved these since the last sync, so their status here is kept: ${outcome.statusNotMoved.join(", ")}.`);
+  if (outcome.cancelled.length) deps.log(`Cancelled in intentdocs, left as they are here: ${outcome.cancelled.join(", ")}.`);
+  const safe = outcome.units.filter((u) => u.kind === "web");
+  const risky = outcome.units.filter((u) => u.kind !== "web");
+  const apply = /* @__PURE__ */ new Set();
+  if (outcome.units.length === 0) {
+    if (!outcome.localOnly.length && !outcome.statusNotMoved.length) deps.log("\nThe repo already matches intentdocs.");
+  } else if (deps.yes) {
+    for (const u of safe) apply.add(u);
+    if (risky.length) deps.log(`
+--yes doesn't settle: ${risky.map((u) => u.title).join("; ")}. Run \`intentdocs pull\` in a terminal to choose.`);
+  } else if (!deps.interactive) {
+    deps.log("\nNothing written. Run `intentdocs pull` in a terminal to choose, or `intentdocs pull --yes` once you've agreed to the changes above.");
+  } else {
+    if (safe.length) {
+      const pick = await deps.choose(`Write ${safe.length === 1 ? "this change" : `these ${safe.length} changes`} from intentdocs?`, [
+        "Write nothing",
+        `Write ${safe.length === 1 ? "it" : `all ${safe.length}`}`,
+        "Choose one by one"
+      ]);
+      if (pick === 1) for (const u of safe) apply.add(u);
+      if (pick === 2) {
+        for (const u of safe) if (await deps.confirm(`Write: ${u.title}?`)) apply.add(u);
+      }
+    }
+    for (const u of risky) {
+      if (await deps.confirm(`${u.title}: replace the repo's version with intentdocs' (your local edits to it are lost)?`)) apply.add(u);
+    }
+  }
+  const result = new Files(deps.readFile);
+  for (const unit of outcome.units.filter((u) => apply.has(u))) {
+    unit.apply(result);
+    unit.record(nextBase);
+  }
+  for (const [path, text] of result.edits()) {
+    deps.writeFile(path, text);
+    outcome.written.push(relative(deps.cwd, path));
+  }
+  deps.writeSyncBase(nextBase);
+  if (outcome.written.length) deps.log(`
+\u2713 Wrote ${outcome.written.join(", ")}`);
+  else if (outcome.units.length) deps.log("\nNothing was written.");
+  return outcome;
+}
+async function pull(opts = {}) {
+  const config = requireConfig();
+  try {
+    await runPull({
+      cwd: process.cwd(),
+      listStories: () => listStories(config),
+      readSyncBase,
+      writeSyncBase,
+      readFile: (p) => existsSync(p) ? readFileSync(p, "utf-8") : null,
+      writeFile: (p, t) => {
+        mkdirSync(dirname(p), { recursive: true });
+        writeFileSync(p, t);
+      },
+      listDir: (p) => existsSync(p) ? readdirSync(p) : [],
+      interactive: isInteractive(),
+      yes: opts.yes ?? false,
+      choose,
+      confirm,
+      log: (line) => console.log(line),
+      now: () => /* @__PURE__ */ new Date()
+    });
+  } catch (err) {
+    if (err instanceof PullError) {
+      console.error(`\u2717 ${err.message}`);
+      for (const d of err.details) console.error(`  - ${d}`);
+    } else {
+      console.error(`\u2717 Pull failed: ${err.message}`);
+    }
+    process.exitCode = 1;
+  } finally {
+    closePrompt();
+  }
+}
+export {
+  PullError,
+  pull,
+  runPull
+};

package/dist/push-7LJ654MJ.js

@@ -0,0 +1,220 @@
+import {
+  login
+} from "./chunk-64I7RLP3.js";
+import {
+  checkoutMismatch
+} from "./chunk-KTGQO3AE.js";
+import {
+  checkoutConfig,
+  readConfig,
+  readIntentFolder,
+  readSyncBase,
+  specOfPushStory,
+  writeConfig,
+  writeSyncBase
+} from "./chunk-RGFGTIIH.js";
+import {
+  choose,
+  closePrompt,
+  isInteractive
+} from "./chunk-WRRUCCVZ.js";
+import {
+  authenticatedFetch,
+  getAuth
+} from "./chunk-XZE2XP6O.js";
+import "./chunk-UYTVTYNB.js";
+
+// src/commands/push.ts
+import { exec } from "child_process";
+
+// src/lib/push-api.ts
+var PUSH_ENDPOINTS = {
+  listWorkspaces: "/api/cli/workspaces",
+  createPersonalWorkspace: "/api/cli/workspaces/personal",
+  createProject: "/api/cli/push",
+  updateProject: (projectId) => `/api/cli/push/${encodeURIComponent(projectId)}`,
+  projectMaps: (projectId) => `/api/cli/projects/${encodeURIComponent(projectId)}/maps`
+};
+var PushApiError = class extends Error {
+  constructor(message, status, code = null, problems = [], projectId = null) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.problems = problems;
+    this.projectId = projectId;
+    this.name = "PushApiError";
+  }
+};
+async function call(fetcher, path, init, what) {
+  const res = await fetcher(path, init);
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    const nested = typeof body.error === "object" && body.error ? body.error : null;
+    const said = body.message ?? (nested ? nested.hint ?? nested.message : void 0);
+    throw new PushApiError(
+      said ?? `Couldn't ${what} (the server returned ${res.status}).`,
+      res.status,
+      typeof body.error === "string" ? body.error : null,
+      Array.isArray(body.problems) ? body.problems : [],
+      body.project_id ?? null
+    );
+  }
+  return await res.json();
+}
+var json = (method, body) => body === void 0 ? { method } : { method, headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) };
+function pushApi(fetcher = authenticatedFetch) {
+  return {
+    listWorkspaces: () => call(fetcher, PUSH_ENDPOINTS.listWorkspaces, json("GET"), "list your workspaces").then((r) => r.workspaces),
+    createPersonalWorkspace: () => call(fetcher, PUSH_ENDPOINTS.createPersonalWorkspace, json("POST"), "open your personal workspace").then(
+      (r) => r.workspace
+    ),
+    createProject: (workspaceId, payload) => call(fetcher, PUSH_ENDPOINTS.createProject, json("POST", { workspace_id: workspaceId, intent: payload }), "create the project"),
+    updateProject: (projectId, mapId, payload) => call(fetcher, PUSH_ENDPOINTS.updateProject(projectId), json("PUT", { map_id: mapId, intent: payload }), "update the project"),
+    /** The project's story maps, newest first. */
+    projectMaps: (projectId) => call(fetcher, PUSH_ENDPOINTS.projectMaps(projectId), json("GET"), "find the project's story map").then(
+      (r) => r.maps
+    )
+  };
+}
+
+// src/commands/push.ts
+var PushError = class extends Error {
+  constructor(message, details = []) {
+    super(message);
+    this.details = details;
+    this.name = "PushError";
+  }
+};
+function summary(p) {
+  const criteria = p.stories.reduce((n, s) => n + s.criteria.length, 0);
+  return `${p.stories.length} stories, ${criteria} criteria, ${p.releases.length} releases, ${p.plans.length} plans, ${p.decisions.length} decisions`;
+}
+async function pickWorkspace(deps, auth) {
+  const workspaces = await deps.api.listWorkspaces();
+  if (auth.binding) {
+    const { orgId, workspaceName } = auth.binding;
+    return workspaces.find((w) => w.orgId === orgId) ?? { id: orgId, orgId, name: workspaceName ?? null, personal: false };
+  }
+  if (workspaces.length === 0) return deps.api.createPersonalWorkspace();
+  if (workspaces.length === 1) return workspaces[0];
+  const personal = Math.max(0, workspaces.findIndex((w) => w.personal));
+  return workspaces[await deps.chooseWorkspace(workspaces, personal)] ?? workspaces[personal];
+}
+function pushNotes(result) {
+  const notes = [];
+  const statuses = result.ignored?.statuses ?? 0;
+  if (statuses > 0) {
+    notes.push(
+      `${statuses} story ${statuses === 1 ? "status was" : "statuses were"} not applied: intentdocs sets status itself. New stories start as To do, existing ones keep theirs, and they move through build and acceptance in intentdocs.`
+    );
+  }
+  const missing = result.summary?.stories?.missing ?? [];
+  if (missing.length) notes.push(`In intentdocs but not in intent/: ${missing.join(", ")}. Push never deletes, so they stay.`);
+  if (result.not_stored?.length) notes.push(`Not stored by intentdocs yet: ${result.not_stored.join(", ")}. They stay in intent/.`);
+  return notes;
+}
+async function runPush(deps) {
+  const read = readIntentFolder(deps.cwd);
+  if (!read.ok) throw new PushError(`intent/ can't be pushed yet (${read.dir}):`, read.errors);
+  const payload = read.payload;
+  let auth = deps.getAuth();
+  if (!auth) {
+    deps.log("You need to log in first. Opening the browser\u2026");
+    await deps.login();
+    auth = deps.getAuth();
+    if (!auth) throw new PushError("Login didn't complete, so nothing was pushed.");
+  }
+  const existing = deps.readConfig();
+  const linked = existing?.projectId && existing.mapId ? { projectId: existing.projectId, mapId: existing.mapId } : null;
+  if (existing) {
+    const mismatch = checkoutMismatch(existing, auth.binding);
+    if (mismatch) throw new PushError(mismatch);
+  }
+  deps.log(`Pushing "${payload.project.name}": ${summary(payload)}`);
+  let workspace = null;
+  let result;
+  let created = !linked;
+  if (linked) {
+    result = await deps.api.updateProject(linked.projectId, linked.mapId, payload);
+  } else {
+    workspace = await pickWorkspace(deps, auth);
+    try {
+      result = await deps.api.createProject(workspace.id, payload);
+    } catch (err) {
+      if (!(err instanceof PushApiError && err.code === "ALREADY_PUSHED" && err.projectId)) throw err;
+      const [map] = await deps.api.projectMaps(err.projectId);
+      if (!map) throw err;
+      deps.log(`"${payload.project.name}" was pushed before, so this updates that project.`);
+      result = await deps.api.updateProject(err.projectId, map.id, payload);
+      created = false;
+    }
+  }
+  deps.writeConfig({
+    ...existing,
+    ...checkoutConfig({ apiBase: auth.apiBase, project: result.project, map: result.map, appUrl: existing?.appUrl }),
+    lastPushed: deps.now().toISOString()
+  });
+  const base = deps.readSyncBase();
+  for (const story of payload.stories) {
+    base.stories[story.key] = specOfPushStory(story);
+    base.activities[story.activity_id] = story.activity;
+  }
+  for (const release of payload.releases) base.releases[String(release.number)] = release.title;
+  for (const key of result.summary?.stories?.created ?? []) base.statuses[key] = "todo";
+  deps.writeSyncBase(base);
+  deps.openBrowser(result.url);
+  return { result, created, workspace };
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  exec(cmd);
+}
+async function push() {
+  const deps = {
+    cwd: process.cwd(),
+    api: pushApi(),
+    getAuth,
+    login,
+    readConfig,
+    writeConfig,
+    readSyncBase,
+    writeSyncBase,
+    openBrowser,
+    chooseWorkspace: async (workspaces, defaultIndex) => {
+      if (!isInteractive()) return defaultIndex;
+      const order = [defaultIndex, ...workspaces.map((_, i) => i).filter((i) => i !== defaultIndex)];
+      const labels = order.map((i, n) => `${workspaces[i].personal ? "Personal" : workspaces[i].name ?? "Workspace"}${n === 0 ? " (default)" : ""}`);
+      return order[await choose("Which workspace should this project go in?", labels)];
+    },
+    log: (line) => console.log(line),
+    now: () => /* @__PURE__ */ new Date()
+  };
+  try {
+    const { result, created } = await runPush(deps);
+    console.log(`
+\u2713 ${created ? "Created" : "Updated"} "${result.map.title}"${result.project.workspace ? ` in ${result.project.workspace.name ?? "your workspace"}` : ""}`);
+    for (const note of pushNotes(result)) console.log(`  ${note}`);
+    console.log(`  Linked this repo in .intent/config.json \u2014 run \`npx intentdocs push\` again to sync.`);
+    console.log(`  Opening ${result.url}
+`);
+  } catch (err) {
+    if (err instanceof PushError) {
+      console.error(`\u2717 ${err.message}`);
+      for (const d of err.details) console.error(`  - ${d}`);
+    } else if (err instanceof PushApiError) {
+      console.error(`\u2717 ${err.message}`);
+      for (const p of err.problems) console.error(`  - ${p}`);
+    } else {
+      console.error(`\u2717 Push failed: ${err.message}`);
+    }
+    process.exitCode = 1;
+  } finally {
+    closePrompt();
+  }
+}
+export {
+  PushError,
+  push,
+  pushNotes,
+  runPush
+};