@koda-sl/baker-cli 0.559.0 → 0.561.0

package/dist/chats-D5W2UWD4.js

@@ -0,0 +1,449 @@
+import {
+  failApi
+} from "./chunk-PXLBPOI3.js";
+import {
+  CHAT_IMPORT_SURFACES
+} from "./chunk-TK7VRZKM.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import {
+  getEnv,
+  requireChatId
+} from "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/chats/index.ts
+import { defineCommand } from "citty";
+
+// src/commands/chats/publish-hints.ts
+function publishHints(publish) {
+  const hints = [];
+  if (!publish.complete) {
+    const failed = publish.failedTotal;
+    hints.push(
+      `This Session's publish left ${failed} change${failed === 1 ? "" : "s"} behind \u2014 see \`publish.surfaces\` for the platform's own words. Do not report those changes as live.`
+    );
+  }
+  const unconfirmed = publish.unconfirmedTotal ?? 0;
+  if (unconfirmed > 0) {
+    hints.push(
+      `${unconfirmed} change${unconfirmed === 1 ? "" : "s"} went through but could not be confirmed when read back from the platform \u2014 \`publish.surfaces[].unconfirmedChanges\` says what it shows instead. Check before reporting them as done.`
+    );
+  }
+  return hints;
+}
+function stillPublishingHints(status) {
+  if (status !== "publishing") return [];
+  return [
+    "This Session is still publishing: its changes are not live yet. Work that has to wait for it (a check on the live page, a test lead) is a Scheduled agent staged now with `baker scheduled-agents create --run-at <time>`, whose brief first checks this Session went live. It exists only once your own chat is published: a page trigger staged now misses this Session's publish, and a `--run-at` that has passed by then is created switched off, so leave hours of headroom, not minutes, and tell the user it runs only once they publish this chat. Never ask the user to come back and tell you when it is done."
+  ];
+}
+
+// src/commands/chats/index.ts
+var STATUS_GROUPS = ["active", "archived", "all"];
+var REPO_SURFACES = ["knowledge", "company", "brand", "landings", "flows", "creatives"];
+function parseBoundedInt(raw, name, min, max) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number.parseInt(raw, 10);
+  if (Number.isNaN(value) || value < min || value > max) {
+    throw new Error(`--${name} must be an integer between ${min} and ${max}`);
+  }
+  return value;
+}
+registerSchema({
+  command: "chats.list",
+  description: 'Start here: list other Sessions on this account (newest first) so you can reuse what was done before. Each row shows the Session id, title, status, and a count of what it produced (creatives, landings, actions, flows, reports\u2026). Looking for one? `--search "PMax Brasil"` finds the Sessions whose title or conversation holds any of the words, newest first, each with the `match` it was found by; read the match before trusting a row, since more words match more Sessions. Then drill in with `baker chats view <id>`, `baker chats transcript <id>`, or `baker chats diff <id>`. Read-only.',
+  args: {
+    status: { type: "string", description: "Filter: active|archived|all (default: all)", required: false },
+    limit: { type: "string", description: "Max Sessions to return, 1-100 (default: 20)", required: false },
+    full: { type: "boolean", description: "Include each Session's full change list", required: false, default: false },
+    search: {
+      type: "string",
+      description: 'Sessions whose title or conversation holds any of these words, newest first, each with its `match` (e.g. --search "PMax Brasil")',
+      required: false
+    }
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List other Sessions on this account, newest first." },
+  args: {
+    status: { type: "string", description: "Filter: active|archived|all (default: all)", required: false },
+    limit: { type: "string", description: "Max Sessions (1-100, default 20)", required: false },
+    full: { type: "boolean", description: "Include each Session's full change list", required: false, default: false },
+    search: {
+      type: "string",
+      description: "Sessions whose title or conversation holds any of these words",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = {};
+      if (args.search) {
+        body.search = args.search;
+      }
+      if (args.status) {
+        if (!STATUS_GROUPS.includes(args.status)) {
+          throw new Error(`--status must be one of: ${STATUS_GROUPS.join("|")}`);
+        }
+        body.status = args.status;
+      }
+      const limit = parseBoundedInt(args.limit, "limit", 1, 100);
+      if (limit !== void 0) {
+        body.limit = limit;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      const selfChatId = getEnv().BAKER_CHAT_ID;
+      if (selfChatId) {
+        body.excludeChatId = selfChatId;
+      }
+      const response = await apiPost("/api/chats/list", body);
+      writeJson({
+        ...response,
+        meta: { count: response.data.chats.length },
+        ...response.data.chats.length === 0 ? {
+          hints: [
+            args.search ? "No Session's title or conversation holds any of those words. Try other words (a name, a figure), widen with --status all, or drop --search to list the newest." : "No Sessions matched. Widen with --status all or a larger --limit."
+          ]
+        } : {
+          hints: [
+            "Drill in: `baker chats view <id>` for outputs, `chats transcript <id>` for the conversation, `chats diff <id>` for the real file changes."
+          ]
+        }
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+registerSchema({
+  command: "chats.view",
+  description: "Inspect one Session's FULL picture of what it changed \u2014 the unified `effects`: git content (landings, creatives, flows, knowledge, brand), plus DB-only effects that never touch the repo \u2014 Actions, Scheduled agents, Tags, Tag Manager, Google Analytics, ad-platform writes, the funnel (`funnel`: which steps it added, changed or removed, and which ways in it added or removed in `triggersAdded`/`triggersRemoved`), what counts as a conversion (`conversions`), conversion sends, event sources, and every other staged or already-applied change (`otherChanges`: A/B tests, recipes, library images) \u2014 each resolved to real detail (names, descriptions, priorities, tag types, ad operations) and, once published, its `outcome`. Also `publish` (what each external surface actually did, with the provider's own error), `activity` (the chat's own timeline: status changes, publish start/fail, workspace recoveries, timeouts), `usage` (per-thread cost and the Session's token totals), the kickoff (how it was asked), threads, and commits. Effects are `staged` (in-progress draft) or applied. A completed Session is NOT proof its external changes landed \u2014 read `publish`. Use after `baker chats list` to decide whether to reuse it. Read-only.",
+  args: {
+    id: { type: "positional", description: "The Session id (from `baker chats list`)", required: true },
+    full: {
+      type: "boolean",
+      description: "Untruncated effect lists and full activity metadata (compact caps each list at 25)",
+      required: false,
+      default: false
+    }
+  }
+});
+var viewCommand = defineCommand({
+  meta: {
+    name: "view",
+    description: "Inspect one Session's full effects \u2014 git content + actions/tags/ads, kickoff, commits."
+  },
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    full: { type: "boolean", description: "Include full detail", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const response = await apiPost("/api/chats/view", {
+        chatId: args.id,
+        ...args.full ? { full: true } : {}
+      });
+      const hints = response.data.publish ? publishHints(response.data.publish) : [];
+      if (response.data.diffAvailable) {
+        hints.push("See the real file-level diff of the git content with `baker chats diff <id> --full`.");
+      } else if (response.data.status === "in_progress" || response.data.status === "publishing") {
+        hints.push(
+          "This Session is still in progress \u2014 read its current file changes with `baker chats diff <id> --live`."
+        );
+      }
+      hints.push(...stillPublishingHints(response.data.status));
+      hints.push("Read the conversation with `baker chats transcript <id>`.");
+      writeJson({ ...response, hints });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var TRANSCRIPT_ROLES = ["user", "assistant"];
+registerSchema({
+  command: "chats.transcript",
+  description: "Start here: read a Session's conversation (user + agent turns), the most recent messages last. Leave out the id to read THIS chat \u2014 the way to recover its own earlier words after a context summary (never grep the raw logs on disk). `--search \"5.700\"` returns only the messages holding the text, from the whole conversation however long; `--role user` keeps one side; `--turns` keeps each request and the agent's closing message of that turn (a recap). Compact truncates long messages (around the match when searching); add --full for verbatim text. Read-only.",
+  args: {
+    id: {
+      type: "positional",
+      description: "The Session id (from `baker chats list`). Default: this chat",
+      required: false
+    },
+    search: {
+      type: "string",
+      description: 'Only messages containing this text, case-insensitive (e.g. --search "5.700")',
+      required: false
+    },
+    role: { type: "string", description: "Only one side: user|assistant", required: false },
+    turns: {
+      type: "boolean",
+      description: "Only each user message and the agent's closing message of that turn",
+      required: false,
+      default: false
+    },
+    limit: { type: "string", description: "Max messages to return, 1-1000 (default: 100)", required: false },
+    full: {
+      type: "boolean",
+      description: "Return verbatim (untruncated) message text",
+      required: false,
+      default: false
+    }
+  }
+});
+var transcriptCommand = defineCommand({
+  meta: { name: "transcript", description: "Read a Session's conversation \u2014 another one, or this chat's own." },
+  args: {
+    id: { type: "positional", description: "The Session id (default: this chat)", required: false },
+    search: { type: "string", description: "Only messages containing this text", required: false },
+    role: { type: "string", description: "Only one side: user|assistant", required: false },
+    turns: { type: "boolean", description: "Each request + the closing reply", required: false, default: false },
+    limit: { type: "string", description: "Max messages (1-1000, default 100)", required: false },
+    full: { type: "boolean", description: "Verbatim message text", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const chatId = args.id ?? getEnv().BAKER_CHAT_ID;
+      if (!chatId) {
+        throw new Error("Pass the Session id: `baker chats transcript <id>` (find it with `baker chats list`).");
+      }
+      const body = { chatId };
+      if (args.search) {
+        body.search = args.search;
+      }
+      if (args.role) {
+        if (!TRANSCRIPT_ROLES.includes(args.role)) {
+          throw new Error(`--role must be one of: ${TRANSCRIPT_ROLES.join("|")}`);
+        }
+        body.role = args.role;
+      }
+      if (args.turns) {
+        body.turns = true;
+      }
+      const limit = parseBoundedInt(args.limit, "limit", 1, 1e3);
+      if (limit !== void 0) {
+        body.limit = limit;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      const response = await apiPost("/api/chats/transcript", body);
+      const hints = [];
+      if (response.data.truncated) {
+        hints.push("Older messages were dropped to fit --limit. Raise --limit, or narrow with --search.");
+      }
+      if (args.search && response.data.entries.length === 0) {
+        hints.push(
+          "No message holds that text. The whole conversation was searched \u2014 try a shorter or differently written piece of it."
+        );
+      }
+      writeJson({ ...response, meta: { count: response.data.entries.length }, ...hints.length > 0 ? { hints } : {} });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+registerSchema({
+  command: "chats.diff",
+  description: "See the real file-level changes a Session made (landings, creatives, brand, flows, knowledge). Published Sessions read from git; for an in-progress (unpublished) Session pass --live to read its changes straight from its running workspace. Without --live, an unpublished Session returns available:false \u2014 use `baker chats view` for the staged summary. Compact lists changed files with +/- counts; add --full for the actual diff text. Read-only.",
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    surface: {
+      type: "string",
+      description: "Filter to one surface: knowledge|company|brand|landings|flows|creatives",
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Include the unified-diff patch text per file",
+      required: false,
+      default: false
+    },
+    live: {
+      type: "boolean",
+      description: "For an in-progress Session, read its changes from the live workspace (slower; resumes the paused Runtime). Ignored for published Sessions.",
+      required: false,
+      default: false
+    }
+  }
+});
+var diffCommand = defineCommand({
+  meta: { name: "diff", description: "See a published Session's real file-level changes." },
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    surface: {
+      type: "string",
+      description: "Filter: knowledge|company|brand|landings|flows|creatives",
+      required: false
+    },
+    full: { type: "boolean", description: "Include the diff patch text per file", required: false, default: false },
+    live: {
+      type: "boolean",
+      description: "Read an in-progress Session's changes from its live workspace (slower)",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = { chatId: args.id };
+      if (args.surface) {
+        if (!REPO_SURFACES.includes(args.surface)) {
+          throw new Error(`--surface must be one of: ${REPO_SURFACES.join("|")}`);
+        }
+        body.surface = args.surface;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      if (args.live) {
+        body.live = true;
+      }
+      const response = await apiPost("/api/chats/diff", body);
+      writeJson({
+        ...response,
+        meta: { count: response.data.files.length },
+        ...!response.data.available && response.data.reason ? { hints: [response.data.reason] } : {},
+        ...response.data.available && !args.full && response.data.files.length > 0 ? { hints: ["Add --full to read the actual diff text for each file."] } : {}
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var IMPORT_DESCRIPTION = `Move what another open chat has staged into this chat, in one call \u2014 and out of that chat, so publishing both can never apply anything twice.
+
+Start here when the user wants another chat's unpublished work brought into this one ("bring over",
+"merge the two chats", "include what the other chat prepared"):
+  baker chats import --from-chat <chat-id>
+  baker chats import --from-chat <chat-id> --only meta-ads,tasks     # only these surfaces
+
+It moves every surface exactly as staged: ads (Google, Meta, LinkedIn, X, ChatGPT), Shopify, Tag Manager,
+Google Analytics, tracking tags, Tasks, scheduled agents, ActiveCampaign, site settings, ad goals, the funnel,
+conversions, conversion sends, event sources and lead routes. When both chats change the same thing, nothing
+moves and the refusal names each clash \u2014 ask the user which version wins. What the other chat changed in
+files (Knowledge, pages, Forms), and what depends on those files, stays there; the result says what and why.
+A change moved here cannot go back: to leave one behind, ask the user first and use --only (Google Ads alone
+can pick single changes: \`baker ads google draft import --from-chat <id> --refs|--exclude\`).
+Find chat ids with \`baker chats list\`; see what one staged with \`baker chats view <id>\`.`;
+registerSchema({
+  command: "chats.import",
+  description: IMPORT_DESCRIPTION,
+  args: {
+    "from-chat": { type: "string", description: "The other open chat whose staged changes move here", required: true },
+    only: {
+      type: "string",
+      description: `Comma-separated surfaces to move (default: all): ${CHAT_IMPORT_SURFACES.join(", ")}`,
+      required: false
+    }
+  }
+});
+function importHints(data) {
+  const hints = [];
+  const moved = data.surfaces.reduce((sum, surface) => sum + surface.moved, 0);
+  const stayed = data.surfaces.filter((surface) => surface.left);
+  if (moved === 0 && stayed.length === 0) {
+    hints.push(`Chat ${data.fromChatId} had no unpublished changes staged, so nothing moved.`);
+  }
+  for (const surface of stayed) {
+    hints.push(
+      `${surface.left?.count ? `${surface.left.count} ` : ""}${surface.surface} change(s) stayed in chat ${data.fromChatId}: ${surface.left?.reason}`
+    );
+  }
+  if (data.filesStayed > 0) {
+    hints.push(
+      `Chat ${data.fromChatId} also changed ${data.filesStayed} file(s) (Knowledge, pages, Forms\u2026), which never move. Read them with \`baker chats diff ${data.fromChatId} --live --full\` and make the same changes here if the user wants them.`
+    );
+  }
+  if (moved > 0) {
+    hints.push(
+      "The moved changes are this chat's now and publish with it; the other chat no longer holds them. Review them with each surface's `draft list` (and `baker ads google draft validate` when Google Ads changes moved)."
+    );
+  }
+  if (moved > 0 && stayed.length === 0) {
+    hints.push(
+      "Nothing staged stayed in the other chat. Never tell the user to discard it for this: its other work is still there."
+    );
+  }
+  return hints;
+}
+function onlyFlag(value) {
+  if (typeof value !== "string") return {};
+  const named = value.split(",").map((surface) => surface.trim()).filter((surface) => surface.length > 0);
+  if (named.length === 0) return { refusal: "--only names no surface" };
+  const unknown = named.filter((surface) => !CHAT_IMPORT_SURFACES.includes(surface));
+  if (unknown.length > 0) return { refusal: `--only names ${unknown.join(", ")}, which is not a surface` };
+  return { surfaces: named };
+}
+function refuse(message, fix) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message, fix } });
+  process.exit(1);
+}
+var importCommand = defineCommand({
+  meta: { name: "import", description: IMPORT_DESCRIPTION },
+  args: {
+    "from-chat": { type: "string", description: "The other open chat whose staged changes move here" },
+    only: { type: "string", description: "Comma-separated surfaces to move (default: all)" }
+  },
+  run: async ({ args }) => {
+    const fromChatId = typeof args["from-chat"] === "string" ? args["from-chat"].trim() : "";
+    if (!fromChatId) {
+      refuse(
+        "--from-chat is required",
+        "Name the other chat: baker chats import --from-chat <chat-id> (ids from `baker chats list`)."
+      );
+    }
+    const only = onlyFlag(args.only);
+    if ("refusal" in only) {
+      refuse(
+        only.refusal,
+        `Name surfaces from: ${CHAT_IMPORT_SURFACES.join(", ")} \u2014 or leave --only off to move them all.`
+      );
+    }
+    try {
+      const response = await apiPost("/api/chats/import", {
+        chatId: requireChatId(),
+        fromChatId,
+        ...only.surfaces ? { surfaces: only.surfaces } : {}
+      });
+      writeJson({ ...response, hints: importHints(response.data) });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var chatsCommand = defineCommand({
+  meta: {
+    name: "chats",
+    description: `Inspect other Sessions on this account: list them, view what they produced, read their conversation, and see their real file changes \u2014 so you can reuse past work for a new goal. \`import --from-chat <id>\` moves another open Session's staged changes into this one.
+Full guide: __tooling__/docs/tools/baker/chats.md`
+  },
+  subCommands: {
+    list: listCommand,
+    view: viewCommand,
+    transcript: transcriptCommand,
+    diff: diffCommand,
+    import: importCommand
+  }
+});
+export {
+  chatsCommand
+};
+//# sourceMappingURL=chats-D5W2UWD4.js.map

package/dist/check-FFMWUB72.js

@@ -0,0 +1,107 @@
+import {
+  readAdWords,
+  ruleRefusal
+} from "./chunk-QPTYTM2X.js";
+import "./chunk-Y43FKOED.js";
+import "./chunk-OFMFBRSL.js";
+import {
+  readAllRules
+} from "./chunk-3FLSRUID.js";
+import {
+  ruleTells
+} from "./chunk-UKZKLXTE.js";
+import "./chunk-KDAINT54.js";
+import "./chunk-Y5PNLB24.js";
+import {
+  findWorkspaceRoot
+} from "./chunk-N3PASNUA.js";
+import "./chunk-H3HA22Z3.js";
+import {
+  selectRules
+} from "./chunk-DLM5OSHM.js";
+import "./chunk-MCJ5I5LR.js";
+import {
+  marketFromCompanyDoc
+} from "./chunk-2WZI36D3.js";
+import "./chunk-65Y3RCWP.js";
+import "./chunk-E56V3RFO.js";
+import "./chunk-EL3TDR5S.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-X6U3B6YK.js";
+import "./chunk-TK7VRZKM.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-MSMTG6OC.js";
+import "./chunk-QEREDRZO.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/creatives/check.ts
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+var DESCRIPTION = `Read every creative already made against the company's rules as they stand now: which ads say words a rule bans, or leave out words a rule requires. Run it after adding a rule (\`baker creatives rules add\`); nothing is re-rendered or marked stale, so ask the person which ads to correct.
+Start here: baker creatives check
+  baker creatives check --slug mba-ia-online   # one creative`;
+var ARGS = {
+  slug: { type: "string", description: "One creative (src/creatives/<slug>/); left out, every one", required: false }
+};
+registerSchema({ command: "creatives.check", description: DESCRIPTION, args: ARGS });
+function checkCreatives(ads, rules, companyLanguage) {
+  const breaking = ads.flatMap(({ slug, ad }) => {
+    const held = selectRules(
+      rules,
+      {
+        kind: ad.kind,
+        ...ad.product ? { product: ad.product } : {},
+        ...ad.platform ? { platform: ad.platform } : {},
+        ...ad.platforms ? { platforms: ad.platforms } : {}
+      },
+      ad.waived
+    );
+    const refusal = ruleRefusal(ruleTells(ad.lines, held, ad.language ?? companyLanguage));
+    return refusal ? [{ creative: slug, broken: refusal.problems }] : [];
+  });
+  return { checked: ads.length, breaking };
+}
+async function readAds(root, slug) {
+  const dir = path.join(root, "src", "creatives");
+  const slugs = slug ? [slug] : (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory() && !e.name.startsWith("_")).map((e) => e.name).sort();
+  const ads = await Promise.all(slugs.map(async (s) => ({ slug: s, ad: await readAdWords(path.join(dir, s)) })));
+  return ads.flatMap(({ slug: s, ad }) => ad ? [{ slug: s, ad }] : []);
+}
+var checkCommand = defineCommand({
+  meta: { name: "check", description: DESCRIPTION },
+  args: ARGS,
+  async run({ args }) {
+    const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
+    const slug = typeof args.slug === "string" && args.slug ? args.slug : void 0;
+    const [ads, rules, companyDoc] = await Promise.all([
+      readAds(root, slug),
+      readAllRules(root),
+      readFile(path.join(root, "COMPANY.md"), "utf8").catch(() => null)
+    ]);
+    const report = checkCreatives(ads, rules, marketFromCompanyDoc(companyDoc)?.language);
+    writeJson({
+      ok: true,
+      data: report,
+      hints: report.breaking.length > 0 ? [
+        `${report.breaking.length} of ${report.checked} ads break a rule now in force. Tell the person which, and correct only the ones they want: edit the words in that ad's prompt.json and run it again, or waive the rule there if the person asked for those words.`
+      ] : [`None of the ${report.checked} ads breaks a wording rule now in force.`]
+    });
+  }
+});
+export {
+  checkCommand,
+  checkCreatives
+};
+//# sourceMappingURL=check-FFMWUB72.js.map

package/dist/chunk-2DAWUWA4.js

@@ -0,0 +1,115 @@
+import {
+  writeJsonEnvelope
+} from "./chunk-RBCO3C3Q.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-QEREDRZO.js";
+import {
+  requireChatId
+} from "./chunk-45D6WRCJ.js";
+
+// src/commands/draft-refs.ts
+function draftRefs(positionals) {
+  const values = Array.isArray(positionals) ? positionals.filter((v) => typeof v === "string") : [];
+  return [
+    ...new Set(
+      values.flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean)
+    )
+  ];
+}
+function failureOf(ref, err) {
+  if (err instanceof ApiError) return { ref, code: err.code, message: err.message };
+  return { ref, code: "INTERNAL_ERROR", message: err instanceof Error ? err.message : String(err) };
+}
+function dataOf(response) {
+  if (typeof response !== "object" || response === null) return {};
+  const record = response;
+  const data = "ok" in record && typeof record.data === "object" && record.data !== null ? record.data : record;
+  return data;
+}
+function removedOf(data) {
+  const { removed } = data;
+  return Array.isArray(removed) ? removed.filter((r) => typeof r === "string") : [];
+}
+function updatedOf(data) {
+  const { updated } = data;
+  return Array.isArray(updated) ? updated.filter((u) => typeof u === "object" && u !== null && typeof u.ref === "string") : [];
+}
+function writeSummary(data, failed, verb) {
+  if (failed.length === 0) {
+    writeJsonEnvelope({ ok: true, data });
+    return;
+  }
+  writeJsonEnvelope({
+    ok: false,
+    data: { ...data, failed },
+    error: {
+      code: failed[0]?.code ?? "INTERNAL_ERROR",
+      message: `${failed.length} ref(s) could not be ${verb}: ${failed.map((f) => `${f.ref} (${f.message})`).join("; ")}`,
+      fix: `Everything else listed in data was ${verb}. Fix or drop only the refs under data.failed (a failure with its own \`fix\` says what to do for that ref), then run the command again for those.`
+    }
+  });
+  process.exit(1);
+}
+function removeSummary(removed, updated, notFound) {
+  const kept = [...updated.values()].filter((op) => !removed.includes(op.ref));
+  return {
+    removed,
+    count: removed.length,
+    ...kept.length > 0 ? { updated: kept } : {},
+    ...notFound.length > 0 ? { notFound } : {}
+  };
+}
+async function removeDraftRefs(path, refs) {
+  const chatId = requireChatId();
+  const removed = [];
+  const updated = /* @__PURE__ */ new Map();
+  const notFound = [];
+  const failed = [];
+  for (const ref of refs) {
+    if (removed.includes(ref)) continue;
+    try {
+      const data = dataOf(await apiPost(path, { chatId, ref }));
+      const gone = removedOf(data);
+      if (gone.length === 0) notFound.push(ref);
+      removed.push(...gone.filter((r) => !removed.includes(r)));
+      for (const op of updatedOf(data)) updated.set(op.ref, op);
+    } catch (err) {
+      if (err instanceof ApiError && err.code === "NOT_FOUND") notFound.push(ref);
+      else failed.push(failureOf(ref, err));
+    }
+  }
+  writeSummary(removeSummary(removed, updated, notFound), failed, "removed");
+}
+async function amendDraftRefs(path, refs, patch, refusalOf) {
+  const chatId = requireChatId();
+  const amended = [];
+  const failed = [];
+  for (const ref of refs) {
+    try {
+      const data = dataOf(await apiPost(path, { chatId, ref, patch }));
+      const refusal = refusalOf?.(data);
+      if (refusal) {
+        failed.push({ ref, ...refusal });
+        continue;
+      }
+      const { summary, warnings } = data;
+      amended.push({
+        ref,
+        ...summary !== void 0 ? { summary } : {},
+        ...Array.isArray(warnings) && warnings.length > 0 ? { warnings } : {}
+      });
+    } catch (err) {
+      failed.push(failureOf(ref, err));
+    }
+  }
+  writeSummary({ amended, count: amended.length }, failed, "amended");
+}
+
+export {
+  draftRefs,
+  removeDraftRefs,
+  amendDraftRefs
+};
+//# sourceMappingURL=chunk-2DAWUWA4.js.map