@koda-sl/baker-cli 0.481.0-dev.2d33e194f → 0.498.0-dev.e2ca08ce6

package/dist/chunk-OTLYELOW.js

@@ -0,0 +1,111 @@
+import {
+  prepareCanvas,
+  unsuppliedPlaceholderAssets
+} from "./chunk-FHYUIYU5.js";
+import {
+  isSourceStale
+} from "./chunk-MV2J73HP.js";
+
+// src/commands/canvas/render-state.ts
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+var RENDER_STATE_DIR = ".rendered";
+function statePath(canvasRoot, slug) {
+  return path.join(canvasRoot, RENDER_STATE_DIR, `${slug}.json`);
+}
+async function readRenderState(canvasRoot, slug) {
+  try {
+    const parsed = JSON.parse(await readFile(statePath(canvasRoot, slug), "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function latestVersion(canvasRoot, slug) {
+  return (await readRenderState(canvasRoot, slug)).rendered?.runId ?? null;
+}
+async function updateRenderState(canvasRoot, slug, patch) {
+  try {
+    const next = { ...await readRenderState(canvasRoot, slug), ...patch };
+    await mkdir(path.join(canvasRoot, RENDER_STATE_DIR), { recursive: true });
+    await writeFile(statePath(canvasRoot, slug), `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  } catch {
+  }
+}
+async function recordRenderAttempt(canvasRoot, slug, sourceSha) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, { attempted: { sourceSha, at: Date.now() } });
+}
+async function recordRendered(canvasRoot, slug, sourceSha, runId, drawn = {}) {
+  if (!sourceSha) return;
+  await updateRenderState(canvasRoot, slug, {
+    rendered: { sourceSha, runId, at: Date.now() },
+    ...drawn.prompt !== void 0 ? { prompt: drawn.prompt } : {},
+    lastFix: drawn.lastFix,
+    picture: drawn.picture,
+    ...drawn.seriesLeadRun ? { seriesLeadRun: drawn.seriesLeadRun } : {}
+  });
+}
+async function recordReviewOutcome(canvasRoot, slug, outcome) {
+  await updateRenderState(canvasRoot, slug, outcome);
+}
+async function recordSeriesLeadRun(canvasRoot, slug, leadRunId) {
+  await updateRenderState(canvasRoot, slug, { seriesLeadRun: leadRunId });
+}
+async function recordSnapshot(canvasRoot, slug, snapshot) {
+  await updateRenderState(canvasRoot, slug, { snapshot });
+}
+function isRenderStale(state, currentSourceSha) {
+  if (!state.rendered) return false;
+  if (!isSourceStale(currentSourceSha, state.rendered.sourceSha)) return false;
+  return state.attempted?.sourceSha !== currentSourceSha;
+}
+async function staleCreatives(workspaceRoot) {
+  const creativesDir = path.join(workspaceRoot, "src", "creatives");
+  const canvasRoot = path.join(workspaceRoot, "canvas");
+  let slugs;
+  try {
+    slugs = (await readdir(creativesDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const stale = [];
+  for (const slug of slugs.sort()) {
+    const state = await readRenderState(canvasRoot, slug);
+    if (!state.rendered) continue;
+    const canvasPath = path.join(creativesDir, slug, `${slug}.canvas.json`);
+    let prepared;
+    try {
+      prepared = await prepareCanvas(canvasPath, { write: false });
+    } catch {
+      continue;
+    }
+    if (unsuppliedPlaceholderAssets(prepared.fileGraph).length > 0) continue;
+    const current = prepared.sourceSha;
+    if (!current || !isRenderStale(state, current)) continue;
+    stale.push({
+      slug,
+      canvasPath: path.relative(workspaceRoot, canvasPath).split(path.sep).join("/"),
+      renderedRunId: state.rendered.runId,
+      sourceSha: current
+    });
+  }
+  return stale;
+}
+async function clearLegacyDirtyMarker(canvasRoot, slug) {
+  await rm(path.join(canvasRoot, ".dirty", `${slug}.json`), { force: true }).catch(() => void 0);
+}
+
+export {
+  readRenderState,
+  latestVersion,
+  recordRenderAttempt,
+  recordRendered,
+  recordReviewOutcome,
+  recordSeriesLeadRun,
+  recordSnapshot,
+  staleCreatives,
+  clearLegacyDirtyMarker
+};
+//# sourceMappingURL=chunk-OTLYELOW.js.map

package/dist/chunk-OTNGMKI6.js

@@ -0,0 +1,309 @@
+import {
+  ApiError,
+  apiGet
+} from "./chunk-OSWCEDFE.js";
+import {
+  getEnv
+} from "./chunk-FZKUUI3F.js";
+
+// src/error-handler.ts
+var REQUEST_CONNECTION_PLATFORM = {
+  google_ads: "google-ads",
+  ga4: "google-analytics",
+  gsc: "google-search-console",
+  linkedin_ads: "linkedin",
+  meta_ads: "meta",
+  x_ads: "x-ads"
+};
+var PLATFORM_NAME = {
+  google_ads: "Google Ads",
+  ga4: "Google Analytics 4",
+  gsc: "Google Search Console",
+  x_ads: "X Ads",
+  meta_ads: "Meta Ads",
+  linkedin_ads: "LinkedIn Ads"
+};
+function connectionFixExplanation(platform) {
+  const name = PLATFORM_NAME[platform];
+  const slug = REQUEST_CONNECTION_PLATFORM[platform];
+  return `${name} is not connected for this company (or no account has been picked). Don't send the user to Settings or end the turn here \u2014 call the \`request_connection\` tool with { platform: "${slug}", reason } and they connect and pick their accounts from inside the chat. If the \`request_connection\` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 ${name}. Then carry on with the rest of the task and say what stays unavailable until it is connected.`;
+}
+function handleConnectionError(platform, originalMessage) {
+  const platformName = PLATFORM_NAME[platform];
+  const alternative = {
+    google_ads: "keywords-for-site or research advertisers",
+    ga4: "lighthouse for page performance",
+    gsc: "keywords-for-site or research keyword-gap",
+    x_ads: "research advertisers",
+    meta_ads: "research advertisers or research keyword-ideas",
+    linkedin_ads: "research advertisers (LinkedIn Ad Library) or research keyword-ideas"
+  }[platform];
+  const code = {
+    google_ads: "NO_GOOGLE_ADS_CONNECTION",
+    ga4: "NO_GA4_CONNECTION",
+    gsc: "NO_GSC_CONNECTION",
+    x_ads: "NO_X_ADS_CONNECTION",
+    meta_ads: "NO_META_ADS_CONNECTION",
+    linkedin_ads: "NO_LINKEDIN_ADS_CONNECTION"
+  }[platform];
+  const envelope = {
+    ok: false,
+    error: {
+      code,
+      message: originalMessage || `No ${platformName} connection found for this company.`,
+      fix: {
+        action: "request_connection",
+        explanation: `${connectionFixExplanation(platform)} (Optional fallback for estimated external insights: 'baker research ${alternative}'.)`
+      },
+      retryable: false
+    }
+  };
+  writeJsonEnvelope(envelope);
+  process.exit(1);
+}
+function isNotConnectedError(code, message) {
+  if (code !== "NOT_FOUND" && code !== "UNAUTHORIZED" && code !== "FORBIDDEN") {
+    return false;
+  }
+  return /no .* connection found|not connected|no .* (selected|picked)|is not in .* connected/i.test(message);
+}
+function needsConnectionFix(code, message) {
+  if (code === "UNAUTHORIZED") {
+    return true;
+  }
+  return isNotConnectedError(code, message);
+}
+
+// src/commands/ads/cache.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CACHE_DIR = join(homedir(), ".baker", "cache", "ads");
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function hashKey(key) {
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+function cachePath(category, key) {
+  const dir = join(CACHE_DIR, category);
+  ensureDir(dir);
+  return join(dir, `${hashKey(key)}.json`);
+}
+function cacheGet(category, key) {
+  const path = cachePath(category, key);
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const entry = JSON.parse(raw);
+    if (entry.expiresAt < Date.now()) {
+      rmSync(path, { force: true });
+      return null;
+    }
+    return entry;
+  } catch {
+    rmSync(path, { force: true });
+    return null;
+  }
+}
+function cacheSet(category, key, data, ttlMs, fields) {
+  const path = cachePath(category, key);
+  const entry = {
+    expiresAt: Date.now() + ttlMs,
+    data,
+    fields
+  };
+  writeFileSync(path, JSON.stringify(entry), "utf-8");
+}
+var HOUR = 60 * 60 * 1e3;
+var MINUTE = 60 * 1e3;
+function getQueryTtl(query) {
+  const upper = query.toUpperCase();
+  if (upper.includes("TODAY")) {
+    return 15 * MINUTE;
+  }
+  if (upper.includes("LAST_7_DAYS") || upper.includes("LAST_14_DAYS")) {
+    return 1 * HOUR;
+  }
+  return 6 * HOUR;
+}
+function buildQueryCacheKey(customerId, query) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return `${customerId}:${today}:${query.trim().replace(/\s+/g, " ")}`;
+}
+function getManagerIdForCustomer(customerId) {
+  const cached = cacheGet("accounts", "list");
+  if (!cached) return void 0;
+  const account = cached.data.find((a) => a.id === customerId);
+  if (account?.access_type === "managed") return account.manager_id;
+  return void 0;
+}
+
+// src/commands/ads/output.ts
+function writeAdsJson(envelope) {
+  process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+}
+function writeJsonEnvelope(envelope) {
+  process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+}
+var TABLE_OUTPUT_FORMATS = ["json", "csv", "jsonl", "md"];
+function outputFormatRefusal(format, supported) {
+  if (supported.includes(format)) return null;
+  const list = supported.length > 1 ? `${supported.slice(0, -1).join(", ")} or ${supported.at(-1)}` : supported.join("");
+  return `--output ${format} is not supported \u2014 use ${list}`;
+}
+function toCsvRow(values) {
+  return values.map((v) => {
+    if (v.includes(",") || v.includes('"') || v.includes("\n")) {
+      return `"${v.replace(/"/g, '""')}"`;
+    }
+    return v;
+  }).join(",");
+}
+function flattenRow(row) {
+  const flat = {};
+  for (const [key, val] of Object.entries(row)) {
+    flat[key] = typeof val === "object" && val !== null ? JSON.stringify(val) : String(val ?? "");
+  }
+  return flat;
+}
+function writeWhole(lines) {
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+function writeAdsCsv(data, fields) {
+  if (data.length === 0) return;
+  const cols = fields ?? Object.keys(data[0] ?? {});
+  const lines = [toCsvRow(cols)];
+  for (const row of data) {
+    const flat = flattenRow(row);
+    lines.push(toCsvRow(cols.map((f) => flat[f] ?? "")));
+  }
+  writeWhole(lines);
+}
+function writeAdsJsonl(data) {
+  if (data.length === 0) return;
+  writeWhole(data.map((row) => JSON.stringify(row)));
+}
+function mdCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function writeAdsMd(data, fields) {
+  if (data.length === 0) return;
+  const cols = fields ?? Object.keys(data[0] ?? {});
+  const lines = [`| ${cols.join(" | ")} |`, `| ${cols.map(() => "---").join(" | ")} |`];
+  for (const row of data) {
+    const flat = flattenRow(row);
+    lines.push(`| ${cols.map((f) => mdCell(flat[f] ?? "")).join(" | ")} |`);
+  }
+  writeWhole(lines);
+}
+function writeAdsOutput(data, format, fields, hints = []) {
+  switch (format) {
+    case "csv":
+      writeAdsCsv(data, fields);
+      break;
+    case "jsonl":
+      writeAdsJsonl(data);
+      break;
+    case "md":
+      writeAdsMd(data, fields);
+      break;
+    default:
+      writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+      return;
+  }
+  for (const hint of hints) process.stderr.write(`${hint}
+`);
+}
+async function fetchAccounts(useCache = true) {
+  if (useCache) {
+    const cached = cacheGet("accounts", "list");
+    if (cached) return cached.data;
+  }
+  const params = !useCache ? { "skip-cache": "true" } : void 0;
+  const data = await apiGet("/api/ads/google/accounts", params);
+  if (useCache) {
+    cacheSet("accounts", "list", data, 60 * 60 * 1e3);
+  }
+  return data;
+}
+async function resolveCustomerId(args) {
+  const fromArgs = args["customer-id"];
+  const customerId = fromArgs || getEnv().BAKER_GOOGLE_ADS_CUSTOMER_ID;
+  if (customerId) {
+    if (!/^\d{10}$/.test(customerId)) {
+      writeAdsJson({
+        ok: false,
+        error: {
+          code: "INVALID_CUSTOMER_ID",
+          message: "Customer ID must be exactly 10 digits without dashes. Pass --customer-id or set BAKER_GOOGLE_ADS_CUSTOMER_ID."
+        }
+      });
+      process.exit(1);
+    }
+    return customerId;
+  }
+  const useCache = !args["no-cache"];
+  try {
+    const accounts = await fetchAccounts(useCache);
+    const [single] = accounts;
+    if (accounts.length === 1 && single) {
+      process.stderr.write(`Using account "${single.name}" (${single.id})
+`);
+      return single.id;
+    }
+    if (accounts.length === 0) {
+      handleConnectionError("google_ads");
+    }
+    const list = accounts.map((a) => `  ${a.id}  ${a.name}`).join("\n");
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MULTIPLE_ACCOUNTS",
+        message: `Multiple accounts found. Pass --customer-id or set BAKER_GOOGLE_ADS_CUSTOMER_ID:
+${list}`
+      }
+    });
+    process.exit(1);
+  } catch (err) {
+    if (err instanceof ApiError && isNotConnectedError(err.code, err.message)) {
+      handleConnectionError("google_ads", err.message);
+    }
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_CUSTOMER_ID",
+        message: "Could not auto-detect account. Pass --customer-id or set BAKER_GOOGLE_ADS_CUSTOMER_ID."
+      }
+    });
+    process.exit(1);
+  }
+}
+
+export {
+  cacheGet,
+  cacheSet,
+  getQueryTtl,
+  buildQueryCacheKey,
+  getManagerIdForCustomer,
+  writeAdsJson,
+  writeJsonEnvelope,
+  TABLE_OUTPUT_FORMATS,
+  outputFormatRefusal,
+  toCsvRow,
+  writeAdsOutput,
+  resolveCustomerId,
+  connectionFixExplanation,
+  handleConnectionError,
+  isNotConnectedError,
+  needsConnectionFix
+};
+//# sourceMappingURL=chunk-OTNGMKI6.js.map

package/dist/chunk-PAJJXZ3Z.js

@@ -0,0 +1,170 @@
+import {
+  CONVERSION_COUNT_MODES,
+  findNameCollision,
+  isLandingViewKey,
+  parseEventKey
+} from "./chunk-BC2BXRXY.js";
+
+// src/commands/analytics/conversionArgs.ts
+var ConversionArgsError = class extends Error {
+};
+function allValues(flag, argv) {
+  const values = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === flag) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) values.push(next);
+      continue;
+    }
+    if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
+  }
+  return values.map((value) => value.trim()).filter((value) => value !== "");
+}
+function onlyOnce(value, flag, argv) {
+  if (value === void 0) return void 0;
+  const given = argv.filter((arg) => arg === flag || arg.startsWith(`${flag}=`)).length;
+  if (given > 1) {
+    throw new ConversionArgsError(
+      `${flag} was given ${given} times and only the last would have been used. It takes one value.`
+    );
+  }
+  const trimmed = String(value).trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function repeatable(flag, cittyValue, argv) {
+  const fromArgv = allValues(flag, argv);
+  if (fromArgv.length > 0) return fromArgv;
+  if (cittyValue === void 0) return [];
+  const trimmed = String(cittyValue).trim();
+  return trimmed === "" ? [] : [trimmed];
+}
+function checkFlagShape(args) {
+  if (args.eventKeys.length > 0 && args.name === void 0 && args.countMode === void 0) {
+    throw new ConversionArgsError(
+      "--event needs --name: a conversion nobody named is a row labelled with a UUID. (--event with only --count-mode changes how an event already counted is counted.)"
+    );
+  }
+  if (args.name !== void 0 && args.eventKeys.length === 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError("--name needs --event, naming which event to count.");
+  }
+  if (args.renameFrom !== void 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError('--rename needs --to: `--rename "Lead form" --to "Lead"`.');
+  }
+  if (args.renameTo !== void 0 && args.renameFrom === void 0) {
+    throw new ConversionArgsError(
+      '--to needs --rename, naming which outcome to rename: `--rename "Lead form" --to "Lead"`.'
+    );
+  }
+}
+function checkEventKeys(eventKeys) {
+  for (const eventKey of eventKeys) {
+    if (parseEventKey(eventKey) === null) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not an event key. Run with --candidates (or --flow <slug> for one Form) and copy one; they look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or exit:<host>.`
+      );
+    }
+    if (isLandingViewKey(eventKey)) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is a landing being viewed \u2014 a funnel step, never a conversion. Add it as a step with \`baker funnel\` instead.`
+      );
+    }
+  }
+}
+function readDays(raw) {
+  if (raw === void 0) return void 0;
+  const days = Number(raw);
+  if (!Number.isFinite(days) || days <= 0) {
+    throw new ConversionArgsError("--days must be a positive number of days.");
+  }
+  return days;
+}
+function parseConversionsArgs(raw, argv) {
+  const countMode = onlyOnce(raw["count-mode"], "--count-mode", argv);
+  if (countMode !== void 0 && !CONVERSION_COUNT_MODES.includes(countMode)) {
+    throw new ConversionArgsError(`--count-mode must be one of ${CONVERSION_COUNT_MODES.join(", ")}.`);
+  }
+  const args = {
+    eventKeys: repeatable("--event", raw.event, argv),
+    removeKeys: repeatable("--remove", raw.remove, argv),
+    name: onlyOnce(raw.name, "--name", argv),
+    countMode,
+    renameFrom: onlyOnce(raw.rename, "--rename", argv),
+    renameTo: onlyOnce(raw.to, "--to", argv),
+    removeName: onlyOnce(raw["remove-name"], "--remove-name", argv),
+    flowSlug: onlyOnce(raw.flow, "--flow", argv),
+    candidates: raw.candidates === true,
+    full: raw.full === true,
+    days: readDays(raw.days)
+  };
+  checkFlagShape(args);
+  checkEventKeys(args.eventKeys);
+  return args;
+}
+function existingNames(existing) {
+  return [...new Set(existing.map((row) => row.name))];
+}
+function checkNameCollision(name, existing) {
+  const collision = findNameCollision(name, existingNames(existing));
+  if (collision === null) return;
+  throw new ConversionArgsError(
+    `This company already counts "${collision}", and "${name}" would be a second row for the same outcome \u2014 Baker groups by exact name, so the number would be split in two. Use "${collision}" to make them one number, or pick a name that means something different.`
+  );
+}
+function under(name, existing) {
+  const rows = existing.filter((row) => row.name === name);
+  if (rows.length === 0) {
+    throw new ConversionArgsError(
+      `Nothing is counted under "${name}". This company counts: ${existingNames(existing).join(", ") || "nothing yet"}.`
+    );
+  }
+  return rows;
+}
+function setFromEvents(args, existing) {
+  if (args.eventKeys.length === 0) return [];
+  if (args.name !== void 0) {
+    checkNameCollision(args.name, existing);
+    const name = args.name;
+    return args.eventKeys.map((eventKey) => ({
+      eventKey,
+      name,
+      ...args.countMode ? { countMode: args.countMode } : {}
+    }));
+  }
+  return args.eventKeys.map((eventKey) => {
+    const current = existing.find((row) => row.eventKey === eventKey);
+    if (!current) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not counted, so there is no count mode to change. Add it with --event "${eventKey}" --name "<what a person calls it>" --count-mode ${args.countMode}.`
+      );
+    }
+    return { eventKey, name: current.name, countMode: args.countMode };
+  });
+}
+function setFromRename(args, existing) {
+  if (args.renameFrom === void 0 || args.renameTo === void 0) return [];
+  const renameTo = args.renameTo;
+  checkNameCollision(renameTo, existing);
+  return under(args.renameFrom, existing).map((row) => ({
+    eventKey: row.eventKey,
+    name: renameTo,
+    countMode: row.countMode
+  }));
+}
+function conversionsWrite(args, existing) {
+  const set = [...setFromEvents(args, existing), ...setFromRename(args, existing)];
+  const remove = [
+    ...args.removeKeys,
+    ...args.removeName === void 0 ? [] : under(args.removeName, existing).map((row) => row.eventKey)
+  ];
+  if (set.length === 0 && remove.length === 0) return null;
+  return { ...set.length > 0 ? { set } : {}, ...remove.length > 0 ? { remove } : {} };
+}
+
+export {
+  ConversionArgsError,
+  onlyOnce,
+  parseConversionsArgs,
+  conversionsWrite
+};
+//# sourceMappingURL=chunk-PAJJXZ3Z.js.map