@aussieljk/forkbook 0.0.0-stage → 0.0.1-10

package/dist/bin/core.js

@@ -0,0 +1,1706 @@
+import CJS_COMPAT_NODE_URL_upaeg5sjpn from 'node:url';
+import CJS_COMPAT_NODE_PATH_upaeg5sjpn from 'node:path';
+import CJS_COMPAT_NODE_MODULE_upaeg5sjpn from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_upaeg5sjpn.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_upaeg5sjpn.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_upaeg5sjpn.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  readRegistry,
+  selectInstances
+} from "../_node-chunks/chunk-KWNBN3DV.js";
+import {
+  resolveStorybookConfigDir
+} from "../_node-chunks/chunk-RC4HPD5Q.js";
+import {
+  instructions
+} from "../_node-chunks/chunk-QFXAGOIO.js";
+import {
+  isReactProject
+} from "../_node-chunks/chunk-IUPE4SU2.js";
+import "../_node-chunks/chunk-FWAF5NBL.js";
+import "../_node-chunks/chunk-LG3NMXCM.js";
+import "../_node-chunks/chunk-BMJPOQ2S.js";
+import {
+  createTools,
+  reportToolsCommandEvent,
+  sanitizeNamePart,
+  toCatalogEntry
+} from "../_node-chunks/chunk-MBPHOLXB.js";
+import {
+  formatMultiInstanceNotice
+} from "../_node-chunks/chunk-DR7NW2MI.js";
+import {
+  ToolsRuntimeError,
+  attachGateReasonFromError,
+  isAttachGateError
+} from "../_node-chunks/chunk-BDU3ZUMK.js";
+import {
+  detectLanguage,
+  getStorybookData
+} from "../_node-chunks/chunk-GGE7TBVX.js";
+import {
+  isClaudePreviewLaunch,
+  resolveSkillInputs
+} from "../_node-chunks/chunk-IL7YA7QJ.js";
+import "../_node-chunks/chunk-PEL4YXU6.js";
+import {
+  frameworkToRendererMap
+} from "../_node-chunks/chunk-CSFNS7HA.js";
+import {
+  getMonorepoType
+} from "../_node-chunks/chunk-FAEOR2AW.js";
+import {
+  version
+} from "../_node-chunks/chunk-ENBDAHOV.js";
+import {
+  detectAgent
+} from "../_node-chunks/chunk-C3PLG47Q.js";
+import "../_node-chunks/chunk-MRCPS4S3.js";
+import "../_node-chunks/chunk-TNFH4Y4G.js";
+import "../_node-chunks/chunk-NGFFEW2B.js";
+import "../_node-chunks/chunk-ACSO4HQP.js";
+import "../_node-chunks/chunk-HCP5DG52.js";
+import {
+  globalSettings
+} from "../_node-chunks/chunk-T6IU66AM.js";
+import "../_node-chunks/chunk-ECOW63CV.js";
+import {
+  leven
+} from "../_node-chunks/chunk-TZIT6SZP.js";
+import {
+  getRegisteredToolsets
+} from "../_node-chunks/chunk-FERXOKZY.js";
+import "../_node-chunks/chunk-GJSYGBI5.js";
+import {
+  getToolName,
+  parseToolsetMethodId,
+  toCliMethodName
+} from "../_node-chunks/chunk-LX2XSPPL.js";
+import {
+  escapeRegExp
+} from "../_node-chunks/chunk-ZD5TUA6I.js";
+import {
+  getService
+} from "../_node-chunks/chunk-BPL3ERBH.js";
+import "../_node-chunks/chunk-AAL6X7YG.js";
+import "../_node-chunks/chunk-DNV3LPV3.js";
+import "../_node-chunks/chunk-5NRWU7S2.js";
+import "../_node-chunks/chunk-KRWR44KT.js";
+import "../_node-chunks/chunk-7KD5DKGZ.js";
+import "../_node-chunks/chunk-MIWBXEUH.js";
+import "../_node-chunks/chunk-SYUOBOB5.js";
+import "../_node-chunks/chunk-G2ZUFOHU.js";
+import "../_node-chunks/chunk-CKE4R4NL.js";
+import "../_node-chunks/chunk-VUMGWJ6Y.js";
+import "../_node-chunks/chunk-T5VZYRL2.js";
+import "../_node-chunks/chunk-LH5QBX2U.js";
+import {
+  require_picocolors
+} from "../_node-chunks/chunk-7O2UIVID.js";
+import "../_node-chunks/chunk-HVOSLI2K.js";
+import "../_node-chunks/chunk-7CV4VEA2.js";
+import "../_node-chunks/chunk-OPG46TLN.js";
+import {
+  __toESM
+} from "../_node-chunks/chunk-FQGQ5KHN.js";
+
+// src/bin/core.ts
+import {
+  HandledError as HandledError2,
+  getEnvConfig,
+  optionalEnvToBoolean,
+  parseList
+} from "@aussieljk/forkbook/internal/common";
+import { logTracker, logger as logger3 } from "@aussieljk/forkbook/internal/node-logger";
+import { addToGlobalContext } from "@aussieljk/forkbook/internal/telemetry";
+import { Option as Option2, program } from "commander";
+var import_picocolors = __toESM(require_picocolors(), 1);
+
+// src/cli/skills/register.ts
+import {
+  experimental_loadStorybook,
+  withTelemetry
+} from "@aussieljk/forkbook/internal/core-server";
+import { telemetry as telemetry2 } from "@aussieljk/forkbook/internal/telemetry";
+
+// src/cli/skills/content/setup-prompts/index.ts
+import { dedent } from "ts-dedent";
+
+// src/cli/skills/content/setup-utils/project-overview.ts
+function getProjectOverview(projectInfo) {
+  let rows = [
+    ["Version", projectInfo.storybookVersion || "unknown"],
+    ["Renderer", projectInfo.rendererPackage || "unknown"],
+    ["Framework", projectInfo.framework || "unknown"],
+    ["Builder", projectInfo.builderPackage || "unknown"],
+    ["Config Dir", `\`${projectInfo.configDir}\``],
+    ["Language", projectInfo.language === "ts" ? "TypeScript" : "JavaScript"]
+  ];
+  return projectInfo.packageManager && rows.push(["Package Manager", projectInfo.packageManagerName || "unknown"]), rows.push(["Addons", projectInfo.addons.length > 0 ? projectInfo.addons.join(", ") : "none"]), ["## Project Info", "", "| Property | Value |", "|----------|-------|", rows.map(([key, value]) => `| ${key} | ${value} |`).join(`
+`)].join(
+    `
+`
+  );
+}
+
+// src/cli/skills/content/setup-prompts/index.ts
+var DEFAULT_PROMPT_NAME = "optimized-tests", CURRENTLY_USED_PROMPT = {
+  [DEFAULT_PROMPT_NAME]: instructions
+}, FORMERLY_USED_PROMPTS = {
+  monorepo: async () => (await import("../_node-chunks/monorepo-GF6H53U4.js")).instructions,
+  "optimized-tests": async () => (await import("../_node-chunks/optimized-tests-KOTSVWTN.js")).instructions,
+  "relaxed-limits": async () => (await import("../_node-chunks/relaxed-limits-C6QU365N.js")).instructions,
+  setup: async () => (await import("../_node-chunks/setup-KEEJK4WI.js")).instructions,
+  "pattern-copy-play": async () => (await import("../_node-chunks/pattern-copy-play-M2QNC4IZ.js")).instructions,
+  "monorepo-optimized-tests-relaxed-limits-no-story-deletion": async () => (await import("../_node-chunks/monorepo-optimized-tests-relaxed-limits-no-story-deletion-K4TTV2DQ.js")).instructions
+}, PROMPT_NAMES = [
+  ...Object.keys(CURRENTLY_USED_PROMPT),
+  ...Object.keys(FORMERLY_USED_PROMPTS)
+], EVAL_SETUP_PROMPT_ENV = "EVAL_SETUP_PROMPT";
+function resolvePromptName() {
+  let requested = process.env[EVAL_SETUP_PROMPT_ENV]?.trim();
+  return requested && (Object.hasOwn(CURRENTLY_USED_PROMPT, requested) || Object.hasOwn(FORMERLY_USED_PROMPTS, requested)) ? requested : DEFAULT_PROMPT_NAME;
+}
+async function getSetupPrompt(projectInfo) {
+  let requestedName = resolvePromptName(), name = !isReactProject(projectInfo) && ["setup", "pattern-copy-play"].includes(requestedName) ? DEFAULT_PROMPT_NAME : requestedName;
+  return { content: (CURRENTLY_USED_PROMPT[name] ?? await FORMERLY_USED_PROMPTS[name]())(projectInfo), name };
+}
+async function getSetupMarkdownOutput(projectInfo) {
+  let { content, name } = await getSetupPrompt(projectInfo);
+  return {
+    markdown: dedent`
+    # Forkbook Setup
+
+    ${getProjectOverview(projectInfo)}
+
+    ${content}
+  `,
+    prompt: name
+  };
+}
+
+// src/cli/skills/project-info.ts
+import { getPrettyPackageManagerName } from "@aussieljk/forkbook/internal/common";
+import { SupportedLanguage } from "@aussieljk/forkbook/internal/types";
+function parseMajorVersion(version2) {
+  let match = version2.match(/^(\d+)/);
+  return match ? parseInt(match[1], 10) : void 0;
+}
+async function getProjectInfo(opts) {
+  try {
+    let data = await getStorybookData({ configDir: opts.configDir });
+    if (!data.frameworkPackage || !data.rendererPackage || !data.builderPackage)
+      return {
+        ok: !1,
+        message: "Could not detect framework, renderer, or builder from your Forkbook config. Make sure you are running this command from your project root, or specify --config-dir."
+      };
+    let majorVersion = data.versionInstalled ? parseMajorVersion(data.versionInstalled) : void 0, language = await detectLanguage(data.packageManager, data.workingDir) === SupportedLanguage.TYPESCRIPT ? "ts" : "js";
+    return { ok: !0, projectInfo: {
+      storybookVersion: data.versionInstalled,
+      majorVersion,
+      framework: data.frameworkPackage,
+      rendererPackage: data.rendererPackage,
+      renderer: data.renderer,
+      builderPackage: data.builderPackage,
+      addons: data.addons ?? [],
+      configDir: data.configDir,
+      storiesPaths: data.storiesPaths,
+      packageManager: data.packageManager,
+      packageManagerName: getPrettyPackageManagerName(data.packageManager.type),
+      language,
+      hasCsfFactoryPreview: data.hasCsfFactoryPreview,
+      monorepoType: getMonorepoType()
+    } };
+  } catch (err) {
+    return {
+      ok: !1,
+      message: `Failed to read Forkbook configuration: ${err instanceof Error ? err.message : String(err)}
+Make sure you are running this command from your project root, or specify --config-dir.`
+    };
+  }
+}
+
+// src/cli/skills/record-setup-run.ts
+import { resolve } from "node:path";
+import { cache } from "@aussieljk/forkbook/internal/common";
+import { telemetry } from "@aussieljk/forkbook/internal/telemetry";
+async function recordSetupRun({ projectInfo, prompt }) {
+  let runId = Math.random().toString(36), configDir = resolve(projectInfo.configDir);
+  await cache.set("ai-setup-ran", {
+    timestamp: Date.now(),
+    runId,
+    configDir
+  }).catch(() => {
+  }), await telemetry(
+    "ai-setup",
+    {
+      cliOptions: {
+        packageManager: projectInfo.packageManager.type,
+        prompt
+      },
+      project: {
+        framework: projectInfo.framework,
+        renderer: projectInfo.rendererPackage,
+        builder: projectInfo.builderPackage,
+        language: projectInfo.language
+      },
+      runId
+    },
+    { configDir }
+  );
+}
+
+// src/cli/skills/run.ts
+import { relative } from "node:path";
+
+// src/cli/tools/help.ts
+import * as v2 from "valibot";
+
+// src/cli/tools/schema-lines.ts
+import * as v from "valibot";
+var JsonSchemaNodeSchema = v.lazy(
+  () => v.looseObject({
+    type: v.optional(v.string()),
+    description: v.optional(v.string()),
+    properties: v.optional(v.record(v.string(), JsonSchemaNodeSchema)),
+    required: v.optional(v.array(v.string())),
+    items: v.optional(v.union([JsonSchemaNodeSchema, v.array(JsonSchemaNodeSchema)])),
+    anyOf: v.optional(v.array(JsonSchemaNodeSchema)),
+    oneOf: v.optional(v.array(JsonSchemaNodeSchema))
+  })
+), MAX_SCHEMA_DEPTH = 4;
+function schemaItem(schema) {
+  return Array.isArray(schema.items) ? schema.items[0] : schema.items;
+}
+function schemaTypeLabel(schema) {
+  if (schema.type === "array") {
+    let item = schemaItem(schema);
+    return item?.type ? `array of ${item.type}` : "array";
+  }
+  return schema.anyOf || schema.oneOf ? "one of" : schema.type;
+}
+function schemaChildLines(schema, indent, depth) {
+  if (depth <= 0)
+    return [];
+  let lines = [];
+  if (schema.type === "object" && schema.properties) {
+    let required = new Set(schema.required ?? []);
+    for (let [name, child] of Object.entries(schema.properties))
+      lines.push(...schemaLines(`\`${name}\``, child, required.has(name), indent, depth));
+  }
+  let item = schemaItem(schema);
+  item && (item.type === "object" && item.properties || item.anyOf || item.oneOf) && (lines.push(`${indent}each item:`), lines.push(...schemaChildLines(item, `${indent}  `, depth - 1)));
+  let variants = schema.anyOf ?? schema.oneOf;
+  return variants && variants.forEach((variant, index) => {
+    let suffix = variant.description ? `: ${variant.description}` : "";
+    lines.push(`${indent}option ${index + 1}${suffix}`), lines.push(...schemaChildLines(variant, `${indent}  `, depth - 1));
+  }), lines;
+}
+function schemaLines(label, schema, isRequired, indent, depth) {
+  let meta = [schemaTypeLabel(schema), isRequired ? "required" : void 0].filter(Boolean).join(", "), description = schema.description ? `: ${schema.description}` : "";
+  return [`${indent}- ${label}${meta ? ` (${meta})` : ""}${description}`, ...schemaChildLines(schema, `${indent}  `, depth - 1)];
+}
+
+// src/cli/tools/tool-tokens.ts
+function parseToolsTokens(tokens, defaults = {}) {
+  let rawInput = defaults.input, help = defaults.help ?? !1, json = defaults.json ?? !1, output = defaults.output, attach = defaults.attach, flagArgs = {}, i = 0;
+  for (; i < tokens.length; ) {
+    let token = tokens[i];
+    if (i += 1, token === "--help" || token === "-h") {
+      help = !0;
+      continue;
+    }
+    if (token === "--json") {
+      json = !0;
+      continue;
+    }
+    if (token === "--attach") {
+      if (attach === !1)
+        return { ok: !1, error: "Cannot combine `--attach` and `--no-attach`." };
+      attach = !0;
+      continue;
+    }
+    if (token === "--no-attach") {
+      if (attach === !0)
+        return { ok: !1, error: "Cannot combine `--attach` and `--no-attach`." };
+      attach = !1;
+      continue;
+    }
+    if (token === "-o") {
+      if (i >= tokens.length || tokens[i].startsWith("-"))
+        return { ok: !1, error: "`-o` requires a file path." };
+      output = tokens[i], i += 1;
+      continue;
+    }
+    if (!token.startsWith("--") || token === "--")
+      return {
+        ok: !1,
+        error: `Unexpected argument \`${token}\`. Tool arguments must be passed as \`--key value\` flags (or via \`--input '<object>'\`).`
+      };
+    let key = token.slice(2), value, equalsIndex = key.indexOf("=");
+    if (equalsIndex !== -1 ? (value = key.slice(equalsIndex + 1), key = key.slice(0, equalsIndex)) : i < tokens.length && !tokens[i].startsWith("--") && (value = tokens[i], i += 1), key === "")
+      return { ok: !1, error: `Invalid flag \`${token}\`.` };
+    if (key === "help" || key === "json" || key === "attach" || key === "no-attach")
+      return { ok: !1, error: `\`--${key}\` does not take a value.` };
+    if (key === "output") {
+      if (!value)
+        return { ok: !1, error: "`--output` requires a file path." };
+      output = value;
+      continue;
+    }
+    if (key === "input") {
+      if (value === void 0)
+        return { ok: !1, error: "`--input` requires a value." };
+      rawInput = value;
+      continue;
+    }
+    flagArgs[key] = value === void 0 ? !0 : coerceValue(value);
+  }
+  let inputArgs = {};
+  if (rawInput !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawInput);
+    } catch (error) {
+      return {
+        ok: !1,
+        error: `\`--input\` must be valid JSON: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+      return {
+        ok: !1,
+        error: '`--input` must be a JSON object, e.g. \'{"id": "button-docs"}\'.'
+      };
+    inputArgs = parsed;
+  }
+  return { ok: !0, help, json, output, attach, args: { ...inputArgs, ...flagArgs } };
+}
+function isJsonToolsRun(tokens, defaults = {}) {
+  let parsed = parseToolsTokens(tokens, defaults);
+  return parsed.ok && parsed.json && !parsed.help;
+}
+function coerceValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parsePort(rawPort) {
+  if (rawPort === void 0)
+    return { ok: !0, port: void 0 };
+  let port = Number(rawPort);
+  return !Number.isInteger(port) || port < 1 || port > 65535 ? {
+    ok: !1,
+    error: `\`--port\` must be a port number (1-65535), got \`${rawPort}\`.`
+  } : { ok: !0, port };
+}
+var TOOLS_OPTION_SPECS = [
+  { flags: "--cwd <path>", description: "Project directory of the target Forkbook" },
+  {
+    flags: "-c, --config-dir <dir-name>",
+    description: "Forkbook config directory of the target Forkbook"
+  },
+  {
+    flags: "-p, --port <number>",
+    description: "Port of a running Forkbook; targets that instance directly, no --cwd or --config-dir needed"
+  },
+  {
+    flags: "--attach",
+    description: "Require attaching to a running Forkbook; gate failures are errors instead of a local fallback"
+  },
+  {
+    flags: "--no-attach",
+    description: "Load the project configuration without attaching"
+  },
+  {
+    flags: "--input <object>",
+    description: "Raw JSON object with the tool arguments (escape hatch for complex values)"
+  },
+  {
+    flags: "--json",
+    description: "Print the tool's structured result data as JSON instead of markdown"
+  },
+  { flags: "-o, --output <path>", description: "Write the result to a file instead of stdout" },
+  {
+    flags: "-h, --help",
+    description: "List the tools of the target Forkbook, or show one tool with its arguments"
+  }
+];
+
+// src/cli/tools/help.ts
+var LOCAL_BADGE = "[local]", DEV_SERVER_BADGE = "[requires running Forkbook]";
+function optionLines() {
+  let column = Math.max(...TOOLS_OPTION_SPECS.map((spec) => spec.flags.length)) + 2;
+  return TOOLS_OPTION_SPECS.map((spec) => `  ${spec.flags.padEnd(column)}${spec.description}`);
+}
+function indented(lines, depth) {
+  let pad = " ".repeat(depth);
+  return lines.flatMap((line) => line.split(`
+`)).map((line) => line && pad + line);
+}
+function cliPath(method) {
+  let { toolsetId, methodName } = parseToolsetMethodId(method.ref);
+  return `${toolsetId} ${toCliMethodName(methodName)}`;
+}
+function badge(method) {
+  return method.requiresDevServer ? DEV_SERVER_BADGE : LOCAL_BADGE;
+}
+function argumentLines(schema, flagPrefix) {
+  if (schema !== void 0)
+    return propertyLines(schema, { flagPrefix });
+}
+function methodBodyLines(method) {
+  let lines = [method.description.trim()], inputLines = argumentLines(method.input, !0);
+  inputLines === void 0 ? lines.push("", "Arguments: (this schema could not be rendered)") : inputLines.length === 0 ? lines.push("", "Arguments: none.") : lines.push("", "Arguments:", ...inputLines);
+  let outputLines = argumentLines(method.output, !1);
+  return outputLines && outputLines.length > 0 && lines.push("", "Output (`--json`):", ...outputLines), lines;
+}
+function propertyLines(schema, { flagPrefix }) {
+  let properties = Object.entries(
+    schema.properties ?? {}
+  ), required = new Set(schema.required ?? []), lines = [];
+  for (let [name, propertySchema] of properties) {
+    let parsed = v2.safeParse(JsonSchemaNodeSchema, propertySchema), node = parsed.success ? parsed.output : {}, label = flagPrefix ? `\`--${name}\`` : `\`${name}\``;
+    lines.push(...schemaLines(label, node, required.has(name), "", MAX_SCHEMA_DEPTH));
+  }
+  return lines;
+}
+function renderToolsetSection(entry) {
+  let sections = [`${entry.id} \u2014 ${entry.description}`];
+  for (let method of entry.methods) {
+    let heading = `  ${cliPath(method)}  ${badge(method)}`;
+    sections.push([heading, "", ...indented(methodBodyLines(method), 4)].join(`
+`));
+  }
+  return sections.join(`
+
+`);
+}
+function renderToolsHelpFromCatalog(catalog) {
+  let commands = catalog.toolsets.flatMap(
+    (toolset) => toolset.methods.map((method) => ({
+      path: cliPath(method),
+      summary: method.title,
+      badge: badge(method)
+    }))
+  ), column = commands.length === 0 ? 0 : Math.max(...commands.map((command2) => command2.path.length)) + 2, commandBlock = commands.length === 0 ? "  (none)" : commands.map((command2) => `  ${command2.path.padEnd(column)}${command2.summary}  ${command2.badge}`).join(`
+`), header = [
+    "Usage: npx forkbook tools [options] [toolset] [tool] [args...]",
+    "",
+    `Forkbook tools from the Forkbook configuration at ${catalog.configDir}.`,
+    "",
+    "Options:",
+    ...optionLines(),
+    "",
+    "Commands:",
+    commandBlock
+  ].join(`
+`), notes = [
+    `${LOCAL_BADGE} tools run without a running Forkbook.`,
+    `${DEV_SERVER_BADGE} tools need a running Forkbook dev server; start it first.`,
+    "Individual `--key value` flags override entries of `--input`.",
+    "Run `npx forkbook tools <toolset> <tool> --help` for the description, arguments and `--json` output of one tool."
+  ].join(`
+`);
+  return [header, notes].join(`
+
+`);
+}
+function renderToolsetHelpFromCatalog(entry) {
+  return [
+    `Usage: npx forkbook tools ${entry.id} <tool> [--key value ...]`,
+    "",
+    renderToolsetSection(entry)
+  ].join(`
+`);
+}
+function renderMethodHelpFromCatalog(method) {
+  return [
+    `Usage: npx forkbook tools ${cliPath(method)} [--key value ...]`,
+    "",
+    method.requiresDevServer ? "Execution: requires a running Forkbook dev server; start it first." : "Execution: local (no running Forkbook required).",
+    "",
+    ...methodBodyLines(method)
+  ].join(`
+`);
+}
+
+// src/cli/skills/command-reference.ts
+var toCommand = getToolName({ transport: "cli" });
+function findReferredTools(skillText, toolsets) {
+  return toolsets.flatMap(
+    (toolset) => toolset.methods.filter(
+      (method) => (
+        // The lookahead keeps `docs show-story` from counting as a mention of `docs show`.
+        new RegExp(`${escapeRegExp(toCommand(method.ref))}(?![\\w-])`).test(skillText)
+      )
+    )
+  );
+}
+function renderCommandReference(skillText, toolsets) {
+  let referred = findReferredTools(skillText, toolsets), namedToolsets = toolsets.filter(
+    (toolset) => toolset.methods.some((method) => referred.includes(method))
+  );
+  for (; ; ) {
+    let text = [skillText, ...referred.map(renderMethodHelpFromCatalog)].join(`
+`), found = findReferredTools(text, namedToolsets);
+    if (found.length === referred.length)
+      break;
+    referred = found;
+  }
+  return referred.length === 0 ? "" : [
+    "# Command reference",
+    "`--json` only changes the output format; to pass all arguments as one JSON object, use `--input '<json>'`.",
+    ...referred.map((method) => ["```text", renderMethodHelpFromCatalog(method), "```"].join(`
+`))
+  ].join(`
+
+`);
+}
+
+// src/cli/skills/content/build-stories-skill.ts
+var ref = getToolName({ transport: "cli" });
+function docsSection() {
+  return `## Look up components first
+
+\`\`\`sh
+${ref("docs.list")}             # every component and docs page, with its id
+${ref("docs.show")} --id <id>   # props and usage examples of one entry
+${ref("docs.showStory")} --storyId <id>   # the code of a story that docs show only lists
+\`\`\`
+
+Do this before you edit any file: run \`docs list\` once, then \`docs show\` for every listed component your change uses, even one you only add such as a button, and for each one you are asked about. Reuse what exists instead of building a duplicate. Use only the props that \`docs show\` documents, never one you assume from a name or another library, and answer props, API and usage questions from these commands. Read source files or \`node_modules\` only when the commands return nothing relevant. When \`docs list\` groups its entries under sources (\`id: acme\`), pass the source of the entry to both commands that show it: \`--storybookId acme\`.`;
+}
+function writeSection({
+  framework,
+  csfFactories,
+  previewFile,
+  typescript
+}) {
+  return `## Write the component and its stories
+
+Every component you create or change gets stories: one per distinct state it can reach (variants, loading, empty, error, disabled), with realistic props. Never export a story under the name of a global such as \`Error\`: export \`ErrorState\` and set \`name: 'Error'\`. An interactive component also gets a \`play\` function that drives it and asserts the visible result; for a callback passed as \`fn()\`, assert whether it was called, as that state expects. The rules below are for the stories you write; do not rewrite existing stories only to match them.
+
+- ${csfFactories ? `This project writes stories with CSF Factories, because \`${previewFile}\` uses \`definePreview\`: \`import preview from '../.forkbook/preview'\` (the path to that file), then \`const meta = preview.meta({ component: Button })\` and \`export const Primary = meta.story({ args: { ... } })\`. Do not import \`Meta\` or \`StoryObj\`. Import` : typescript ? `Import \`Meta\` and \`StoryObj\` from \`${framework}\`, and` : "Import"} \`fn\`, \`expect\`, \`mocked\` and \`sb\` from \`@aussieljk/forkbook/test\`.
+- \`play: async ({ canvas, userEvent }) => { ... }\`: query \`canvas\` directly, by role or label. Never wrap it in \`within()\`. \`userEvent.click(element)\` takes no options.
+- A story never calls a real service. Mock network requests with MSW, never with a module mock or a replaced \`fetch\`: give the story \`beforeEach({ msw }) { msw.use(http.get('/api/users', () => HttpResponse.json([...]))) }\`, and leave the code that calls \`fetch\` as it is. When the project has no \`msw-storybook-addon\` yet, set it up first: install \`msw\` and \`msw-storybook-addon\` as dev dependencies, run \`npx msw init ./public --save\` (\`../public\` has to be in \`staticDirs\` of the main config), and add ${csfFactories ? "`addons: [addonMsw()]` (`import addonMsw from 'msw-storybook-addon'`, without an `initialize()` call)" : "`loaders: [mswLoader()]` (`import { mswLoader } from 'msw-storybook-addon/csf3'`, without an `initialize()` call)"} to \`${previewFile}\`. Read the addon's version in \`package.json\`: only before version 3 do stories have no \`msw\` in \`beforeEach\` and take \`parameters: { msw: { handlers: [...] } }\` instead. From version 3 on, never write \`parameters.msw\`.
+- Mock a module only for a dependency that is not a network call: register it in \`${previewFile}\` with \`sb.mock(import('../src/api.${typescript ? "ts" : "js"}'), { spy: true })\` (path relative to that file, with its extension), then set the result per story in \`beforeEach\` with \`mocked(getUser).mockResolvedValue(...)\`.`;
+}
+function testSection(a11yEnabled) {
+  let a11y = a11yEnabled ? "\n\nThe run lists accessibility violations under `## Accessibility Violations`. Fix semantic ones yourself (roles, labels, alt text, keyboard access). For visual ones such as color contrast, do not change the design: describe the problem, offer two or three options and ask the user." : "";
+  return `## Test
+
+\`\`\`sh
+${ref("test.run")} --stories '[{"storyId":"<id>"}]'   # ids: see "Find the stories"; leave out --stories to run every story
+\`\`\`
+
+Run this after every change. It is the only way to run story tests: never a \`package.json\` test script (such as \`npm run test:stories\`) or \`vitest\` directly, also when the user asks you to run the tests. Use focused runs while iterating and one full run before you finish. Fix failures and rerun; never finish with failing tests.${a11y}`;
+}
+function discoverSection(inputs) {
+  let commands = [
+    inputs.moduleGraphSupported && `${ref("stories.changed")}   # stories affected by your uncommitted changes`,
+    inputs.moduleGraphSupported && `${ref("stories.findByComponent")} --componentPaths '["/abs/path/Button.tsx"]'   # stories that render these files`,
+    inputs.docsEnabled && `${ref("docs.list")} --withStoryIds true   # every story id`
+  ].filter(Boolean);
+  if (commands.length === 0)
+    return `## Find the stories
+
+This project has no command that lists story ids. Select a story by its file and export instead: \`--stories '[{"absoluteStoryPath":"/abs/path/Button.stories.tsx","exportName":"Primary"}]'\`.`;
+  let several = commands.length > 1, guidance = [
+    inputs.moduleGraphSupported && "Run `stories changed` or `find-by-component` before every review, also when you already know the ids of the stories you wrote: they add the stories of other components that your change affects.",
+    `Story ids come only from ${several ? "these commands" : "this command"}. Never build one from a file name, a title or memory.`,
+    inputs.moduleGraphSupported && "When `stories changed` leaves out a file you touched, pass that file to `find-by-component`; for a shared file (design token, theme, util, hook), which has no stories of its own, pass the components that use it. When `find-by-component` reports stories hidden by `maxDistance`, rerun it with a higher `--maxDistance`.",
+    `When ${several ? "none of them finds" : "it does not find"} a story for a component, it has no stories yet: say so, or write them.`
+  ].filter(Boolean).join(" ");
+  return `## Find the stories
+
+\`\`\`sh
+${commands.join(`
+`)}
+\`\`\`
+
+${guidance}`;
+}
+function reviewSection({ moduleGraphSupported }) {
+  let discoverFirst = moduleGraphSupported ? " When you changed files, run `stories changed` or `find-by-component` right before it and take the story ids from there, also when you only wrote stories, not from the output of the tests." : "";
+  return `## Finish with a review
+
+\`\`\`sh
+${ref("review.create")} --input '{
+  "title": "Rounder buttons",
+  "description": "The **Button** corner radius goes from 4px to 8px.",
+  "collections": [
+    { "title": "Button variants", "rationale": "The component that changed.", "storyIds": ["button--primary", "button--disabled"] },
+    { "title": "Forms that use it", "rationale": "Where the change shows up in context.", "storyIds": ["login-form--default"] }
+  ],
+  "changedFiles": ["src/Button.tsx"]
+}'
+\`\`\`
+
+Publish a review after every change the user can see, and again after each later change. It needs a running Forkbook.${discoverFirst} Group the stories into two to five collections, from the changed component up to the pages that show it (one is enough when a single component is affected), and include every story you created. List every file you created or changed in \`changedFiles\`, story files too. When the user only asks to see or browse components or stories and you changed no files, publish the same review with \`"changedFiles": []\`. Skip the review only when nothing visible changed and the user did not ask to see anything, and say that instead.
+
+Then do both things the command prints, every time: open the review in the in-app browser with a browser tool (unless you have none), and end your answer with the review section it gives you. Do not list separate story links next to it.`;
+}
+function previewSection() {
+  return `## Link to one story
+
+\`\`\`sh
+${ref("stories.preview")} --stories '[{"storyId":"<id>"}]'   # direct links to stories
+\`\`\`
+
+Only for a look at one story while you iterate, or when the user asks for a direct link. It does not replace the review, unless \`review create\` keeps failing after you fixed what it reported: then share these links and say why.`;
+}
+function buildStoriesSkill(inputs) {
+  return [
+    "# Forkbook workflow\n\nFollow this for every change to how the UI looks (components, stories, styles, themes, tokens) and for requests to show components or stories. Some commands print what to do next; follow that too. Add `--help` to a command only when a call fails.",
+    inputs.docsEnabled && docsSection(),
+    writeSection(inputs),
+    inputs.testSupported && testSection(inputs.a11yEnabled),
+    discoverSection(inputs),
+    reviewSection(inputs),
+    previewSection()
+  ].filter(Boolean).join(`
+
+`);
+}
+
+// src/cli/skills/content/build-server-instructions.ts
+function getFinalLinksGuidance(transport) {
+  let ref2 = getToolName({ transport });
+  return `In your final user-facing response, show one set of links \u2014 never both. If you published a review with **${ref2("review.create")}**, finish your reply with a dedicated review section as the very last thing in the output: its own top-level heading on a line by itself (for example \`## \u{1F440} Review your changes\`), then a one-line explanation that the review shows the handful of stories most relevant to this change and that, because it is AI-curated, results may be inaccurate or incomplete, then on the next line the review page as a markdown link prefixed with a \u{1F449} so it is easy to spot, using the returned \`reviewUrl\` (for example \`\u{1F449} [Open the Forkbook review page](<reviewUrl>)\`). Nothing should come after this section. Never also list the individual story or preview URLs. Avoid internal jargon like "collection" or "trigger" in anything the user reads \u2014 those are terms from this tooling, not words that mean anything to them; use plain language unless the user used the term first. A visually observable change is not finished until its review is published \u2014 never substitute preview URLs for the review. If **${ref2("review.create")}** keeps failing, end with the **${ref2("stories.preview")}** URLs instead and say the review could not be published. Only when there is no review because the change has no visually observable impact, say so plainly; include preview URLs only if the user asked to see specific stories.`;
+}
+
+// src/cli/skills/content/instructions/a11y-instructions.md
+var a11y_instructions_default = `### Accessibility Violations
+
+**Fix automatically** (semantic/structural, no visual change):
+
+- ARIA attributes, roles, labels, alt text
+- Heading hierarchy, landmarks, table structure
+- Keyboard access (tabindex, focus, handlers)
+- Document-level: lang attr, frame titles, duplicate IDs
+
+**Confirm with user first** (visual/design changes):
+
+- Color contrast ratios
+- Font sizes, spacing, layout
+- Focus indicator styling
+
+Describe the issue, ask how the user wants to proceed, and provide 2-3 concrete options.
+Do not auto-apply visual changes before user confirmation, and do not claim visual issues are fixed until they approve an option.
+`;
+
+// src/cli/skills/content/instructions/story-testing-instructions.md
+var story_testing_instructions_default = `## Story Testing Requirements
+
+**Run \`{{RUN_STORY_TESTS_TOOL_NAME}}\` after EVERY component or story change.** This includes creating, modifying, or refactoring components, stories, or their dependencies. It is the only way to run story tests \u2014 never run package.json test scripts (like \`npm run test:stories\`) instead.
+
+### Workflow
+
+1. Make your change
+2. Run \`{{RUN_STORY_TESTS_TOOL_NAME}}\` with related stories for focused feedback (faster while iterating)
+3. If tests fail: analyze, fix{{A11Y_FIX_SUFFIX}}, re-run
+4. Repeat until all tests pass
+
+Do not skip tests, ignore failures, or move on with failing tests. If stuck after multiple attempts, report to user.
+
+### Focused vs. full-suite test runs
+
+- Prefer focused runs (\`stories\` input) during development to validate the parts you changed quickly.
+- Run all tests (omit \`stories\`) before final handoff, after broad/refactor changes, or when impact is unclear and you need project-wide verification.
+`;
+
+// src/cli/skills/content/instructions/storybook-story-instructions.md
+var storybook_story_instructions_default = `# Writing User Interfaces
+
+Use the configured framework (\`{{FRAMEWORK}}\`) and renderer (\`{{RENDERER}}\`). Follow the project\u2019s component syntax, story format, imports, and setup conventions. Use examples for this framework when consulting documentation.
+
+When writing UI, prefer breaking larger components up into smaller parts.
+
+ALWAYS write a Forkbook story for any component written. If editing a component, ensure appropriate changes have been made to stories for that component.
+{{DOCS_WORKFLOW_GUIDANCE}}
+
+## How to write good stories
+
+Goal: Cover every distinct piece of business logic and state the component can reach (happy paths, error/edge states, loading, permissions/roles, empty states, variations from props/context). Avoid redundant stories that show the same logic.
+
+Interactivity: If the component is interactive, add Interaction tests using play functions that drive the UI with @aussieljk/forkbook/test utilities (e.g., fn, userEvent, expect). Simulate key user flows: clicking buttons/links, typing, focus/blur, keyboard nav, form submit, async responses, toggle/selection changes, pagination/filters, etc. When passing \`fn\` functions as \`args\` for callback functions, make sure to add a play function which interacts with the component and assert whether the callback function was actually called.
+
+Data/setup: Provide realistic props, state, and mocked data. Include meaningful labels/text to make behaviors observable. Stub network/services with deterministic fixtures; keep stories reliable.
+
+Assertions: In play functions, assert the visible outcome of the interaction (text, aria state, enabled/disabled, class/state changes, emitted events). Prefer role/label-based queries.
+
+Variants to consider (pick only those that change behavior): default vs. alternate themes; loading vs. loaded vs. empty vs. error; validated vs. invalid input; permissions/roles/capabilities; feature flags; size/density/layout variants that alter logic.
+
+Accessibility: Use semantic roles/labels; ensure focusable/keyboard interactions are test-covered where relevant.
+
+Naming/structure: Use clear story names that describe the scenario (\u201CError state after failed submit\u201D). Group related variants logically; don\u2019t duplicate.
+
+Imports/format: Import Meta/StoryObj from the framework package; import test helpers from @aussieljk/forkbook/test (not @storybook/test). Keep stories minimal\u2014only what's needed to demonstrate behavior.
+
+## Forkbook 9 Essential Changes for Story Writing
+
+### Package Consolidation
+
+#### \`Meta\` and \`StoryObj\` imports
+
+Update story imports to use the framework package:
+
+\`\`\`diff
+- import { Meta, StoryObj } from '{{RENDERER}}';
++ import { Meta, StoryObj } from '{{FRAMEWORK}}';
+\`\`\`
+
+#### Test utility imports
+
+Update test imports to use \`@aussieljk/forkbook/test\` instead of \`@storybook/test\`
+
+\`\`\`diff
+- import { fn } from '@storybook/test';
++ import { fn } from '@aussieljk/forkbook/test';
+\`\`\`
+
+### Global State Changes
+
+The \`globals\` annotation has be renamed to \`initialGlobals\`:
+
+\`\`\`diff
+// .forkbook/preview.js
+export default {
+- globals: { theme: 'light' }
++ initialGlobals: { theme: 'light' }
+};
+\`\`\`
+
+### Autodocs Configuration
+
+Instead of \`parameters.docs.autodocs\` in main.js, use tags:
+
+\`\`\`js
+// .forkbook/preview.js or in individual stories
+export default {
+	tags: ['autodocs'], // generates autodocs for all stories
+};
+\`\`\`
+
+### Mocking imports in Forkbook
+
+To mock imports in Forkbook, use Forkbook's mocking features. ALWAYS mock external dependencies to ensure stories render consistently.
+
+1. **Register in the mock in Forkbook's preview file**:
+   To mock dependendencies, you MUST register a module mock in \`.forkbook/preview.ts\` (or equivalent):
+
+\`\`\`js
+import { sb } from '@aussieljk/forkbook/test';
+
+// Prefer spy mocks (keeps functions, but allows to override them and spy on them)
+sb.mock(import('some-library'), { spy: true });
+\`\`\`
+
+**Important: Use file extensions when referring to relative files!**
+
+\`\`\`js
+sb.mock(import('./relative/module.ts'), { spy: true });
+\`\`\`
+
+2. **Specify mock values in stories**:
+   You can override the behaviour of the mocks per-story using \`beforeEach\` and the \`mocked()\` type function:
+
+\`\`\`js
+import { expect, mocked, fn } from '@aussieljk/forkbook/test';
+import { library } from 'some-library';
+
+const meta = {
+  component: AuthButton,
+  beforeEach: async () => {
+    mocked(library).mockResolvedValue({  user: 'data' });
+  },
+};
+
+export const LoggedIn: Story = {
+  play: async ({ canvas }) => {
+    await expect(library).toHaveBeenCalled();
+  },
+};
+\`\`\`
+
+Before doing this ensure you have mocked the import in the preview file.
+
+### Play Function Parameters
+
+- The play function has a \`canvas\` parameter that can be used directly with testing-library-like query methods.
+- It also has a \`canvasElement\` which is the actual DOM element.
+- The \`within\`-function imported from \`@aussieljk/forkbook/test\` transforms a DOM element to an object with query methods, similar to \`canvas\`.
+
+**DO NOT** use \`within(canvas)\` - it is redundant because \`canvas\` already has the query methods, \`canvas\` is not a DOM element.
+
+\`\`\`ts
+// \u2705 Correct: Use canvas directly
+play: async ({ canvas }) => {
+	await canvas.getByLabelText('Submit').click();
+};
+
+// \u26A0\uFE0F Also acceptable: Use \`canvasElement\` with \`within\`
+import { within } from '@aussieljk/forkbook/test';
+
+play: async ({ canvasElement }) => {
+	const canvas = within(canvasElement);
+	await canvas.getByLabelText('Submit').click();
+};
+
+// \u274C Wrong: Do NOT use within(canvas)
+play: async ({ canvas }) => {
+	const screen = within(canvas); // Error!
+};
+\`\`\`
+
+### Key Requirements
+
+- **Node.js 22.12+**
+- For TypeScript projects, use a version supported by the configured Forkbook framework and application framework.
+{{RENDERER_REQUIREMENTS}}
+
+## Story Linking Agent Behavior
+
+- ALWAYS provide story links after any changes to stories files, including changes to existing stories.
+- {{STORY_LINKING_WORKFLOW}}
+- {{FINAL_LINKS_GUIDANCE}}
+- When you will share preview/story links (i.e. when you are not collapsing everything into a single review section), pass only the most relevant story IDs into **{{PREVIEW_STORIES}}** (generally no more than 5) so the returned URL list stays manageable. Include every URL returned by that call in your final response \u2014 do not drop links there.
+- {{CHANGED_STORY_FALLBACK_LINK_GUIDANCE}}
+- After changing any UI components, ALWAYS search for related stories that might cover the changes you've made. If you find any, provide the story links to the user. THIS IS VERY IMPORTANT, as it allows the user to visually inspect the changes you've made. Even later in a session when changing UI components or stories that have already been linked to previously, YOU MUST PROVIDE THE LINKS AGAIN.
+`;
+
+// src/cli/skills/content/build-story-instructions.ts
+function buildStoryInstructions({
+  transport,
+  framework,
+  renderer,
+  testSupported,
+  a11yEnabled,
+  docsEnabled
+}) {
+  let ref2 = getToolName({ transport }), resolvedRenderer = renderer ?? frameworkToRendererMap[framework] ?? framework, storyLinkingWorkflow = `After changing any component or story, call \`${ref2("stories.changed")}\` to discover the new, modified, and related stories affected by your change. Story IDs must come from that call (or a fallback discovery tool such as ${ref2("stories.findByComponent")} for shared-infrastructure changes) \u2014 never construct them from file names, export names, or memory. Feed the discovered IDs into **${ref2("review.create")}** when the change is visually observable; use \`${ref2("stories.preview")}\` only while iterating on a specific story.`, changedStoryFallbackLinkGuidance = `When sharing preview/story links (not when ending with a review section): if you did not pass every changed story into \`${ref2("stories.preview")}\`, include this Forkbook fallback link so the user can view the complete changed list: \`/?statuses=affected;modified;new\`.`, docsWorkflowGuidance = `
+
+## Using library components
+
+This Forkbook exposes component documentation tools. Before creating or changing any UI, call **${ref2("docs.list")}** once to see what the design system already provides \u2014 build on existing components instead of hand-rolling duplicates \u2014 then call **${ref2("docs.show")}** with the \`id\` of each component you build on or get asked about, for its real props and usage examples. When multiple Forkbook sources are configured, pass the \`storybookId\` from **${ref2("docs.list")}** on follow-up calls. Do this instead of reading the library's source or type definitions out of \`node_modules\` \u2014 stories show intended usage, raw types don't \u2014 and answer props/usage questions from these tools too. Never assume or invent props.`, uiInstructions = storybook_story_instructions_default.replaceAll("{{FRAMEWORK}}", framework).replaceAll("{{RENDERER}}", resolvedRenderer).replace(
+    "{{RENDERER_REQUIREMENTS}}",
+    resolvedRenderer === "@storybook/react-native" ? "- React Native uses `.rnforkbook` directory" : ""
+  ).replace(`
+{{DOCS_WORKFLOW_GUIDANCE}}`, docsEnabled ? docsWorkflowGuidance : "").replace("{{STORY_LINKING_WORKFLOW}}", storyLinkingWorkflow).replace("{{FINAL_LINKS_GUIDANCE}}", getFinalLinksGuidance(transport)).replace("{{PREVIEW_STORIES}}", ref2("stories.preview")).replace("{{CHANGED_STORY_FALLBACK_LINK_GUIDANCE}}", changedStoryFallbackLinkGuidance);
+  if (testSupported) {
+    let a11yFixSuffix = a11yEnabled ? " (see a11y guidelines below)" : "", storyTestingInstructions = story_testing_instructions_default.replaceAll("{{RUN_STORY_TESTS_TOOL_NAME}}", ref2("test.run")).replace("{{A11Y_FIX_SUFFIX}}", a11yFixSuffix);
+    uiInstructions += `
+
+${storyTestingInstructions}`, a11yEnabled && (uiInstructions += `
+${a11y_instructions_default}`);
+  }
+  return uiInstructions;
+}
+
+// src/cli/skills/content/skills.ts
+var SKILL_IDS = ["stories", "write-story", "setup"], SKILLS = {
+  stories: {
+    blurb: "The workflow for UI changes, with every command it needs: look up components, write stories, test, and publish a review."
+  },
+  "write-story": {
+    blurb: "How to write, update, and test Forkbook stories for this project: imports, patterns, and conventions."
+  },
+  setup: {
+    blurb: "Setup instructions to write stories for the real components in this project."
+  }
+};
+function isSkillId(value) {
+  return SKILL_IDS.includes(value);
+}
+
+// src/cli/skills/setup-support.ts
+var SUPPORTED_SETUP_RENDERERS = ["@aussieljk/forkbook/react"];
+function getSetupSupportError({
+  rendererPackage,
+  builderPackage
+}) {
+  if (!(rendererPackage && SUPPORTED_SETUP_RENDERERS.includes(rendererPackage) && builderPackage === "@aussieljk/forkbook/builder-vite"))
+    return `AI-assisted setup is currently only available for React projects using the Vite builder. Detected renderer: ${rendererPackage ?? "unknown"}, builder: ${builderPackage ?? "unknown"}.`;
+}
+
+// src/cli/skills/run.ts
+var SKILLS_OPTION_SPECS = [
+  { flags: "--cwd <path>", description: "Project directory of the target Forkbook" },
+  {
+    flags: "-c, --config-dir <dir-name>",
+    description: "Forkbook config directory of the target Forkbook"
+  },
+  { flags: "--all", description: "Print every skill in full" },
+  { flags: "-h, --help", description: "Show this usage and every skill" }
+];
+function resolveSkillsIntent({
+  tokens,
+  help,
+  all
+}) {
+  let [id, ...rest] = tokens;
+  return help ? { kind: "catalog" } : id === void 0 ? all ? { kind: "all" } : { kind: "catalog" } : isSkillId(id) ? all ? {
+    kind: "error",
+    message: `\`--all\` prints every skill and takes no skill id; drop "${id}" or \`--all\`.`
+  } : rest.length > 0 ? {
+    kind: "error",
+    message: `Unexpected arguments: ${rest.map((token) => `"${token}"`).join(" ")}. Run \`npx forkbook skills --help\` for usage.`
+  } : { kind: "get", id } : {
+    kind: "error",
+    message: `Unknown skill "${id}". Available skills: ${SKILL_IDS.join(", ")}.`
+  };
+}
+async function runSkillsCommand(input, deps) {
+  let intent = resolveSkillsIntent(input);
+  if (intent.kind === "catalog")
+    return { output: renderCatalogHelp(), exitCode: 0 };
+  if (intent.kind === "error")
+    return { output: "", errorOutput: intent.message, exitCode: 1 };
+  try {
+    let ids = intent.kind === "all" ? SKILL_IDS : [intent.id], { docs, setupRun } = await serveSkills(
+      ids,
+      resolveStorybookConfigDir(input.target),
+      deps
+    );
+    return {
+      output: docs.join(`
+
+---
+
+`),
+      exitCode: 0,
+      skill: intent.kind === "all" ? "all" : intent.id,
+      ...intent.kind === "get" && setupRun ? { setupRun } : {}
+    };
+  } catch (error) {
+    if (error instanceof SkillsError)
+      return { output: "", errorOutput: error.message, exitCode: 1 };
+    throw error;
+  }
+}
+var SkillsError = class extends Error {
+};
+async function serveSkills(ids, configDir, deps) {
+  let inputs, toolsets, setupRun, docs = [];
+  for (let id of ids)
+    if (id === "setup") {
+      let setup = await serveSetup(configDir, deps);
+      docs.push(setup.markdown), setupRun = setup.run;
+    } else
+      inputs ??= await loadInputs(configDir, deps), toolsets ??= deps.describeToolsets(), docs.push(withCommandReference(id, inputs, toolsets));
+  return { docs, setupRun };
+}
+async function serveSetup(configDir, deps) {
+  let probed = await deps.getProjectInfo({
+    configDir: relative(process.cwd(), configDir) || "."
+  });
+  if (!probed.ok)
+    throw new SkillsError(probed.message);
+  let supportError = getSetupSupportError(probed.projectInfo);
+  if (supportError)
+    throw new SkillsError(supportError);
+  let { markdown, prompt } = await deps.getSetupMarkdown(probed.projectInfo);
+  return { markdown, run: { projectInfo: probed.projectInfo, prompt } };
+}
+async function loadInputs(configDir, deps) {
+  try {
+    return await deps.resolveSkillInputs(await deps.loadStorybook({ configDir }));
+  } catch (error) {
+    throw new SkillsError(
+      `Could not load the Forkbook configuration for this project: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function table(rows) {
+  let column = Math.max(...rows.map(([key]) => key.length)) + 2;
+  return rows.map(([key, text]) => `  ${key.padEnd(column)}${text}`);
+}
+function renderCatalogHelp() {
+  return [
+    "Usage: npx forkbook skills [options] [id]",
+    "",
+    "Agent skills served by this Forkbook.",
+    "",
+    "Options:",
+    ...table(SKILLS_OPTION_SPECS.map((spec) => [spec.flags, spec.description])),
+    "",
+    "Skills:",
+    ...table(SKILL_IDS.map((id) => [id, SKILLS[id].blurb])),
+    "",
+    "Print a skill with `npx forkbook skills <id>`, or every skill with `npx forkbook skills --all`."
+  ].join(`
+`);
+}
+function withCommandReference(id, inputs, toolsets) {
+  let text = assemble(id, inputs);
+  if (id === "stories")
+    return text;
+  let reference = renderCommandReference(text, toolsets);
+  return reference ? `${text.trimEnd()}
+
+${reference}` : text;
+}
+function assemble(id, inputs) {
+  return id === "stories" ? buildStoriesSkill({
+    framework: inputs.framework,
+    csfFactories: inputs.csfFactories,
+    previewFile: inputs.previewFile,
+    typescript: inputs.typescript,
+    docsEnabled: inputs.docsEnabledForCli,
+    testSupported: inputs.testSupported,
+    a11yEnabled: inputs.a11yEnabled,
+    moduleGraphSupported: inputs.moduleGraphSupported
+  }) : buildStoryInstructions({
+    transport: "cli",
+    framework: inputs.framework,
+    renderer: inputs.renderer,
+    testSupported: inputs.testSupported,
+    a11yEnabled: inputs.a11yEnabled,
+    docsEnabled: inputs.docsEnabledForCli
+  });
+}
+
+// src/cli/skills/register.ts
+function registerSkillsCommand(program2, skillsCommand2, handleCommandFailure2) {
+  program2.enablePositionalOptions(), skillsCommand2.helpOption(!1).helpCommand(!1).usage("[options] [id]").argument("[tokens...]", "A skill id from `forkbook skills --help`");
+  for (let { flags, description } of SKILLS_OPTION_SPECS)
+    skillsCommand2.option(flags, description);
+  skillsCommand2.action(async (tokens, options) => {
+    let cliOptions = {
+      disableTelemetry: options.disableTelemetry,
+      logfile: options.logfile,
+      configDir: resolveStorybookConfigDir({ cwd: options.cwd, configDir: options.configDir })
+    }, invocation = {
+      tokens: tokens ?? [],
+      help: options.help,
+      all: options.all,
+      target: { cwd: options.cwd, configDir: options.configDir }
+    }, intent = resolveSkillsIntent(invocation), run = async () => {
+      let result = await runSkillsCommand(invocation, defaultDeps());
+      await printResult(result), result.setupRun && await recordSetupRun(result.setupRun), result.skill && await telemetry2("skills-get", { skill: result.skill }, { configDir: cliOptions.configDir });
+    };
+    intent.kind === "catalog" ? await run() : await withTelemetry("skills-get", { cliOptions, fallbackTelemetryState: !0 }, run).catch(
+      handleCommandFailure2(options.logfile)
+    ), process.exit();
+  });
+}
+function defaultDeps() {
+  return {
+    loadStorybook: experimental_loadStorybook,
+    resolveSkillInputs,
+    getProjectInfo,
+    getSetupMarkdown: getSetupMarkdownOutput,
+    describeToolsets: () => getRegisteredToolsets().map(
+      (toolset) => toCatalogEntry(toolset, {
+        transport: "cli",
+        getService: (serviceId, options) => getService(serviceId, options)
+      })
+    )
+  };
+}
+async function printResult(result) {
+  result.errorOutput && await new Promise(
+    (done) => process.stderr.write(`${result.errorOutput}
+`, () => done())
+  ), result.output && await new Promise((done) => process.stdout.write(`${result.output}
+`, () => done())), result.exitCode !== 0 && (process.exitCode = result.exitCode);
+}
+
+// src/cli/tools/register.ts
+import { writeFile } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+import { sendTelemetryError, withTelemetry as withTelemetry2 } from "@aussieljk/forkbook/internal/core-server";
+import { logger } from "@aussieljk/forkbook/internal/node-logger";
+import { Option } from "commander";
+
+// src/cli/tools/run.ts
+import { versions } from "@aussieljk/forkbook/internal/common";
+
+// src/cli/tools/discover-instance.ts
+import { resolve as resolve2 } from "node:path";
+async function discoverRunningInstance(target, deps = {}) {
+  let cwd = resolve2(target.cwd ?? process.cwd()), configDir = resolveStorybookConfigDir({ cwd, configDir: target.configDir }), records = await readRegistry(deps.registryDir), selection = selectInstances(records, {
+    cwd,
+    configDir,
+    configDirExplicit: target.configDir != null,
+    port: target.port,
+    agent: detectAgent()?.name
+  });
+  return { currentRecord: selection.kind === "match" ? selection.matches[0] : void 0, records };
+}
+
+// src/cli/tools/run.ts
+var CLI_CLIENT_INFO = {
+  name: "storybook-cli",
+  version: versions["@aussieljk/forkbook"],
+  kind: "cli"
+};
+function toMethodKey(cliName) {
+  return cliName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function isAgentFacingError(error) {
+  return error instanceof Error && error.agentFacing === !0;
+}
+function isInvalidInputError(error) {
+  return error instanceof ToolsRuntimeError && error.data.reason === "invalid-input";
+}
+function normalizeHelpFlag(invocation) {
+  return invocation.tool !== "--help" && invocation.tool !== "-h" ? invocation : {
+    ...invocation,
+    tool: void 0,
+    flags: { ...invocation.flags, help: !0 }
+  };
+}
+function resolveToolsMode(invocationAttach, parsedAttach) {
+  let flag = parsedAttach ?? invocationAttach;
+  return flag === !0 ? "attached" : flag === !1 ? "local" : "auto";
+}
+async function runToolsCommand(invocation, deps = {}) {
+  let normalized = normalizeHelpFlag(invocation), { tokens, flags = {}, attach } = normalized, parsed = parseToolsTokens(tokens, flags), requestedMode = parsed.ok ? resolveToolsMode(attach, parsed.attach) : resolveToolsMode(attach, void 0);
+  if (!parsed.ok)
+    return {
+      exitCode: 1,
+      output: parsed.error,
+      outcome: { kind: "intercept", reason: "invalid-arguments" },
+      outputPath: flags.output,
+      requestedMode,
+      attachMode: requestedMode
+    };
+  let parsedPort = parsePort(normalized.port);
+  if (!parsedPort.ok)
+    return {
+      exitCode: 1,
+      output: parsedPort.error,
+      outcome: { kind: "intercept", reason: "invalid-arguments" },
+      outputPath: parsed.output,
+      requestedMode,
+      attachMode: requestedMode
+    };
+  let target = {
+    ...normalized.target,
+    ...parsedPort.port !== void 0 ? { port: parsedPort.port } : {}
+  }, result = (partial) => ({
+    ...partial,
+    outputPath: parsed.output,
+    requestedMode,
+    attachMode: requestedMode
+  }), tools, create = deps.createTools ?? createTools;
+  try {
+    tools = await create({
+      cwd: target.cwd,
+      configDir: target.configDir,
+      ...target.port != null ? { port: target.port } : {},
+      mode: requestedMode,
+      clientInfo: CLI_CLIENT_INFO
+    });
+  } catch (error) {
+    return isAttachGateError(error) ? result({
+      exitCode: 1,
+      output: error instanceof Error ? error.message : String(error),
+      outcome: { kind: "attach-gate", reason: attachGateReasonFromError(error) }
+    }) : result({
+      exitCode: 1,
+      output: error instanceof Error ? error.message : String(error),
+      outcome: { kind: "error", error }
+    });
+  }
+  try {
+    return {
+      ...await dispatchTools(
+        tools,
+        { ...normalized, target },
+        parsed,
+        deps,
+        requestedMode,
+        result
+      ),
+      requestedMode: tools.requestedMode,
+      attachMode: tools.mode,
+      host: tools.host,
+      fallbackNotice: tools.fallbackNotice,
+      fallbackReason: tools.fallbackReason,
+      ...tools.storybook.siblings?.length ? { multiInstanceNotice: formatMultiInstanceNotice(tools.storybook), multipleMatches: !0 } : {}
+    };
+  } finally {
+    await tools.close();
+  }
+}
+async function dispatchTools(tools, invocation, parsed, deps, requestedMode, result) {
+  let { toolset: toolsetName, tool: toolName } = invocation, catalog;
+  try {
+    catalog = await tools.describe();
+  } catch (error) {
+    return isAgentFacingError(error) ? result({ exitCode: 1, output: error.message, outcome: { kind: "failure" } }) : result({
+      exitCode: 1,
+      output: error instanceof Error ? error.message : String(error),
+      outcome: { kind: "error", error }
+    });
+  }
+  if (!toolsetName)
+    return result({
+      exitCode: 0,
+      output: renderToolsHelpFromCatalog(catalog),
+      outcome: { kind: "help" }
+    });
+  let entry = catalog.toolsets.find((candidate) => candidate.id === toolsetName);
+  if (!entry)
+    return result({
+      exitCode: 1,
+      output: formatUnknownToolsetFromCatalog(toolsetName, catalog),
+      outcome: { kind: "intercept", reason: "unknown-toolset" }
+    });
+  if (!toolName)
+    return result({
+      exitCode: 0,
+      output: renderToolsetHelpFromCatalog(entry),
+      outcome: { kind: "help" }
+    });
+  let method = entry.methods.find((candidate) => {
+    let { methodName: methodName2 } = parseToolsetMethodId(candidate.ref);
+    return methodName2 === toMethodKey(toolName) || toCliMethodName(methodName2) === toolName;
+  });
+  if (!method)
+    return result({
+      exitCode: 1,
+      output: formatUnknownToolFromCatalog(toolName, entry),
+      outcome: { kind: "intercept", reason: "unknown-tool" }
+    });
+  if (parsed.help)
+    return result({
+      exitCode: 0,
+      output: renderMethodHelpFromCatalog(method),
+      outcome: { kind: "help" }
+    });
+  let { methodName } = parseToolsetMethodId(method.ref), toolPath = `${entry.id} ${toCliMethodName(methodName)}`, commandPath = `npx forkbook tools ${toolPath}`;
+  if (tools.mode === "local" && method.requiresDevServer) {
+    let discovery = await (deps.discoverInstance ?? discoverRunningInstance)(invocation.target);
+    return result({
+      exitCode: 1,
+      output: formatRequiresDevServer(commandPath, discovery, requestedMode),
+      outcome: { kind: "intercept", reason: "requires-dev-server" }
+    });
+  }
+  try {
+    let outcome = await tools.call(method.ref, parsed.args, {
+      ...tools.storybook.url ? { origin: tools.storybook.url } : {}
+    }), output = parsed.json ? JSON.stringify(outcome.data, null, 2) : joinMarkdown(outcome.markdown);
+    return result({
+      exitCode: outcome.ok ? 0 : 1,
+      output,
+      outcome: { kind: outcome.ok ? "success" : "failure" },
+      ...outcome.telemetry ? { report: outcome.telemetry } : {}
+    });
+  } catch (error) {
+    return isInvalidInputError(error) ? result({
+      exitCode: 1,
+      output: formatValidationIssues(toolPath, error.data.issues ?? [], method.input),
+      outcome: { kind: "intercept", reason: "invalid-arguments" }
+    }) : isAgentFacingError(error) ? result({ exitCode: 1, output: error.message, outcome: { kind: "failure" } }) : result({
+      exitCode: 1,
+      output: error instanceof Error ? error.message : String(error),
+      outcome: { kind: "error", error }
+    });
+  }
+}
+function formatUnknownToolsetFromCatalog(toolsetName, catalog) {
+  let available = catalog.toolsets.map((toolset) => `- \`${toolset.id}\``).join(`
+`);
+  return `Unknown toolset \`${toolsetName}\`. The Forkbook configuration at ${catalog.configDir} provides:
+
+${available}
+
+Run \`npx forkbook tools --help\` for every tool.`;
+}
+function formatUnknownToolFromCatalog(toolName, entry) {
+  let available = entry.methods.map((method) => `- \`${toCliMethodName(parseToolsetMethodId(method.ref).methodName)}\``).join(`
+`);
+  return `Unknown tool \`${toolName}\`. The \`${entry.id}\` toolset provides:
+
+${available}
+
+Run \`npx forkbook tools ${entry.id}\` for their descriptions.`;
+}
+function joinMarkdown(markdown) {
+  return Array.isArray(markdown) ? markdown.join(`
+
+`) : markdown;
+}
+function formatRequiresDevServer(commandPath, discovery, requestedMode) {
+  if (discovery.currentRecord && requestedMode === "local")
+    return `Found your Forkbook running at ${discovery.currentRecord.url}, but \`${commandPath}\` cannot run from a local tools host. Re-run without \`--no-attach\` to attach to that instance.`;
+  if (discovery.currentRecord)
+    return `Found your Forkbook running at ${discovery.currentRecord.url}, but \`${commandPath}\` could not attach to it. Start or restart that Forkbook, then re-run this command.`;
+  let lines = [
+    `\`${commandPath}\` requires a running Forkbook dev server, and none was found for this project. Start it first (for example \`npm run forkbook\`), then re-run this command.`
+  ];
+  if (discovery.records.length > 0) {
+    let candidates = discovery.records.map((record2) => `- ${record2.url} (cwd \`${record2.cwd}\`)`).join(`
+`);
+    lines.push(
+      "",
+      "Running Forkbook instances that did not match this project \u2014 target one with `--cwd` or `--config-dir`:",
+      candidates
+    );
+  }
+  return lines.join(`
+`);
+}
+var TARGET_OPTIONS = ["cwd", "config-dir", "port"];
+function formatValidationIssues(toolPath, issues, input) {
+  let commandPath = `npx forkbook tools ${toolPath}`, declaredKeys = input?.properties ? Object.keys(input.properties) : void 0, hasUnknownKey = !1, lines = issues.map((issue) => {
+    let segments = issue.path?.map(
+      (segment) => String(typeof segment == "object" && segment !== null ? segment.key : segment)
+    ) ?? [], [key] = segments;
+    if (declaredKeys && segments.length === 1 && !declaredKeys.includes(key))
+      return hasUnknownKey = !0, TARGET_OPTIONS.includes(key) ? `- Unknown flag \`--${key}\`. It selects the target Forkbook, so it goes before the toolset name: \`npx forkbook tools --${key} <value> ${toolPath}\`.` : `- Unknown flag \`--${key}\`.`;
+    let path = segments.join(".");
+    return path ? `- \`${path}\`: ${issue.message}` : `- ${issue.message}`;
+  }), validFlags = declaredKeys?.length ? `Valid flags: ${declaredKeys.map((key) => `\`--${key}\``).join(", ")}.` : "This tool takes no arguments.";
+  return `Invalid arguments for \`${commandPath}\`:
+
+${lines.join(`
+`)}
+${hasUnknownKey ? `
+${validFlags}
+` : ""}
+Run \`${commandPath} --help\` for the expected arguments.`;
+}
+
+// src/cli/tools/register.ts
+function registerToolsPassthrough(program2, toolsCommand2, handleCommandFailure2) {
+  program2.enablePositionalOptions(), toolsCommand2.helpOption(!1).usage("[options] [toolset] [tool] [args...]").argument("[toolset]", "A toolset provided by the target Forkbook configuration").argument("[tool]", "One of the toolset's tools, e.g. `stories find-by-component`").argument(
+    "[args...]",
+    "Tool arguments as `--key value` flags; values are JSON-parsed when possible"
+  );
+  for (let { flags, description } of TOOLS_OPTION_SPECS) {
+    if (flags === "--no-attach") {
+      let option = new Option(flags, description);
+      option.negate = !1, toolsCommand2.addOption(option);
+      continue;
+    }
+    toolsCommand2.option(flags, description);
+  }
+  toolsCommand2.passThroughOptions().action(
+    async (toolset, tool, tokens, options) => {
+      let cliOptions = pickCliOptions(options), flags = {
+        input: options.input,
+        json: options.json,
+        output: options.output,
+        help: options.help,
+        attach: options.noAttach ? !1 : options.attach
+      }, originalStdoutWrite = process.stdout.write;
+      isJsonToolsRun(tokens, flags) && (process.stdout.write = process.stderr.write.bind(
+        process.stderr
+      ));
+      try {
+        await withTelemetry2(
+          "tools-command",
+          { cliOptions, fallbackTelemetryState: !0 },
+          async () => {
+            let keepAlive = setInterval(() => {
+            }, 6e4), start = Date.now(), result;
+            try {
+              options.attach && options.noAttach ? result = {
+                exitCode: 1,
+                output: "Cannot combine `--attach` and `--no-attach`.",
+                outcome: { kind: "intercept", reason: "invalid-arguments" },
+                requestedMode: "auto",
+                attachMode: "auto"
+              } : result = await runToolsCommand({
+                toolset,
+                tool,
+                tokens,
+                target: { cwd: options.cwd, configDir: options.configDir },
+                port: options.port,
+                attach: options.noAttach ? !1 : options.attach,
+                flags
+              });
+            } finally {
+              clearInterval(keepAlive);
+            }
+            let duration = Date.now() - start;
+            try {
+              await printResult2(result, originalStdoutWrite);
+            } finally {
+              await reportToolsCommandTelemetry({ toolset, tool, result, duration }, cliOptions);
+            }
+          }
+        ).catch(handleCommandFailure2(options.logfile));
+      } finally {
+        process.stdout.write = originalStdoutWrite;
+      }
+      process.exit();
+    }
+  );
+}
+function pickCliOptions(options) {
+  let targetCwd = options.cwd ?? process.cwd();
+  return {
+    disableTelemetry: options.disableTelemetry,
+    logfile: options.logfile,
+    configDir: resolveStorybookConfigDir({ cwd: targetCwd, configDir: options.configDir })
+  };
+}
+async function reportToolsCommandTelemetry(run, cliOptions) {
+  let { toolset, tool, result, duration } = run, { outcome } = result;
+  outcome.kind !== "help" && (await reportToolsCommandEvent(
+    {
+      ...toolset !== void 0 ? { toolset: sanitizeNamePart(toolset) } : {},
+      ...tool !== void 0 ? { tool: sanitizeNamePart(tool) } : {},
+      success: outcome.kind === "success",
+      outcome: outcome.kind,
+      client: "cli",
+      requestedMode: result.requestedMode,
+      attachMode: result.attachMode,
+      ...result.host && (result.attachMode === "attached" || result.attachMode === "local") ? { resolvedMode: result.attachMode } : {},
+      ...result.host ? { host: result.host } : {},
+      ...result.multipleMatches ? { multipleMatches: !0 } : {},
+      ...result.fallbackReason ? { attachGate: result.fallbackReason } : {},
+      ...outcome.kind === "attach-gate" ? { attachGate: outcome.reason } : {},
+      ...outcome.kind === "intercept" ? { interceptReason: outcome.reason } : {},
+      duration
+    },
+    // Metadata must describe the target project, consistent with the opt-out resolution.
+    { report: result.report, configDir: cliOptions.configDir }
+  ), outcome.kind === "error" && await sendTelemetryError(outcome.error, "tools-command", { cliOptions }));
+}
+async function printResult2({ output, exitCode, outputPath, fallbackNotice, multiInstanceNotice }, stdoutWrite) {
+  for (let notice of [fallbackNotice, multiInstanceNotice])
+    notice && await new Promise((resolveWrite) => {
+      process.stderr.write(`${notice}
+`, () => resolveWrite());
+    });
+  if (outputPath) {
+    let resolvedPath = resolve3(outputPath);
+    await writeFile(resolvedPath, `${output}
+`, "utf-8"), logger.log(`Output written to ${resolvedPath}`);
+  } else
+    await new Promise((resolveWrite) => {
+      stdoutWrite.call(process.stdout, `${output}
+`, void 0, () => resolveWrite());
+    });
+  exitCode !== 0 && (process.exitCode = exitCode);
+}
+
+// src/cli/build.ts
+import { cache as cache2, defaultConfigDir } from "@aussieljk/forkbook/internal/common";
+import { buildStaticStandalone, withTelemetry as withTelemetry3 } from "@aussieljk/forkbook/internal/core-server";
+var build = async (cliOptions) => {
+  let { default: packageJson } = await import("@aussieljk/forkbook/package.json", { with: { type: "json" } }), options = {
+    ...cliOptions,
+    configDir: cliOptions.configDir || defaultConfigDir(),
+    outputDir: cliOptions.outputDir || "./forkbook-static",
+    configType: "PRODUCTION",
+    cache: cache2,
+    packageJson
+  };
+  await withTelemetry3(
+    "build",
+    { cliOptions, presetOptions: options },
+    () => buildStaticStandalone(options)
+  );
+};
+
+// src/cli/buildIndex.ts
+import { Channel } from "@aussieljk/forkbook/internal/channels";
+import { cache as cache3, defaultConfigDir as defaultConfigDir2 } from "@aussieljk/forkbook/internal/common";
+import { buildIndexStandalone, withTelemetry as withTelemetry4 } from "@aussieljk/forkbook/internal/core-server";
+var buildIndex = async (cliOptions) => {
+  let options = {
+    ...cliOptions,
+    configDir: cliOptions.configDir || defaultConfigDir2(),
+    outputFile: cliOptions.outputFile || "index.json",
+    configType: "PRODUCTION",
+    cache: cache3,
+    packageJson: cliOptions.packageJson
+  }, presetOptions = {
+    ...options,
+    corePresets: [],
+    overridePresets: [],
+    channel: new Channel({})
+  };
+  await withTelemetry4("index", { cliOptions, presetOptions }, () => buildIndexStandalone(options));
+};
+
+// src/cli/dev.ts
+import { cache as cache4, defaultConfigDir as defaultConfigDir3 } from "@aussieljk/forkbook/internal/common";
+import { buildDevStandalone, withTelemetry as withTelemetry5 } from "@aussieljk/forkbook/internal/core-server";
+import { logger as logger2 } from "@aussieljk/forkbook/internal/node-logger";
+import { dedent as dedent2 } from "ts-dedent";
+function printError(error) {
+  error instanceof Error ? error.error ? logger2.error(error.error) : error.stats && error.stats.compilation.errors ? error.stats.compilation.errors.forEach((e) => logger2.log(e)) : logger2.error(error) : error.compilation?.errors && error.compilation.errors.forEach((e) => logger2.log(e)), logger2.warn(
+    error.close ? dedent2`
+          FATAL broken build!, will close the process,
+          Fix the error below and restart storybook.
+        ` : dedent2`
+          Broken build, fix the error above.
+          You may need to refresh the browser.
+        `
+  );
+}
+var dev = async (cliOptions) => {
+  let { env } = process;
+  env.NODE_ENV = env.NODE_ENV || "development";
+  let { default: packageJson } = await import("@aussieljk/forkbook/package.json", { with: { type: "json" } }), options = {
+    ...cliOptions,
+    configDir: cliOptions.configDir || defaultConfigDir3(),
+    configType: "DEVELOPMENT",
+    cache: cache4,
+    packageJson
+  };
+  await withTelemetry5(
+    "dev",
+    {
+      cliOptions,
+      presetOptions: options,
+      printError
+    },
+    () => buildDevStandalone(options)
+  );
+};
+
+// src/bin/dev-options.ts
+import * as v3 from "valibot";
+import { HandledError } from "@aussieljk/forkbook/internal/common";
+var PortSchema = v3.message(
+  v3.pipe(
+    v3.union([v3.pipe(v3.string(), v3.trim(), v3.regex(/^\d+$/), v3.transform(Number)), v3.number()]),
+    v3.minValue(1),
+    v3.integer(),
+    v3.maxValue(65535)
+  ),
+  (issue) => `Port must be a valid number from 1 to 65535, received ${issue.received}.`
+), DevOptionsSchema = v3.looseObject({
+  ci: v3.optional(v3.union([v3.boolean(), v3.string()])),
+  configDir: v3.optional(v3.string()),
+  host: v3.optional(v3.string()),
+  open: v3.optional(v3.boolean()),
+  port: v3.optional(PortSchema),
+  staticDir: v3.optional(v3.string())
+});
+function resolveDevCommandOptions(options, { env = process.env } = {}) {
+  let isClaudePreview = isClaudePreviewLaunch(env), PORT = env.PORT ?? void 0, SBCONFIG_PORT = env.SBCONFIG_PORT ?? void 0, result = v3.safeParse(DevOptionsSchema, {
+    ...options,
+    host: env.SBCONFIG_HOSTNAME || options.host,
+    staticDir: env.SBCONFIG_STATIC_DIR || options.staticDir,
+    configDir: env.SBCONFIG_CONFIG_DIR || options.configDir,
+    ci: env.CI || options.ci,
+    port: isClaudePreview ? PORT ?? options.port ?? SBCONFIG_PORT : options.port ?? SBCONFIG_PORT ?? PORT,
+    open: options.open ?? !1
+  });
+  if (!result.success)
+    throw new HandledError(v3.summarize(result.issues));
+  return result.output;
+}
+
+// src/bin/core.ts
+addToGlobalContext("cliVersion", version);
+process.env.STORYBOOK = "true";
+var handleCommandFailure = async (logFilePath) => {
+  try {
+    let logFile = await logTracker.writeToFile(logFilePath);
+    logger3.log(`Debug logs are written to: ${logFile}`);
+  } catch {
+  }
+  logger3.outro("Forkbook exited with an error"), process.exit(1);
+}, command = (name) => program.command(name).option(
+  "--disable-telemetry",
+  "Disable sending telemetry data",
+  optionalEnvToBoolean(process.env.FORKBOOK_DISABLE_TELEMETRY)
+).option("--debug", "Get more logs in debug mode", !1).option("--enable-crash-reports", "Enable sending crash reports to telemetry data").addOption(
+  new Option2("--loglevel <level>", "Define log level").choices(["trace", "debug", "info", "warn", "error", "silent"]).default("info")
+).option(
+  "--logfile [path]",
+  "Write all debug logs to the specified file at the end of the run. Defaults to debug-storybook.log when [path] is not provided"
+).hook("preAction", async (self) => {
+  try {
+    let options = self.opts(), loglevel = options.debug ? "debug" : options.loglevel;
+    logger3.setLogLevel(loglevel), options.logfile && logTracker.enableLogWriting(), await globalSettings();
+  } catch (e) {
+    logger3.error(`Error loading global settings:
+` + String(e));
+  }
+}).hook("postAction", async (command2) => {
+  if (logTracker.shouldWriteLogsToFile)
+    try {
+      let logFile = await logTracker.writeToFile(command2.getOptionValue("logfile"));
+      logger3.outro(`Debug logs are written to: ${logFile}`);
+    } catch {
+    }
+  command2.name() === "build" && process.exit(0);
+});
+command("dev").option("-p, --port <number>", "Port to run Forkbook").option("-h, --host <string>", "Host to run Forkbook").option("-c, --config-dir <dir-name>", "Directory where to load Forkbook configurations from").option(
+  "--https",
+  "Serve Forkbook over HTTPS. Note: You must provide your own certificate information."
+).option(
+  "--ssl-ca <ca>",
+  "Provide an SSL certificate authority. (Optional with --https, required if using a self-signed certificate)",
+  parseList
+).option("--ssl-cert <cert>", "Provide an SSL certificate. (Required with --https)").option("--ssl-key <key>", "Provide an SSL key. (Required with --https)").option("--smoke-test", "Exit after successful start").option("--ci", "CI mode (skip interactive prompts, don't open browser)").option("--open", "Open Forkbook automatically in the browser", !1).option("--no-open", "Do not open Forkbook in the browser (the default)").option("--quiet", "Suppress verbose build output").option("--no-version-updates", "Suppress update check", !0).option("--debug-webpack", "Display final webpack configurations for debugging purposes").option("--stats-json [directory]", "Write stats JSON to disk").option("--docs", "Build a documentation-only site using addon-docs").option("--exact-port", "Exit early if the desired port is not available").option(
+  "--initial-path [path]",
+  "URL path to be appended when visiting Forkbook for the first time"
+).option("--preview-only", "Use the preview without the manager UI").action(async (options) => {
+  let { default: packageJson } = await import("@aussieljk/forkbook/package.json", { with: { type: "json" } });
+  logger3.intro(`${packageJson.name} v${packageJson.version}`);
+  let resolvedOptions;
+  try {
+    resolvedOptions = resolveDevCommandOptions(options);
+  } catch (error) {
+    return logger3.error(error instanceof Error ? error.message : String(error)), handleCommandFailure(options.logfile);
+  }
+  await dev({ ...resolvedOptions, packageJson }).catch(() => {
+    handleCommandFailure(options.logfile);
+  });
+});
+command("build").option("-o, --output-dir <dir-name>", "Directory where to store built files").option("-c, --config-dir <dir-name>", "Directory where to load Forkbook configurations from").option("--quiet", "Suppress verbose build output").option("--debug-webpack", "Display final webpack configurations for debugging purposes").option("--stats-json [directory]", "Write stats JSON to disk").option("--docs", "Build a documentation-only site using addon-docs").option("--test", "Build stories optimized for testing purposes.").option("--preview-only", "Use the preview without the manager UI").action(async (options) => {
+  let { env } = process;
+  env.NODE_ENV = env.NODE_ENV || "production";
+  let { default: packageJson } = await import("@aussieljk/forkbook/package.json", { with: { type: "json" } });
+  logger3.intro(`Building ${packageJson.name} v${packageJson.version}`), getEnvConfig(options, {
+    staticDir: "SBCONFIG_STATIC_DIR",
+    outputDir: "SBCONFIG_OUTPUT_DIR",
+    configDir: "SBCONFIG_CONFIG_DIR"
+  }), await build({
+    ...options,
+    packageJson,
+    test: !!options.test || optionalEnvToBoolean(process.env.FB_TESTBUILD)
+  }).catch(() => {
+    logger3.outro("Forkbook exited with an error"), process.exit(1);
+  }), logger3.outro("Forkbook build completed successfully");
+});
+command("index").option("-o, --output-file <file-name>", "JSON file to output index").option("-c, --config-dir <dir-name>", "Directory where to load Forkbook configurations from").option("--quiet", "Suppress verbose build output").action(async (options) => {
+  let { env } = process;
+  env.NODE_ENV = env.NODE_ENV || "production";
+  let { default: packageJson } = await import("@aussieljk/forkbook/package.json", { with: { type: "json" } });
+  logger3.log(import_picocolors.default.bold(`${packageJson.name} v${packageJson.version}
+`)), getEnvConfig(options, {
+    configDir: "SBCONFIG_CONFIG_DIR",
+    outputFile: "SBCONFIG_OUTPUT_FILE"
+  }), await buildIndex({
+    ...options,
+    packageJson
+  }).catch(() => process.exit(1));
+});
+var handleCliCommandFailure = (logFilePath) => async (error) => (error instanceof HandledError2 || logger3.error(String(error)), handleCommandFailure(logFilePath ?? !1)), toolsCommand = command("tools").description(
+  "Run the agent tools provided by the target Forkbook configuration"
+);
+registerToolsPassthrough(program, toolsCommand, handleCliCommandFailure);
+var skillsCommand = command("skills").description(
+  "Agent skills served by the target Forkbook configuration"
+);
+registerSkillsCommand(program, skillsCommand, handleCliCommandFailure);
+program.on("command:*", ([invalidCmd]) => {
+  let errorMessage = ` Invalid command: ${import_picocolors.default.bold(invalidCmd)}.
+ See --help for a list of available commands.`, suggestion = program.commands.map((cmd) => cmd.name()).find((cmd) => leven(cmd, invalidCmd) < 3);
+  suggestion && (errorMessage += `
+ Did you mean ${import_picocolors.default.yellow(suggestion)}?`), logger3.error(errorMessage), process.exit(1);
+});
+program.usage("<command> [options]").version(String(version)).parse(process.argv);