@koda-sl/baker-cli 0.545.0-dev.2a6beac48 → 0.545.0

package/dist/draft-VYIRZO3E.js

@@ -0,0 +1,220 @@
+import {
+  CHAT_READ_ARG
+} from "./chunk-X32MFGWW.js";
+import {
+  failApi,
+  failValidation,
+  isTempId
+} from "./chunk-YEISVDKW.js";
+import {
+  REMOVABLE_DRAFT_OP_KINDS
+} from "./chunk-R65V26HH.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiPost,
+  validateConvexId
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import {
+  requireChatId,
+  resolveChatId
+} from "./chunk-E54435XT.js";
+import {
+  registerSchema,
+  writeJson,
+  writeOutput
+} from "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/draft.ts
+import { defineCommand } from "citty";
+var REMOVE_OP_KINDS = REMOVABLE_DRAFT_OP_KINDS;
+registerSchema({
+  command: "actions.draft.list",
+  description: "Review the action ops staged in THIS chat's draft before publish (creates/updates/completes/discards/links). Staged ops are invisible to `actions list`/`status` until the chat publishes \u2014 use this to verify what will apply and catch duplicates. Takes --chat <id> to read an earlier chat's staged ops instead. Start here: `baker actions draft --output md` for a one-row-per-op table; add --fields to pick columns.",
+  args: {
+    chat: { type: "string", description: CHAT_READ_ARG.description, required: false },
+    output: {
+      type: "string",
+      description: "Output format: json (default, full envelope with status/count/warnings) | md | files. md and files render one row per staged op.",
+      required: false,
+      enum: ["json", "md", "files"]
+    },
+    fields: {
+      type: "string",
+      description: "Comma-separated columns for md/files output, e.g. kind,name,ref,tags",
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Include each op's payload (description, note, reason, blocker) in md/files output",
+      required: false,
+      default: false
+    }
+  }
+});
+var OUTPUT_ARGS = {
+  output: { type: "string", description: "Output format: json|md|files", required: false, default: "json" },
+  fields: { type: "string", description: "Comma-separated field names to include (md/files)", required: false },
+  full: { type: "boolean", description: "Include each op's full payload", required: false, default: false }
+};
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function draftOpNormalizer(record, full) {
+  const compact = {
+    kind: text(record.kind),
+    name: text(record.targetName),
+    ref: text(record.tempId) || text(record.targetActionId),
+    tags: Array.isArray(record.tags) ? record.tags.join(",") : ""
+  };
+  if (!full) {
+    return compact;
+  }
+  return {
+    ...compact,
+    description: text(record.description),
+    note: text(record.note),
+    reason: text(record.reason),
+    blocker: text(record.blockerTempId) || text(record.blockerActionId) || text(record.blockerName)
+  };
+}
+registerSchema({
+  command: "actions.draft.remove",
+  description: "Drop a single staged action op from this chat's draft before publish. For a tempId, removing the create cascades into its complete/link ops. For a real action ID, pass --op to say which op to drop. Use this to UNDO a staged op \u2014 never stage `complete` to delete an action.",
+  args: {
+    ref: { type: "string", description: "tempId (temp_*) or real action ID to drop from the draft", required: true },
+    op: {
+      type: "string",
+      description: "Required for real action IDs: which op to drop (update|complete|discard|assign|reopen)",
+      required: false
+    }
+  }
+});
+registerSchema({
+  command: "actions.draft.clear",
+  description: "Discard ALL staged action ops in this chat's draft before publish. Nothing applies on publish. Does not touch already-published actions.",
+  args: {}
+});
+var listCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "Show every action op staged in this chat's draft, with footgun warnings. Example: baker actions draft --output md"
+  },
+  args: { chat: CHAT_READ_ARG, ...OUTPUT_ARGS },
+  run: async ({ args }) => {
+    try {
+      const chatId = resolveChatId(args.chat);
+      const response = await apiPost("/api/actions/draft", { chatId });
+      const format = args.output === "md" || args.output === "files" ? args.output : "json";
+      if (format === "json") {
+        writeJson(response);
+        return;
+      }
+      writeOutput(
+        { ok: true, data: response.data.ops },
+        format,
+        args.fields ? args.fields.split(",") : void 0,
+        args.full,
+        draftOpNormalizer
+      );
+      process.stderr.write(`draft status: ${response.data.status}, ${response.data.count} op(s)
+`);
+      for (const warning of response.data.warnings) {
+        process.stderr.write(`warning: ${warning.tempId} \u2014 ${warning.name}
+`);
+      }
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var removeCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Drop one staged op from the draft. Example: baker actions draft remove temp_abc123  |  baker actions draft remove jx7... --op complete"
+  },
+  args: {
+    ref: { type: "positional", description: "tempId or real action ID", required: false },
+    op: {
+      type: "string",
+      description: "Op kind for real IDs: update|complete|discard|assign|reopen",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const ref = args.ref;
+      if (!ref) {
+        failValidation("A tempId or action ID is required.");
+      }
+      const chatId = requireChatId();
+      if (isTempId(ref)) {
+        await apiPost("/api/actions/draft-op/remove", {
+          chatId,
+          target: { kind: "tempId", tempId: ref }
+        });
+        writeJson({ ok: true, data: { removed: ref, kind: "tempId" } });
+        return;
+      }
+      validateConvexId(ref);
+      const op = args.op;
+      if (!op || !REMOVE_OP_KINDS.includes(op)) {
+        failValidation(
+          `Removing a staged op for a real action ID requires --op (one of: ${REMOVE_OP_KINDS.join("|")}).`
+        );
+      }
+      await apiPost("/api/actions/draft-op/remove", {
+        chatId,
+        target: { kind: "actionId", actionId: ref, opKind: op }
+      });
+      writeJson({ ok: true, data: { removed: ref, kind: "actionId", op } });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var clearCommand = defineCommand({
+  meta: {
+    name: "clear",
+    description: "Discard every staged op in this chat's draft. Example: baker actions draft clear"
+  },
+  run: async () => {
+    try {
+      const chatId = requireChatId();
+      await apiPost("/api/actions/draft/clear", { chatId });
+      writeJson({ ok: true, data: { cleared: true } });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var draftCommand = defineCommand({
+  meta: {
+    name: "draft",
+    description: "Review and edit the action ops staged in this chat BEFORE publish. Subcommands: list (default), remove, clear. Staged ops are invisible to `actions list`/`status` until publish, so check here before finishing. `list` takes --chat <id> to read an earlier chat's staged ops instead."
+  },
+  // Declared on the parent too: `default: "list"` dispatches the bare `draft --chat <id>` form, and
+  // citty prints help for a flag the parent does not know instead of forwarding it.
+  args: { chat: CHAT_READ_ARG, ...OUTPUT_ARGS },
+  subCommands: {
+    list: listCommand,
+    remove: removeCommand,
+    clear: clearCommand
+  },
+  // Bare `baker actions draft` (no subcommand) shows the staged ops. This must be
+  // `default`, not `run`: citty falls through to `run` after dispatching a subcommand,
+  // so a `run` here would also list the draft on every `remove` / `clear`.
+  default: "list"
+});
+export {
+  draftCommand,
+  draftOpNormalizer
+};
+//# sourceMappingURL=draft-VYIRZO3E.js.map

package/dist/engine/index.js

@@ -8,15 +8,15 @@ import {
   defaultRegistry,
   generateCatalog,
   validateCanvasDeep
-} from "../chunk-G6J6AWTE.js";
-import "../chunk-E5H7JIWB.js";
-import "../chunk-GCZK4BMB.js";
-import "../chunk-Q6LCL67T.js";
+} from "../chunk-QK3HMAVU.js";
+import "../chunk-JY3OJBKZ.js";
+import "../chunk-XYNQMRNX.js";
+import "../chunk-TARINRA4.js";
 import "../chunk-DGCUPJZD.js";
-import "../chunk-4IRJ5JXA.js";
-import "../chunk-XU6XQPNM.js";
-import "../chunk-B3CDNANO.js";
-import "../chunk-F3CZFUXZ.js";
+import "../chunk-RP36XHWT.js";
+import "../chunk-KIXVHP2C.js";
+import "../chunk-4D73PLXU.js";
+import "../chunk-MCJ5I5LR.js";
 import "../chunk-2WZI36D3.js";
 import "../chunk-65Y3RCWP.js";
 import "../chunk-JF2XP76K.js";

package/dist/experiments-6DOKWFH4.js

@@ -0,0 +1,236 @@
+import {
+  bareAccountId,
+  failWriteValidation,
+  parseDateFlag,
+  requireTarget,
+  stageOp
+} from "./chunk-HETNOUE4.js";
+import {
+  handleLinkedinError
+} from "./chunk-SEHJ7Y7J.js";
+import "./chunk-3W4IORXH.js";
+import "./chunk-4NZ47VXO.js";
+import "./chunk-D5FY4FAK.js";
+import "./chunk-NGQ5J4FV.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-MGWAZXY6.js";
+import "./chunk-VWOKPC3T.js";
+import "./chunk-BGT5ZA4L.js";
+import "./chunk-JF2XP76K.js";
+import "./chunk-SYLPRIFM.js";
+import "./chunk-XBR7TSZN.js";
+import "./chunk-DGUN7FUH.js";
+import "./chunk-R65V26HH.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiGet
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/experiments.ts
+import { defineCommand } from "citty";
+var STAGED_NOTE = "Staged until publish \u2014 review with `baker ads linkedin draft`.";
+var accountArgs = {
+  "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+  "account-urn": { type: "string", description: "Alias for --account-id" }
+};
+var STOP_AT = {
+  "end-date": "AUTO_STOP_AT_END_DATE",
+  winner: "AUTO_STOP_AT_WINNER",
+  never: "AUTO_STOP_DISABLED"
+};
+function stopAtArg(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const mapped = STOP_AT[String(value)];
+  if (!mapped) {
+    failWriteValidation(`--stop-at must be one of ${Object.keys(STOP_AT).join("|")}`);
+  }
+  return mapped;
+}
+function numberArg(value, flag) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    failWriteValidation(`${flag} must be a whole number`);
+  }
+  return parsed;
+}
+var experimentsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List the ad account's A/B tests, newest first: name, state (what was asked), running (what LinkedIn is doing: PENDING|RUNNING|ON_HOLD|STOPPED|ENDED), metric, dates and the two versions (ad sets + traffic split). Runs by default."
+  },
+  args: { ...accountArgs },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/ads/linkedin/experiments", {
+        "account-id": bareAccountId(args)
+      });
+      writeJsonEnvelope({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var experimentsGetCommand = defineCommand({
+  meta: {
+    name: "get",
+    description: "One A/B test with LinkedIn's setup checks (an ERROR keeps it from running \u2014 e.g. NO_ACTIVE_CREATIVES; a WARNING may skew it) and its latest result: the winning version, p-value, and each version's confidence interval for the metric. `result: null` until LinkedIn computes the first one (daily)."
+  },
+  args: {
+    id: { type: "positional", description: "A/B test id from `experiments`", required: true },
+    ...accountArgs
+  },
+  run: async ({ args }) => {
+    try {
+      const data = await apiGet("/api/ads/linkedin/experiments", {
+        "account-id": bareAccountId(args),
+        id: requireTarget(args, "A/B test")
+      });
+      writeJsonEnvelope({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var experimentsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: `Stage an A/B test between two ad sets of the SAME campaign: LinkedIn splits the audience so each member sees only one version, and calls a winner on the metric. ${STAGED_NOTE}
+Rules LinkedIn enforces: exactly 2 ad sets, same campaign, that campaign must NOT share its budget across ad sets, at most 90 days, confidence 51\u201399 (90+ recommended), each ad set needs an active ad. Best practice: two new ad sets identical but for the one thing tested, equal budgets, 3+ weeks.
+Examples:
+  baker ads linkedin experiments create --name "Image vs video" --version-a li_temp_x1 --version-b li_temp_x2 --metric CPC --start 2026-11-01 --end 2026-11-28
+  baker ads linkedin experiments create --name "Headline test" --version-a 896802423 --name-a "Pain" --version-b 896812053 --name-b "Gain" --metric CPM --start 2026-11-01 --end 2026-12-01 --stop-at winner --confidence 95`
+  },
+  args: {
+    ...accountArgs,
+    name: { type: "string", description: "Test name (\u2264100)", required: true },
+    description: { type: "string", description: "What is being tested" },
+    "version-a": { type: "string", description: "Ad set id/URN or li_temp_* ref for version A", required: true },
+    "version-b": { type: "string", description: "Ad set id/URN or li_temp_* ref for version B", required: true },
+    "name-a": { type: "string", description: "Version A label (default A)" },
+    "name-b": { type: "string", description: "Version B label (default B)" },
+    "weight-a": { type: "string", description: "Version A share of the audience, 1\u201399 (default 50; B gets the rest)" },
+    metric: { type: "string", description: "CPC|CPM|CPV (video ad sets)|CPMS (message ads)", required: true },
+    confidence: { type: "string", description: "51\u201399 (default 90)" },
+    start: { type: "string", description: "Start date (ISO or epoch ms)", required: true },
+    end: { type: "string", description: "End date (\u226490 days after start)", required: true },
+    "stop-at": {
+      type: "string",
+      description: "end-date (default, pauses both) | winner | never (ad sets keep running)"
+    },
+    draft: { type: "boolean", description: "Create it set up but not running" }
+  },
+  run: async ({ args }) => {
+    const weightA = numberArg(args["weight-a"], "--weight-a") ?? 50;
+    await stageOp({
+      kind: "experiment.create",
+      accountId: bareAccountId(args),
+      payload: {
+        name: args.name,
+        description: args.description,
+        keyMetric: args.metric ? String(args.metric).toUpperCase() : void 0,
+        confidence: numberArg(args.confidence, "--confidence"),
+        start: parseDateFlag(args.start, "--start"),
+        end: parseDateFlag(args.end, "--end"),
+        autoStop: stopAtArg(args["stop-at"]),
+        state: args.draft ? "DRAFT" : void 0,
+        cells: [
+          { name: args["name-a"] ?? "A", campaign: args["version-a"], trafficWeight: weightA },
+          { name: args["name-b"] ?? "B", campaign: args["version-b"], trafficWeight: 100 - weightA }
+        ]
+      }
+    });
+  }
+});
+var experimentsUpdateCommand = defineCommand({
+  meta: {
+    name: "update",
+    description: `Stage changes to an A/B test. Once it has started only the name, description, end date (still \u226490 days from start), confidence and when it stops can change \u2014 the versions are fixed. ${STAGED_NOTE}
+Example: baker ads linkedin experiments update 5633011 --end 2026-12-15 --stop-at winner`
+  },
+  args: {
+    id: { type: "positional", description: "A/B test id", required: true },
+    ...accountArgs,
+    name: { type: "string", description: "New name" },
+    description: { type: "string", description: "New description" },
+    end: { type: "string", description: "New end date" },
+    confidence: { type: "string", description: "51\u201399" },
+    "stop-at": { type: "string", description: "end-date|winner|never" }
+  },
+  run: async ({ args }) => {
+    await stageOp({
+      kind: "experiment.update",
+      accountId: bareAccountId(args),
+      target: requireTarget(args, "A/B test"),
+      payload: {
+        name: args.name,
+        description: args.description,
+        end: parseDateFlag(args.end, "--end"),
+        confidence: numberArg(args.confidence, "--confidence"),
+        autoStop: stopAtArg(args["stop-at"])
+      }
+    });
+  }
+});
+function experimentStateCommand(name, state, what) {
+  return defineCommand({
+    meta: {
+      name,
+      description: `Stage ${what}. ${STAGED_NOTE}
+Example: baker ads linkedin experiments ${name} 5633011`
+    },
+    args: {
+      id: { type: "positional", description: "A/B test id", required: true },
+      ...accountArgs
+    },
+    run: async ({ args }) => {
+      await stageOp({
+        kind: "experiment.update",
+        accountId: bareAccountId(args),
+        target: requireTarget(args, "A/B test"),
+        payload: { state }
+      });
+    }
+  });
+}
+var experimentsCommand = defineCommand({
+  meta: {
+    name: "experiments",
+    description: `LinkedIn A/B tests: two ad sets of one campaign shown to separate halves of the audience, with a winner called on CPC/CPM/CPV/CPMS.
+Examples:
+  baker ads linkedin experiments                       # list
+  baker ads linkedin experiments get 5633011           # setup checks + result
+  baker ads linkedin experiments create --name "Image vs video" --version-a <ad set> --version-b <ad set> --metric CPC --start 2026-11-01 --end 2026-11-28
+  baker ads linkedin experiments pause|start|end 5633011`
+  },
+  subCommands: {
+    list: experimentsListCommand,
+    get: experimentsGetCommand,
+    create: experimentsCreateCommand,
+    update: experimentsUpdateCommand,
+    start: experimentStateCommand("start", "ACTIVE", "starting (or resuming) an A/B test"),
+    pause: experimentStateCommand("pause", "PAUSED", "pausing an A/B test \u2014 both ad sets pause, the end date stays"),
+    end: experimentStateCommand("end", "CANCELED", "ending an A/B test for good")
+  },
+  args: { ...accountArgs },
+  default: "list"
+});
+export {
+  experimentsCommand
+};
+//# sourceMappingURL=experiments-6DOKWFH4.js.map

package/dist/facets-ZU5DT2QW.js

@@ -0,0 +1,117 @@
+import {
+  csvOrJson,
+  handleLinkedinError
+} from "./chunk-SEHJ7Y7J.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-MGWAZXY6.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-FPTEBOB5.js";
+import "./chunk-R65V26HH.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-MSMTG6OC.js";
+import {
+  apiGet
+} from "./chunk-B2OHCWYB.js";
+import "./chunk-SVUFNCOE.js";
+import "./chunk-E54435XT.js";
+import "./chunk-WCIS4FZH.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/facets.ts
+import { defineCommand } from "citty";
+var listCmd = defineCommand({
+  meta: {
+    name: "list",
+    description: `List every targeting facet LinkedIn supports.
+
+Cached 7 days. Use this to discover what dimensions you can target on (industries,
+seniorities, titles, employers, growthRate, companyCategory, skills, etc.).`
+  },
+  args: {
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = {};
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/facets", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var valuesCmd = defineCommand({
+  meta: {
+    name: "values",
+    description: `Look up entity values for a single facet \u2014 full list or typeahead search.
+
+Examples:
+  baker ads linkedin facets values --facet seniorities                          \u2014 all seniority URNs
+  baker ads linkedin facets values --facet titles --query "marketing director"  \u2014 typeahead
+  baker ads linkedin facets values --facet industries --output csv
+
+The --facet flag accepts the bare name (industries, seniorities, titles, etc.)
+or the full URN (urn:li:adTargetingFacet:industries).`
+  },
+  args: {
+    facet: { type: "string", description: "Facet name (e.g. industries) or URN", required: true },
+    query: { type: "string", description: "Typeahead query (auto-switches finder to typeahead)" },
+    finder: { type: "string", description: "adTargetingFacet | typeahead | similarEntities (default: auto)" },
+    locale: { type: "string", description: "Locale (default: en_US)" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    try {
+      const params = { facet: String(args.facet) };
+      const finder = args.finder ?? (args.query ? "typeahead" : "adTargetingFacet");
+      params.finder = finder;
+      if (args.query) params.query = String(args.query);
+      if (args.locale) params.locale = String(args.locale);
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/facets/entities", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var facetsCommand = defineCommand({
+  meta: {
+    name: "facets",
+    description: `LinkedIn targeting facets and entity lookup.
+
+Subcommands:
+  list                          \u2014 every facet (industries, seniorities, titles, employers, \u2026)
+  values --facet titles         \u2014 entity URNs for one facet
+  values --facet titles --query "marketing director"  \u2014 typeahead`
+  },
+  subCommands: {
+    list: listCmd,
+    values: valuesCmd
+  }
+});
+export {
+  facetsCommand
+};
+//# sourceMappingURL=facets-ZU5DT2QW.js.map