intentdocs 0.8.0 → 0.10.1

package/README.md

@@ -98,6 +98,11 @@ intent sync          # Refresh INTENT.md
 intent sync --context  # Regenerate CLAUDE.md from your project page
 ```
 
+`intent` is a short alias for typing. Another tool on your machine may also be
+called `intent`, so everything the CLI writes for your agent (CLAUDE.md, slash
+commands, hints) spells commands as `npx intentdocs …`, which always runs this
+package.
+
 ---
 
 ## All Commands
@@ -106,8 +111,9 @@ intent sync --context  # Regenerate CLAUDE.md from your project page
 
 | Command | Description |
 |---|---|
-| `intent login` | Authenticate (opens browser) |
+| `intent login` | Authenticate (opens browser) — choose the workspace the token is bound to |
 | `intent logout` | Log out |
+| `intent projects` | List the projects your token can reach — the whole workspace it is bound to |
 | `intent init` | Connect project directory to a story map + generate CLAUDE.md |
 | `intent setup` | Configure Claude Code / Cursor with slash commands |
 | `intent sync` | Refresh `INTENT.md` with latest stories |

package/bin/intentdocs.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/chunk-34JCN66H.js

@@ -0,0 +1,170 @@
+import {
+  getAuth
+} from "./chunk-XZE2XP6O.js";
+
+// src/lib/api.ts
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+function checkoutMismatch(config, binding) {
+  const checkout = config.workspace;
+  if (!checkout || !checkout.orgId) return null;
+  const checkoutName = checkout.name ?? "another workspace";
+  const here = config.mapTitle ? `"${config.mapTitle}"` : "this checkout";
+  if (!binding) {
+    return `${here} belongs to ${checkoutName}, but your token is personal. Run \`npx intentdocs login\` and choose ${checkoutName}.`;
+  }
+  if (binding.orgId !== checkout.orgId) {
+    const bound = binding.workspaceName ?? "a different workspace";
+    return `This checkout is ${checkoutName}'s \u2014 ${here} \u2014 but your token is bound to ${bound}. Run \`npx intentdocs login\` and choose ${checkoutName}, or work from a checkout of ${bound}'s.`;
+  }
+  return null;
+}
+function syncHeaders(init, auth = getAuth()) {
+  const headers = {};
+  if (init) {
+    new Headers(init).forEach((value, key) => {
+      headers[key] = value;
+    });
+  }
+  if (auth?.token) headers["Authorization"] = `Bearer ${auth.token}`;
+  return headers;
+}
+async function refusalMessage(res) {
+  try {
+    const body = await res.clone().json();
+    if (typeof body.message === "string") return body.message;
+    if (body.error && typeof body.error === "object") return body.error.hint ?? body.error.message ?? null;
+  } catch {
+  }
+  return null;
+}
+async function apiFetch(config, path, init) {
+  const auth = getAuth();
+  const mismatch = checkoutMismatch(config, auth?.binding);
+  if (mismatch) throw new AuthError(mismatch);
+  if (!auth?.token) {
+    throw new AuthError("Not logged in \u2014 every sync runs as you now. Run `npx intentdocs login`.");
+  }
+  const withBearer = { ...init, headers: syncHeaders(init?.headers, auth) };
+  const res = await fetch(apiUrl(config, path), withBearer);
+  if (res.status === 401) {
+    const said = await refusalMessage(res);
+    throw new AuthError(said ?? "Your login is no longer valid. Run `npx intentdocs login`.");
+  }
+  if (res.status === 404) {
+    const said = await refusalMessage(res);
+    if (said) throw new AuthError(said);
+  }
+  if (res.status === 403) {
+    const said = await refusalMessage(res);
+    throw new AuthError(
+      said ?? "Access denied \u2014 you may not have permission for this project. Run `npx intentdocs login` to re-authenticate."
+    );
+  }
+  if (!res.ok) throw new Error(`API error: ${res.status}`);
+  return res;
+}
+function apiUrl(config, path) {
+  if (!config.mapId) {
+    throw new AuthError("This checkout has no map id. Run `npx intentdocs init` to reconnect it.");
+  }
+  return `${config.apiBase}/api/sync/${config.mapId}${path}`;
+}
+async function listStories(config) {
+  const res = await apiFetch(config, "/stories");
+  return res.json();
+}
+async function getContext(config) {
+  const res = await apiFetch(config, "/context");
+  return res.text();
+}
+async function updateStories(config, stories) {
+  const res = await apiFetch(config, "/stories", {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ stories })
+  });
+  return res.json();
+}
+async function uploadScreenshot(config, storyId, screenshot) {
+  try {
+    const form = new FormData();
+    form.append("story_id", storyId);
+    form.append(
+      "image",
+      new Blob([Uint8Array.from(screenshot.buffer)], { type: screenshot.mimeType }),
+      screenshot.filename
+    );
+    const res = await apiFetch(config, "/screenshots", {
+      method: "POST",
+      body: form
+    });
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function createStories(config, stories) {
+  const res = await apiFetch(config, "/stories", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ stories })
+  });
+  return res.json();
+}
+async function reportCriteria(config, storyId, results) {
+  const res = await apiFetch(config, "/criteria", {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ story_id: storyId, results })
+  });
+  return res.json();
+}
+async function raiseBlocker(config, payload) {
+  const res = await apiFetch(config, "/blocker", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  return res.json();
+}
+async function listDecisions(config) {
+  const res = await apiFetch(config, "/decisions");
+  return res.json();
+}
+async function amendDecision(config, decisionId, fields) {
+  const res = await apiFetch(config, `/decisions/${decisionId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(fields)
+  });
+  return res.json();
+}
+async function retractDecision(config, decisionId, reason) {
+  const res = await apiFetch(config, `/decisions/${decisionId}`, {
+    method: "DELETE",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ reason })
+  });
+  return res.json();
+}
+
+export {
+  syncHeaders,
+  apiFetch,
+  apiUrl,
+  listStories,
+  getContext,
+  updateStories,
+  uploadScreenshot,
+  createStories,
+  reportCriteria,
+  raiseBlocker,
+  listDecisions,
+  amendDecision,
+  retractDecision
+};

package/dist/chunk-6X4BORMW.js

@@ -0,0 +1,317 @@
+import {
+  captureCli,
+  shutdownCliAnalytics
+} from "./chunk-KPQ42YE6.js";
+import {
+  requireConfig
+} from "./chunk-JX2RLGOM.js";
+import {
+  closePrompt,
+  confirm,
+  isInteractive
+} from "./chunk-WRRUCCVZ.js";
+import {
+  authenticatedFetch,
+  requireValidAuth
+} from "./chunk-XZE2XP6O.js";
+import {
+  canonicalApiBase
+} from "./chunk-UYTVTYNB.js";
+
+// src/commands/ci.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/ci-workflow.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var CI_SECRET_NAME = "INTENTDOCS_CI_KEY";
+function detectTestRunner(cwd) {
+  try {
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps["vitest"]) return "vitest";
+      if (deps["jest"]) return "jest";
+    }
+    if (existsSync(join(cwd, "pyproject.toml")) || existsSync(join(cwd, "pytest.ini")) || existsSync(join(cwd, "requirements.txt"))) {
+      return "pytest";
+    }
+    if (existsSync(join(cwd, "go.mod"))) return "go";
+  } catch {
+  }
+  return "unknown";
+}
+var JUNIT_ARTIFACT = "test-results.xml";
+function junitTestCommand(runner) {
+  switch (runner) {
+    case "vitest":
+      return `npx vitest run --reporter=junit --outputFile=${JUNIT_ARTIFACT}`;
+    case "jest":
+      return `JEST_JUNIT_OUTPUT_NAME=${JUNIT_ARTIFACT} npx jest --ci --reporters=default --reporters=jest-junit`;
+    case "pytest":
+      return `pytest --junitxml=${JUNIT_ARTIFACT}`;
+    case "go":
+      return `go test ./... -v 2>&1 | go-junit-report > ${JUNIT_ARTIFACT}`;
+    case "unknown":
+      return null;
+  }
+}
+function reportCurl(t, indent) {
+  const secret = t.secretName ?? CI_SECRET_NAME;
+  const base = canonicalApiBase(t.apiBase);
+  return [
+    `curl -sS -X POST "${base}/api/ci/${t.projectId}/report" \\`,
+    `${indent}  -H "Authorization: Bearer $${secret}" \\`,
+    `${indent}  -H "X-Commit-SHA: $COMMIT_SHA" \\`,
+    `${indent}  -H "X-Branch: $BRANCH" \\`,
+    `${indent}  -H "Content-Type: application/xml" \\`,
+    `${indent}  --data-binary @${JUNIT_ARTIFACT}`
+  ].join("\n");
+}
+function reportStepYaml(t) {
+  const secret = t.secretName ?? CI_SECRET_NAME;
+  const base = canonicalApiBase(t.apiBase);
+  return [
+    `      - name: Report test results to IntentDocs`,
+    `        if: always()`,
+    `        env:`,
+    `          ${secret}: \${{ secrets.${secret} }}`,
+    `          COMMIT_SHA: \${{ github.sha }}`,
+    `          BRANCH: \${{ github.ref_name }}`,
+    `        run: |`,
+    `          curl -sS -X POST "${base}/api/ci/${t.projectId}/report" \\`,
+    `            -H "Authorization: Bearer $${secret}" \\`,
+    `            -H "X-Commit-SHA: $COMMIT_SHA" \\`,
+    `            -H "X-Branch: $BRANCH" \\`,
+    `            -H "Content-Type: application/xml" \\`,
+    `            --data-binary @${JUNIT_ARTIFACT}`
+  ].join("\n");
+}
+function standaloneWorkflowYaml(t) {
+  const testCmd = junitTestCommand(t.runner);
+  if (!testCmd) return null;
+  const isNode = t.runner === "vitest" || t.runner === "jest";
+  const setup = isNode ? [
+    `      - uses: actions/setup-node@v4`,
+    `        with:`,
+    `          node-version: 20`,
+    `      - run: npm ci`
+  ] : t.runner === "pytest" ? [
+    `      - uses: actions/setup-python@v5`,
+    `        with:`,
+    `          python-version: "3.12"`,
+    `      - run: pip install -r requirements.txt`
+  ] : [
+    `      - uses: actions/setup-go@v5`,
+    `        with:`,
+    `          go-version: stable`,
+    `      - run: go install github.com/jstemmer/go-junit-report/v2@latest`
+  ];
+  return [
+    `# Generated by \`intentdocs ci\`. Reports each test's result to its story.`,
+    `name: Tests`,
+    `on:`,
+    `  push:`,
+    `  pull_request:`,
+    `jobs:`,
+    `  test:`,
+    `    runs-on: ubuntu-latest`,
+    `    steps:`,
+    `      - uses: actions/checkout@v4`,
+    ...setup,
+    `      - name: Run tests`,
+    `        run: ${testCmd}`,
+    reportStepYaml(t),
+    ``
+  ].join("\n");
+}
+function reportCommandSnippet(t) {
+  const secret = t.secretName ?? CI_SECRET_NAME;
+  return [
+    `# After your test step writes ${JUNIT_ARTIFACT}, with ${secret} in the environment:`,
+    `COMMIT_SHA=<your commit sha> BRANCH=<your branch> \\`,
+    `  ${reportCurl(t, "  ")}`
+  ].join("\n");
+}
+
+// src/commands/ci.ts
+function ghReady() {
+  try {
+    execSync("gh auth status", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGitHubRepo(cwd) {
+  if (existsSync2(join2(cwd, ".github", "workflows"))) return true;
+  try {
+    const remote = execSync("git remote get-url origin", { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    return remote.includes("github.com");
+  } catch {
+    return false;
+  }
+}
+function timeAgo(iso) {
+  const diff = Date.now() - new Date(iso).getTime();
+  const mins = Math.round(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.round(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  return `${Math.round(hrs / 24)}d ago`;
+}
+async function listKeys(projectId) {
+  const res = await authenticatedFetch(`/api/cli/projects/${projectId}/ci-keys`);
+  if (!res.ok) return [];
+  const data = await res.json();
+  return data.keys ?? [];
+}
+async function reportStatus(projectId) {
+  const keys = (await listKeys(projectId)).filter((k) => !k.revoked_at);
+  if (keys.length === 0) {
+    console.log("No CI key yet. Run `npx intentdocs ci` to set up test reporting.");
+    return;
+  }
+  const reported = keys.filter((k) => k.last_report_at);
+  if (reported.length === 0) {
+    console.log("A CI key is set up, but no results have arrived yet. They appear here after your next CI run on the default branch.");
+    return;
+  }
+  for (const k of reported) {
+    const total = k.last_report_total ?? 0;
+    const unmatched = k.last_report_unmatched ?? 0;
+    const matched = Math.max(0, total - unmatched);
+    console.log(
+      `Last report ${timeAgo(k.last_report_at)}: ${matched} of ${total} result${total === 1 ? "" : "s"} matched a saved test` + (unmatched > 0 ? `, ${unmatched} did not.` : ".")
+    );
+    if (unmatched > 0) {
+      console.log("  Unmatched results are tests CI ran that no story records. Save them with file + full name so they reach a story.");
+    }
+  }
+}
+async function ci(opts = {}) {
+  const config = requireConfig();
+  await requireValidAuth();
+  const projectId = config.projectId;
+  if (!projectId) {
+    console.error("This checkout has no project id. Run `npx intentdocs init` to reconnect.");
+    process.exit(1);
+  }
+  if (opts.status) {
+    try {
+      await reportStatus(projectId);
+    } finally {
+      await shutdownCliAnalytics();
+    }
+    return;
+  }
+  const cwd = process.cwd();
+  const start = Date.now();
+  try {
+    const existing = (await listKeys(projectId)).filter((k) => !k.revoked_at);
+    let rawKey = null;
+    if (existing.length > 0 && !opts.new) {
+      console.log(`
+An active CI key already exists (${existing[0].key_prefix}\u2026). Its value can't be shown again.`);
+      if (isInteractive()) {
+        const rotate = await confirm("Create a new key and rotate it?");
+        if (rotate) rawKey = await createKey(projectId);
+      } else {
+        console.log("Re-run with --new to rotate it. Continuing with workflow setup \u2014 make sure the repo secret is already set.\n");
+      }
+    } else {
+      rawKey = await createKey(projectId);
+    }
+    const runner = detectTestRunner(cwd);
+    const base = config.apiBase;
+    const onGitHub = isGitHubRepo(cwd);
+    if (onGitHub) {
+      const workflow = standaloneWorkflowYaml({ runner, apiBase: base, projectId });
+      const workflowPath = join2(cwd, ".github", "workflows", "intentdocs.yml");
+      if (workflow && !existsSync2(workflowPath)) {
+        mkdirSync(join2(cwd, ".github", "workflows"), { recursive: true });
+        writeFileSync(workflowPath, workflow);
+        console.log(`
+\u2713 Wrote .github/workflows/intentdocs.yml \u2014 it runs your tests and reports each result to its story.`);
+      } else if (existsSync2(workflowPath)) {
+        console.log(`
+.github/workflows/intentdocs.yml already exists \u2014 leaving it as is.`);
+      } else {
+        console.log(`
+Add this step to the GitHub Actions workflow that runs your tests, after the test step:
+`);
+        console.log(reportStepYaml({ apiBase: base, projectId }));
+        console.log(`
+Your test step must write JUnit XML to test-results.xml first.`);
+      }
+    } else {
+      console.log(`
+No GitHub repo detected. Add this to your CI after your tests write JUnit XML:
+`);
+      console.log(reportCommandSnippet({ apiBase: base, projectId }));
+    }
+    if (rawKey) {
+      if (onGitHub && ghReady()) {
+        try {
+          execSync(`gh secret set ${CI_SECRET_NAME}`, { input: rawKey, stdio: ["pipe", "ignore", "ignore"] });
+          console.log(`
+\u2713 Stored the key as the ${CI_SECRET_NAME} repo secret with gh.`);
+        } catch {
+          printSecretInstructions(rawKey);
+        }
+      } else {
+        printSecretInstructions(rawKey);
+      }
+    }
+    const testCmd = junitTestCommand(runner);
+    if (testCmd) {
+      console.log(`
+Tell your agent to save each test with its file and full name so CI results can reach the story \u2014 see the "Set up test reporting" prompt in the Prompt library.`);
+    }
+    captureCli(
+      "ci_setup",
+      { runner, on_github: onGitHub, created_key: Boolean(rawKey), duration_ms: Date.now() - start },
+      { project: projectId }
+    );
+    console.log(`
+After your next default-branch CI run, check how results matched with: npx intentdocs ci --status
+`);
+  } finally {
+    closePrompt();
+    await shutdownCliAnalytics();
+  }
+}
+async function createKey(projectId) {
+  const res = await authenticatedFetch(`/api/cli/projects/${projectId}/ci-keys`, {
+    method: "POST",
+    body: JSON.stringify({ label: "intentdocs ci" })
+  });
+  if (!res.ok) {
+    console.error("Could not create a CI key. Only the project owner can \u2014 check you're logged in as the owner.");
+    return null;
+  }
+  const data = await res.json();
+  if (!data.raw_key) {
+    console.error("The server did not return a key. Try again.");
+    return null;
+  }
+  console.log("\n\u2713 Created a project CI key (shown once below \u2014 store it now).");
+  return data.raw_key;
+}
+function printSecretInstructions(rawKey) {
+  console.log(`
+Add this as a repo secret named ${CI_SECRET_NAME}:
+`);
+  console.log(`  ${rawKey}
+`);
+  console.log(`GitHub: Settings \u2192 Secrets and variables \u2192 Actions \u2192 New repository secret.`);
+  console.log(`Or with the GitHub CLI:  gh secret set ${CI_SECRET_NAME}`);
+}
+
+export {
+  ci
+};

package/dist/{chunk-6FGYJ3W2.js → chunk-F52HPVNQ.js}

@@ -1,3 +1,7 @@
+import {
+  storyRef
+} from "./chunk-LQTPZL2Y.js";
+
 // src/lib/story-context.ts
 import { mkdirSync, writeFileSync, readFileSync, existsSync } from "fs";
 import { join } from "path";
@@ -6,9 +10,12 @@ import { join } from "path";
 function criterionPriority(ac) {
   return ac.priority ?? "should";
 }
+function isCriterionCancelled(ac) {
+  return !!ac.cancelled_at;
+}
 function findBlockingMusts(criteria) {
   return criteria.filter(
-    (ac) => criterionPriority(ac) === "must" && ac.last_result?.status !== "pass"
+    (ac) => !isCriterionCancelled(ac) && criterionPriority(ac) === "must" && ac.last_result?.status !== "pass"
   );
 }
 function criterionStatusLabel(ac) {
@@ -22,6 +29,12 @@ var METHOD_LABELS = {
 };
 function renderCriterionLines(ac) {
   const checkbox = ac.done ? "x" : " ";
+  if (isCriterionCancelled(ac)) {
+    const reason = ac.cancellation_reason?.trim();
+    return [
+      `- [-] ~~${ac.text}~~ (cancelled${reason ? `: ${reason}` : ""})`
+    ];
+  }
   const isLegacy = ac.priority === void 0 && ac.verification === void 0;
   if (isLegacy) {
     return [`- [${checkbox}] ${ac.text}`];
@@ -39,6 +52,28 @@ function renderCriterionLines(ac) {
   return lines;
 }
 
+// src/lib/design-refs.ts
+var MATCH_INSTRUCTION = {
+  figma: "Match this Figma frame/node exactly \u2014 fetch it with get_design if you need the visual, or open the link.",
+  "claude-design": "Match this design exactly \u2014 fetch it with get_design for the rendered HTML, or open the link.",
+  "image-url": "Match this reference image exactly.",
+  "repo-path": "Match the layout and patterns already in this file/folder.",
+  storybook: "Match this Storybook story's states and props.",
+  other: "Match this reference."
+};
+function designRefMatchInstruction(ref) {
+  return MATCH_INSTRUCTION[ref.kind];
+}
+function designRefHasDrifted(ref) {
+  return !!ref.baseline_hash && !!ref.content_hash && ref.baseline_hash !== ref.content_hash;
+}
+function formatDesignRefLine(ref) {
+  const parts = [`[${ref.kind}]`, ref.url];
+  if (ref.selector) parts.push(`(${ref.selector})`);
+  const drift = designRefHasDrifted(ref) ? " (design changed since this story was written)" : "";
+  return `${parts.join(" ")} \u2014 ${designRefMatchInstruction(ref)}${drift}`;
+}
+
 // src/lib/story-context.ts
 var CONTEXT_DIR = ".intent/stories";
 function storyContextPath(storyId) {
@@ -49,6 +84,8 @@ function writeStoryContext(story) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   const acLines = story.acceptance_criteria.length ? story.acceptance_criteria.flatMap((ac) => renderCriterionLines(ac)).join("\n") : "_No acceptance criteria defined._";
   const specSection = story.notes?.trim() ? [`## Spec`, ``, story.notes.trim(), ``] : [];
+  const designRefs = story.design_refs ?? [];
+  const designRefsSection = designRefs.length ? [`## Design references`, ``, ...designRefs.map((ref) => `- ${formatDesignRefLine(ref)}`), ``] : [];
   const plan = story.implementation_plan;
   const hasPlan = plan?.status === "ready" && plan.markdown;
   const approachSection = hasPlan ? [
@@ -82,15 +119,16 @@ function writeStoryContext(story) {
     ``,
     acLines,
     ``,
+    ...designRefsSection,
     ...specSection,
     ...approachSection,
     `## Implementation notes`,
     ``,
-    `_Notes added via \`intent note ${story.id.slice(0, 8)} "..."\`_`,
+    `_Notes added via \`npx intentdocs note ${storyRef(story)} "..."\`_`,
     ``,
     `## Decisions`,
     ``,
-    `_Log decisions via \`intent decide "..." -s ${story.id.slice(0, 8)}\`_`,
+    `_Log decisions via \`npx intentdocs decide "..." -s ${storyRef(story)}\`_`,
     ``,
     `## Relevant files`,
     ``,
@@ -98,7 +136,7 @@ function writeStoryContext(story) {
     ``,
     `---`,
     ``,
-    `Mark done: \`intent done ${story.id.slice(0, 8)}\``
+    `Mark done: \`npx intentdocs done ${storyRef(story)}\``
   ].join("\n");
   const path = storyContextPath(story.id);
   writeFileSync(path, md);
@@ -134,6 +172,7 @@ export {
   criterionPriority,
   findBlockingMusts,
   criterionStatusLabel,
+  formatDesignRefLine,
   storyContextPath,
   writeStoryContext,
   appendNoteToContext

package/dist/{chunk-ICOMMHKG.js → chunk-JX2RLGOM.js}

@@ -1,3 +1,7 @@
+import {
+  canonicalApiBase
+} from "./chunk-UYTVTYNB.js";
+
 // src/lib/config.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { join, dirname } from "path";
@@ -20,7 +24,8 @@ function hasConfig() {
 function readConfig() {
   try {
     const raw = readFileSync(configPath(), "utf-8");
-    return JSON.parse(raw);
+    const config = JSON.parse(raw);
+    return config.apiBase ? { ...config, apiBase: canonicalApiBase(config.apiBase) } : config;
   } catch {
     return null;
   }
@@ -34,7 +39,13 @@ function writeConfig(config) {
 function requireConfig() {
   const config = readConfig();
   if (!config) {
-    console.error("Not initialized. Run: intent init");
+    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;

package/dist/chunk-KPQ42YE6.js

@@ -0,0 +1,43 @@
+import {
+  getAuth
+} from "./chunk-XZE2XP6O.js";
+
+// src/lib/analytics.ts
+import { PostHog } from "posthog-node";
+var client = null;
+function getClient() {
+  if (client) return client;
+  const auth = getAuth();
+  if (!auth?.posthogKey) return null;
+  client = new PostHog(auth.posthogKey, {
+    host: auth.posthogHost ?? "https://eu.i.posthog.com",
+    flushAt: 1,
+    flushInterval: 0
+  });
+  return client;
+}
+function getDistinctId() {
+  return getAuth()?.userId ?? null;
+}
+function captureCli(event, properties, groups) {
+  const posthog = getClient();
+  const distinctId = getDistinctId();
+  if (!posthog || !distinctId) return;
+  posthog.capture({
+    distinctId,
+    event,
+    properties: {
+      ...properties,
+      ...groups?.project ? { project_id: groups.project } : {}
+    },
+    ...groups ? { groups } : {}
+  });
+}
+async function shutdownCliAnalytics() {
+  if (client) await client.shutdown();
+}
+
+export {
+  captureCli,
+  shutdownCliAnalytics
+};