@koda-sl/baker-cli 0.498.0 → 0.499.0

package/dist/keyword-metrics-SRLCDGCB.js

@@ -0,0 +1,198 @@
+import {
+  keywordMetricsHints
+} from "./chunk-HW53ERJX.js";
+import {
+  RESEARCH_DATA_NOTE,
+  handleResearchError,
+  writeResearchHints,
+  writeResearchJson,
+  writeResearchOutput
+} from "./chunk-GSKZ3ZDO.js";
+import {
+  buildResearchQueryContext,
+  warnDefaults
+} from "./chunk-PGRDGQ23.js";
+import "./chunk-ANLLW3KZ.js";
+import {
+  RESEARCH_KEYWORD_METRICS_MAX_KEYWORDS
+} from "./chunk-RLDQDCW3.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-ERSL4WZT.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/keyword-metrics.ts
+import { defineCommand } from "citty";
+
+// src/commands/research/keyword-metrics-rows.ts
+var KEYWORD_METRICS_SOURCE = "keyword_planner_estimate_via_dataforseo";
+function toOutputRow(row, options) {
+  const out = {
+    source: KEYWORD_METRICS_SOURCE,
+    keyword: row.keyword,
+    planner_search_volume: row.search_volume,
+    planner_cpc: row.cpc,
+    planner_low_top_of_page_bid: row.low_top_of_page_bid,
+    planner_high_top_of_page_bid: row.high_top_of_page_bid,
+    planner_competition: row.competition,
+    planner_competition_index: row.competition_index
+  };
+  if (options.clickstream) {
+    out.clickstream_search_volume = row.clickstream_search_volume;
+  }
+  if (options.full) {
+    out.keyword_difficulty = row.keyword_difficulty;
+    out.main_intent = row.main_intent;
+    out.planner_monthly_searches = row.monthly_searches;
+  }
+  return out;
+}
+function keywordMetricsFields(options) {
+  const fields = {
+    source: `Always "${KEYWORD_METRICS_SOURCE}". Every planner_ column below is Google's Keyword Planner ESTIMATE of total market volume, resold by DataForSEO \u2014 the same number \`baker ads google keywords metrics\` returns, not an independent measurement of it. Columns without the planner_ prefix are DataForSEO's own.`,
+    keyword: "The keyword asked for. A row with every metric null means DataForSEO holds no data on it \u2014 not that nobody searches it.",
+    planner_search_volume: "ESTIMATE: average monthly searches across the whole market, last 12 months",
+    planner_cpc: "ESTIMATE: average cost per click in USD (a single blended figure, not a top-of-page range)",
+    planner_low_top_of_page_bid: "ESTIMATE: low-range top-of-page bid in USD",
+    planner_high_top_of_page_bid: "ESTIMATE: high-range top-of-page bid in USD",
+    planner_competition: "ESTIMATE: competition level \u2014 LOW, MEDIUM or HIGH",
+    planner_competition_index: "ESTIMATE: competition index 0-100 (higher = more advertisers)"
+  };
+  if (options.clickstream) {
+    fields.clickstream_search_volume = "DataForSEO's OWN volume estimate, from clickstream panels \u2014 not Google's, and the only number here that is a genuine second opinion on demand. Expect it to differ from planner_search_volume; that is the point.";
+  }
+  if (options.full) {
+    fields.keyword_difficulty = "DataForSEO's 0-100 estimate of how hard ranking in the organic top 10 would be";
+    fields.main_intent = "DataForSEO's intent classification: informational, navigational, commercial or transactional";
+    fields.planner_monthly_searches = "ESTIMATE: 12-month volume breakdown ({year, month, search_volume})";
+  }
+  return fields;
+}
+
+// src/commands/research/keyword-metrics.ts
+registerSchema({
+  command: "research.keyword-metrics",
+  description: "Search volume, CPC, top-of-page bids and competition for a list of keywords you name \u2014 no domain needed. This is the command for sizing a market you have keywords for; the domain-bound ones (keywords-for-site, keyword-gap) answer a different question and should not be used as a workaround for this one. The volume is Google's Keyword Planner figure resold by DataForSEO, so it is not a second opinion on `baker ads google keywords metrics` \u2014 for that, pass --clickstream. If --location and --language are omitted, defaults to United States (us) and English (en). The response includes a query_context object showing which location/language were used.",
+  args: {
+    keywords: {
+      type: "string",
+      description: `Comma-separated keywords (max ${RESEARCH_KEYWORD_METRICS_MAX_KEYWORDS}, 80 chars each)`,
+      required: true
+    },
+    location: {
+      type: "string",
+      description: "Country code (us, mx, br, es...) or DataForSEO location code. Defaults to us (United States) if omitted \u2014 always set this for non-US markets",
+      required: false
+    },
+    language: {
+      type: "string",
+      description: "Language code or name. Defaults to en (English) if omitted \u2014 always set this for non-English markets",
+      required: false
+    },
+    clickstream: {
+      type: "boolean",
+      description: "Also return DataForSEO's own panel-derived volume (clickstream_search_volume), the only genuinely independent estimate of demand available here. Costs 2x.",
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Add keyword difficulty, search intent and the 12-month volume trend to each row",
+      required: false
+    },
+    "no-cache": { type: "boolean", description: "Skip server cache, hit API directly", required: false }
+  }
+});
+var keywordMetricsCommand = defineCommand({
+  meta: {
+    name: "keyword-metrics",
+    description: `Volume, CPC and competition for keywords you name. No domain required.
+
+Numbers are Keyword Planner ESTIMATES of total market volume, resold by DataForSEO \u2014 every column carrying one is named planner_. Pass --clickstream for DataForSEO's own independent estimate alongside.
+
+Examples:
+  baker research keyword-metrics "chatbot whatsapp,agente whatsapp ecommerce" --location mx --language es
+  baker research keyword-metrics "chatbot whatsapp" --location br --language pt --clickstream
+  baker research keyword-metrics "crm software,best crm" --full --output md`
+  },
+  args: {
+    keywords: { type: "positional", description: "Comma-separated keywords", required: true },
+    location: { type: "string", description: "Country code or location code (default: us)", required: false },
+    language: { type: "string", description: "Language code or name (default: en)", required: false },
+    clickstream: { type: "boolean", description: "Add DataForSEO's own volume estimate (costs 2x)", required: false },
+    full: { type: "boolean", description: "Add difficulty, intent and the 12-month trend", required: false },
+    output: { type: "string", description: "Format: json|csv|md|jsonl", required: false, default: "json" },
+    "no-cache": { type: "boolean", description: "Skip server cache, hit API directly", required: false }
+  },
+  run: async ({ args }) => {
+    const keywords = args.keywords.split(",").map((k) => k.trim()).filter(Boolean);
+    if (keywords.length === 0) {
+      writeResearchJson({
+        ok: false,
+        error: { code: "VALIDATION_ERROR", message: "Provide at least one keyword" }
+      });
+      process.exit(1);
+    }
+    if (keywords.length > RESEARCH_KEYWORD_METRICS_MAX_KEYWORDS) {
+      writeResearchJson({
+        ok: false,
+        error: {
+          code: "VALIDATION_ERROR",
+          message: `Maximum ${RESEARCH_KEYWORD_METRICS_MAX_KEYWORDS} keywords per request`,
+          fix: {
+            action: "retry_with_changes",
+            explanation: `You sent ${keywords.length}. Split the list into batches of ${RESEARCH_KEYWORD_METRICS_MAX_KEYWORDS} and run the command once per batch \u2014 each batch is a separate charge, so batch by priority.`
+          }
+        }
+      });
+      process.exit(1);
+    }
+    const location = args.location || void 0;
+    const language = args.language || void 0;
+    const clickstream = Boolean(args.clickstream);
+    const full = Boolean(args.full);
+    const queryContext = buildResearchQueryContext(location, language);
+    try {
+      const result = await apiPost("/api/research/keyword-metrics", {
+        keywords,
+        location,
+        language,
+        includeClickstream: clickstream,
+        skipCache: args["no-cache"] ? true : void 0
+      });
+      const columns = { clickstream, full };
+      const rows = result.data.map((row) => toOutputRow(row, columns));
+      const hints = keywordMetricsHints({ rows: result.data, asked: keywords, clickstream, queryContext });
+      warnDefaults(queryContext);
+      const format = args.output || "json";
+      if (format !== "json") {
+        writeResearchOutput(rows, format);
+        writeResearchHints([...hints, RESEARCH_DATA_NOTE], format);
+        return;
+      }
+      writeResearchJson({
+        ok: true,
+        data: rows,
+        fields: keywordMetricsFields(columns),
+        note: RESEARCH_DATA_NOTE,
+        hints,
+        query_context: queryContext
+      });
+    } catch (err) {
+      handleResearchError(err);
+    }
+  }
+});
+export {
+  keywordMetricsCommand
+};
+//# sourceMappingURL=keyword-metrics-SRLCDGCB.js.map

package/dist/keywords-for-site-NIXJTFHX.js

@@ -0,0 +1,129 @@
+import {
+  keywordsForSiteHints
+} from "./chunk-HW53ERJX.js";
+import {
+  RESEARCH_DATA_NOTE,
+  handleResearchError,
+  writeResearchHints,
+  writeResearchJson,
+  writeResearchOutput
+} from "./chunk-GSKZ3ZDO.js";
+import {
+  buildResearchQueryContext,
+  warnDefaults
+} from "./chunk-PGRDGQ23.js";
+import "./chunk-ANLLW3KZ.js";
+import "./chunk-RLDQDCW3.js";
+import "./chunk-CAZGM2NX.js";
+import "./chunk-NZS3KEQ2.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-UI6BKYQD.js";
+import "./chunk-ERSL4WZT.js";
+import {
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/keywords-for-site.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "research.keywords-for-site",
+  description: "Get keywords a competitor targets in Google. Use --type paid to see only paid keywords, --type organic for organic only. If --location and --language are omitted, defaults to United States (us) and English (en). The response includes a query_context object showing which location/language were used.",
+  args: {
+    target: { type: "string", description: "Domain or URL to analyze (positional)", required: true },
+    location: {
+      type: "string",
+      description: "Country code (us, uk, es, de...) or DataForSEO location code. Defaults to us (United States) if omitted \u2014 always set this for non-US markets",
+      required: false
+    },
+    language: {
+      type: "string",
+      description: "Language code or name. Defaults to en (English) if omitted \u2014 always set this for non-English markets",
+      required: false
+    },
+    sort: {
+      type: "string",
+      description: "Sort: search_volume, competition, cpc (default: search_volume)",
+      required: false
+    },
+    type: { type: "string", description: "Filter: paid, organic, all (default: all)", required: false },
+    limit: { type: "string", description: "Max results (default: 50, max: 1000)", required: false },
+    "no-cache": { type: "boolean", description: "Skip server cache, hit API directly", required: false }
+  }
+});
+var FIELDS = {
+  keyword: "Keyword the site targets",
+  search_volume: "Monthly search volume",
+  cpc: "Cost per click in USD",
+  competition: "LOW, MEDIUM, or HIGH",
+  competition_index: "Competition score 0-100"
+};
+var keywordsForSiteCommand = defineCommand({
+  meta: {
+    name: "keywords-for-site",
+    description: `Get keywords a competitor targets in Google. Use --type to filter paid/organic.
+
+Examples:
+  baker research keywords-for-site "competitor.com"
+  baker research keywords-for-site "competitor.com" --type paid --limit 20
+  baker research keywords-for-site "competitor.com" --type organic --location uk`
+  },
+  args: {
+    target: { type: "positional", description: "Domain or URL to analyze", required: true },
+    location: { type: "string", description: "Country code or location code (default: us)", required: false },
+    language: { type: "string", description: "Language code or name (default: en)", required: false },
+    sort: { type: "string", description: "Sort: search_volume, competition, cpc", required: false },
+    type: { type: "string", description: "Filter: paid, organic, all (default: all)", required: false },
+    limit: { type: "string", description: "Max results (default: 50, max: 1000)", required: false },
+    output: { type: "string", description: "Format: json|csv|md|jsonl", required: false, default: "json" },
+    "no-cache": { type: "boolean", description: "Skip server cache, hit API directly", required: false }
+  },
+  run: async ({ args }) => {
+    const target = args.target;
+    const location = args.location || void 0;
+    const language = args.language || void 0;
+    const sort = args.sort || void 0;
+    const type = args.type || void 0;
+    const limit = args.limit ? Number(args.limit) : void 0;
+    const skipCache = args["no-cache"] ? true : void 0;
+    const queryContext = buildResearchQueryContext(location, language);
+    try {
+      const data = await apiPost("/api/research/keywords-for-site", {
+        target,
+        location,
+        language,
+        sort,
+        type,
+        limit,
+        skipCache
+      });
+      warnDefaults(queryContext);
+      const format = args.output || "json";
+      const hints = keywordsForSiteHints(data.length, queryContext, type);
+      if (format !== "json") {
+        writeResearchOutput(data, format);
+        writeResearchHints(hints, format);
+        return;
+      }
+      writeResearchJson({
+        ok: true,
+        data,
+        fields: FIELDS,
+        note: RESEARCH_DATA_NOTE,
+        query_context: queryContext,
+        hints
+      });
+    } catch (err) {
+      handleResearchError(err);
+    }
+  }
+});
+export {
+  keywordsForSiteCommand
+};
+//# sourceMappingURL=keywords-for-site-NIXJTFHX.js.map

package/dist/landing-GEGH44N7.js

@@ -0,0 +1,28 @@
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/index.ts
+import { defineCommand } from "citty";
+var landingCommand = defineCommand({
+  meta: {
+    name: "landing",
+    description: `Design-quality tools for landing pages (src/pages/<slug>/), and downloading the published ones.
+
+Start here: \`baker landing critique <slug>\` after building or editing a landing.
+
+Subcommands:
+  baker landing inspiration      \u2014 reference library of real landing-page sections; search it during research, BEFORE writing the Direction Contract. Inspiration only: take the mechanism, never the words.
+  baker landing variant <control> <slug> \u2014 the alternative version of a page for an A/B test: shares the control's sections, forks only the component you name, so the two arms differ by exactly your hypothesis. Run \`baker experiment plan\` first.
+  baker landing critique <slug>   \u2014 design-quality critic (advisory): flags the known AI 'slop' tells (gradient text, overused fonts, side-tab borders, cream palettes, broken images) and reads the copy in any language for buzzwords, AI copy tells and positioning integrity (copy ranking a competitor above the client), tiered block/warn/advisory, respecting the client's brand. Records the critique the publish quality gate requires \u2014 run it before finishing a landing.
+  baker landing export start      \u2014 download the PUBLISHED landings as a ZIP of plain HTML ("download my landings", "send me the HTML"); \`baker landing export status <id>\` gives the link.`
+  },
+  subCommands: {
+    inspiration: () => import("./inspiration-CW4ADEPT.js").then((m) => m.inspirationCommand),
+    critique: () => import("./critique-LA45SBLU.js").then((m) => m.critiqueCommand),
+    variant: () => import("./variant-NZL2ZMYM.js").then((m) => m.variantCommand),
+    export: () => import("./export-T5WPU75G.js").then((m) => m.exportCommand)
+  }
+});
+export {
+  landingCommand
+};
+//# sourceMappingURL=landing-GEGH44N7.js.map

package/dist/landings-FLELWQDN.js

@@ -0,0 +1,151 @@
+import {
+  reportError,
+  splitList
+} from "./chunk-XB63MQ6E.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  LANDING_ANALYSE_BATCH,
+  registerSchema,
+  writeJson
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/winning-ads/landings.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "winning-ads.landings",
+  description: "Every landing page one brand's ads send people to, the ones in use now first (a short or tracking link counts as the page it opens; Instant Forms, chats, app stores and social profiles are not pages): how many ads point there, how many still run, platforms, when each was used (`used`: one stretch per run of ads, `\u2192 now` while running), `address_only` on an address only Google search ads print (Google publishes no search ad's real destination, and the path need not exist \u2014 not analysed), and \u2014 once analysed \u2014 the page's headline, value propositions, offer, pricing, CTAs, proof, audience and sections in order. Compact by default; --full returns every field, the ads behind each page and its screenshot. --analyse studies the top pages not yet analysed (a few minutes each).",
+  args: {
+    advertiser: { type: "string", description: "Advertiser id (from `advertisers` or `following`)", required: true },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "Every field of every page", required: false, default: false },
+    analyse: {
+      type: "boolean",
+      description: `Analyse the top ${LANDING_ANALYSE_BATCH} pages not analysed yet (or those named in --pages)`,
+      required: false,
+      default: false
+    },
+    pages: {
+      type: "string",
+      description: `With --analyse: comma list of page urls to analyse instead (max ${LANDING_ANALYSE_BATCH})`,
+      required: false
+    }
+  }
+});
+var COMPACT_PAGES = 20;
+var COMPACT_VALUE_PROPS = 3;
+var day = (iso) => iso.slice(0, 10);
+function compactPage(p) {
+  const pitch = p.analysis.pitch;
+  return {
+    url: p.canonical_url,
+    in_use_now: p.active_ads > 0,
+    ads: p.ads,
+    running: p.active_ads,
+    platforms: p.platforms,
+    used: p.windows.map((w) => `${day(w.from)} \u2192 ${w.to ? day(w.to) : "now"}`),
+    last_seen_at: p.last_seen_at,
+    ...p.address_only ? { address_only: true } : {},
+    analysis: p.analysis.status,
+    ...pitch ? {
+      headline: pitch.headline,
+      value_propositions: pitch.value_propositions.slice(0, COMPACT_VALUE_PROPS),
+      offer: pitch.offer
+    } : {}
+  };
+}
+function compactLandings(report) {
+  return {
+    advertiser_id: report.advertiser_id,
+    total_pages: report.total_pages,
+    analysed: report.pages.filter((p) => p.analysis.status === "ready").length,
+    pages: report.pages.slice(0, COMPACT_PAGES).map(compactPage)
+  };
+}
+function pagesToAnalyse(report) {
+  return report.pages.filter((p) => !p.address_only && (p.analysis.status === "not_analysed" || p.analysis.status === "failed")).slice(0, LANDING_ANALYSE_BATCH).map((p) => p.canonical_url);
+}
+function landingsHints(report, advertiser) {
+  const hints = [];
+  const top = report.pages.slice(0, COMPACT_PAGES);
+  const pending = top.filter((p) => !p.address_only && p.analysis.status === "not_analysed").length;
+  const addressOnly = report.pages.filter((p) => p.address_only).length;
+  const analysing = report.pages.filter((p) => p.analysis.status === "analysing").length;
+  if (report.pages.length === 0) {
+    hints.push("No ad of this brand links to a landing page yet.");
+    return hints;
+  }
+  if (addressOnly > 0) {
+    hints.push(
+      `${addressOnly} ${addressOnly === 1 ? "address" : "addresses"} only Google search ads show (\`address_only\`): Google publishes no search ad's destination, only the address printed on it, whose path the brand types freely and need not exist. Quote it as the address the ad shows, never as a page the ads lead to; it is not analysed.`
+    );
+  }
+  if (pending > 0) {
+    hints.push(
+      `${pending} of the top pages are not analysed yet: \`baker winning-ads landings ${advertiser} --analyse\` studies the top ${LANDING_ANALYSE_BATCH} (value propositions, offer, pricing, proof, sections). It takes a few minutes; run this again to read them.`
+    );
+  }
+  if (analysing > 0) {
+    hints.push(`${analysing} pages are being analysed now: run this again in a few minutes.`);
+  }
+  if (report.pages.some((p) => p.analysis.status === "ready")) {
+    hints.push(
+      "--full returns each analysed page's whole read: pricing, CTAs, proof, audience and its sections in order."
+    );
+  }
+  return hints;
+}
+var landingsCommand = defineCommand({
+  meta: {
+    name: "landings",
+    description: "Every landing page a brand's ads point to, with how the page sells once analysed. Start here: baker winning-ads landings adv_123 (--analyse to study the top pages not analysed yet, --full for everything)"
+  },
+  args: {
+    advertiser: { type: "positional", description: "Advertiser id", required: true },
+    platform: { type: "string", description: "Only this platform: meta|linkedin|tiktok|google", required: false },
+    full: { type: "boolean", description: "Every field of every page", required: false, default: false },
+    analyse: {
+      type: "boolean",
+      description: `Analyse the top ${LANDING_ANALYSE_BATCH} pages not analysed yet`,
+      required: false,
+      default: false
+    },
+    pages: { type: "string", description: "With --analyse: comma list of page urls to analyse", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const advertiser = String(args.advertiser);
+      const params = { advertiser };
+      if (args.platform) params.platform = String(args.platform);
+      let report = await apiGet("/api/ad-library/landing-pages", params);
+      let started;
+      if (args.analyse) {
+        const named = args.pages ? splitList(String(args.pages)) : [];
+        const urls = named.length > 0 ? named.slice(0, LANDING_ANALYSE_BATCH) : pagesToAnalyse(report);
+        if (urls.length > 0) {
+          started = (await apiPost("/api/ad-library/landing-pages/analyse", { urls })).pages;
+          report = await apiGet("/api/ad-library/landing-pages", params);
+        }
+      }
+      writeJson({
+        ok: true,
+        data: { ...args.full ? report : compactLandings(report), ...started ? { analyse: started } : {} },
+        hints: landingsHints(report, advertiser)
+      });
+    } catch (err) {
+      reportError(err);
+    }
+  }
+});
+export {
+  compactLandings,
+  landingsCommand,
+  landingsHints,
+  pagesToAnalyse
+};
+//# sourceMappingURL=landings-FLELWQDN.js.map

package/dist/languages-J275RIZC.js

@@ -0,0 +1,55 @@
+import {
+  writeResearchJson
+} from "./chunk-GSKZ3ZDO.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/research/languages.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "research.languages",
+  description: "List all supported language codes for --language flag in research commands.",
+  args: {}
+});
+var LANGUAGES = [
+  { code: "en", name: "english" },
+  { code: "es", name: "spanish" },
+  { code: "fr", name: "french" },
+  { code: "de", name: "german" },
+  { code: "it", name: "italian" },
+  { code: "pt", name: "portuguese" },
+  { code: "nl", name: "dutch" },
+  { code: "ja", name: "japanese" },
+  { code: "ko", name: "korean" },
+  { code: "zh", name: "chinese" },
+  { code: "ar", name: "arabic" },
+  { code: "ru", name: "russian" },
+  { code: "pl", name: "polish" },
+  { code: "tr", name: "turkish" },
+  { code: "sv", name: "swedish" },
+  { code: "no", name: "norwegian" },
+  { code: "da", name: "danish" },
+  { code: "fi", name: "finnish" }
+];
+var FIELDS = {
+  code: "Language code to pass as --language",
+  name: "Language name (also accepted by --language)"
+};
+var languagesCommand = defineCommand({
+  meta: {
+    name: "languages",
+    description: "List all supported language codes for --language flag."
+  },
+  run: () => {
+    writeResearchJson({ ok: true, data: LANGUAGES, fields: FIELDS });
+  }
+});
+export {
+  languagesCommand
+};
+//# sourceMappingURL=languages-J275RIZC.js.map

package/dist/languages-WKOFWZ7S.js

@@ -0,0 +1,40 @@
+import {
+  GOOGLE_ADS_LANGUAGES
+} from "./chunk-PGRDGQ23.js";
+import "./chunk-ANLLW3KZ.js";
+import {
+  writeAdsJson
+} from "./chunk-ZRP7Y2DM.js";
+import "./chunk-ERSL4WZT.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/ads/google/keywords/languages.ts
+import { defineCommand } from "citty";
+registerSchema({
+  command: "ads.google.keywords.languages",
+  description: "List all supported language IDs for --language flag in Google Ads keyword commands.",
+  args: {}
+});
+var FIELDS = {
+  id: "Language ID to pass as --language",
+  name: "Language name"
+};
+var languagesCommand = defineCommand({
+  meta: {
+    name: "languages",
+    description: "List all supported language IDs for --language flag."
+  },
+  run: () => {
+    writeAdsJson({ ok: true, data: GOOGLE_ADS_LANGUAGES, fields: FIELDS });
+  }
+});
+export {
+  languagesCommand
+};
+//# sourceMappingURL=languages-WKOFWZ7S.js.map

package/dist/launches-CGRWUGRB.js

@@ -0,0 +1,19 @@
+import {
+  IDEA_HINT,
+  compactLaunches,
+  launchesCommand,
+  launchesHints
+} from "./chunk-G4HLEELG.js";
+import "./chunk-XB63MQ6E.js";
+import "./chunk-X7VQFLHI.js";
+import "./chunk-LU4HI4KI.js";
+import "./chunk-LGK7UWBN.js";
+import "./chunk-Q7US4OOA.js";
+import "./chunk-YQSBHWOI.js";
+export {
+  IDEA_HINT,
+  compactLaunches,
+  launchesCommand,
+  launchesHints
+};
+//# sourceMappingURL=launches-CGRWUGRB.js.map