intentdocs 0.11.0 → 0.12.1

package/dist/{chunk-65EDM7QH.js → chunk-5GATVQEI.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-KPQ42YE6.js";
 import {
   requireConfig
-} from "./chunk-K5SNF6CG.js";
+} from "./chunk-RGFGTIIH.js";
 import {
   closePrompt,
   confirm,

package/dist/{chunk-ID4B5RZ2.js → chunk-Q6BSSJK5.js}

@@ -5,7 +5,7 @@ import {
   checkoutConfig,
   hasConfig,
   writeConfig
-} from "./chunk-K5SNF6CG.js";
+} from "./chunk-RGFGTIIH.js";
 import {
   ask,
   closePrompt,
@@ -196,7 +196,7 @@ async function scope(projectId) {
     "  Configure your AI tool (Claude Code / Cursor) with intentdocs agent workflows?"
   );
   if (wantSetup) {
-    const { setup } = await import("./setup-UILQVYIB.js");
+    const { setup } = await import("./setup-W4PKG6GB.js");
     await setup();
     return;
   }

package/dist/chunk-RGFGTIIH.js

@@ -0,0 +1,536 @@
+import {
+  canonicalApiBase
+} from "./chunk-UYTVTYNB.js";
+
+// src/lib/intent-folder.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { basename, dirname, join, relative } from "path";
+import { parse } from "yaml";
+var VISION_SECTIONS = ["Users", "Problem", "Switch", "First", "Proof"];
+var STORY_ID = /^[A-Z][A-Z0-9]{0,9}-[0-9]+$/;
+var PRIORITIES = ["must", "should", "could", "wont"];
+var STATUS = { todo: "todo", in_progress: "in_progress", needs_rework: "needs_rework", done: "dev_complete" };
+function findIntentDir(start) {
+  return existsSync(join(start, "storymap.yaml")) ? start : join(start, "intent");
+}
+function walk(dir, ext) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).sort().flatMap((f) => {
+    const p = join(dir, f);
+    if (statSync(p).isDirectory()) return walk(p, ext);
+    return p.endsWith(ext) ? [p] : [];
+  });
+}
+function frontMatter(text) {
+  const m = /^---\n([\s\S]*?)\n---\n?/.exec(text);
+  if (!m) return null;
+  const meta = parse(m[1]) ?? {};
+  return { meta, body: text.slice(m[0].length) };
+}
+function sections(body) {
+  return [...body.matchAll(/^## (.+)\n([\s\S]*?)(?=^## |(?![\s\S]))/gm)].map((s) => ({ title: s[1].trim(), text: s[2].trim() }));
+}
+function tagsOf(line) {
+  return line.trim().split(/\s+/).filter((t) => t.startsWith("@")).map((t) => t.slice(1));
+}
+var EFFORTS = ["XS", "S", "M", "L", "XL"];
+function effortOf(tags) {
+  const tag = tags.find((t) => t.startsWith("effort-"))?.slice("effort-".length).toUpperCase();
+  if (!tag) return null;
+  return EFFORTS.includes(tag) ? tag : "M";
+}
+function priorityOf(tags) {
+  return tags.find((t) => PRIORITIES.includes(t)) ?? null;
+}
+function featureFiles(intentDir) {
+  const files = /* @__PURE__ */ new Map();
+  for (const path of walk(join(intentDir, "features"), ".feature")) {
+    const parsed = parseFeature(readFileSync(path, "utf-8"));
+    const key = parsed?.tags.find((t) => /^[A-Z][A-Z0-9]*-\d+$/.test(t));
+    if (key && !files.has(key)) files.set(key, path);
+  }
+  return files;
+}
+function stepsSentence(steps) {
+  return steps.map(({ keyword, text }, i) => {
+    const k = keyword.toLowerCase();
+    if (k === "and" || k === "but") return `${k} ${text}`;
+    return i === 0 ? `${keyword} ${text}` : `, ${k} ${text}`;
+  }).join(" ").replace(/ ,/g, ",");
+}
+function parseFeature(text) {
+  const lines = text.split("\n");
+  const featureAt = lines.findIndex((l) => l.trim().startsWith("Feature:"));
+  if (featureAt < 0) return null;
+  const tags = lines.slice(0, featureAt).flatMap(tagsOf);
+  const title = lines[featureAt].trim().slice("Feature:".length).trim();
+  let asA = "";
+  let iWant = "";
+  let soThat = "";
+  const criteria = [];
+  let pendingTags = [];
+  let current = null;
+  const flush = () => {
+    if (current) criteria.push({ label: current.label, title: current.title, text: stepsSentence(current.steps), priority: current.priority });
+    current = null;
+  };
+  for (const raw of lines.slice(featureAt + 1)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("@")) {
+      pendingTags.push(...tagsOf(line));
+      continue;
+    }
+    const scenario = /^Scenario(?: Outline)?:\s*(.*)$/.exec(line);
+    if (scenario) {
+      flush();
+      const name = scenario[1].trim();
+      const label = pendingTags.find((t) => /^AC\d+$/.test(t)) ?? /^(AC\d+)\b/.exec(name)?.[1] ?? "";
+      current = { label, title: name.replace(/^AC\d+\s*[—–-]\s*/, ""), priority: priorityOf(pendingTags), steps: [] };
+      pendingTags = [];
+      continue;
+    }
+    const step = /^(Given|When|Then|And|But)\s+(.*)$/.exec(line);
+    if (step && current) {
+      current.steps.push({ keyword: step[1], text: step[2] });
+      continue;
+    }
+    if (!current) {
+      const story = /^(As (?:a|an|the)\b.*|I want\b.*|So that\b.*)$/i.exec(line);
+      if (story) {
+        const s = story[1];
+        if (/^as /i.test(s)) asA = s.replace(/^As (a|an|the)\s+/i, "");
+        else if (/^i want/i.test(s)) iWant = s.replace(/^I want( to)?\s+/i, "");
+        else soThat = s.replace(/^So that\s+/i, "");
+      }
+    }
+  }
+  flush();
+  return { tags, title, asA, iWant, soThat, criteria };
+}
+function parsePlanSteps(body) {
+  return sections(body).map(({ title, text }) => {
+    const field = (name) => new RegExp(`^\\*\\*${name}:\\*\\*\\s*(.*)$`, "m").exec(text)?.[1]?.trim() ?? "";
+    const list = (name) => field(name).split(",").map((s) => s.trim()).filter(Boolean);
+    const notes = text.split("\n").filter((l) => !/^\*\*(Why|Criteria|Files|Tests|Needs you):\*\*/.test(l.trim())).join("\n").trim();
+    const needs = field("Needs you");
+    return {
+      title: title.replace(/^\d+\.\s*/, ""),
+      why: field("Why"),
+      criteria: list("Criteria"),
+      files: list("Files"),
+      tests: list("Tests"),
+      needs_you: needs ? { question: needs } : null,
+      agent_notes: notes
+    };
+  });
+}
+function parseDecisions(text) {
+  const uncommented = text.replace(/<!--[\s\S]*?-->/g, "");
+  return sections(uncommented).map(({ title, text: body }) => {
+    const heading = /^(\d{4}-\d{2}-\d{2})\s*[—–-]\s*(.*?)(?:\s+\(([A-Z][A-Z0-9]{0,9}-\d+)\))?$/.exec(title);
+    const category = /^\*\*Category:\*\*\s*(.*)$/m.exec(body)?.[1]?.trim() ?? "architecture";
+    const description = body.split("\n").filter((l) => !/^\*\*(Category|Supersedes):\*\*/.test(l.trim())).join("\n").trim();
+    return {
+      title: heading?.[2] ?? title,
+      description,
+      category,
+      date: heading?.[1] ?? "",
+      story: heading?.[3] ?? null
+    };
+  });
+}
+function readIntentFolder(start) {
+  const dir = findIntentDir(start);
+  const errors = [];
+  const fail = () => ({ ok: false, dir, errors });
+  const file = (name) => join(dir, name);
+  if (!existsSync(dir)) return { ok: false, dir, errors: ["No intent/ folder here. Run `npx nikos init` first, or push from the repo root."] };
+  for (const name of ["constitution.md", "storymap.yaml", "state.yaml"]) {
+    if (!existsSync(file(name))) errors.push(`${name} is missing`);
+  }
+  if (errors.length) return fail();
+  let storymap;
+  let state;
+  try {
+    storymap = parse(readFileSync(file("storymap.yaml"), "utf-8")) ?? {};
+    state = parse(readFileSync(file("state.yaml"), "utf-8")) ?? {};
+  } catch (err) {
+    errors.push(`invalid YAML: ${err.message.split("\n")[0]}`);
+    return fail();
+  }
+  const constitution = frontMatter(readFileSync(file("constitution.md"), "utf-8"));
+  const vision = {};
+  if (!constitution) {
+    errors.push("constitution.md has no front matter (name and idea)");
+  } else {
+    for (const key of ["name", "idea"]) {
+      if (typeof constitution.meta[key] !== "string" || !constitution.meta[key].trim()) errors.push(`constitution.md front matter is missing '${key}'`);
+    }
+    const found = sections(constitution.body);
+    for (const name of VISION_SECTIONS) {
+      const text = found.find((s) => s.title === name)?.text ?? "";
+      if (!text) errors.push(`constitution.md ## ${name} is missing or empty`);
+      vision[name.toLowerCase()] = text;
+    }
+  }
+  if (!storymap.key || !/^[A-Z]{2,5}$/.test(storymap.key)) errors.push("storymap.yaml needs a key of 2\u20135 capital letters, like HT");
+  const activities = new Map((storymap.activities ?? []).map((a) => [a.id, a.title]));
+  const releaseOf = /* @__PURE__ */ new Map();
+  for (const r of storymap.releases ?? []) for (const id of r.stories ?? []) releaseOf.set(id, r.number);
+  const features = /* @__PURE__ */ new Map();
+  for (const path of walk(file("features"), ".feature")) {
+    const where = relative(dir, path);
+    const parsed = parseFeature(readFileSync(path, "utf-8"));
+    if (!parsed) {
+      errors.push(`${where} has no Feature:`);
+      continue;
+    }
+    const ids = parsed.tags.filter((t) => STORY_ID.test(t));
+    if (ids.length !== 1) {
+      errors.push(`${where} needs exactly one story id tag (found ${ids.length})`);
+      continue;
+    }
+    features.set(ids[0], { path, parsed });
+  }
+  const stories = [];
+  for (const [key, release] of releaseOf) {
+    const feature = features.get(key);
+    if (!feature) {
+      errors.push(`${key} is in storymap.yaml but has no feature file`);
+      continue;
+    }
+    const { parsed, path } = feature;
+    const where = relative(dir, path);
+    const activityId = parsed.tags.find((t) => t.startsWith("activity-"))?.slice("activity-".length) ?? basename(dirname(path));
+    const activity = activities.get(activityId);
+    if (!activity) errors.push(`${where}: activity '${activityId}' is not in storymap.yaml`);
+    if (!parsed.asA || !parsed.iWant || !parsed.soThat) errors.push(`${where}: needs "As a / I want / So that" under Feature:`);
+    if (!parsed.criteria.length) errors.push(`${where}: has no scenarios`);
+    for (const c of parsed.criteria) if (!c.label) errors.push(`${where}: scenario "${c.title}" has no @AC label`);
+    const entry = state.stories?.[key];
+    if (!entry) errors.push(`state.yaml has no entry for ${key}`);
+    const status = STATUS[entry?.status ?? "todo"];
+    if (!status) errors.push(`state.yaml ${key} has unknown status '${entry?.status}'`);
+    stories.push({
+      key,
+      title: parsed.title,
+      as_a: parsed.asA,
+      i_want: parsed.iWant,
+      so_that: parsed.soThat,
+      priority: priorityOf(parsed.tags),
+      release,
+      activity: activity ?? activityId,
+      activity_id: activityId,
+      effort: effortOf(parsed.tags),
+      status: status ?? "todo",
+      blockers: entry?.blockers ?? [],
+      claimed_by: entry?.claimed_by ?? null,
+      plan_version: entry?.plan_version ?? null,
+      criteria: parsed.criteria
+    });
+  }
+  for (const key of features.keys()) if (!releaseOf.has(key)) errors.push(`${key} has a feature file but is in no release in storymap.yaml`);
+  const plans = [];
+  for (const path of walk(file("plans"), ".md")) {
+    const m = /^([A-Z][A-Z0-9]{0,9}-\d+)\.v(\d+)\.md$/.exec(basename(path));
+    if (!m) continue;
+    const fm = frontMatter(readFileSync(path, "utf-8"));
+    if (!fm) {
+      errors.push(`plans/${basename(path)} has no front matter`);
+      continue;
+    }
+    plans.push({
+      story: m[1],
+      version: Number(m[2]),
+      summary: typeof fm.meta.summary === "string" ? fm.meta.summary : "",
+      risk: typeof fm.meta.risk === "string" ? fm.meta.risk : null,
+      introduces: Array.isArray(fm.meta.introduces) ? fm.meta.introduces.map(String) : [],
+      steps: parsePlanSteps(fm.body)
+    });
+  }
+  plans.sort((a, b) => a.story.localeCompare(b.story) || a.version - b.version);
+  const decisions = existsSync(file("decisions.md")) ? parseDecisions(readFileSync(file("decisions.md"), "utf-8")) : [];
+  if (errors.length) return fail();
+  return {
+    ok: true,
+    dir,
+    payload: {
+      format_version: 1,
+      project: { name: constitution.meta.name, idea: constitution.meta.idea, key: storymap.key, vision },
+      releases: (storymap.releases ?? []).map((r) => ({ number: r.number, title: r.title ?? `Release ${r.number}`, stories: r.stories ?? [] })),
+      stories,
+      plans,
+      decisions,
+      run_queue: state.run?.queue ?? []
+    }
+  };
+}
+
+// src/lib/pull-feature.ts
+var emptyBase = () => ({ stories: {}, releases: {}, activities: {}, plans: {}, statuses: {} });
+var storyPriority = (p) => p === "must" ? "must" : p === "could" || p === "wont" ? "could" : "should";
+var criterionPriority = (p) => p === "must" ? "must" : "should";
+var effortOrM = (e) => effortOf(e ? [`effort-${e}`] : []) ?? "M";
+var slug = (title) => title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "activity";
+function specOfPushStory(s) {
+  return {
+    title: s.title,
+    as_a: s.as_a,
+    i_want: s.i_want,
+    so_that: s.so_that,
+    priority: storyPriority(s.priority),
+    effort: effortOrM(s.effort),
+    release: s.release,
+    activity: s.activity_id,
+    criteria: s.criteria.map((c) => ({ text: c.text.trim(), priority: criterionPriority(c.priority) }))
+  };
+}
+function userStoryParts(story) {
+  if (story.as_a != null || story.i_want != null || story.so_that != null) {
+    return { as_a: story.as_a ?? "", i_want: story.i_want ?? "", so_that: story.so_that ?? "" };
+  }
+  const m = /^As an? (.*), I want (.*), so that (.*)$/s.exec(story.user_story ?? "");
+  return { as_a: m?.[1] ?? "", i_want: m?.[2] ?? "", so_that: m?.[3] ?? "" };
+}
+function activityIdOf(ref, title, local = []) {
+  if (ref?.startsWith("nikos:")) return ref.slice("nikos:".length);
+  return local.find((a) => a.title === title)?.id ?? slug(title);
+}
+function specOfStory(story, localActivities = []) {
+  return {
+    title: story.title,
+    ...userStoryParts(story),
+    priority: storyPriority(story.priority),
+    effort: effortOrM(story.effort),
+    release: story.release,
+    activity: activityIdOf(story.activity_ref, story.activity, localActivities),
+    criteria: story.acceptance_criteria.filter((c) => !c.cancelled_at).map((c) => ({ text: c.text.trim(), priority: criterionPriority(c.priority) }))
+  };
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function classify(local, remote, base) {
+  if (same(local, remote)) return null;
+  if (base === void 0) return "unrecorded";
+  if (same(local, base)) return "web";
+  if (same(remote, base)) return "local";
+  return "clash";
+}
+function sentenceSteps(text) {
+  const gwt = /^Given (.+?), when (.+?), then (.+)$/is.exec(text);
+  if (gwt) return [{ keyword: "Given", text: gwt[1] }, { keyword: "When", text: gwt[2] }, { keyword: "Then", text: gwt[3] }];
+  const wt = /^When (.+?), then (.+)$/is.exec(text);
+  if (wt) return [{ keyword: "When", text: wt[1] }, { keyword: "Then", text: wt[2] }];
+  return [{ keyword: "Then", text: text.replace(/^then\s+/i, "") }];
+}
+var PRIORITY_TAG = /^@(must|should|could|wont)$/;
+var isTagLine = (l) => l.trim().startsWith("@");
+var isScenario = (l) => /^\s*Scenario(?: Outline)?:/.test(l);
+var indentOf = (l) => /^\s*/.exec(l)[0];
+function withPriority(line, priority, equal) {
+  const tokens = line.trim().split(/\s+/);
+  const at = tokens.findIndex((t) => PRIORITY_TAG.test(t));
+  if (at >= 0) {
+    if (equal(tokens[at].slice(1))) return line;
+    tokens[at] = `@${priority}`;
+  } else {
+    tokens.push(`@${priority}`);
+  }
+  return indentOf(line) + tokens.join(" ");
+}
+function scenarioBlocks(lines) {
+  const blocks = [];
+  let current = [];
+  const close = () => {
+    while (current.length && !current[current.length - 1].trim()) current.pop();
+    if (!current.length) return;
+    const steps = current.map((l) => /^\s*(Given|When|Then|And|But)\s+(.*)$/.exec(l)).filter((m) => !!m).map((m) => ({ keyword: m[1], text: m[2] }));
+    const label = current.join(" ").match(/\bAC(\d+)\b/);
+    blocks.push({ lines: current, sentence: stepsSentence(steps).trim(), label: label ? Number(label[1]) : null });
+    current = [];
+  };
+  for (const line of lines) {
+    const last = [...current].reverse().find((l) => l.trim());
+    if ((isTagLine(line) || isScenario(line)) && last !== void 0 && !isTagLine(last)) close();
+    current.push(line);
+  }
+  close();
+  return blocks;
+}
+function renderFeature(text, remote) {
+  const lines = text.split("\n");
+  const featureAt = lines.findIndex((l) => l.trim().startsWith("Feature:"));
+  if (featureAt < 0) return text;
+  const head = lines.slice(0, featureAt).map((line, n) => {
+    if (!isTagLine(line)) return line;
+    let out2 = line;
+    if (n === lines.findIndex(isTagLine)) {
+      out2 = withPriority(out2, remote.priority, (tag) => storyPriority(tag) === remote.priority);
+      const tokens = out2.trim().split(/\s+/);
+      const at = tokens.findIndex((t) => t.startsWith("@effort-"));
+      if (at >= 0 && effortOrM(tokens[at].slice("@effort-".length)) !== remote.effort) tokens[at] = `@effort-${remote.effort}`;
+      if (at < 0 && remote.effort !== "M") tokens.push(`@effort-${remote.effort}`);
+      const swap = (prefix, value) => {
+        const i = tokens.findIndex((t) => t.startsWith(`@${prefix}`));
+        if (i >= 0 && tokens[i] !== `@${prefix}${value}`) tokens[i] = `@${prefix}${value}`;
+      };
+      swap("release-", String(remote.release));
+      swap("activity-", remote.activity);
+      out2 = indentOf(out2) + tokens.join(" ");
+    }
+    return out2;
+  });
+  const featureLine = lines[featureAt];
+  const parsedTitle = featureLine.trim().slice("Feature:".length).trim();
+  const feature = parsedTitle === remote.title ? featureLine : `${indentOf(featureLine)}Feature: ${remote.title}`;
+  const bodyStart = featureAt + 1;
+  let scenariosAt = lines.findIndex((l, n) => n >= bodyStart && (isScenario(l) || isTagLine(l)));
+  if (scenariosAt < 0) scenariosAt = lines.length;
+  const intro = lines.slice(bodyStart, scenariosAt).map((line) => {
+    const as = /^(\s*)As (a|an|the)\s+(.*)$/i.exec(line);
+    if (as) return as[3] === remote.as_a ? line : `${as[1]}As ${as[2]} ${remote.as_a}`;
+    const want = /^(\s*)I want( to)?\s+(.*)$/i.exec(line);
+    if (want) return want[3] === remote.i_want ? line : `${want[1]}I want${want[2] ?? ""} ${remote.i_want}`;
+    const so = /^(\s*)So that\s+(.*)$/i.exec(line);
+    if (so) return so[2] === remote.so_that ? line : `${so[1]}So that ${remote.so_that}`;
+    return line;
+  });
+  while (intro.length && !intro[intro.length - 1].trim()) intro.pop();
+  const blocks = scenarioBlocks(lines.slice(scenariosAt));
+  const scenarioIndent = indentOf(blocks[0]?.lines.find(isScenario) ?? "  Scenario:") || "  ";
+  const stepIndent = scenarioIndent + "  ";
+  let nextLabel = Math.max(0, ...blocks.map((b) => b.label ?? 0)) + 1;
+  const used = /* @__PURE__ */ new Set();
+  const rendered = remote.criteria.map((criterion) => {
+    const kept = blocks.find((b) => !used.has(b) && b.sentence === criterion.text);
+    if (kept) {
+      used.add(kept);
+      const tagAt = kept.lines.findIndex(isTagLine);
+      if (tagAt < 0) return kept.lines.join("\n");
+      const out2 = [...kept.lines];
+      out2[tagAt] = withPriority(out2[tagAt], criterion.priority, (tag) => criterionPriority(tag) === criterion.priority);
+      return out2.join("\n");
+    }
+    const label = nextLabel++;
+    const steps = sentenceSteps(criterion.text);
+    const then = steps[steps.length - 1].text;
+    return [
+      `${scenarioIndent}@AC${label} @${criterion.priority}`,
+      `${scenarioIndent}Scenario: AC${label} \u2014 ${then.charAt(0).toUpperCase()}${then.slice(1)}`,
+      ...steps.map((s) => `${stepIndent}${s.keyword} ${s.text}`)
+    ].join("\n");
+  });
+  const top = [...head, feature, ...intro].join("\n");
+  const out = rendered.length ? `${top}
+
+${rendered.join("\n\n")}` : top;
+  return text.endsWith("\n") ? `${out}
+` : out;
+}
+function newFeature(key, remote) {
+  const tags = [`@${key}`, `@release-${remote.release}`, `@${remote.priority}`, `@activity-${remote.activity}`, `@effort-${remote.effort}`];
+  const scenarios = remote.criteria.map((c, i) => {
+    const steps = sentenceSteps(c.text);
+    const then = steps[steps.length - 1].text;
+    return [
+      `  @AC${i + 1} @${c.priority}`,
+      `  Scenario: AC${i + 1} \u2014 ${then.charAt(0).toUpperCase()}${then.slice(1)}`,
+      ...steps.map((st) => `    ${st.keyword} ${st.text}`)
+    ].join("\n");
+  });
+  const head = [tags.join(" "), `Feature: ${remote.title}`, "", `  As a ${remote.as_a}`, `  I want ${remote.i_want}`, `  So that ${remote.so_that}`].join("\n");
+  return `${[head, ...scenarios].join("\n\n")}
+`;
+}
+
+// src/lib/config.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+function checkoutConfig(input) {
+  return {
+    apiBase: input.apiBase,
+    mapTitle: input.map.title,
+    projectId: input.project.id,
+    mapId: input.map.id,
+    workspace: input.project.workspace ? { orgId: input.project.workspace.orgId, name: input.project.workspace.name } : { orgId: null, name: null },
+    ...input.appUrl && { appUrl: input.appUrl }
+  };
+}
+var CONFIG_DIR = ".intent";
+var CONFIG_FILE = "config.json";
+function configPath() {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = join2(dir, CONFIG_DIR, CONFIG_FILE);
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join2(process.cwd(), CONFIG_DIR, CONFIG_FILE);
+}
+function hasConfig() {
+  return existsSync2(configPath());
+}
+function readConfig() {
+  try {
+    const raw = readFileSync2(configPath(), "utf-8");
+    const config = JSON.parse(raw);
+    return config.apiBase ? { ...config, apiBase: canonicalApiBase(config.apiBase) } : config;
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  const existing = existsSync2(configPath()) ? configPath() : null;
+  const dir = existing ? dirname2(existing) : join2(process.cwd(), CONFIG_DIR);
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join2(dir, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+}
+var SYNC_BASE_FILE = "sync-base.json";
+function readSyncBase() {
+  try {
+    return { ...emptyBase(), ...JSON.parse(readFileSync2(join2(dirname2(configPath()), SYNC_BASE_FILE), "utf-8")) };
+  } catch {
+    return emptyBase();
+  }
+}
+function writeSyncBase(base) {
+  const dir = dirname2(configPath());
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join2(dir, SYNC_BASE_FILE), JSON.stringify(base, null, 2) + "\n");
+}
+function requireConfig() {
+  const config = readConfig();
+  if (!config) {
+    console.error("Not initialized. Run: npx intentdocs init");
+    process.exit(1);
+  }
+  if (!config.mapId) {
+    console.error(
+      "This checkout was connected with a sync token, which has been retired: every sync now runs as you.\nRemove .intent/config.json and run `npx intentdocs login` then `npx intentdocs init` to reconnect."
+    );
+    process.exit(1);
+  }
+  return config;
+}
+
+export {
+  findIntentDir,
+  featureFiles,
+  parseFeature,
+  readIntentFolder,
+  slug,
+  specOfPushStory,
+  specOfStory,
+  classify,
+  renderFeature,
+  newFeature,
+  checkoutConfig,
+  hasConfig,
+  readConfig,
+  writeConfig,
+  readSyncBase,
+  writeSyncBase,
+  requireConfig
+};

package/dist/{chunk-IORMKLAQ.js → chunk-SDXDVNNP.js}

@@ -13,7 +13,7 @@ import {
 import {
   hasConfig,
   requireConfig
-} from "./chunk-K5SNF6CG.js";
+} from "./chunk-RGFGTIIH.js";
 import {
   choose,
   closePrompt

package/dist/{ci-NOCV3XUV.js → ci-CWPLSRCQ.js}

@@ -1,8 +1,8 @@
 import {
   ci
-} from "./chunk-65EDM7QH.js";
+} from "./chunk-5GATVQEI.js";
 import "./chunk-KPQ42YE6.js";
-import "./chunk-K5SNF6CG.js";
+import "./chunk-RGFGTIIH.js";
 import "./chunk-WRRUCCVZ.js";
 import "./chunk-XZE2XP6O.js";
 import "./chunk-UYTVTYNB.js";

package/dist/{complexity-OJVM37NF.js → complexity-HLJTXY55.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-KTGQO3AE.js";
 import {
   requireConfig
-} from "./chunk-K5SNF6CG.js";
+} from "./chunk-RGFGTIIH.js";
 import "./chunk-XZE2XP6O.js";
 import "./chunk-UYTVTYNB.js";
 

package/dist/{import-prd-5FCVXCYO.js → import-prd-FQI4J45M.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-KTGQO3AE.js";
 import {
   requireConfig
-} from "./chunk-K5SNF6CG.js";
+} from "./chunk-RGFGTIIH.js";
 import {
   closePrompt,
   confirm