@koda-sl/baker-cli 0.453.0 → 0.454.0-dev.67ad219ab

package/dist/conversions-KF4AHFCY.js

@@ -0,0 +1,135 @@
+import {
+  csvOrJson,
+  handleLinkedinError,
+  resolveAccountIdArg
+} from "./chunk-DMA7XZLS.js";
+import {
+  writeAdsJson,
+  writeAdsOutput
+} from "./chunk-CWW5ITFK.js";
+import {
+  NO_CACHE_ARG
+} from "./chunk-UK4DUS6I.js";
+import "./chunk-IDYAVGCS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  apiGet
+} from "./chunk-5BQCBI2G.js";
+import "./chunk-A7F3C6AJ.js";
+import "./chunk-YZIZEPAQ.js";
+import "./chunk-5WW456MW.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/linkedin/conversions.ts
+import { defineCommand } from "citty";
+var DAY_MS = 864e5;
+function healthOf(rules) {
+  const enabled = rules.filter((r) => r.enabled !== false);
+  const capi = enabled.filter((r) => r.conversionMethod === "CONVERSIONS_API");
+  const pixel = enabled.filter((r) => r.conversionMethod === "PIXEL");
+  const staleCapi = capi.filter(
+    (r) => !r.lastConversionReportedAt || Date.now() - r.lastConversionReportedAt > 7 * DAY_MS
+  );
+  const longView = enabled.filter(
+    (r) => r.viewThroughAttributionWindowSize !== void 0 && r.viewThroughAttributionWindowSize > 7
+  );
+  const leads = enabled.filter((r) => r.type === "LEAD");
+  const wrongDedup = leads.filter((r) => r.countingMethod && r.countingMethod !== "ONE_TIME_EACH_MEMBER");
+  return {
+    totalRules: rules.length,
+    enabledRules: enabled.length,
+    capiRules: capi.length,
+    pixelRules: pixel.length,
+    hasLeadEvent: leads.length > 0,
+    hasPurchaseEvent: enabled.some((r) => r.type === "PURCHASE"),
+    staleCapiRules: staleCapi,
+    longViewWindow: longView,
+    wrongLeadDedup: wrongDedup
+  };
+}
+var listCmd = defineCommand({
+  meta: {
+    name: "list",
+    description: `List conversion rules on the account.`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json|csv|jsonl|md", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/conversions", params);
+      const fmt = csvOrJson(args);
+      if (fmt !== "json") {
+        writeAdsOutput(data, fmt);
+        return;
+      }
+      writeAdsJson({ ok: true, data });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var healthCmd = defineCommand({
+  meta: {
+    name: "health",
+    description: `5-point Insight Tag / CAPI health check (playbook \xA707).
+
+Surfaces:
+  - Are rules enabled?
+  - Do we have at least one LEAD or PURCHASE event?
+  - Do CAPI rules show recent activity (\u22647 days)?
+  - Is the view-through window \u22647 days?
+  - Do LEAD rules use ONE_TIME_EACH_MEMBER de-dup?`
+  },
+  args: {
+    "account-id": { type: "string", description: "Numeric account ID or urn:li:sponsoredAccount:N" },
+    "account-urn": { type: "string", description: "Alias for --account-id" },
+    "no-cache": NO_CACHE_ARG,
+    output: { type: "string", description: "json", default: "json" }
+  },
+  run: async ({ args }) => {
+    const accountId = resolveAccountIdArg(args);
+    try {
+      const params = { "account-id": accountId };
+      if (args["no-cache"]) params["skip-cache"] = "true";
+      const data = await apiGet("/api/ads/linkedin/conversions", params);
+      writeAdsJson({ ok: true, data: healthOf(data) });
+    } catch (err) {
+      handleLinkedinError(err);
+    }
+  }
+});
+var conversionsCommand = defineCommand({
+  meta: {
+    name: "conversions",
+    description: `Conversion rules \u2014 Insight Tag and Conversions API.
+
+Subcommands:
+  list                \u2014 every rule on the account
+  health              \u2014 playbook \xA707 5-point health check
+  create / update     \u2014 stage a conversion-rule write (applies on chat publish)
+  associate-campaign / dissociate-campaign
+                      \u2014 which ad sets a rule counts for (its own LinkedIn record, not a field on the rule)`
+  },
+  subCommands: {
+    list: listCmd,
+    health: healthCmd,
+    create: () => import("./write-commands-PKB23ZBZ.js").then((m) => m.conversionsCreateCommand),
+    update: () => import("./write-commands-PKB23ZBZ.js").then((m) => m.conversionsUpdateCommand),
+    "associate-campaign": () => import("./write-commands-PKB23ZBZ.js").then((m) => m.conversionsAssociateCommand),
+    "dissociate-campaign": () => import("./write-commands-PKB23ZBZ.js").then((m) => m.conversionsDissociateCommand)
+  }
+});
+export {
+  conversionsCommand
+};
+//# sourceMappingURL=conversions-KF4AHFCY.js.map

package/dist/conversions-OI7JVWXC.js

@@ -0,0 +1,76 @@
+import {
+  CHATGPT_ADS_REFERENCE,
+  runChatgptListRead
+} from "./chunk-JGCYENVG.js";
+import "./chunk-CWW5ITFK.js";
+import "./chunk-5BQCBI2G.js";
+import "./chunk-A7F3C6AJ.js";
+import "./chunk-YZIZEPAQ.js";
+import {
+  registerSchema
+} from "./chunk-5WW456MW.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/chatgpt/conversions.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.chatgpt.conversions",
+  description: "What the connected ChatGPT Ads account measures: its pixels (with the pixel id a landing page installs) and its conversion events (standard type, attribution window, sources, the campaigns using each).",
+  args: {}
+});
+function conversionHints(conversions) {
+  const hints = [];
+  if (conversions.pixels === null) {
+    hints.push(
+      "ChatGPT Ads does not let this account list its pixels through the API. The pixel id is in Ads Manager \u2192 Conversions."
+    );
+  } else if (conversions.pixels.length === 0) {
+    hints.push(
+      "No pixel yet: without one on the landing pages, ChatGPT Ads counts no conversions and cannot optimise for them."
+    );
+  }
+  if (conversions.events.filter((event) => !event.archived).length === 0) {
+    hints.push(
+      "No conversion is defined, so no campaign measures or optimises for one. Stage one with `baker ads chatgpt conversions create`."
+    );
+  }
+  return hints;
+}
+var conversionsListCommand = defineCommand({
+  meta: { name: "list", description: "Pixels and conversions. Example: baker ads chatgpt conversions" },
+  args: {},
+  run: async () => {
+    await runChatgptListRead(
+      CHATGPT_ADS_REFERENCE.conversions,
+      "/api/ads/chatgpt/conversions",
+      void 0,
+      conversionHints
+    );
+  }
+});
+var conversionsCommand = defineCommand({
+  meta: {
+    name: "conversions",
+    description: `What a ChatGPT Ads account measures \u2014 its pixels and conversions \u2014 define a new conversion, and check the pixel's events arrive.
+
+Examples:
+  baker ads chatgpt conversions
+  baker ads chatgpt conversions create --name "Quote requests" --event custom --custom-name quote_requested
+  baker ads chatgpt conversions events
+  baker ads chatgpt conversions report --ids cmpn_123 --days 30   \u2014 click-through and view-through`
+  },
+  subCommands: {
+    list: conversionsListCommand,
+    create: () => import("./conversion-writes-W7ICHG76.js").then((m) => m.conversionsCreateCommand),
+    events: () => import("./conversion-writes-W7ICHG76.js").then((m) => m.conversionsEventsCommand),
+    report: () => import("./conversion-report-RC7G5FYK.js").then((m) => m.conversionsReportCommand)
+  },
+  // A parent must never declare `run`: citty falls through to it after the matched subcommand.
+  args: {},
+  default: "list"
+});
+export {
+  conversionHints,
+  conversionsCommand
+};
+//# sourceMappingURL=conversions-OI7JVWXC.js.map

package/dist/countries-DYGDGADD.js

@@ -0,0 +1,82 @@
+import {
+  writeResearchJson
+} from "./chunk-S5MBDWB3.js";
+import "./chunk-5BQCBI2G.js";
+import "./chunk-A7F3C6AJ.js";
+import "./chunk-YZIZEPAQ.js";
+import {
+  registerSchema
+} from "./chunk-5WW456MW.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/countries.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "research.countries",
+  description: "List all supported country codes for --location flag in research commands.",
+  args: {}
+});
+var COUNTRIES = [
+  { code: "us", name: "United States" },
+  { code: "uk", name: "United Kingdom" },
+  { code: "ca", name: "Canada" },
+  { code: "au", name: "Australia" },
+  { code: "de", name: "Germany" },
+  { code: "fr", name: "France" },
+  { code: "es", name: "Spain" },
+  { code: "it", name: "Italy" },
+  { code: "br", name: "Brazil" },
+  { code: "mx", name: "Mexico" },
+  { code: "nl", name: "Netherlands" },
+  { code: "be", name: "Belgium" },
+  { code: "at", name: "Austria" },
+  { code: "ch", name: "Switzerland" },
+  { code: "pt", name: "Portugal" },
+  { code: "se", name: "Sweden" },
+  { code: "no", name: "Norway" },
+  { code: "dk", name: "Denmark" },
+  { code: "fi", name: "Finland" },
+  { code: "ie", name: "Ireland" },
+  { code: "nz", name: "New Zealand" },
+  { code: "in", name: "India" },
+  { code: "jp", name: "Japan" },
+  { code: "kr", name: "South Korea" },
+  { code: "sg", name: "Singapore" },
+  { code: "ar", name: "Argentina" },
+  { code: "cl", name: "Chile" },
+  { code: "co", name: "Colombia" },
+  { code: "pe", name: "Peru" },
+  { code: "pl", name: "Poland" },
+  { code: "cz", name: "Czech Republic" },
+  { code: "ro", name: "Romania" },
+  { code: "hu", name: "Hungary" },
+  { code: "za", name: "South Africa" },
+  { code: "il", name: "Israel" },
+  { code: "ae", name: "United Arab Emirates" },
+  { code: "sa", name: "Saudi Arabia" },
+  { code: "tr", name: "Turkey" },
+  { code: "ph", name: "Philippines" },
+  { code: "th", name: "Thailand" },
+  { code: "my", name: "Malaysia" },
+  { code: "id", name: "Indonesia" },
+  { code: "vn", name: "Vietnam" },
+  { code: "tw", name: "Taiwan" },
+  { code: "hk", name: "Hong Kong" }
+];
+var FIELDS = {
+  code: "Country code to pass as --location",
+  name: "Country name"
+};
+var countriesCommand = defineCommand({
+  meta: {
+    name: "countries",
+    description: "List all supported country codes for --location flag."
+  },
+  run: () => {
+    writeResearchJson({ ok: true, data: COUNTRIES, fields: FIELDS });
+  }
+});
+export {
+  countriesCommand
+};
+//# sourceMappingURL=countries-DYGDGADD.js.map

package/dist/create-5ZYWRS65.js

@@ -0,0 +1,59 @@
+import {
+  failApi,
+  failValidation,
+  writeOk
+} from "./chunk-63VMGEZI.js";
+import "./chunk-IDYAVGCS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  apiPost
+} from "./chunk-5BQCBI2G.js";
+import "./chunk-A7F3C6AJ.js";
+import "./chunk-YZIZEPAQ.js";
+import {
+  registerSchema
+} from "./chunk-5WW456MW.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/tags/create.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "actions.tags.create",
+  description: "Create a company custom action tag, minting a new slug usable with --tags. The name is slugified (lowercased, spaces\u2192hyphens). Use when no existing tag fits the work.",
+  args: {
+    slug: { type: "string", description: "Tag name/slug (e.g. pmax, retargeting)", required: true },
+    description: { type: "string", description: "What this tag means", required: false }
+  }
+});
+var tagsCreateCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: 'Create a custom action tag. Example: baker actions tags create --slug pmax --description "Performance Max work"'
+  },
+  args: {
+    slug: { type: "string", description: "Tag name/slug", required: false },
+    description: { type: "string", description: "Description", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const slug = args.slug;
+      if (!slug || slug.trim().length === 0) {
+        failValidation("--slug is required.");
+      }
+      const response = await apiPost("/api/actions/tags/create", {
+        name: slug,
+        description: args.description
+      });
+      writeOk(response.data);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  tagsCreateCommand
+};
+//# sourceMappingURL=create-5ZYWRS65.js.map

package/dist/create-HOZVJTLQ.js

@@ -0,0 +1,235 @@
+import {
+  holdWorkspaceSpend
+} from "./chunk-RNHSGH44.js";
+import "./chunk-TIL76IDK.js";
+import {
+  askJev
+} from "./chunk-6TDEGWZJ.js";
+import "./chunk-S2IOUC5B.js";
+import "./chunk-33F4O6OO.js";
+import "./chunk-YYBQUXFX.js";
+import {
+  ACTION_PRIORITIES,
+  buildCreateHints,
+  failApi,
+  failValidation,
+  generateTempId,
+  parsePriority,
+  parseTagList
+} from "./chunk-63VMGEZI.js";
+import {
+  actionTempIdSchema
+} from "./chunk-IDYAVGCS.js";
+import "./chunk-GXDLWBOY.js";
+import "./chunk-TEINLN64.js";
+import "./chunk-ZJWUBJYQ.js";
+import "./chunk-NE4F3FHN.js";
+import {
+  apiPost
+} from "./chunk-5BQCBI2G.js";
+import "./chunk-A7F3C6AJ.js";
+import {
+  requireChatId
+} from "./chunk-YZIZEPAQ.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-5WW456MW.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/actions/create.ts
+import { defineCommand } from "citty";
+
+// src/commands/actions/advisory.ts
+var EXECUTABLE_SURFACES = [
+  "ask-user",
+  "analysis",
+  "ads-write",
+  "tag-manager",
+  "site-tags",
+  "landing",
+  "flow"
+];
+var SCHEDULED_HINT = 'This reads as recurring/scheduled work. If it should run on a cadence or a future date, create a Scheduled agent instead \u2014 baker scheduled-agents create --cron "0 9 * * MON" (or --run-at, or --trigger for a reaction rather than a clock; guide: `__tooling__/docs/tools/baker/scheduled-agents.md`). Do not capture "set up a schedule" as a Work Action.';
+var SURFACES = {
+  "ask-user": {
+    questions: [
+      "Does `task` say the work cannot go ahead until the client or user gives or confirms one specific value, such as a production domain, an account ID or credentials? Work that is blocked for any other reason is not."
+    ],
+    hint: "This is a missing input, not blocked work. Ask for it with AskUserQuestion (one question), then do the work in the same turn \u2014 filing the Task AND asking the question is the same request twice."
+  },
+  analysis: {
+    questions: [
+      "Is the work `task` names itself an investigation: to audit, review, analyse, verify, check, document or research something, where the result is a finding rather than a change?"
+    ],
+    hint: "This names the analysis itself \u2014 investigating, auditing and documenting are work you do now, not work you file. Run it in this chat and deliver the finding; a Task is for a fix something genuinely blocks (bar: `__tooling__/docs/tools/baker/actions.md`)."
+  },
+  "ads-write": {
+    // The platform often goes unnamed ("6 new WhatsApp campaigns" are Google Ads campaigns).
+    questions: [
+      "Is `task` a change to the settings of paid ad campaigns or ad sets: location targeting, ad schedule, audiences or audience signals, bids, tracking URL templates or final URLs?",
+      "Is `task` setting, applying, raising, lowering or capping the budget of paid ad campaigns or ad sets? Approving a budget is not.",
+      "Is `task` a change to what paid ads say or show: ad copy, search ad (RSA) headlines or descriptions, display paths, claims in the ads, callouts, sitelinks, structured snippets or other ad extensions?",
+      "Is `task` a change to the keywords of paid search campaigns: adding keywords, match types or negative keywords? Work that needs another company's permission first is not.",
+      "Is `task` pausing, launching, enabling, duplicating, pruning, reweighting or restructuring paid ad campaigns, ad sets or ads, or labelling them? Getting a decision or an approval is not."
+    ],
+    hint: "This is an ad-platform change the write surface covers \u2014 stage it now with `baker ads google|meta|linkedin` and it applies at publish (guides: `__tooling__/docs/tools/baker/ads-google.md`, `__tooling__/docs/tools/baker/ads-meta.md`, `__tooling__/docs/tools/baker/ads-linkedin.md`). Staging is not going live."
+  },
+  "tag-manager": {
+    questions: [
+      "Is `task` a change inside the Google Tag Manager container: its tags, triggers, variables, data layer events, consent settings, GA4 events or conversion measurement? Server-side tagging, or hosting, is not."
+    ],
+    hint: "This is a change inside the GTM container \u2014 `baker tag-manager` stages it now and it applies at publish (guide: `__tooling__/docs/tools/baker/tag-manager.md`). Stage it instead of filing it, and if several container fixes really are blocked, they belong in ONE Task, not one per finding."
+  },
+  "site-tags": {
+    questions: [
+      "Is `task` installing, configuring or removing a tracking script, pixel or tag on the website pages (a Meta pixel and its Conversions API events, Clarity, Hotjar, a HubSpot tracking code, a LinkedIn Insight tag)? A server-side setup on the company's own domain is not."
+    ],
+    hint: "This is a tag or script on the site \u2014 it goes through the `request_tag_input` approval form in this chat, which also collects any secret values (guide: `__tooling__/docs/tools/baker/tags.md`). Show the form instead of filing a Task."
+  },
+  landing: {
+    questions: [
+      "Is `task` building or editing a page of the website or a landing page: its copy, hero, headline, sections or layout? A headline of an ad, or a page only mentioned as the cause of another problem, is not."
+    ],
+    hint: "This is a page change \u2014 build it in this chat with the `/landing` skill. Only file it if something outside the page blocks the work."
+  },
+  flow: {
+    questions: ["Is `task` changing how a form behaves: its steps, branching logic, or the redirect after it is sent?"],
+    hint: "This is form behaviour \u2014 change it in this chat with the `/flow-builder` skill. Only file it if something outside the form blocks the work."
+  }
+};
+var SCHEDULED_QUESTIONS = [
+  "Does `task` ask for work to be done again and again on a schedule (every day, every week, each Monday, monthly)? A month or period that only says what the work is about is not.",
+  "Does `task` ask to be reminded, or for work to be done, at a later date or moment (before a launch, on a given day)? A month or date that only names the period the work is about is not."
+];
+var ROUTING_BANDS = { scheduled: 0.5, surface: 0.5 };
+var jevTaskJudge = async (task) => {
+  const groups = [
+    SCHEDULED_QUESTIONS,
+    ...EXECUTABLE_SURFACES.map((s) => SURFACES[s].questions)
+  ];
+  const spent = [];
+  const answers = await askJev(
+    groups.flat().map((question) => ({ instructions: { task, question } })),
+    (usage) => spent.push(usage)
+  );
+  await holdWorkspaceSpend(spent);
+  if (answers === null) return null;
+  let next = 0;
+  const [scheduled = 0, ...surfaces] = groups.map((group) => Math.max(...group.map(() => answers[next++] ?? 0)));
+  return {
+    scheduled,
+    surfaces: Object.fromEntries(EXECUTABLE_SURFACES.map((s, i) => [s, surfaces[i] ?? 0]))
+  };
+};
+function hintFor(reading) {
+  if (reading.scheduled >= ROUTING_BANDS.scheduled) return { kind: "scheduled", hint: SCHEDULED_HINT };
+  if (reading.surfaces["ask-user"] >= ROUTING_BANDS.surface) {
+    return { kind: "executable", surface: "ask-user", hint: SURFACES["ask-user"].hint };
+  }
+  let best = null;
+  for (const surface of EXECUTABLE_SURFACES) {
+    const p = reading.surfaces[surface];
+    if (p >= ROUTING_BANDS.surface && (best === null || p > best.p)) best = { surface, p };
+  }
+  return best ? { kind: "executable", surface: best.surface, hint: SURFACES[best.surface].hint } : null;
+}
+function taskText(name, description) {
+  return description.trim() ? `${name.trim()}
+
+${description.trim()}` : name.trim();
+}
+async function advisoryHint(name, description, judge) {
+  const reading = await judge(taskText(name, description)).catch(() => null);
+  return reading === null ? null : hintFor(reading);
+}
+
+// src/commands/actions/create.ts
+registerSchema({
+  command: "actions.create",
+  description: "Stage creation of a new action (applies when the chat is published). Returns a tempId you can use to link in the same draft. Pass --tags (REQUIRED \u2014 run `baker actions tags list` for the taxonomy) and --priority (one of urgent|high|medium|low \u2014 drives the dependency-aware 'Do first' ordering). After creating, check if this action blocks or is blocked by other actions and wire dependencies with `baker actions link`.",
+  args: {
+    name: { type: "string", description: "Action name (short, action-verb, \u22646 words)", required: true },
+    description: {
+      type: "string",
+      description: "Context-complete description in markdown: what / why / where / done-when. Use `##` headings for those sections, `-` bullets for lists of items, and `**bold**` for the figures that drive the decision. Anything longer than a couple of sentences needs headings \u2014 it is read in a narrow panel.",
+      required: false
+    },
+    tags: {
+      type: "string",
+      description: "Comma-separated tag slugs (e.g. google-ads,audit-finding). Must be known \u2014 see `baker actions tags list`.",
+      required: false
+    },
+    priority: {
+      type: "string",
+      description: `User priority for the do-first ordering. One of: ${ACTION_PRIORITIES.join(", ")}.`,
+      required: false
+    },
+    "temp-id": {
+      type: "string",
+      description: "Custom tempId \u2014 must start with `temp_` (e.g. temp_hero_copy). Auto-generated if omitted; omitting it is fine.",
+      required: false
+    }
+  }
+});
+var createCommand = defineCommand({
+  meta: {
+    name: "create",
+    description: 'Stage a new action. Applies when the chat is published. Example: baker actions create --name "Build hero"'
+  },
+  args: {
+    name: { type: "string", description: "Action name", required: false },
+    description: { type: "string", description: "Description", required: false, default: "" },
+    tags: { type: "string", description: "Comma-separated tag slugs (see `baker actions tags list`)", required: false },
+    priority: { type: "string", description: `User priority: ${ACTION_PRIORITIES.join("|")}`, required: false },
+    "temp-id": { type: "string", description: "Optional custom tempId (must start with `temp_`)", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const name = args.name;
+      if (!name || name.trim().length === 0) {
+        failValidation("--name is required.");
+      }
+      const customTempId = args["temp-id"];
+      if (customTempId) {
+        const parsed = actionTempIdSchema.safeParse(customTempId);
+        if (!parsed.success) {
+          failValidation(parsed.error.issues[0]?.message ?? "Invalid --temp-id.");
+        }
+      }
+      const chatId = requireChatId();
+      const tempId = customTempId || generateTempId();
+      const tags = parseTagList(args.tags);
+      const priority = parsePriority(args.priority, { allowClear: false });
+      const description = args.description ?? "";
+      const [response, advisory] = await Promise.all([
+        apiPost("/api/actions/create", {
+          chatId,
+          tempId,
+          name,
+          description,
+          ...tags ? { tags } : {},
+          ...priority !== void 0 && priority !== null ? { priority } : {}
+        }),
+        advisoryHint(name, description, jevTaskJudge)
+      ]);
+      writeJson({
+        ...response,
+        hints: buildCreateHints({
+          advisory,
+          description,
+          tempId,
+          tags,
+          prioritySet: priority !== void 0,
+          draftCreateCount: response.data.draftCreateCount ?? 0
+        })
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+export {
+  createCommand
+};
+//# sourceMappingURL=create-HOZVJTLQ.js.map