@koda-sl/baker-cli 0.442.0 → 0.443.0-dev.043c1d4ac

package/dist/chunk-NGT6MARJ.js

@@ -1,274 +0,0 @@
-import {
-  chatgptDraftOpInputSchema,
-  chatgptFailure
-} from "./chunk-4VKV3DNC.js";
-import {
-  writeJsonEnvelope
-} from "./chunk-6YWRJMGR.js";
-import {
-  ApiError,
-  apiPost
-} from "./chunk-EPK2GYLV.js";
-import {
-  requireChatId
-} from "./chunk-SXRSLUW7.js";
-import {
-  registerSchema
-} from "./chunk-JIHG6K7N.js";
-
-// src/commands/ads/chatgpt/write-shared.ts
-import { defineCommand } from "citty";
-function fail(envelope) {
-  writeJsonEnvelope({ ...envelope });
-  process.exit(1);
-}
-function failWriteValidation(message) {
-  fail({
-    ok: false,
-    error: {
-      code: "VALIDATION_ERROR",
-      message,
-      fix: { action: "add_required_field", explanation: `${message}. Nothing was staged.` },
-      retryable: false
-    }
-  });
-}
-function writeFailure(err, reference) {
-  if (!(err instanceof ApiError) && err instanceof Error && err.message.includes("BAKER_CHAT_ID")) {
-    return {
-      ok: false,
-      error: {
-        code: "NO_CHAT",
-        message: err.message,
-        fix: {
-          action: "reject",
-          explanation: "ChatGPT Ads changes are staged on a chat and apply when it is published; run this from the chat."
-        },
-        retryable: false
-      }
-    };
-  }
-  return chatgptFailure(err, reference);
-}
-function decimalPlaces(value) {
-  const [mantissa, exponent] = String(value).trim().split(/e/i);
-  const written = (mantissa?.split(".")[1] ?? "").length;
-  return Math.max(0, written - (exponent ? Number(exponent) : 0));
-}
-function parseChatgptMoney(value) {
-  if (value === void 0 || value === "") {
-    return { ok: true, micros: void 0 };
-  }
-  const amount = Number(value);
-  if (!Number.isFinite(amount) || amount <= 0) {
-    return { ok: false, reason: "must be a positive amount, for example 12.50" };
-  }
-  if (decimalPlaces(value) > 6) {
-    return { ok: false, reason: "is finer than ChatGPT Ads can express" };
-  }
-  return { ok: true, micros: Math.round(amount * 1e6) };
-}
-function microsFromArg(value, flag) {
-  const parsed = parseChatgptMoney(value);
-  if (!parsed.ok) {
-    failWriteValidation(`${flag} ${parsed.reason}`);
-  }
-  return parsed.micros;
-}
-function csvArg(value) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    return void 0;
-  }
-  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
-  return parts.length > 0 ? parts : void 0;
-}
-function schemaArgs(args) {
-  return Object.fromEntries(
-    Object.entries(args).map(([name, arg]) => [
-      name,
-      {
-        type: arg.type === "positional" ? "string" : arg.type,
-        description: arg.description,
-        required: arg.required === true
-      }
-    ])
-  );
-}
-function lowerArg(value) {
-  return typeof value === "string" && value.trim() !== "" ? value.trim().toLowerCase() : void 0;
-}
-function lowerCsvArg(value) {
-  return csvArg(value)?.map((part) => part.toLowerCase());
-}
-function compact(payload) {
-  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0 && value !== ""));
-}
-function requireTarget(args, name) {
-  const value = args[name];
-  if (typeof value !== "string" || value.trim().length === 0) {
-    failWriteValidation(`${name} is required`);
-  }
-  return value.trim();
-}
-function requireTargets(args, name) {
-  const ids = csvArg(args[name]);
-  if (!ids) {
-    failWriteValidation(`${name} is required \u2014 pass one or more ids, comma-separated`);
-  }
-  return ids;
-}
-function preflight(raw) {
-  const parsed = chatgptDraftOpInputSchema.safeParse(raw);
-  if (parsed.success) {
-    return parsed.data;
-  }
-  const fields = parsed.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }));
-  const message = fields.map((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; ");
-  return fail({
-    ok: false,
-    error: {
-      code: "VALIDATION_ERROR",
-      message,
-      fix: {
-        action: "retry_with_modified_query",
-        explanation: "Fix the named fields and stage again. Nothing was staged \u2014 the draft is as it was before this call."
-      },
-      retryable: false
-    }
-  });
-}
-async function postStage(chatId, op) {
-  return await apiPost("/api/ads/chatgpt/draft/stage", { chatId, op });
-}
-async function stageChatgptOp(raw, reference, hintsFor) {
-  const op = preflight(raw);
-  try {
-    const staged = await postStage(requireChatId(), op);
-    const hints = hintsFor?.(staged) ?? [];
-    writeJsonEnvelope({ ok: true, data: staged, ...hints.length > 0 ? { hints } : {} });
-  } catch (err) {
-    fail(writeFailure(err, reference));
-  }
-}
-async function stageChatgptOps(raws, reference) {
-  if (raws.length === 1 && raws[0]) {
-    await stageChatgptOp(raws[0], reference);
-    return;
-  }
-  const ops = raws.map(preflight);
-  const staged = [];
-  try {
-    const chatId = requireChatId();
-    for (const op of ops) {
-      staged.push(await postStage(chatId, op));
-    }
-    writeJsonEnvelope({ ok: true, data: staged });
-  } catch (err) {
-    const failure = writeFailure(err, reference);
-    if (staged.length > 0) {
-      failure.error.message = `${failure.error.message} (already staged: ${staged.map((s) => s.summary).join("; ")})`;
-    }
-    fail(failure);
-  }
-}
-function clearableCsvArg(value) {
-  return typeof value === "string" && value.trim().toLowerCase() === "none" ? [] : csvArg(value);
-}
-function clearableArg(value) {
-  if (typeof value !== "string" || value.trim() === "") {
-    return void 0;
-  }
-  return value.trim().toLowerCase() === "none" ? null : value.trim();
-}
-function cropArg(value, flag) {
-  const parts = csvArg(value);
-  if (!parts) {
-    return void 0;
-  }
-  const numbers = parts.map(Number);
-  const [x, y, width, height] = numbers;
-  if (numbers.length !== 4 || numbers.some(Number.isNaN) || x === void 0 || y === void 0 || width === void 0 || height === void 0) {
-    failWriteValidation(`${flag} takes four shares of the image, x,y,width,height \u2014 e.g. 0.1,0,0.8,0.8`);
-  }
-  return { x, y, width, height };
-}
-var STATUS_OF = {
-  pause: "paused",
-  resume: "active",
-  archive: "archived"
-};
-function statusOps(entity, ids, status) {
-  return ids.map((id) => ({ kind: `${entity}.update`, target: id, payload: { status } }));
-}
-var STATUS_NOUN = {
-  campaign: { command: "campaigns", plural: "campaigns", example: "cmpn_123,cmpn_456" },
-  adGroup: { command: "ad-groups", plural: "ad groups", example: "adgrp_123,adgrp_456" },
-  ad: { command: "ads", plural: "cards", example: "ad_123,ad_456" }
-};
-var STATUS_DOING = { pause: "pausing", resume: "resuming", archive: "archiving" };
-function statusCommand(entity, verb, reference) {
-  const noun = STATUS_NOUN[entity];
-  const args = {
-    ids: { type: "positional", description: `${noun.plural} ids, comma-separated`, required: true }
-  };
-  const forGood = verb === "archive" ? ` Archiving is for good: ChatGPT Ads cannot bring archived ${noun.plural} back, and their results stay in reports. Pause instead unless the user asked to archive.` : "";
-  registerSchema({
-    command: `ads.chatgpt.${noun.command}.${verb}`,
-    description: `Stage ${STATUS_DOING[verb]} one or more ChatGPT Ads ${noun.plural}. Pass every id in one call.${forGood}`,
-    args: schemaArgs(args)
-  });
-  return defineCommand({
-    meta: {
-      name: verb,
-      description: `Stage ${STATUS_DOING[verb]} ${noun.plural}.${forGood}
-
-Example:
-  baker ads chatgpt ${noun.command} ${verb} ${noun.example}`
-    },
-    args,
-    run: async ({ args: parsed }) => {
-      await stageChatgptOps(statusOps(entity, requireTargets(parsed, "ids"), STATUS_OF[verb]), reference);
-    }
-  });
-}
-function productFiltersArg(value) {
-  if (typeof value !== "string" || value.trim() === "") {
-    return void 0;
-  }
-  if (value.trim().toLowerCase() === "none") {
-    return [];
-  }
-  return value.split(";").map((condition) => condition.trim()).filter(Boolean).map((condition) => {
-    const match = /^(\S+)\s+(\S+)\s+(.+)$/.exec(condition);
-    if (!match?.[1] || !match[2] || !match[3]) {
-      failWriteValidation(
-        `"${condition}" is not a product filter \u2014 write field operator values, e.g. price lte 5000`
-      );
-    }
-    return {
-      field: match[1],
-      operator: match[2].toLowerCase(),
-      values: match[3].split("|").map((part) => part.trim()).filter(Boolean)
-    };
-  });
-}
-
-export {
-  failWriteValidation,
-  microsFromArg,
-  csvArg,
-  schemaArgs,
-  lowerArg,
-  lowerCsvArg,
-  compact,
-  requireTarget,
-  requireTargets,
-  stageChatgptOp,
-  stageChatgptOps,
-  clearableCsvArg,
-  clearableArg,
-  cropArg,
-  statusCommand,
-  productFiltersArg
-};
-//# sourceMappingURL=chunk-NGT6MARJ.js.map

package/dist/chunk-NGYKF4T6.js

@@ -1,20 +0,0 @@
-import {
-  ANALYTICS_BUSY_FIX,
-  isAnalyticsBusy
-} from "./chunk-SSJK7FEV.js";
-import {
-  ApiError
-} from "./chunk-EPK2GYLV.js";
-
-// src/commands/analytics/errorEnvelope.ts
-function analyticsErrorEnvelope(err) {
-  if (err instanceof ApiError) {
-    return isAnalyticsBusy(err.message) ? { code: err.code, message: err.message, fix: ANALYTICS_BUSY_FIX } : { code: err.code, message: err.message };
-  }
-  return { code: "NETWORK_ERROR", message: err instanceof Error ? err.message : "Unexpected error" };
-}
-
-export {
-  analyticsErrorEnvelope
-};
-//# sourceMappingURL=chunk-NGYKF4T6.js.map

package/dist/chunk-NMMKTPGI.js

@@ -1,136 +0,0 @@
-import {
-  coercePathUrlToUrl,
-  looksLikeHttpUrl
-} from "./chunk-QTERC4PG.js";
-
-// src/commands/canvas/resolve-paths.ts
-import path from "path";
-function resolveRelativeCanvasPaths(canvas, baseDir) {
-  if (!canvas || typeof canvas !== "object") return canvas;
-  const c = canvas;
-  if (!Array.isArray(c.nodes)) return canvas;
-  return { ...canvas, nodes: c.nodes.map((n) => resolveNode(n, baseDir)) };
-}
-function localPathParam(node) {
-  if (node.type === "ingest") return node.params?.source === "path" ? "path" : null;
-  if (node.type === "hyperframe_render" || node.type === "hyperframe_snapshot") return "composition";
-  return null;
-}
-function resolveNode(node, baseDir) {
-  if (!node || typeof node !== "object") return node;
-  const n = node;
-  const params = n.params;
-  if (!params || typeof params !== "object") return node;
-  const key = localPathParam(n);
-  if (key && isResolvableRelative(params[key])) {
-    return { ...node, params: { ...params, [key]: path.resolve(baseDir, params[key]) } };
-  }
-  return node;
-}
-function isResolvableRelative(value) {
-  return typeof value === "string" && value.length > 0 && !value.includes("[TODO") && !looksLikeHttpUrl(value) && !path.isAbsolute(value);
-}
-
-// src/commands/canvas/normalize-paths.ts
-import { existsSync, realpathSync } from "fs";
-import { writeFile } from "fs/promises";
-import path2 from "path";
-function findWorkspaceRoot(startDir, exists = existsSync, maxDepth = 12) {
-  let dir = path2.resolve(startDir);
-  for (let i = 0; i < maxDepth; i++) {
-    if (exists(path2.join(dir, "package.json"))) return dir;
-    const parent = path2.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function canvasOutputsRoot(canvasFile, cwd = process.cwd(), exists = existsSync) {
-  const root = findWorkspaceRoot(path2.dirname(path2.resolve(cwd, canvasFile)), exists) ?? cwd;
-  return path2.join(root, "canvas");
-}
-function canonicalize(target) {
-  const abs = path2.resolve(target);
-  let dir = abs;
-  for (; ; ) {
-    try {
-      const real = realpathSync(dir);
-      return dir === abs ? real : path2.join(real, path2.relative(dir, abs));
-    } catch {
-      const parent = path2.dirname(dir);
-      if (parent === dir) return abs;
-      dir = parent;
-    }
-  }
-}
-function isInside(root, target) {
-  const rel = path2.relative(root, target);
-  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
-}
-function toCanvasRelative(canvasDir, target) {
-  return path2.relative(canvasDir, target).split(path2.sep).join("/");
-}
-var RUNTIME_WORKSPACE_ROOT = "/home/user/repo";
-function rewriteTarget(value, workspaceRoot) {
-  if (typeof value !== "string" || value.length === 0) return null;
-  if (value.includes("[TODO") || looksLikeHttpUrl(value) || !path2.isAbsolute(value)) return null;
-  const target = canonicalize(value);
-  if (isInside(workspaceRoot, target)) return target;
-  const fromRuntime = path2.relative(RUNTIME_WORKSPACE_ROOT, path2.normalize(value));
-  if (fromRuntime !== "" && !fromRuntime.startsWith("..") && !path2.isAbsolute(fromRuntime)) {
-    return path2.join(workspaceRoot, fromRuntime);
-  }
-  return null;
-}
-function normalizeCanvasPaths(canvas, canvasDir, workspaceRoot) {
-  if (!canvas || typeof canvas !== "object") return { canvas, rewrites: [] };
-  const c = canvas;
-  if (!Array.isArray(c.nodes)) return { canvas, rewrites: [] };
-  const root = canonicalize(workspaceRoot);
-  const dir = canonicalize(canvasDir);
-  const rewrites = [];
-  const nodes = c.nodes.map((node) => {
-    if (!node || typeof node !== "object") return node;
-    const n = node;
-    const params = n.params;
-    if (!params || typeof params !== "object") return node;
-    const nodeId = typeof n.id === "string" ? n.id : "?";
-    if (n.type === "ingest" && params.source === "path" && looksLikeHttpUrl(params.path)) {
-      rewrites.push({ nodeId, param: "source", from: "path", to: "url" });
-      return { ...node, params: coercePathUrlToUrl(params) };
-    }
-    const key = localPathParam(n);
-    if (!key) return node;
-    const target = rewriteTarget(params[key], root);
-    if (target === null) return node;
-    const to = toCanvasRelative(dir, target);
-    rewrites.push({ nodeId, param: key, from: params[key], to });
-    return { ...node, params: { ...params, [key]: to } };
-  });
-  return rewrites.length === 0 ? { canvas, rewrites } : { canvas: { ...canvas, nodes }, rewrites };
-}
-async function healCanvasPaths(filePath, canvas) {
-  const canvasDir = path2.dirname(filePath);
-  const workspaceRoot = findWorkspaceRoot(canvasDir);
-  if (!workspaceRoot) return { canvas, rewrites: [], text: null };
-  const normalized = normalizeCanvasPaths(canvas, canvasDir, workspaceRoot);
-  if (normalized.rewrites.length === 0) return { ...normalized, text: null };
-  const text = `${JSON.stringify(normalized.canvas, null, 2)}
-`;
-  await writeFile(filePath, text, "utf8");
-  return { ...normalized, text };
-}
-function describeRewrites(rewrites) {
-  return rewrites.map((r) => `  ${r.nodeId}.${r.param}: ${r.from} \u2192 ${r.to}`).join("\n");
-}
-
-export {
-  resolveRelativeCanvasPaths,
-  localPathParam,
-  findWorkspaceRoot,
-  canvasOutputsRoot,
-  normalizeCanvasPaths,
-  healCanvasPaths,
-  describeRewrites
-};
-//# sourceMappingURL=chunk-NMMKTPGI.js.map