@koda-sl/baker-cli 0.571.0-dev.6a3439a0a → 0.572.0-dev.61ba69c66

package/dist/chats-4HK6UYD2.js

@@ -0,0 +1,584 @@
+import {
+  failApi
+} from "./chunk-6IL7JFX5.js";
+import {
+  CHAT_IMPORT_SURFACES
+} from "./chunk-YOHGEF2N.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-IMS53EQU.js";
+import {
+  apiPost
+} from "./chunk-UUDWZIDC.js";
+import "./chunk-S4V2GOKV.js";
+import {
+  getEnv,
+  requireChatId
+} from "./chunk-6LUDG5AB.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-6V4UAC5I.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/chats/index.ts
+import { defineCommand } from "citty";
+
+// src/commands/chats/carry-files.ts
+import { execFileSync } from "child_process";
+async function readSourceFiles(fromChatId) {
+  const response = await apiPost("/api/chats/diff", {
+    chatId: fromChatId,
+    live: true,
+    gitPatch: true
+  });
+  const { data } = response;
+  if (!data.available) {
+    return { kind: "stayed", reason: data.reason ?? "its files could not be read." };
+  }
+  if (data.source === "published") {
+    return { kind: "none" };
+  }
+  if (data.files.length === 0) {
+    return { kind: "none" };
+  }
+  if (data.gitPatch === void 0) {
+    return {
+      kind: "stayed",
+      reason: "its file changes are too large to bring over in one piece, so none of them came along."
+    };
+  }
+  return { kind: "patch", patch: data.gitPatch, paths: data.files.map((file) => file.path) };
+}
+function repoRoot() {
+  return execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+}
+function gitApply(patch, mode) {
+  const flags = mode === "check" ? ["--check"] : mode === "reverse" ? ["--reverse"] : [];
+  execFileSync("git", ["apply", "--whitespace=nowarn", ...flags, "-"], {
+    cwd: repoRoot(),
+    input: patch,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+function clashingFiles(stderr) {
+  const named = [...stderr.matchAll(/^error: ([^:\n]+): /gm)].map((match) => match[1]).filter((path) => path !== void 0 && path !== "patch failed");
+  return named.length > 0 ? [...new Set(named)] : [stderr.trim()];
+}
+function patchRefusal(patch) {
+  try {
+    gitApply(patch, "check");
+    return void 0;
+  } catch (error) {
+    const stderr = error.stderr;
+    return clashingFiles(stderr === void 0 ? String(error) : String(stderr));
+  }
+}
+function applyPatch(patch) {
+  gitApply(patch, "apply");
+}
+function revertPatch(patch) {
+  gitApply(patch, "reverse");
+}
+
+// src/commands/chats/publish-hints.ts
+function publishHints(publish) {
+  const hints = [];
+  const failed = publish.failedTotal;
+  if (failed > 0) {
+    hints.push(
+      `This Session's publish left ${failed} change${failed === 1 ? "" : "s"} behind \u2014 see \`publish.surfaces\` for why each did not apply. Do not report those changes as live.`
+    );
+  }
+  const unconfirmed = publish.unconfirmedTotal ?? 0;
+  if (unconfirmed > 0) {
+    hints.push(
+      `${unconfirmed} change${unconfirmed === 1 ? "" : "s"} went through but could not be confirmed when read back from the platform \u2014 \`publish.surfaces[].unconfirmedChanges\` says what it shows instead. Check before reporting them as done.`
+    );
+  }
+  return hints;
+}
+function stillPublishingHints(status) {
+  if (status !== "publishing") return [];
+  return [
+    "This Session is still publishing: its changes are not live yet. Work that has to wait for it (a check on the live page, a test lead) is a Scheduled agent staged now with `baker scheduled-agents create --run-at <time>`, whose brief first checks this Session went live. It exists only once your own chat is published: a page trigger staged now misses this Session's publish, and a `--run-at` that has passed by then is created switched off, so leave hours of headroom, not minutes, and tell the user it runs only once they publish this chat. Never ask the user to come back and tell you when it is done."
+  ];
+}
+
+// src/commands/chats/index.ts
+var STATUS_GROUPS = ["active", "archived", "all"];
+var REPO_SURFACES = ["knowledge", "company", "brand", "landings", "flows", "creatives"];
+function parseBoundedInt(raw, name, min, max) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const value = Number.parseInt(raw, 10);
+  if (Number.isNaN(value) || value < min || value > max) {
+    throw new Error(`--${name} must be an integer between ${min} and ${max}`);
+  }
+  return value;
+}
+registerSchema({
+  command: "chats.list",
+  description: 'Start here: list other Sessions on this account (newest first) so you can reuse what was done before. Each row shows the Session id, title, status, and a count of what it produced (creatives, landings, actions, flows, reports\u2026). Looking for one? `--search "PMax Brasil"` finds the Sessions whose title or conversation holds any of the words, newest first, each with the `match` it was found by; read the match before trusting a row, since more words match more Sessions. Then drill in with `baker chats view <id>`, `baker chats transcript <id>`, or `baker chats diff <id>`. Read-only.',
+  args: {
+    status: { type: "string", description: "Filter: active|archived|all (default: all)", required: false },
+    limit: { type: "string", description: "Max Sessions to return, 1-100 (default: 20)", required: false },
+    full: { type: "boolean", description: "Include each Session's full change list", required: false, default: false },
+    search: {
+      type: "string",
+      description: 'Sessions whose title or conversation holds any of these words, newest first, each with its `match` (e.g. --search "PMax Brasil")',
+      required: false
+    }
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List other Sessions on this account, newest first." },
+  args: {
+    status: { type: "string", description: "Filter: active|archived|all (default: all)", required: false },
+    limit: { type: "string", description: "Max Sessions (1-100, default 20)", required: false },
+    full: { type: "boolean", description: "Include each Session's full change list", required: false, default: false },
+    search: {
+      type: "string",
+      description: "Sessions whose title or conversation holds any of these words",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = {};
+      if (args.search) {
+        body.search = args.search;
+      }
+      if (args.status) {
+        if (!STATUS_GROUPS.includes(args.status)) {
+          throw new Error(`--status must be one of: ${STATUS_GROUPS.join("|")}`);
+        }
+        body.status = args.status;
+      }
+      const limit = parseBoundedInt(args.limit, "limit", 1, 100);
+      if (limit !== void 0) {
+        body.limit = limit;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      const selfChatId = getEnv().BAKER_CHAT_ID;
+      if (selfChatId) {
+        body.excludeChatId = selfChatId;
+      }
+      const response = await apiPost("/api/chats/list", body);
+      writeJson({
+        ...response,
+        meta: { count: response.data.chats.length },
+        ...response.data.chats.length === 0 ? {
+          hints: [
+            args.search ? "No Session's title or conversation holds any of those words. Try other words (a name, a figure), widen with --status all, or drop --search to list the newest." : "No Sessions matched. Widen with --status all or a larger --limit."
+          ]
+        } : {
+          hints: [
+            "Drill in: `baker chats view <id>` for outputs, `chats transcript <id>` for the conversation, `chats diff <id>` for the real file changes."
+          ]
+        }
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+registerSchema({
+  command: "chats.view",
+  description: "Inspect one Session's FULL picture of what it changed \u2014 the unified `effects`: git content (landings, creatives, flows, knowledge, brand), plus DB-only effects that never touch the repo \u2014 Actions, Scheduled agents, Tags, Tag Manager, Google Analytics, ad-platform writes, the funnel (`funnel`: which steps it added, changed or removed, and which ways in it added or removed in `triggersAdded`/`triggersRemoved`), what counts as a conversion (`conversions`), conversion sends, event sources, and every other staged or already-applied change (`otherChanges`: A/B tests, recipes, library images) \u2014 each resolved to real detail (names, descriptions, priorities, tag types, ad operations) and, once published, its `outcome`. Also `publish` (what each external surface actually did, with the provider's own error), `activity` (the chat's own timeline: status changes, publish start/fail, workspace recoveries, timeouts), `usage` (per-thread cost and the Session's token totals), the kickoff (how it was asked), threads, and commits. Effects are `staged` (in-progress draft) or applied. A completed Session is NOT proof its external changes landed \u2014 read `publish`. Use after `baker chats list` to decide whether to reuse it. Read-only.",
+  args: {
+    id: { type: "positional", description: "The Session id (from `baker chats list`)", required: true },
+    full: {
+      type: "boolean",
+      description: "Untruncated effect lists and full activity metadata (compact caps each list at 25)",
+      required: false,
+      default: false
+    }
+  }
+});
+var viewCommand = defineCommand({
+  meta: {
+    name: "view",
+    description: "Inspect one Session's full effects \u2014 git content + actions/tags/ads, kickoff, commits."
+  },
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    full: { type: "boolean", description: "Include full detail", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const response = await apiPost("/api/chats/view", {
+        chatId: args.id,
+        ...args.full ? { full: true } : {}
+      });
+      const hints = response.data.publish ? publishHints(response.data.publish) : [];
+      if (response.data.diffAvailable) {
+        hints.push("See the real file-level diff of the git content with `baker chats diff <id> --full`.");
+      } else if (response.data.status === "in_progress" || response.data.status === "publishing") {
+        hints.push(
+          "This Session is still in progress \u2014 read its current file changes with `baker chats diff <id> --live`."
+        );
+      }
+      hints.push(...stillPublishingHints(response.data.status));
+      hints.push("Read the conversation with `baker chats transcript <id>`.");
+      writeJson({ ...response, hints });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var TRANSCRIPT_ROLES = ["user", "assistant"];
+registerSchema({
+  command: "chats.transcript",
+  description: "Start here: read a Session's conversation (user + agent turns), the most recent messages last. Leave out the id to read THIS chat \u2014 the way to recover its own earlier words after a context summary (never grep the raw logs on disk). `--search \"5.700\"` returns only the messages holding the text, from the whole conversation however long; `--role user` keeps one side; `--turns` keeps each request and the agent's closing message of that turn (a recap). Compact truncates long messages (around the match when searching); add --full for verbatim text. Read-only.",
+  args: {
+    id: {
+      type: "positional",
+      description: "The Session id (from `baker chats list`). Default: this chat",
+      required: false
+    },
+    search: {
+      type: "string",
+      description: 'Only messages containing this text, case-insensitive (e.g. --search "5.700")',
+      required: false
+    },
+    role: { type: "string", description: "Only one side: user|assistant", required: false },
+    turns: {
+      type: "boolean",
+      description: "Only each user message and the agent's closing message of that turn",
+      required: false,
+      default: false
+    },
+    limit: { type: "string", description: "Max messages to return, 1-1000 (default: 100)", required: false },
+    full: {
+      type: "boolean",
+      description: "Return verbatim (untruncated) message text",
+      required: false,
+      default: false
+    }
+  }
+});
+var transcriptCommand = defineCommand({
+  meta: { name: "transcript", description: "Read a Session's conversation \u2014 another one, or this chat's own." },
+  args: {
+    id: { type: "positional", description: "The Session id (default: this chat)", required: false },
+    search: { type: "string", description: "Only messages containing this text", required: false },
+    role: { type: "string", description: "Only one side: user|assistant", required: false },
+    turns: { type: "boolean", description: "Each request + the closing reply", required: false, default: false },
+    limit: { type: "string", description: "Max messages (1-1000, default 100)", required: false },
+    full: { type: "boolean", description: "Verbatim message text", required: false, default: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const chatId = args.id ?? getEnv().BAKER_CHAT_ID;
+      if (!chatId) {
+        throw new Error("Pass the Session id: `baker chats transcript <id>` (find it with `baker chats list`).");
+      }
+      const body = { chatId };
+      if (args.search) {
+        body.search = args.search;
+      }
+      if (args.role) {
+        if (!TRANSCRIPT_ROLES.includes(args.role)) {
+          throw new Error(`--role must be one of: ${TRANSCRIPT_ROLES.join("|")}`);
+        }
+        body.role = args.role;
+      }
+      if (args.turns) {
+        body.turns = true;
+      }
+      const limit = parseBoundedInt(args.limit, "limit", 1, 1e3);
+      if (limit !== void 0) {
+        body.limit = limit;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      const response = await apiPost("/api/chats/transcript", body);
+      const hints = [];
+      if (response.data.truncated) {
+        hints.push("Older messages were dropped to fit --limit. Raise --limit, or narrow with --search.");
+      }
+      if (args.search && response.data.entries.length === 0) {
+        hints.push(
+          "No message holds that text. The whole conversation was searched \u2014 try a shorter or differently written piece of it."
+        );
+      }
+      writeJson({ ...response, meta: { count: response.data.entries.length }, ...hints.length > 0 ? { hints } : {} });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+registerSchema({
+  command: "chats.diff",
+  description: "See the real file-level changes a Session made (landings, creatives, brand, flows, knowledge). Published Sessions read from git; for an in-progress (unpublished) Session pass --live to read its changes straight from its running workspace. Without --live, an unpublished Session returns available:false \u2014 use `baker chats view` for the staged summary. Compact lists changed files with +/- counts; add --full for the actual diff text. Read-only.",
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    surface: {
+      type: "string",
+      description: "Filter to one surface: knowledge|company|brand|landings|flows|creatives",
+      required: false
+    },
+    full: {
+      type: "boolean",
+      description: "Include the unified-diff patch text per file",
+      required: false,
+      default: false
+    },
+    live: {
+      type: "boolean",
+      description: "For an in-progress Session, read its changes from the live workspace (slower; resumes the paused Runtime). Ignored for published Sessions.",
+      required: false,
+      default: false
+    }
+  }
+});
+var diffCommand = defineCommand({
+  meta: { name: "diff", description: "See a published Session's real file-level changes." },
+  args: {
+    id: { type: "positional", description: "The Session id", required: true },
+    surface: {
+      type: "string",
+      description: "Filter: knowledge|company|brand|landings|flows|creatives",
+      required: false
+    },
+    full: { type: "boolean", description: "Include the diff patch text per file", required: false, default: false },
+    live: {
+      type: "boolean",
+      description: "Read an in-progress Session's changes from its live workspace (slower)",
+      required: false,
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    try {
+      const body = { chatId: args.id };
+      if (args.surface) {
+        if (!REPO_SURFACES.includes(args.surface)) {
+          throw new Error(`--surface must be one of: ${REPO_SURFACES.join("|")}`);
+        }
+        body.surface = args.surface;
+      }
+      if (args.full) {
+        body.full = true;
+      }
+      if (args.live) {
+        body.live = true;
+      }
+      const response = await apiPost("/api/chats/diff", body);
+      writeJson({
+        ...response,
+        meta: { count: response.data.files.length },
+        ...!response.data.available && response.data.reason ? { hints: [response.data.reason] } : {},
+        ...response.data.available && !args.full && response.data.files.length > 0 ? { hints: ["Add --full to read the actual diff text for each file."] } : {}
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var IMPORT_DESCRIPTION = `Bring another chat's unpublished work into this chat, in one call \u2014 and take it out of that chat, so publishing both can never apply anything twice.
+
+Start here when the user wants another chat's work brought into this one ("bring over", "merge the two
+chats", "its publish keeps failing \u2014 carry it over", "recover what the discarded chat did"):
+  baker chats import --from-chat <chat-id>                            # everything: files and staged changes
+  baker chats import --from-chat <chat-id> --only meta-ads,tasks      # only these staged surfaces, no files
+  baker chats import --from-chat <chat-id> --failed                   # a PUBLISHED chat: the ad changes its publish could not apply
+
+The other chat may be open, its publish may have failed, or it may be discarded. Its file changes (Knowledge,
+pages, Forms, pictures) are applied in this workspace exactly as it made them, and every staged surface moves
+exactly as staged: ads (Google, Meta, LinkedIn, X, ChatGPT), Shopify, Tag Manager, Google Analytics, tracking
+tags, Tasks, scheduled agents, ActiveCampaign, site settings, ad goals, the funnel, conversions, conversion
+sends, event sources and lead routes. When both chats change the same file or the same thing, nothing moves
+and the refusal names each clash \u2014 ask the user which version wins. A chat whose publish failed is then closed
+to publishing, so the same work never goes live twice.
+--failed takes the Google Ads, Meta, LinkedIn, X and ChatGPT changes a published chat's publish could not
+apply (failed, or skipped because what they needed failed), stages them here as they were \u2014 naming what did
+apply by its real id \u2014 and takes them out of that chat, so its Retry cannot apply them twice.
+A change moved here cannot go back: to leave one behind, ask the user first and use --only (Google Ads alone
+can pick single changes: \`baker ads google draft import --from-chat <id> --refs|--exclude\`).
+Find chat ids with \`baker chats list\`; see what one staged with \`baker chats view <id>\`.`;
+registerSchema({
+  command: "chats.import",
+  description: IMPORT_DESCRIPTION,
+  args: {
+    "from-chat": {
+      type: "string",
+      description: "The other chat \u2014 open, publish failed or discarded; published with --failed",
+      required: true
+    },
+    only: {
+      type: "string",
+      description: `Comma-separated staged surfaces to move, leaving its files there (default: everything): ${CHAT_IMPORT_SURFACES.join(", ")}`,
+      required: false
+    },
+    failed: {
+      type: "boolean",
+      description: "The other chat is published: stage here the ad changes its publish could not apply",
+      required: false,
+      default: false
+    }
+  }
+});
+function filesHints(data, files) {
+  const hints = [];
+  if (files?.kind === "patch") {
+    hints.push(
+      `Its ${files.paths.length} changed file(s) are now in this workspace, exactly as that chat left them: ${files.paths.join(", ")}. Check them in the preview; never rebuild them by hand.`
+    );
+  }
+  if (files?.kind === "stayed") {
+    hints.push(
+      `Its file changes (Knowledge, pages, Forms\u2026) did not come along: ${files.reason} Tell the user what is missing; do not rebuild it from memory.`
+    );
+  } else if (data.filesStayed > 0) {
+    hints.push(
+      `Chat ${data.fromChatId} also changed ${data.filesStayed} file(s) (Knowledge, pages, Forms\u2026) that did not come along. Run the import without --only to bring them.`
+    );
+  }
+  if (data.carried) {
+    hints.push(
+      "That chat holds nothing of its own any more and can no longer be published, so the same work never goes live twice. This chat publishes all of it."
+    );
+  } else if (files?.kind === "patch") {
+    hints.push(
+      "That chat still has its own copy of these files: tell the user to publish only this chat, or the same file changes would go live twice."
+    );
+  }
+  return hints;
+}
+function importHints(data, files, failed) {
+  const hints = [];
+  const moved = data.surfaces.reduce((sum, surface) => sum + surface.moved, 0);
+  const stayed = data.surfaces.filter((surface) => surface.left);
+  if (moved === 0 && stayed.length === 0 && files?.kind !== "patch") {
+    hints.push(
+      failed ? `Every ad change of chat ${data.fromChatId} applied, so there was nothing to bring over.` : `Chat ${data.fromChatId} had no unpublished changes, so nothing moved.`
+    );
+  }
+  for (const surface of stayed) {
+    hints.push(
+      `${surface.left?.count ? `${surface.left.count} ` : ""}${surface.surface} change(s) stayed in chat ${data.fromChatId}: ${surface.left?.reason}`
+    );
+  }
+  hints.push(...filesHints(data, files));
+  if (moved > 0) {
+    hints.push(
+      "The moved changes are this chat's now and publish with it; the other chat no longer holds them. Review them with each surface's `draft list` (and `baker ads google draft validate` when Google Ads changes moved)."
+    );
+  }
+  if (moved > 0 && stayed.length === 0 && !data.carried) {
+    hints.push(
+      "Nothing staged stayed in the other chat. Never tell the user to discard it for this: its other work is still there."
+    );
+  }
+  if (failed && moved > 0) {
+    hints.push(
+      "They failed once for a reason: read each one's error with `baker chats view <id>` (publish) and amend it here before the user publishes, or it can fail the same way."
+    );
+  }
+  return hints;
+}
+function onlyFlag(value) {
+  if (typeof value !== "string") return {};
+  const named = value.split(",").map((surface) => surface.trim()).filter((surface) => surface.length > 0);
+  if (named.length === 0) return { refusal: "--only names no surface" };
+  const unknown = named.filter((surface) => !CHAT_IMPORT_SURFACES.includes(surface));
+  if (unknown.length > 0) return { refusal: `--only names ${unknown.join(", ")}, which is not a surface` };
+  return { surfaces: named };
+}
+function refuse(message, fix) {
+  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message, fix } });
+  process.exit(1);
+}
+async function carryFiles(fromChatId) {
+  const files = await readSourceFiles(fromChatId);
+  if (files.kind !== "patch") return files;
+  const clashes = patchRefusal(files.patch);
+  if (clashes) return { kind: "clash", paths: clashes };
+  applyPatch(files.patch);
+  return files;
+}
+var importCommand = defineCommand({
+  meta: { name: "import", description: IMPORT_DESCRIPTION },
+  args: {
+    "from-chat": { type: "string", description: "The other chat whose work comes here" },
+    only: { type: "string", description: "Comma-separated staged surfaces to move, without files (default: all)" },
+    failed: {
+      type: "boolean",
+      description: "From a published chat: the ad changes its publish could not apply",
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    const fromChatId = typeof args["from-chat"] === "string" ? args["from-chat"].trim() : "";
+    if (!fromChatId) {
+      refuse(
+        "--from-chat is required",
+        "Name the other chat: baker chats import --from-chat <chat-id> (ids from `baker chats list`)."
+      );
+    }
+    const only = onlyFlag(args.only);
+    if ("refusal" in only) {
+      refuse(
+        only.refusal,
+        `Name surfaces from: ${CHAT_IMPORT_SURFACES.join(", ")} \u2014 or leave --only off to move them all.`
+      );
+    }
+    if (args.failed && only.surfaces) {
+      refuse("--failed takes every ad platform's failed changes", "Leave --only off with --failed.");
+    }
+    const chatId = requireChatId();
+    let files;
+    try {
+      files = args.failed || only.surfaces ? void 0 : await carryFiles(fromChatId);
+    } catch (err) {
+      failApi(err);
+    }
+    if (files?.kind === "clash") {
+      refuse(
+        `Nothing moved: these files changed in both chats, differently: ${files.paths.join(", ")}.`,
+        "Ask the user which version should win. To bring only the other chat's staged changes and leave its files there, run the import again with --only and the surfaces it staged."
+      );
+    }
+    try {
+      const response = await apiPost("/api/chats/import", {
+        chatId,
+        fromChatId,
+        ...only.surfaces ? { surfaces: only.surfaces } : {},
+        ...files?.kind === "patch" ? { filesCarried: true } : {},
+        ...args.failed ? { failed: true } : {}
+      });
+      writeJson({ ...response, hints: importHints(response.data, files, Boolean(args.failed)) });
+    } catch (err) {
+      if (files?.kind === "patch") revertPatch(files.patch);
+      failApi(err);
+    }
+  }
+});
+var chatsCommand = defineCommand({
+  meta: {
+    name: "chats",
+    description: `Inspect other Sessions on this account: list them, view what they produced, read their conversation, and see their real file changes \u2014 so you can reuse past work for a new goal. \`import --from-chat <id>\` moves another open Session's staged changes into this one.
+Full guide: __tooling__/docs/tools/baker/chats.md`
+  },
+  subCommands: {
+    list: listCommand,
+    view: viewCommand,
+    transcript: transcriptCommand,
+    diff: diffCommand,
+    import: importCommand
+  }
+});
+export {
+  chatsCommand
+};
+//# sourceMappingURL=chats-4HK6UYD2.js.map