@woodsportal/hubspot-kit 1.0.2

package/dist/cli.js

@@ -0,0 +1,1849 @@
+#!/usr/bin/env node
+import {
+  ExitCode,
+  WpHsError,
+  isWpHsError,
+  runCommand,
+  runNodeScript
+} from "./chunk-JDGIAYHX.js";
+
+// src/cli/program.ts
+import { readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve17 } from "path";
+import { Command } from "commander";
+
+// src/lib/config.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/lib/config-files.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+var WOODSCLI_CONFIG_FILE = "woodscli.json";
+var LEGACY_WOODSPORTAL_HS_FILE = "woodsportal.hs.json";
+function envConfigPath(projectRoot) {
+  const fromEnv = process.env.WOODSCLI_CONFIG?.trim() || process.env.WP_HS_CONFIG?.trim() || null;
+  if (!fromEnv) return null;
+  return resolve(projectRoot, fromEnv);
+}
+function legacyConfigPath(projectRoot) {
+  return resolve(projectRoot, LEGACY_WOODSPORTAL_HS_FILE);
+}
+function woodscliConfigPath(projectRoot) {
+  return resolve(projectRoot, WOODSCLI_CONFIG_FILE);
+}
+function legacyConfigConflict(projectRoot) {
+  const hasWoodscli = existsSync(woodscliConfigPath(projectRoot));
+  const hasLegacy = existsSync(legacyConfigPath(projectRoot));
+  if (hasLegacy && hasWoodscli) return "duplicate";
+  if (hasLegacy && !hasWoodscli) return "legacy-only";
+  return null;
+}
+function resolveProjectConfig(projectRoot) {
+  const envPath = envConfigPath(projectRoot);
+  if (envPath) {
+    if (!existsSync(envPath)) return null;
+    return { path: envPath, fileName: WOODSCLI_CONFIG_FILE };
+  }
+  const path = woodscliConfigPath(projectRoot);
+  if (existsSync(path)) {
+    return { path, fileName: WOODSCLI_CONFIG_FILE };
+  }
+  return null;
+}
+function findProjectRoot(from = process.cwd()) {
+  if (process.env.WP_HS_PROJECT_ROOT?.trim()) {
+    return resolve(process.env.WP_HS_PROJECT_ROOT.trim());
+  }
+  let dir = resolve(from);
+  while (true) {
+    if (resolveProjectConfig(dir)) {
+      return dir;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+// src/schema/woodsportal-hs.ts
+import { z } from "zod";
+var CONFIG_VERSION = 1;
+var WPHS_WORKSPACE_DIR = ".wphs";
+var WoodsPortalHsSchema = z.object({
+  configVersion: z.number().int().default(CONFIG_VERSION),
+  projectType: z.enum(["module-hybrid-cdn", "module-monolith", "theme-starter"]),
+  module: z.object({
+    name: z.string().min(1),
+    uploadPath: z.string().min(1),
+    outDir: z.string().default("dist/WoodsPortal.Module")
+  }),
+  theme: z.object({
+    name: z.string().min(1),
+    uploadPath: z.string().min(1),
+    srcDir: z.string().default("src/theme"),
+    themeJson: z.string().default("src/theme/theme.json")
+  }).optional(),
+  cdn: z.object({
+    mode: z.enum(["jsdelivr", "custom", "local", "none"]).default("jsdelivr"),
+    buildIdFile: z.string().default(".portal-build-id"),
+    mirror: z.string().default("portal.cdn.json")
+  }).default({}),
+  entries: z.object({
+    app: z.string().default("src/cdn/app-entry.ts"),
+    vendor: z.string().default("src/cdn/vendor-entry.ts"),
+    hubspotBootstrap: z.string().default("src/hubspot/bootstrap.ts"),
+    localDev: z.string().default("src/main.tsx")
+  }).default({}),
+  env: z.object({
+    tiers: z.array(z.enum(["dev", "stg", "prod"])).default(["dev", "stg", "prod"])
+  }).default({}),
+  dev: z.object({
+    moduleConfigDir: z.literal(WPHS_WORKSPACE_DIR).default(WPHS_WORKSPACE_DIR),
+    adapter: z.string().default("./wphs.adapter.ts"),
+    fieldsJson: z.string().default("public/fields.json"),
+    themeFieldsJson: z.string().optional()
+  }).default({})
+});
+var DEFAULT_WOODSPORTAL_HS = {
+  configVersion: CONFIG_VERSION,
+  projectType: "module-hybrid-cdn",
+  module: {
+    name: "woodsportal-module",
+    uploadPath: "dw-modules/woodsportal-module.module",
+    outDir: "dist/WoodsPortal.Module"
+  },
+  cdn: {
+    mode: "jsdelivr",
+    buildIdFile: ".portal-build-id",
+    mirror: "portal.cdn.json"
+  },
+  entries: {
+    app: "src/cdn/app-entry.ts",
+    vendor: "src/cdn/vendor-entry.ts",
+    hubspotBootstrap: "src/hubspot/bootstrap.ts",
+    localDev: "src/main.tsx"
+  },
+  env: {
+    tiers: ["dev", "stg", "prod"]
+  },
+  dev: {
+    moduleConfigDir: WPHS_WORKSPACE_DIR,
+    adapter: "./wphs.adapter.ts",
+    fieldsJson: "public/fields.json"
+  }
+};
+function isModuleProject(config) {
+  return config.projectType === "module-hybrid-cdn" || config.projectType === "module-monolith";
+}
+function isThemeProject(config) {
+  return config.projectType === "theme-starter";
+}
+function usesCdnPipeline(config) {
+  return config.projectType === "module-hybrid-cdn" && config.cdn.mode !== "none";
+}
+
+// src/lib/paths.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var KIT_PACKAGE_NAME = "@woodsportal/hubspot-kit";
+function resolveKitRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const pkgPath = resolve2(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.name === KIT_PACKAGE_NAME) {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  throw new WpHsError("Could not resolve @woodsportal/hubspot-kit package root.", {
+    exitCode: ExitCode.INTERNAL
+  });
+}
+var kitRoot = resolveKitRoot();
+function getKitRoot() {
+  return kitRoot;
+}
+function findProjectRoot2(from = process.cwd()) {
+  const root = findProjectRoot(from);
+  if (!root) {
+    throw new WpHsError("Could not find woodscli.json in this directory or any parent.", {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Run wp init, wp adopt, or pass --project <path>. Legacy config: wp migrate --yes."
+    });
+  }
+  return root;
+}
+function kitPath(...segments) {
+  return resolve2(kitRoot, ...segments);
+}
+
+// src/lib/config.ts
+function loadConfig(projectRoot) {
+  const root = projectRoot ?? findProjectRoot2();
+  const resolved = resolveProjectConfig(root);
+  if (!resolved) {
+    throw new WpHsError(`Missing ${WOODSCLI_CONFIG_FILE}`, {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Run wp init or wp adopt. Legacy woodsportal.hs.json \u2192 run wp migrate --yes."
+    });
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(resolved.path, "utf8"));
+  } catch (cause) {
+    throw new WpHsError(`Invalid JSON in ${resolved.fileName}`, {
+      exitCode: ExitCode.USER_ERROR,
+      cause
+    });
+  }
+  const parsed = WoodsPortalHsSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new WpHsError(`${resolved.fileName} validation failed: ${parsed.error.message}`, {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Run wp config validate for details."
+    });
+  }
+  return {
+    root,
+    config: parsed.data,
+    configPath: resolved.path,
+    configFileName: resolved.fileName
+  };
+}
+function validateConfigFile(projectRoot) {
+  try {
+    const { config } = loadConfig(projectRoot);
+    return { valid: true, errors: [], config };
+  } catch (error) {
+    if (error instanceof WpHsError) {
+      return { valid: false, errors: [error.message] };
+    }
+    return { valid: false, errors: [String(error)] };
+  }
+}
+
+// src/lib/logger.ts
+import pc from "picocolors";
+function shouldUseColor() {
+  if (process.env.NO_COLOR !== void 0) return false;
+  if (process.env.CI === "true") return false;
+  return process.stdout.isTTY === true;
+}
+function createLogger(options = {}) {
+  const useColor = shouldUseColor();
+  const { verbose = false, quiet = false, json = false } = options;
+  const emit = (level, message, meta) => {
+    if (json) return;
+    if (quiet && level !== "error" && level !== "warn") return;
+    if (level === "debug" && !verbose) return;
+    const prefix = level === "error" ? useColor ? pc.red("error") : "error" : level === "warn" ? useColor ? pc.yellow("warn") : "warn" : level === "debug" ? useColor ? pc.dim("debug") : "debug" : useColor ? pc.cyan("info") : "info";
+    const line = meta ? `${message} ${JSON.stringify(meta)}` : message;
+    const stream = level === "error" || level === "warn" ? process.stderr : process.stdout;
+    stream.write(`[${prefix}] ${line}
+`);
+  };
+  return {
+    debug: (message, meta) => emit("debug", message, meta),
+    info: (message, meta) => emit("info", message, meta),
+    warn: (message, meta) => emit("warn", message, meta),
+    error: (message, meta) => emit("error", message, meta),
+    success: (message, meta) => {
+      if (json) return;
+      if (quiet) return;
+      const prefix = useColor ? pc.green("ok") : "ok";
+      process.stdout.write(`[${prefix}] ${message}
+`);
+      if (meta) process.stdout.write(`${JSON.stringify(meta)}
+`);
+    },
+    json: (payload) => {
+      if (!json) return;
+      process.stdout.write(`${JSON.stringify(payload)}
+`);
+    }
+  };
+}
+
+// src/lib/wphs-baseline.ts
+import { resolve as resolve3 } from "path";
+function defaultBaselineDir(projectRoot, config) {
+  const workspace = config.dev.moduleConfigDir ?? WPHS_WORKSPACE_DIR;
+  return resolve3(projectRoot, workspace, "audit", "baseline");
+}
+
+// src/cli/commands/doctor.ts
+import { existsSync as existsSync4 } from "fs";
+import { join, resolve as resolve5 } from "path";
+
+// src/lib/hubspot-cli-setup.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+import { spawnSync } from "child_process";
+var HUBSPOT_CONFIG_FILE = "hubspot.config.yml";
+var HUBSPOT_CONFIG_EXAMPLE = "hubspot.config.yml.example";
+var PLACEHOLDER_PATTERNS = [
+  /YOUR_PAT_HERE/i,
+  /your-portal-id/i,
+  /personalAccessKey:\s*$/m,
+  /portalId:\s*12345678\b/
+];
+function assessHubSpotCliSetup(projectRoot) {
+  const configPath = resolve4(projectRoot, HUBSPOT_CONFIG_FILE);
+  const examplePath = resolve4(projectRoot, HUBSPOT_CONFIG_EXAMPLE);
+  const configPresent = existsSync3(configPath);
+  const examplePresent = existsSync3(examplePath);
+  let looksLikePlaceholder = false;
+  if (configPresent) {
+    const raw = readFileSync3(configPath, "utf8");
+    looksLikePlaceholder = PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(raw));
+  } else {
+    looksLikePlaceholder = true;
+  }
+  const hsVersion = spawnSync("hs", ["--version"], { encoding: "utf8" });
+  const hsCliInstalled = hsVersion.status === 0;
+  const hsCliVersion = hsCliInstalled ? (hsVersion.stdout || hsVersion.stderr || "").trim() : null;
+  let authenticated = false;
+  let accountsHint = null;
+  if (hsCliInstalled) {
+    const accounts = spawnSync("hs", ["accounts", "list"], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      timeout: 15e3
+    });
+    const output = `${accounts.stdout || ""}
+${accounts.stderr || ""}`.trim();
+    accountsHint = output || null;
+    authenticated = accounts.status === 0 && /Account:|portalId|portal/i.test(output) && !/No accounts/i.test(output);
+  }
+  return {
+    configPath,
+    examplePath,
+    configPresent,
+    examplePresent,
+    looksLikePlaceholder,
+    hsCliInstalled,
+    hsCliVersion,
+    authenticated,
+    accountsHint
+  };
+}
+function hubSpotSetupRemediation(projectRoot) {
+  const assessment = assessHubSpotCliSetup(projectRoot);
+  const steps = [];
+  if (!assessment.hsCliInstalled) {
+    steps.push("Install HubSpot CLI: npm i -g @hubspot/cli");
+  }
+  if (!assessment.configPresent) {
+    if (assessment.examplePresent) {
+      steps.push(`Copy ${HUBSPOT_CONFIG_EXAMPLE} \u2192 ${HUBSPOT_CONFIG_FILE} and add your portal + PAT`);
+    } else {
+      steps.push(`Create ${HUBSPOT_CONFIG_FILE} (see docs/HUBSPOT-CLI-SETUP.md)`);
+    }
+    steps.push("Generate a PAT: https://app.hubspot.com/l/personal-access-key");
+  } else if (assessment.looksLikePlaceholder) {
+    steps.push(`Edit ${HUBSPOT_CONFIG_FILE} \u2014 replace placeholder portalId and personalAccessKey`);
+  }
+  if (assessment.configPresent && !assessment.looksLikePlaceholder && !assessment.authenticated) {
+    steps.push("Run wp auth (or hs auth) and confirm with: hs accounts list");
+  }
+  return steps;
+}
+function ensureHubSpotCliSetup(ctx, mode) {
+  if (ctx.global.dryRun || ctx.global.json) return;
+  const assessment = assessHubSpotCliSetup(ctx.projectRoot);
+  const needsSetup = !assessment.hsCliInstalled || !assessment.configPresent || assessment.looksLikePlaceholder || !assessment.authenticated;
+  if (!needsSetup) return;
+  const steps = hubSpotSetupRemediation(ctx.projectRoot);
+  const headline = mode === "local" ? "HubSpot upload/watch is not configured for this project (local preview still works)." : "HubSpot CLI is not ready for cms upload/watch in this project.";
+  if (mode === "local") {
+    ctx.logger.warn(headline);
+    for (const step of steps) {
+      ctx.logger.info(`  \u2192 ${step}`);
+    }
+    ctx.logger.info("  \u2192 Docs: @woodsportal/hubspot-kit/docs/HUBSPOT-CLI-SETUP.md");
+    return;
+  }
+  throw new WpHsError(headline, {
+    exitCode: ExitCode.PREREQUISITE,
+    remediation: steps.join("; ")
+  });
+}
+function doctorHubSpotChecks(projectRoot) {
+  const assessment = assessHubSpotCliSetup(projectRoot);
+  const steps = hubSpotSetupRemediation(projectRoot);
+  const remediation = steps.length > 0 ? steps.join(" \xB7 ") : void 0;
+  return [
+    {
+      name: "hubspot-cli",
+      ok: assessment.hsCliInstalled,
+      message: assessment.hsCliInstalled ? `HubSpot CLI ${assessment.hsCliVersion ?? ""}`.trim() : "HubSpot CLI not installed",
+      remediation: assessment.hsCliInstalled ? void 0 : "npm i -g @hubspot/cli",
+      severity: "error"
+    },
+    {
+      name: "hubspot-config",
+      ok: assessment.configPresent && !assessment.looksLikePlaceholder,
+      message: !assessment.configPresent ? `${HUBSPOT_CONFIG_FILE} missing (required for wp upload / wp watch)` : assessment.looksLikePlaceholder ? `${HUBSPOT_CONFIG_FILE} still has placeholder values` : `${HUBSPOT_CONFIG_FILE} present`,
+      remediation,
+      severity: "warn"
+    },
+    {
+      name: "hubspot-auth",
+      ok: assessment.authenticated,
+      message: assessment.authenticated ? "HubSpot CLI authenticated for this project" : "HubSpot CLI not authenticated (or no portal in hubspot.config.yml)",
+      remediation: assessment.authenticated ? void 0 : "wp auth \xB7 hs accounts list",
+      severity: "warn"
+    }
+  ];
+}
+
+// src/cli/commands/doctor.ts
+function checkNode() {
+  const major = Number(process.versions.node.split(".")[0]);
+  const ok = major >= 20;
+  return {
+    name: "node",
+    ok,
+    message: ok ? `Node ${process.versions.node}` : `Node ${process.versions.node} (need >= 20)`,
+    remediation: ok ? void 0 : "Install Node 20 LTS or newer.",
+    severity: "error"
+  };
+}
+function checkLegacyConfig(projectRoot) {
+  const conflict = legacyConfigConflict(projectRoot);
+  if (conflict === "legacy-only") {
+    return {
+      name: "config-filename",
+      ok: false,
+      message: `Legacy ${LEGACY_WOODSPORTAL_HS_FILE} \u2014 ${WOODSCLI_CONFIG_FILE} is required`,
+      remediation: "Run wp migrate --yes",
+      severity: "error"
+    };
+  }
+  if (conflict === "duplicate") {
+    return {
+      name: "config-filename",
+      ok: false,
+      message: `Both ${WOODSCLI_CONFIG_FILE} and ${LEGACY_WOODSPORTAL_HS_FILE} present`,
+      remediation: "Run wp migrate --yes to remove the legacy file",
+      severity: "error"
+    };
+  }
+  return null;
+}
+function checkConfig(ctx) {
+  const legacy = checkLegacyConfig(ctx.projectRoot);
+  if (legacy) {
+    return [legacy];
+  }
+  try {
+    const loaded = loadConfig(ctx.projectRoot);
+    return [
+      {
+        name: "config",
+        ok: true,
+        message: `${loaded.configFileName} valid`,
+        severity: "error"
+      }
+    ];
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [
+      {
+        name: "config",
+        ok: false,
+        message,
+        remediation: "Run wp config validate",
+        severity: "error"
+      }
+    ];
+  }
+}
+function checkEnvFiles(ctx) {
+  return ctx.config.env.tiers.map((tier) => {
+    const file = tier === "dev" ? ".env.dev" : tier === "stg" ? ".env.stg" : ".env.prod";
+    const path = resolve5(ctx.projectRoot, file);
+    const example = resolve5(ctx.projectRoot, `${file}.example`);
+    const ok = existsSync4(path);
+    return {
+      name: `env-${tier}`,
+      ok,
+      message: ok ? `${file} present` : `${file} missing`,
+      remediation: ok ? void 0 : existsSync4(example) ? `cp ${file}.example ${file}` : `Create ${file}`,
+      severity: "warn"
+    };
+  });
+}
+function checkBuildId(ctx) {
+  if (isThemeProject(ctx.config) || !usesCdnPipeline(ctx.config)) return null;
+  const file = resolve5(ctx.projectRoot, ctx.config.cdn.buildIdFile);
+  const ok = existsSync4(file);
+  return {
+    name: "build-id",
+    ok,
+    message: ok ? `${ctx.config.cdn.buildIdFile} present` : `${ctx.config.cdn.buildIdFile} missing`,
+    remediation: ok ? void 0 : `Create ${ctx.config.cdn.buildIdFile} with your release tag (e.g. v0.0.1-dev.1)`,
+    severity: "warn"
+  };
+}
+function checkDevViteConfig(ctx) {
+  const path = resolve5(ctx.projectRoot, "vite.config.dev.mjs");
+  const ok = existsSync4(path);
+  return {
+    name: "vite-dev-config",
+    ok,
+    message: ok ? "vite.config.dev.mjs present" : "vite.config.dev.mjs missing",
+    remediation: ok ? void 0 : "Add vite.config.dev.mjs that re-exports @woodsportal/hubspot-kit/vite/vite.config.dev.mjs",
+    severity: "error"
+  };
+}
+function checkKitScripts() {
+  const script = kitPath("scripts", "build-cdn.mjs");
+  const ok = existsSync4(script);
+  return {
+    name: "kit-scripts",
+    ok,
+    message: ok ? "@woodsportal/hubspot-kit scripts installed" : "Kit build scripts missing",
+    remediation: ok ? void 0 : "Reinstall @woodsportal/hubspot-kit",
+    severity: "error"
+  };
+}
+function checkWphsWorkspace(ctx) {
+  const workspace = ctx.config.dev.moduleConfigDir;
+  const checks = [];
+  for (const legacy of [".dev", ".woodsportal"]) {
+    const legacyPath = resolve5(ctx.projectRoot, legacy);
+    if (existsSync4(legacyPath)) {
+      checks.push({
+        name: `legacy-${legacy}`,
+        ok: false,
+        message: `Legacy workspace ${legacy}/ still present`,
+        remediation: "Run wp migrate --yes",
+        severity: "error"
+      });
+    }
+  }
+  if (existsSync4(resolve5(ctx.projectRoot, ".wp-hs-baseline"))) {
+    checks.push({
+      name: "legacy-baseline",
+      ok: false,
+      message: "Legacy .wp-hs-baseline/ at repo root",
+      remediation: "Run wp migrate --yes",
+      severity: "error"
+    });
+  }
+  if (workspace !== WPHS_WORKSPACE_DIR) {
+    checks.push({
+      name: "wphs-dir",
+      ok: false,
+      message: `dev.moduleConfigDir must be "${WPHS_WORKSPACE_DIR}" (got "${workspace}")`,
+      remediation: "Run wp migrate --yes",
+      severity: "error"
+    });
+    return checks;
+  }
+  const wphsRoot = resolve5(ctx.projectRoot, workspace);
+  const required = ["config", "assets/branding", "fixtures", "cache", "audit/baseline", "state"];
+  for (const sub of required) {
+    const ok = existsSync4(join(wphsRoot, sub));
+    checks.push({
+      name: `wphs-${sub.replace(/\//g, "-")}`,
+      ok,
+      message: ok ? `.wphs/${sub}/ present` : `.wphs/${sub}/ missing`,
+      remediation: ok ? void 0 : "Run wp doctor (auto-scaffolds) or wp init",
+      severity: "error"
+    });
+  }
+  return checks;
+}
+function checkAdapter(ctx) {
+  if (isThemeProject(ctx.config)) return null;
+  const adapterPath = resolve5(ctx.projectRoot, ctx.config.dev.adapter);
+  const ok = existsSync4(adapterPath);
+  return {
+    name: "wphs-adapter",
+    ok,
+    message: ok ? `${ctx.config.dev.adapter} present` : `${ctx.config.dev.adapter} missing`,
+    remediation: ok ? void 0 : "Run wp adopt or create wphs.adapter.ts",
+    severity: "warn"
+  };
+}
+async function runDoctor(ctx) {
+  if (!ctx.global.dryRun) {
+    try {
+      runNodeScript(kitPath("scripts/ensure-wphs-workspace.mjs"), [], {
+        cwd: ctx.projectRoot,
+        logger: ctx.logger,
+        dryRun: false
+      });
+    } catch {
+    }
+  }
+  const checks = [
+    checkNode(),
+    checkKitScripts(),
+    checkDevViteConfig(ctx),
+    ...checkConfig(ctx),
+    ...checkWphsWorkspace(ctx),
+    checkAdapter(ctx),
+    ...doctorHubSpotChecks(ctx.projectRoot),
+    checkBuildId(ctx),
+    ...checkEnvFiles(ctx)
+  ].filter((c) => c !== null);
+  const failed = checks.filter((c) => !c.ok && (c.severity ?? "error") === "error");
+  const warnings = checks.filter((c) => !c.ok && c.severity === "warn");
+  if (ctx.global.json) {
+    ctx.logger.json({
+      command: "doctor",
+      ok: failed.length === 0,
+      warnings: warnings.length,
+      checks
+    });
+  } else {
+    for (const check of checks) {
+      if (check.ok) {
+        ctx.logger.success(check.message);
+      } else if (check.severity === "warn") {
+        ctx.logger.warn(check.message);
+        if (check.remediation) ctx.logger.info(`  \u2192 ${check.remediation}`);
+      } else {
+        ctx.logger.error(check.message);
+        if (check.remediation) ctx.logger.info(`  \u2192 ${check.remediation}`);
+      }
+    }
+  }
+  if (failed.length > 0) {
+    throw new WpHsError(`${failed.length} doctor check(s) failed`, {
+      exitCode: ExitCode.PREREQUISITE
+    });
+  }
+  if (warnings.length > 0 && !ctx.global.quiet && !ctx.global.json) {
+    ctx.logger.warn(
+      `${warnings.length} optional check(s) \u2014 local dev may work; fix before wp upload / wp watch`
+    );
+  }
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/config-validate.ts
+async function runConfigValidate(ctx) {
+  const result = validateConfigFile(ctx.projectRoot);
+  if (ctx.global.json) {
+    ctx.logger.json({
+      command: "config validate",
+      valid: result.valid,
+      errors: result.errors,
+      config: result.config
+    });
+  } else if (result.valid) {
+    ctx.logger.success(`${WOODSCLI_CONFIG_FILE} is valid`);
+  } else {
+    for (const err of result.errors) {
+      ctx.logger.error(err);
+    }
+  }
+  return result.valid ? ExitCode.SUCCESS : ExitCode.USER_ERROR;
+}
+
+// src/cli/commands/build.ts
+import { resolve as resolve6 } from "path";
+function tierToStgFlag(tier) {
+  return tier === "dev" || tier === "stg" ? ["--stg"] : [];
+}
+async function runBuild(ctx, options) {
+  const tier = options.tier ?? "prod";
+  const env = { ...process.env, WP_HS_PROJECT_ROOT: ctx.projectRoot };
+  const isTheme = isThemeProject(ctx.config);
+  const useCdn = usesCdnPipeline(ctx.config) && !isTheme;
+  const execOpts = {
+    cwd: ctx.projectRoot,
+    env,
+    logger: ctx.logger,
+    dryRun: ctx.global.dryRun
+  };
+  const run = (script, args = []) => {
+    runNodeScript(kitPath("scripts", script), args, execOpts);
+  };
+  try {
+    if (isTheme && !options.cdnOnly) {
+      ctx.logger.info("Theme project \u2014 skipping CDN/module.js build (use wp upload for theme assets)");
+      if (ctx.global.json) {
+        ctx.logger.json({ command: "build", tier, ok: true, projectType: ctx.config.projectType });
+      } else {
+        ctx.logger.success("Theme build complete (no-op)");
+      }
+      return ExitCode.SUCCESS;
+    }
+    if (ctx.config.projectType === "module-monolith" && !options.cdnOnly) {
+      ctx.logger.info(`Building monolith module (${tier})\u2026`);
+      run("run-vite-build.mjs", [
+        resolve6(ctx.projectRoot, "vite.config.monolith.mjs"),
+        ...tierToStgFlag(tier)
+      ]);
+      run("run-hubspot-module-postbuild.mjs");
+    } else {
+      if (!options.hubspotOnly && useCdn) {
+        ctx.logger.info(`Building CDN (${tier})\u2026`);
+        if (options.cdnEsm) {
+          run("run-vite-build.mjs", [
+            resolve6(ctx.projectRoot, "vite.config.cdn-esm.mjs"),
+            ...tierToStgFlag(tier)
+          ]);
+        } else {
+          run("build-cdn.mjs", tierToStgFlag(tier));
+        }
+        run("generate-cdn-manifest.mjs");
+      }
+      if (!options.cdnOnly) {
+        ctx.logger.info(`Building HubSpot module (${tier})\u2026`);
+        run("run-vite-build.mjs", [
+          resolve6(ctx.projectRoot, "vite.config.hubspot.mjs"),
+          ...tierToStgFlag(tier)
+        ]);
+        run("run-hubspot-module-postbuild.mjs");
+      }
+    }
+    if (!options.cdnOnly && !options.hubspotOnly) {
+      run("check-hubspot-bundle-size.mjs");
+      run("write-audit-artifacts.mjs");
+    }
+    if (ctx.global.json) {
+      ctx.logger.json({
+        command: "build",
+        tier,
+        ok: true,
+        outDir: resolve6(ctx.projectRoot, ctx.config.module.outDir)
+      });
+    } else {
+      ctx.logger.success("Build complete");
+    }
+    return ExitCode.SUCCESS;
+  } catch (error) {
+    throw new WpHsError(error instanceof Error ? error.message : String(error), {
+      exitCode: ExitCode.BUILD_FAILED
+    });
+  }
+}
+
+// src/cli/commands/dev.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve8 } from "path";
+import { spawn } from "child_process";
+
+// src/vite/resolve-dev-config.ts
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve7 } from "path";
+var CONSUMER_DEV_CONFIG = "vite.config.dev.mjs";
+function resolveDevViteConfigPath(projectRoot) {
+  const consumerConfig = resolve7(projectRoot, CONSUMER_DEV_CONFIG);
+  if (existsSync5(consumerConfig)) {
+    return consumerConfig;
+  }
+  return kitPath("vite", "vite.config.dev.mjs");
+}
+function resolveProjectViteBin(projectRoot) {
+  const localBin = resolve7(projectRoot, "node_modules", ".bin", "vite");
+  if (existsSync5(localBin)) {
+    return localBin;
+  }
+  return "vite";
+}
+
+// src/cli/commands/dev.ts
+async function runDev(ctx, options) {
+  ensureHubSpotCliSetup(ctx, "local");
+  const port = options.port ?? 3e3;
+  const env = {
+    ...process.env,
+    WP_HS_PROJECT_ROOT: ctx.projectRoot
+  };
+  const configPath = resolveDevViteConfigPath(ctx.projectRoot);
+  const viteBin = resolveProjectViteBin(ctx.projectRoot);
+  if (ctx.global.dryRun) {
+    ctx.logger.info(`[dry-run] ${viteBin} --config ${configPath} --port ${port}`);
+    return ExitCode.SUCCESS;
+  }
+  if (viteBin === "vite") {
+    throw new WpHsError("vite is not installed in this project.", {
+      exitCode: ExitCode.PREREQUISITE,
+      remediation: "Run yarn install in the project root (vite is a devDependency)."
+    });
+  }
+  const consumerConfig = resolve8(ctx.projectRoot, "vite.config.dev.mjs");
+  if (!existsSync6(consumerConfig)) {
+    throw new WpHsError("vite.config.dev.mjs is missing in the project root.", {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Add vite.config.dev.mjs (see @woodsportal/hubspot-kit templates/module-hybrid-cdn)."
+    });
+  }
+  return new Promise((resolvePromise) => {
+    const child = spawn(
+      viteBin,
+      ["--config", configPath, "--port", String(port), "--mode", "dev"],
+      {
+        cwd: ctx.projectRoot,
+        env,
+        stdio: "inherit"
+      }
+    );
+    child.on("exit", (code) => {
+      resolvePromise(code ?? ExitCode.USER_ERROR);
+    });
+  });
+}
+
+// src/cli/commands/deploy.ts
+import { resolve as resolve10 } from "path";
+
+// src/cli/commands/publish.ts
+async function runPublish(ctx, options) {
+  const tier = options.tier ?? "prod";
+  const env = { ...process.env, WP_HS_PROJECT_ROOT: ctx.projectRoot };
+  const execOpts = {
+    cwd: ctx.projectRoot,
+    env,
+    logger: ctx.logger,
+    dryRun: ctx.global.dryRun || options.dryRun
+  };
+  const verifyFlag = tier === "prod" ? ["--prod"] : ["--stg"];
+  const publishArgs = options.dryRun ? ["--dry-run"] : [];
+  try {
+    if (!options.dryRun) {
+      ctx.logger.info(`Verifying CDN API endpoint (${tier})\u2026`);
+      runNodeScript(kitPath("scripts", "verify-cdn-api-endpoint.mjs"), verifyFlag, execOpts);
+    }
+    ctx.logger.info(options.dryRun ? "CDN publish dry-run\u2026" : `Publishing CDN (${tier})\u2026`);
+    runNodeScript(kitPath("scripts", "publish-cdn-github.mjs"), publishArgs, execOpts);
+    if (ctx.global.json) {
+      ctx.logger.json({ command: "publish", tier, dryRun: Boolean(options.dryRun), ok: true });
+    } else {
+      ctx.logger.success(options.dryRun ? "CDN publish dry-run complete" : "CDN publish complete");
+    }
+    return ExitCode.SUCCESS;
+  } catch (error) {
+    throw new WpHsError(error instanceof Error ? error.message : String(error), {
+      exitCode: ExitCode.PUBLISH_FAILED,
+      remediation: "Check CDN PAT, portal.cdn.json, and verify-cdn-api-endpoint."
+    });
+  }
+}
+
+// src/cli/commands/upload.ts
+import { resolve as resolve9 } from "path";
+async function runUpload(ctx, options = {}) {
+  ensureHubSpotCliSetup(ctx, "cms");
+  const tier = options.tier ?? "prod";
+  if (tier === "prod" && !ctx.global.yes && !ctx.global.ci) {
+    const confirmed = process.env.WP_HS_CONFIRM_PROD === "1";
+    if (!confirmed) {
+      throw new WpHsError("Production upload blocked \u2014 pass --yes or set WP_HS_CONFIRM_PROD=1", {
+        exitCode: ExitCode.USER_ERROR,
+        remediation: "wp upload --tier prod --yes"
+      });
+    }
+  }
+  if (isThemeProject(ctx.config)) {
+    const theme = ctx.config.theme;
+    if (!theme) {
+      throw new WpHsError("theme block missing in woodscli.json", { exitCode: ExitCode.USER_ERROR });
+    }
+    const srcDir = resolve9(ctx.projectRoot, theme.srcDir);
+    try {
+      runCommand("hs", ["cms", "upload", srcDir, theme.uploadPath], {
+        cwd: ctx.projectRoot,
+        logger: ctx.logger,
+        dryRun: ctx.global.dryRun
+      });
+      if (!ctx.global.json && !ctx.global.quiet) {
+        ctx.logger.success(`Uploaded theme ${srcDir} \u2192 ${theme.uploadPath}`);
+      }
+      return ExitCode.SUCCESS;
+    } catch (error) {
+      throw new WpHsError("HubSpot theme upload failed", {
+        exitCode: ExitCode.PUBLISH_FAILED,
+        cause: error
+      });
+    }
+  }
+  const outDir = resolve9(ctx.projectRoot, ctx.config.module.outDir);
+  const uploadPath = ctx.config.module.uploadPath;
+  try {
+    runCommand("hs", ["cms", "upload", outDir, uploadPath], {
+      cwd: ctx.projectRoot,
+      logger: ctx.logger,
+      dryRun: ctx.global.dryRun
+    });
+    if (!ctx.global.json && !ctx.global.quiet) {
+      ctx.logger.success(`Uploaded ${outDir} \u2192 ${uploadPath}`);
+    }
+    return ExitCode.SUCCESS;
+  } catch (error) {
+    throw new WpHsError("HubSpot upload failed", {
+      exitCode: ExitCode.PUBLISH_FAILED,
+      cause: error,
+      remediation: "Run wp auth, then build the module before upload."
+    });
+  }
+}
+
+// src/cli/commands/deploy.ts
+async function runDeploy(ctx, options) {
+  ensureHubSpotCliSetup(ctx, "cms");
+  const tier = options.tier ?? "prod";
+  const env = { ...process.env, WP_HS_PROJECT_ROOT: ctx.projectRoot };
+  const execOpts = {
+    cwd: ctx.projectRoot,
+    env,
+    logger: ctx.logger,
+    dryRun: ctx.global.dryRun
+  };
+  await runBuild(ctx, { tier, cdnOnly: true });
+  if (!options.skipPublish) {
+    await runPublish(ctx, { tier });
+  }
+  await runBuild(ctx, { tier, hubspotOnly: true });
+  runNodeScript(kitPath("scripts", "check-hubspot-bundle-size.mjs"), [], execOpts);
+  runNodeScript(kitPath("scripts", "write-audit-artifacts.mjs"), [], execOpts);
+  await runUpload(ctx, { tier });
+  if (!ctx.global.json) {
+    ctx.logger.success(`Deploy complete (${resolve10(ctx.projectRoot, ctx.config.module.outDir)} \u2192 ${ctx.config.module.uploadPath})`);
+  }
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/audit.ts
+import { createHash } from "crypto";
+import { cpSync, existsSync as existsSync7, mkdirSync, readFileSync as readFileSync4, readdirSync, rmSync, statSync } from "fs";
+import { resolve as resolve11, join as join2 } from "path";
+var FORBIDDEN_SHIP_TOKENS = [
+  "ModuleConfigOverlay",
+  "module-config-store",
+  "__dev/module-config",
+  "src/dev/module-config",
+  "dev.module-config"
+];
+function hashFile(path) {
+  return createHash("sha256").update(readFileSync4(path)).digest("hex");
+}
+function walkFiles(dir) {
+  if (!existsSync7(dir)) return [];
+  const entries = readdirSync(dir);
+  const files = [];
+  for (const entry of entries) {
+    const full = join2(dir, entry);
+    if (statSync(full).isDirectory()) {
+      files.push(...walkFiles(full));
+    } else {
+      files.push(full);
+    }
+  }
+  return files;
+}
+async function runAuditShipBundle(ctx) {
+  const root = ctx.projectRoot;
+  const targets = [
+    resolve11(root, "dist/cdn"),
+    resolve11(root, ctx.config.module.outDir)
+  ];
+  const violations = [];
+  for (const dir of targets) {
+    for (const file of walkFiles(dir)) {
+      if (!/\.(js|css|html)$/i.test(file)) continue;
+      const content = readFileSync4(file, "utf8");
+      for (const token of FORBIDDEN_SHIP_TOKENS) {
+        if (content.includes(token)) {
+          violations.push(`${file}: contains forbidden token "${token}"`);
+        }
+      }
+    }
+  }
+  if (ctx.global.json) {
+    ctx.logger.json({ command: "audit:ship-bundle", ok: violations.length === 0, violations });
+  } else if (violations.length === 0) {
+    ctx.logger.success("Ship bundle audit passed");
+  } else {
+    for (const v of violations) ctx.logger.error(v);
+  }
+  if (violations.length > 0) {
+    throw new WpHsError("Ship bundle audit failed \u2014 dev tooling leaked into production artifacts", {
+      exitCode: ExitCode.AUDIT_FAILED,
+      remediation: "Ensure dev-only code is not imported in production build graph."
+    });
+  }
+  return ExitCode.SUCCESS;
+}
+async function runAuditBaselineCapture(ctx, options) {
+  const root = ctx.projectRoot;
+  const baseline = options.baselineDir ?? defaultBaselineDir(root, ctx.config);
+  const sources = [
+    { label: "cdn", path: resolve11(root, "dist/cdn") },
+    { label: "hubspot", path: resolve11(root, ctx.config.module.outDir) }
+  ];
+  if (ctx.global.dryRun) {
+    ctx.logger.info(`[dry-run] Would capture baseline to ${baseline}`);
+    return ExitCode.SUCCESS;
+  }
+  for (const { label, path } of sources) {
+    if (!existsSync7(path)) {
+      throw new WpHsError(`Cannot capture baseline \u2014 missing ${path}`, {
+        exitCode: ExitCode.USER_ERROR,
+        remediation: "Run wp build before wp audit baseline --capture."
+      });
+    }
+    const target = resolve11(baseline, label);
+    rmSync(target, { recursive: true, force: true });
+    mkdirSync(baseline, { recursive: true });
+    cpSync(path, target, { recursive: true });
+  }
+  if (ctx.global.json) {
+    ctx.logger.json({ command: "audit:baseline", ok: true, baseline });
+  } else {
+    ctx.logger.success(`Baseline captured at ${baseline}`);
+  }
+  return ExitCode.SUCCESS;
+}
+async function runAuditParity(ctx, options) {
+  const root = ctx.projectRoot;
+  const baseline = options.baselineDir ?? defaultBaselineDir(root, ctx.config);
+  const currentDirs = [
+    { label: "cdn", path: resolve11(root, "dist/cdn") },
+    { label: "hubspot", path: resolve11(root, ctx.config.module.outDir) }
+  ];
+  const mismatches = [];
+  for (const { label, path } of currentDirs) {
+    const baselinePath = resolve11(baseline, label);
+    if (!existsSync7(baselinePath)) {
+      ctx.logger.warn(`No baseline at ${baselinePath} \u2014 skipping ${label} parity`);
+      continue;
+    }
+    const baselineFiles = walkFiles(baselinePath).filter((f) => !f.endsWith(".map"));
+    const currentFiles = walkFiles(path).filter((f) => !f.endsWith(".map"));
+    const baselineNames = new Set(baselineFiles.map((f) => f.replace(baselinePath, "")));
+    const currentNames = new Set(currentFiles.map((f) => f.replace(path, "")));
+    for (const name of baselineNames) {
+      if (!currentNames.has(name)) {
+        mismatches.push(`missing file: ${label}${name}`);
+      }
+    }
+    for (const file of baselineFiles) {
+      const rel = file.replace(baselinePath, "");
+      const current = resolve11(path, rel.slice(1));
+      if (!existsSync7(current)) continue;
+      const bh = hashFile(file);
+      const ch = hashFile(current);
+      if (bh !== ch) {
+        mismatches.push(`hash mismatch: ${label}${rel}`);
+      }
+    }
+  }
+  if (ctx.global.json) {
+    ctx.logger.json({ command: "audit:parity", ok: mismatches.length === 0, mismatches });
+  } else if (mismatches.length === 0) {
+    ctx.logger.success("Parity audit passed (or no baseline configured)");
+  } else {
+    for (const m of mismatches) ctx.logger.error(m);
+  }
+  if (mismatches.length > 0) {
+    throw new WpHsError("Parity audit failed", { exitCode: ExitCode.AUDIT_FAILED });
+  }
+  return ExitCode.SUCCESS;
+}
+var SECRET_PATTERNS = [
+  /(?:api[_-]?key|secret|password|token|private[_-]?key)\s*[:=]\s*['"][^'"]{8,}['"]/gi,
+  /sk_live_[a-zA-Z0-9]{16,}/g,
+  /pat-[a-z]{2}-[a-f0-9-]{20,}/gi
+];
+async function runAuditSecrets(ctx) {
+  const root = ctx.projectRoot;
+  const scanRoots = ["src", "public", ".wphs/config"].map((d) => resolve11(root, d));
+  const findings = [];
+  for (const dir of scanRoots) {
+    for (const file of walkFiles(dir)) {
+      if (!/\.(ts|tsx|js|jsx|json|env|yml|yaml|html)$/i.test(file)) continue;
+      if (file.includes("node_modules")) continue;
+      const content = readFileSync4(file, "utf8");
+      for (const pattern of SECRET_PATTERNS) {
+        pattern.lastIndex = 0;
+        if (pattern.test(content)) {
+          findings.push(`${file}: possible secret pattern matched`);
+        }
+      }
+    }
+  }
+  if (ctx.global.json) {
+    ctx.logger.json({ command: "audit:secrets", ok: findings.length === 0, findings });
+  } else if (findings.length === 0) {
+    ctx.logger.success("Secrets audit passed");
+  } else {
+    for (const f of findings) ctx.logger.error(f);
+  }
+  if (findings.length > 0) {
+    throw new WpHsError("Secrets audit found potential credentials in source files", {
+      exitCode: ExitCode.AUDIT_FAILED,
+      remediation: "Move secrets to env vars; never commit PATs or API keys."
+    });
+  }
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/init.ts
+import { cpSync as cpSync2, existsSync as existsSync8, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync5, writeFileSync } from "fs";
+import { basename, resolve as resolve12 } from "path";
+import * as p from "@clack/prompts";
+
+// src/lib/project-name.ts
+var PROJECT_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+function normalizeProjectName(input) {
+  return input.trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function validateProjectName(name) {
+  if (!name) return "Project name is required";
+  if (!PROJECT_NAME_PATTERN.test(name)) {
+    return "Use lowercase letters, numbers, and hyphens (e.g. my-portal-module)";
+  }
+  if (name.length > 64) return "Project name is too long (max 64 characters)";
+  return void 0;
+}
+function moduleOutDirFromSlug(slug) {
+  const pascal = slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return `dist/${pascal || "HubSpot"}.Module`;
+}
+
+// src/cli/commands/init.ts
+var TEMPLATE_SCRIPTS = {
+  "module-hybrid-cdn": {
+    dev: "wp dev",
+    local: "wp dev",
+    "build:prod": "wp build --tier prod",
+    "build:dev": "wp build --tier dev",
+    "deploy:prod": "wp deploy --tier prod --yes",
+    "deploy:dev": "wp deploy --tier dev --yes",
+    doctor: "wp doctor"
+  },
+  "module-monolith": {
+    dev: "wp dev",
+    local: "wp dev",
+    "build:prod": "wp build --tier prod --hubspot-only",
+    doctor: "wp doctor"
+  },
+  "theme-starter": {
+    dev: "wp dev",
+    local: "wp dev",
+    doctor: "wp doctor"
+  }
+};
+function buildConfigForProject(template, projectName) {
+  const base = { ...DEFAULT_WOODSPORTAL_HS, projectType: template };
+  if (template === "theme-starter") {
+    return {
+      ...base,
+      theme: {
+        name: projectName,
+        uploadPath: `themes/${projectName}`,
+        srcDir: "src/theme",
+        themeJson: "src/theme/theme.json"
+      }
+    };
+  }
+  return {
+    ...base,
+    module: {
+      name: projectName,
+      uploadPath: `dw-modules/${projectName}.module`,
+      outDir: moduleOutDirFromSlug(projectName)
+    },
+    cdn: {
+      ...base.cdn,
+      mode: template === "module-monolith" ? "none" : base.cdn.mode
+    }
+  };
+}
+function assertTargetDirIsScaffoldable(targetDir) {
+  if (!existsSync8(targetDir)) return;
+  const entries = readdirSync2(targetDir).filter((entry) => entry !== ".DS_Store");
+  if (entries.length > 0) {
+    throw new WpHsError(`Target directory is not empty: ${targetDir}`, {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Choose a different project name or remove existing files."
+    });
+  }
+}
+function resolveInitTargetDir(options, interactiveName) {
+  if (options.directory) {
+    return resolve12(options.directory);
+  }
+  const parentDir = process.cwd();
+  const slug = options.name ?? interactiveName;
+  if (!slug) {
+    throw new WpHsError("Project name is required", {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Run interactively, or pass --name my-project (or --directory ./my-project)."
+    });
+  }
+  const error = validateProjectName(slug);
+  if (error) {
+    throw new WpHsError(error, { exitCode: ExitCode.USER_ERROR });
+  }
+  return resolve12(parentDir, slug);
+}
+async function runInit(ctx, options) {
+  const nonInteractive = ctx.global.ci || ctx.global.yes || ctx.global.json;
+  let template = options.template;
+  let projectName = options.name ? normalizeProjectName(options.name) : void 0;
+  if (!nonInteractive) {
+    if (!template) {
+      const type = await p.select({
+        message: "Project type",
+        options: [
+          {
+            value: "module-hybrid-cdn",
+            label: "Module (hybrid CDN)",
+            hint: "jsDelivr + thin module.js"
+          },
+          { value: "module-monolith", label: "Module (monolith)", hint: "Single module.js IIFE" },
+          { value: "theme-starter", label: "Theme starter", hint: "CMS theme templates" }
+        ]
+      });
+      if (p.isCancel(type)) throw new WpHsError("Init cancelled", { exitCode: ExitCode.USER_ERROR });
+      template = type;
+    }
+    if (!options.directory && !projectName) {
+      const nameAnswer = await p.text({
+        message: "Project name (folder name)",
+        placeholder: "my-portal-module",
+        validate: (value) => validateProjectName(normalizeProjectName(value ?? ""))
+      });
+      if (p.isCancel(nameAnswer)) {
+        throw new WpHsError("Init cancelled", { exitCode: ExitCode.USER_ERROR });
+      }
+      projectName = normalizeProjectName(nameAnswer);
+    }
+  }
+  if (!template) {
+    template = "module-hybrid-cdn";
+  }
+  const targetDir = resolveInitTargetDir(options, projectName);
+  const slug = projectName ?? basename(targetDir);
+  assertTargetDirIsScaffoldable(targetDir);
+  const templateDir = kitPath("templates", template);
+  if (!existsSync8(templateDir)) {
+    throw new WpHsError(`Template not found: ${template}`, { exitCode: ExitCode.USER_ERROR });
+  }
+  if (ctx.global.dryRun) {
+    ctx.logger.info(`[dry-run] Would scaffold ${template} in ${targetDir}`);
+    return ExitCode.SUCCESS;
+  }
+  mkdirSync2(targetDir, { recursive: true });
+  cpSync2(templateDir, targetDir, { recursive: true });
+  const config = buildConfigForProject(template, slug);
+  writeFileSync(resolve12(targetDir, WOODSCLI_CONFIG_FILE), `${JSON.stringify(config, null, 2)}
+`);
+  const pkgPath = resolve12(targetDir, "package.json");
+  if (existsSync8(pkgPath)) {
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
+    pkg.name = slug;
+    pkg.scripts = { ...pkg.scripts, ...TEMPLATE_SCRIPTS[template] };
+    pkg.devDependencies = {
+      ...pkg.devDependencies,
+      "@woodsportal/hubspot-kit": "^1.0.2"
+    };
+    writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  }
+  runNodeScript(kitPath("scripts/ensure-wphs-workspace.mjs"), [], {
+    cwd: targetDir,
+    logger: ctx.logger,
+    dryRun: false
+  });
+  const gitignorePath = resolve12(targetDir, ".gitignore");
+  const gitignoreExtras = [
+    "hubspot.config.yml",
+    ".wphs/config/module-config.local.json",
+    ".wphs/assets/",
+    ".wphs/cache/",
+    ".wphs/audit/",
+    ".wphs/state/",
+    ".wphs/fixtures/hubspot-data.json",
+    ".wphs/.kit-module-config",
+    ".wphs/.kit-bootstrap.tsx"
+  ];
+  const existing = existsSync8(gitignorePath) ? readFileSync5(gitignorePath, "utf8") : "";
+  const toAppend = gitignoreExtras.filter((line) => !existing.includes(line)).join("\n");
+  if (toAppend) {
+    writeFileSync(gitignorePath, `${existing.trimEnd()}
+${toAppend}
+`);
+  }
+  if (!nonInteractive) {
+    p.log.success(`Scaffolded ${template} in ${targetDir}`);
+    p.note(`cd ${slug} && npm install && wp doctor && wp dev`, "Getting started");
+  } else {
+    ctx.logger.success(`Scaffolded ${template} in ${targetDir}`);
+  }
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/adopt.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve13 } from "path";
+import { pathToFileURL } from "url";
+import * as p2 from "@clack/prompts";
+async function loadDetectLayout() {
+  const mod = await import(pathToFileURL(kitPath("scripts", "detect-layout.mjs")).href);
+  return mod.detectProjectLayout;
+}
+async function runAdopt(ctx, _options = {}) {
+  const detectProjectLayout = await loadDetectLayout();
+  const layout = detectProjectLayout(ctx.projectRoot);
+  const configPath = resolve13(ctx.projectRoot, WOODSCLI_CONFIG_FILE);
+  if (layout.track === "unknown") {
+    throw new WpHsError("Could not detect module or theme layout.", {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Ensure fields.json + module.html (module) or theme.json + templates/ (theme) exist."
+    });
+  }
+  let projectType;
+  if (layout.projectType) {
+    projectType = layout.projectType;
+  } else if (layout.track === "theme") {
+    projectType = "theme-starter";
+  } else if (existsSync9(resolve13(ctx.projectRoot, "vite.config.monolith.mjs"))) {
+    projectType = "module-monolith";
+  } else {
+    projectType = "module-hybrid-cdn";
+  }
+  const config = {
+    ...DEFAULT_WOODSPORTAL_HS,
+    projectType,
+    ...layout.track === "theme" ? {
+      theme: {
+        name: "my-theme",
+        uploadPath: "themes/my-theme",
+        srcDir: "src/theme",
+        themeJson: "src/theme/theme.json"
+      }
+    } : {}
+  };
+  if (ctx.global.dryRun) {
+    ctx.logger.info(`[dry-run] Would adopt as ${projectType} (${layout.track})`);
+    return ExitCode.SUCCESS;
+  }
+  if (!existsSync9(configPath)) {
+    writeFileSync2(configPath, `${JSON.stringify(config, null, 2)}
+`);
+    ctx.logger.success(`Created ${WOODSCLI_CONFIG_FILE}`);
+  } else if (!layout.projectType) {
+    const existing = JSON.parse(readFileSync6(configPath, "utf8"));
+    writeFileSync2(configPath, `${JSON.stringify({ ...existing, projectType }, null, 2)}
+`);
+    ctx.logger.info(`Set projectType \u2192 ${projectType}`);
+  }
+  runNodeScript(kitPath("scripts/ensure-wphs-workspace.mjs"), [], {
+    cwd: ctx.projectRoot,
+    logger: ctx.logger,
+    dryRun: false
+  });
+  const adapterPath = resolve13(ctx.projectRoot, "wphs.adapter.ts");
+  if (!existsSync9(adapterPath) && isModuleProject(config)) {
+    writeFileSync2(
+      adapterPath,
+      `import type { HubSpotKitAdapter } from '@woodsportal/hubspot-kit'
+
+const adapter: HubSpotKitAdapter = {
+  syncLiveData(built) {
+    ;(window as Window & { __WPHS_DATA__?: Record<string, unknown> }).__WPHS_DATA__ = built
+  },
+}
+
+export default adapter
+`
+    );
+    ctx.logger.info("Created wphs.adapter.ts stub");
+  }
+  if (!ctx.global.ci && !ctx.global.quiet) {
+    p2.note(
+      [
+        `Review ${WOODSCLI_CONFIG_FILE} upload paths`,
+        "Implement wphs.adapter.ts for your app (if module)",
+        "Add vite.config.dev.mjs re-export if missing",
+        "Patch main.dev.css @source to .wphs/.kit-module-config/**"
+      ].join("\n"),
+      "Manual follow-ups"
+    );
+  }
+  ctx.logger.success(`Adopted ${layout.track} project (${projectType})`);
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/migrate.ts
+import { cpSync as cpSync3, existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync7, readdirSync as readdirSync3, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3, resolve as resolve14 } from "path";
+var LEGACY_DIRS = [".dev", ".woodsportal"];
+var LEGACY_BASELINE = ".wp-hs-baseline";
+async function runMigrate(ctx, _options = {}) {
+  const root = ctx.projectRoot;
+  const wphsRoot = resolve14(root, WPHS_WORKSPACE_DIR);
+  const actions = [];
+  for (const legacy of LEGACY_DIRS) {
+    const legacyPath = resolve14(root, legacy);
+    if (!existsSync10(legacyPath)) continue;
+    actions.push(`Move ${legacy}/ \u2192 .wphs/`);
+    if (ctx.global.dryRun) continue;
+    mkdirSync3(join3(wphsRoot, "config"), { recursive: true });
+    mkdirSync3(join3(wphsRoot, "assets", "branding"), { recursive: true });
+    const localConfig = join3(legacyPath, "module-config.local.json");
+    const exampleConfig = join3(legacyPath, "module-config.example.json");
+    if (existsSync10(localConfig)) {
+      cpSync3(localConfig, join3(wphsRoot, "config", "module-config.local.json"));
+    }
+    if (existsSync10(exampleConfig)) {
+      cpSync3(exampleConfig, join3(wphsRoot, "config", "module-config.example.json"));
+    }
+    const branding = join3(legacyPath, "branding-assets");
+    if (existsSync10(branding)) {
+      for (const file of readdirSync3(branding)) {
+        cpSync3(join3(branding, file), join3(wphsRoot, "assets", "branding", file));
+      }
+    }
+    rmSync2(legacyPath, { recursive: true, force: true });
+  }
+  const legacyBaseline = resolve14(root, LEGACY_BASELINE);
+  const targetBaseline = join3(wphsRoot, "audit", "baseline");
+  if (existsSync10(legacyBaseline)) {
+    actions.push(`Move ${LEGACY_BASELINE}/ \u2192 .wphs/audit/baseline/`);
+    if (!ctx.global.dryRun) {
+      mkdirSync3(targetBaseline, { recursive: true });
+      cpSync3(legacyBaseline, targetBaseline, { recursive: true });
+      rmSync2(legacyBaseline, { recursive: true, force: true });
+    }
+  }
+  const legacyConfigPath2 = resolve14(root, LEGACY_WOODSPORTAL_HS_FILE);
+  const woodscliPath = resolve14(root, WOODSCLI_CONFIG_FILE);
+  if (existsSync10(legacyConfigPath2) && !existsSync10(woodscliPath)) {
+    actions.push(`Rename ${LEGACY_WOODSPORTAL_HS_FILE} \u2192 ${WOODSCLI_CONFIG_FILE}`);
+    if (!ctx.global.dryRun) {
+      renameSync(legacyConfigPath2, woodscliPath);
+    }
+  } else if (existsSync10(legacyConfigPath2) && existsSync10(woodscliPath)) {
+    actions.push(`Remove duplicate ${LEGACY_WOODSPORTAL_HS_FILE}`);
+    if (!ctx.global.dryRun) {
+      rmSync2(legacyConfigPath2, { force: true });
+    }
+  }
+  if (existsSync10(woodscliPath)) {
+    const raw = JSON.parse(readFileSync7(woodscliPath, "utf8"));
+    if (raw?.dev?.moduleConfigDir && raw.dev.moduleConfigDir !== WPHS_WORKSPACE_DIR) {
+      actions.push(`Update dev.moduleConfigDir \u2192 .wphs in project config`);
+      if (!ctx.global.dryRun) {
+        raw.dev.moduleConfigDir = WPHS_WORKSPACE_DIR;
+        writeFileSync3(woodscliPath, `${JSON.stringify(raw, null, 2)}
+`);
+      }
+    }
+  }
+  if (actions.length === 0) {
+    ctx.logger.success("Nothing to migrate \u2014 already on .wphs / woodscli.json");
+    return ExitCode.SUCCESS;
+  }
+  if (ctx.global.dryRun) {
+    for (const action of actions) ctx.logger.info(`[dry-run] ${action}`);
+    return ExitCode.SUCCESS;
+  }
+  if (!ctx.global.yes && !ctx.global.ci) {
+    throw new WpHsError("Migration requires --yes.", {
+      exitCode: ExitCode.USER_ERROR,
+      remediation: "Run: wp migrate --yes"
+    });
+  }
+  runNodeScript(kitPath("scripts/ensure-wphs-workspace.mjs"), [], {
+    cwd: root,
+    logger: ctx.logger,
+    dryRun: false
+  });
+  for (const action of actions) ctx.logger.success(action);
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/examples.ts
+import { readFileSync as readFileSync8 } from "fs";
+function loadManifest() {
+  const manifestPath = kitPath("examples", "manifest.json");
+  const raw = JSON.parse(readFileSync8(manifestPath, "utf8"));
+  return raw.scenarios;
+}
+async function runExamplesList(ctx, options = {}) {
+  let scenarios = loadManifest();
+  if (options.track) scenarios = scenarios.filter((s) => s.track === options.track);
+  if (options.setup) scenarios = scenarios.filter((s) => s.setup === options.setup);
+  if (ctx.global.json) {
+    ctx.logger.json({ command: "examples:list", scenarios });
+  } else {
+    for (const s of scenarios) {
+      ctx.logger.info(`${s.id} (${s.setup}/${s.track}) tier=${s.smokeTier}`);
+    }
+  }
+  return ExitCode.SUCCESS;
+}
+async function runExamplesSmoke(ctx, options = {}) {
+  const tier = options.tier ?? "static";
+  const args = ["--tier", tier];
+  if (options.scenario) args.push("--scenario", options.scenario);
+  const { runNodeScript: runNodeScript2 } = await import("./exec-K5C6LZP4.js");
+  runNodeScript2(kitPath("examples", "smoke", "run-matrix.mjs"), args, {
+    cwd: ctx.projectRoot,
+    logger: ctx.logger,
+    dryRun: ctx.global.dryRun
+  });
+  if (ctx.global.json) {
+    ctx.logger.json({ command: "examples:smoke", tier, scenario: options.scenario ?? "all", ok: true });
+  }
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/fields.ts
+import { cpSync as cpSync4, existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve15 } from "path";
+async function runFieldsSync(ctx, options = {}) {
+  const direction = options.direction ?? "pull";
+  const fieldsPath = resolve15(ctx.projectRoot, ctx.config.dev.fieldsJson);
+  const cacheDir = resolve15(ctx.projectRoot, ctx.config.dev.moduleConfigDir, "cache", "fields-sync");
+  const cachePath = resolve15(cacheDir, "fields.json");
+  if (direction === "pull") {
+    if (!existsSync11(fieldsPath)) {
+      throw new WpHsError(`Missing ${ctx.config.dev.fieldsJson}`, {
+        exitCode: ExitCode.USER_ERROR,
+        remediation: "Add fields.json or run wp init."
+      });
+    }
+    if (ctx.global.dryRun || options.dryRun) {
+      ctx.logger.info(`[dry-run] Would cache ${fieldsPath} \u2192 ${cachePath}`);
+      return ExitCode.SUCCESS;
+    }
+    const { mkdirSync: mkdirSync4 } = await import("fs");
+    mkdirSync4(cacheDir, { recursive: true });
+    cpSync4(fieldsPath, cachePath);
+    ctx.logger.success(`Cached fields \u2192 ${cachePath}`);
+    return ExitCode.SUCCESS;
+  }
+  if (!existsSync11(cachePath)) {
+    throw new WpHsError("No cached fields \u2014 run wp fields sync pull first.", {
+      exitCode: ExitCode.USER_ERROR
+    });
+  }
+  if (ctx.global.dryRun || options.dryRun) {
+    ctx.logger.info(`[dry-run] Would write ${cachePath} \u2192 ${fieldsPath}`);
+    return ExitCode.SUCCESS;
+  }
+  writeFileSync4(fieldsPath, readFileSync9(cachePath, "utf8"));
+  ctx.logger.success(`Restored fields from cache \u2192 ${fieldsPath}`);
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/regression.ts
+import { existsSync as existsSync12 } from "fs";
+import { resolve as resolve16 } from "path";
+var LEGACY_SHIM_SCRIPTS = [
+  "build-cdn.mjs",
+  "run-vite-build.mjs",
+  "run-hubspot-module-postbuild.mjs",
+  "watch-hubspot.mjs"
+];
+var FORBIDDEN_CONSUMER_PATHS = ["src/dev/module-config", "src/dev/bootstrap.tsx"];
+async function runRegressionSmoke(ctx, options = {}) {
+  const failures = [];
+  const checks = [];
+  if (!options.skipDoctor) {
+    const doctorCode = await runDoctor(ctx);
+    const doctorOk = doctorCode === ExitCode.SUCCESS;
+    checks.push({ name: "doctor", ok: doctorOk });
+    if (!doctorOk) failures.push("wp doctor failed");
+  }
+  const validateCode = await runConfigValidate(ctx);
+  const validateOk = validateCode === ExitCode.SUCCESS;
+  checks.push({ name: "config-validate", ok: validateOk });
+  if (!validateOk) failures.push("wp config validate failed");
+  if (options.checkLegacyShims !== false) {
+    for (const script of LEGACY_SHIM_SCRIPTS) {
+      const shim = resolve16(ctx.projectRoot, "scripts", script);
+      const kitScript = kitPath("scripts", script);
+      const shimOk = existsSync12(shim) && existsSync12(kitScript);
+      checks.push({ name: `shim:${script}`, ok: shimOk });
+      if (!shimOk) failures.push(`Missing legacy shim or kit script: ${script}`);
+    }
+  }
+  for (const rel of FORBIDDEN_CONSUMER_PATHS) {
+    const forbidden = resolve16(ctx.projectRoot, rel);
+    const absent = !existsSync12(forbidden);
+    checks.push({ name: `no-${rel}`, ok: absent });
+    if (!absent) failures.push(`Forbidden dev path still present: ${rel}`);
+  }
+  const woodscliConfig = resolve16(ctx.projectRoot, WOODSCLI_CONFIG_FILE);
+  const configOk = existsSync12(woodscliConfig);
+  checks.push({ name: WOODSCLI_CONFIG_FILE, ok: configOk });
+  if (!configOk) failures.push(`${WOODSCLI_CONFIG_FILE} missing`);
+  if (ctx.global.json) {
+    ctx.logger.json({
+      command: "regression:smoke",
+      ok: failures.length === 0,
+      checks,
+      failures
+    });
+  } else if (failures.length === 0) {
+    ctx.logger.success("Regression smoke passed");
+  } else {
+    for (const f of failures) ctx.logger.error(f);
+  }
+  if (failures.length > 0) {
+    throw new WpHsError("Regression smoke failed", {
+      exitCode: ExitCode.AUDIT_FAILED,
+      remediation: "Run wp doctor and fix listed checks. See docs/REGRESSION-SMOKE.md."
+    });
+  }
+  return ExitCode.SUCCESS;
+}
+
+// src/cli/commands/watch.ts
+async function runWatch(ctx, options) {
+  ensureHubSpotCliSetup(ctx, "cms");
+  const tier = options.tier ?? "dev";
+  const args = [];
+  if (tier === "prod") args.push("--prod");
+  if (options.rebuild) args.push("--rebuild");
+  try {
+    runNodeScript(kitPath("scripts", "watch-hubspot.mjs"), args, {
+      cwd: ctx.projectRoot,
+      env: { ...process.env, WP_HS_PROJECT_ROOT: ctx.projectRoot },
+      logger: ctx.logger,
+      dryRun: ctx.global.dryRun
+    });
+    return ExitCode.SUCCESS;
+  } catch (error) {
+    throw new WpHsError("Watch failed", {
+      exitCode: ExitCode.BUILD_FAILED,
+      cause: error,
+      remediation: "Ensure HubSpot module is built once before watch, or pass --rebuild."
+    });
+  }
+}
+
+// src/cli/program.ts
+function readVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync10(resolve17(getKitRoot(), "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function parseTier(value) {
+  if (value === "dev" || value === "stg" || value === "prod") return value;
+  return "prod";
+}
+function buildContext(global) {
+  const logger = createLogger({
+    verbose: global.verbose,
+    quiet: global.quiet,
+    json: global.json,
+    ci: global.ci
+  });
+  const projectRoot = global.project ?? findProjectRoot2();
+  const { config } = loadConfig(projectRoot);
+  return { projectRoot, config, logger, global };
+}
+function attachGlobals(command) {
+  command.option("--project <path>", "Project root (woodscli.json)").option("--ci", "Non-interactive CI mode", false).option("--json", "Machine-readable JSON output", false).option("--verbose", "Verbose logging", false).option("--quiet", "Errors only", false).option("--dry-run", "Print planned actions without executing", false).option("-y, --yes", "Assume yes (non-interactive)", false);
+}
+async function handle(fn) {
+  try {
+    const code = await fn();
+    process.exit(code);
+  } catch (error) {
+    if (isWpHsError(error)) {
+      process.stderr.write(`Error: ${error.message}
+`);
+      if (error.remediation) {
+        process.stderr.write(`\u2192 ${error.remediation}
+`);
+      }
+      process.exit(error.exitCode);
+    }
+    process.stderr.write(`Error: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(ExitCode.INTERNAL);
+  }
+}
+function createProgram() {
+  const program2 = new Command().name("wp").description("WoodsCLI \u2014 HubSpot CMS dev kit by WoodsPortal (modules + themes)").version(readVersion()).addHelpText("after", "\nWoodsCLI \xB7 WoodsPortal HubSpot CLI \xB7 npm @woodsportal/hubspot-kit");
+  attachGlobals(program2);
+  program2.command("doctor").description("Check prerequisites (Node, HubSpot CLI, .wphs workspace, config)").action(async () => {
+    const global = program2.opts();
+    await handle(() => runDoctor(buildContext(global)));
+  });
+  const configCmd = program2.command("config").description("Project configuration");
+  configCmd.command("validate").description("Validate woodscli.json").action(async () => {
+    const global = program2.opts();
+    await handle(() => runConfigValidate(buildContext(global)));
+  });
+  program2.command("init").description("Scaffold a new module or theme project").option("-t, --template <type>", "module-hybrid-cdn | module-monolith | theme-starter").option("-n, --name <slug>", "Project name (creates ./<name>/ under cwd)").option("-d, --directory <path>", "Full target directory (skips name \u2192 folder prompt)").action(async (opts) => {
+    const global = program2.opts();
+    const logger = createLogger({
+      verbose: global.verbose,
+      quiet: global.quiet,
+      json: global.json,
+      ci: global.ci
+    });
+    const ctx = {
+      projectRoot: process.cwd(),
+      config: DEFAULT_WOODSPORTAL_HS,
+      logger,
+      global
+    };
+    await handle(
+      () => runInit(ctx, {
+        template: opts.template,
+        name: opts.name,
+        directory: opts.directory
+      })
+    );
+  });
+  program2.command("adopt").description("Detect existing module/theme repo and add WoodsCLI config + .wphs/").action(async () => {
+    const global = program2.opts();
+    await handle(() => runAdopt(buildContext(global)));
+  });
+  program2.command("migrate").description("Migrate legacy .dev/ or .wp-hs-baseline/ to .wphs/").action(async () => {
+    const global = program2.opts();
+    await handle(() => runMigrate(buildContext(global)));
+  });
+  program2.command("dev").alias("local").description("Start local development server (Vite HMR + CMS dev tool)").option("-p, --port <port>", "Port", "3000").action(async (opts) => {
+    const global = program2.opts();
+    await handle(() => runDev(buildContext(global), { port: Number(opts.port) }));
+  });
+  program2.command("build").description("Build CDN + HubSpot module (or theme no-op)").option("--tier <tier>", "dev | stg | prod", "prod").option("--cdn-only", "CDN chunks only").option("--hubspot-only", "HubSpot module only").option("--cdn-esm", "Build CDN via ESM preset").action(
+    async (opts) => {
+      const global = program2.opts();
+      await handle(
+        () => runBuild(buildContext(global), {
+          tier: parseTier(opts.tier),
+          cdnOnly: opts.cdnOnly,
+          hubspotOnly: opts.hubspotOnly,
+          cdnEsm: opts.cdnEsm
+        })
+      );
+    }
+  );
+  program2.command("deploy").description("Build, publish CDN, upload HubSpot module").option("--tier <tier>", "dev | stg | prod", "prod").option("--skip-publish", "Skip CDN publish").action(async (opts) => {
+    const global = program2.opts();
+    await handle(
+      () => runDeploy(buildContext(global), {
+        tier: parseTier(opts.tier),
+        skipPublish: opts.skipPublish
+      })
+    );
+  });
+  program2.command("publish").description("Publish CDN artifacts to jsDelivr mirror").option("--tier <tier>", "dev | stg | prod", "prod").option("--dry-run", "Print publish plan without pushing").action(async (opts) => {
+    const global = program2.opts();
+    await handle(
+      () => runPublish(buildContext(global), {
+        tier: parseTier(opts.tier),
+        dryRun: opts.dryRun
+      })
+    );
+  });
+  const audit = program2.command("audit").description("Build audits");
+  audit.command("ship-bundle").description("Fail if dev tooling appears in dist artifacts").action(async () => {
+    const global = program2.opts();
+    await handle(() => runAuditShipBundle(buildContext(global)));
+  });
+  audit.command("parity").description("Compare dist output to baseline snapshot").option("--baseline <dir>", "Baseline directory").action(async (opts) => {
+    const global = program2.opts();
+    const ctx = buildContext(global);
+    const baseline = opts.baseline ?? defaultBaselineDir(ctx.projectRoot, ctx.config);
+    await handle(() => runAuditParity(ctx, { baselineDir: baseline }));
+  });
+  audit.command("baseline").description("Capture dist output as parity baseline").option("--baseline <dir>", "Baseline directory").action(async (opts) => {
+    const global = program2.opts();
+    const ctx = buildContext(global);
+    const baseline = opts.baseline ?? defaultBaselineDir(ctx.projectRoot, ctx.config);
+    await handle(() => runAuditBaselineCapture(ctx, { baselineDir: baseline }));
+  });
+  audit.command("secrets").description("Scan source for hardcoded secrets / PAT patterns").action(async () => {
+    const global = program2.opts();
+    await handle(() => runAuditSecrets(buildContext(global)));
+  });
+  const fields = program2.command("fields").description("Module fields.json utilities");
+  fields.command("sync").description("Pull/push fields.json vs local cache").option("--direction <dir>", "pull | push", "pull").action(async (opts) => {
+    const global = program2.opts();
+    const direction = opts.direction === "push" ? "push" : "pull";
+    await handle(() => runFieldsSync(buildContext(global), { direction }));
+  });
+  const examples = program2.command("examples").description("Examples smoke matrix");
+  examples.command("list").description("List scenarios from examples/manifest.json").option("--track <track>", "module | theme").option("--setup <setup>", "greenfield | existing | adopted").action(async (opts) => {
+    const global = program2.opts();
+    await handle(
+      () => runExamplesList(buildContext(global), {
+        track: opts.track,
+        setup: opts.setup
+      })
+    );
+  });
+  examples.command("smoke").description("Run static/live smoke checks for example scenarios").option("--scenario <id>", "Single scenario id").option("--tier <tier>", "static | live", "static").action(async (opts) => {
+    const global = program2.opts();
+    const tier = opts.tier === "live" ? "live" : "static";
+    await handle(
+      () => runExamplesSmoke(buildContext(global), { scenario: opts.scenario, tier })
+    );
+  });
+  const regression = program2.command("regression").description("Compatibility regression checks");
+  regression.command("smoke").description("Doctor + config validate + consumer boundary checks").option("--skip-doctor", "Skip prerequisite doctor check").action(async (opts) => {
+    const global = program2.opts();
+    await handle(
+      () => runRegressionSmoke(buildContext(global), { skipDoctor: opts.skipDoctor })
+    );
+  });
+  program2.command("watch").description("Watch HubSpot module or theme folder and re-upload on change").option("--tier <tier>", "dev | stg | prod", "dev").option("--rebuild", "Rebuild module before watch").action(async (opts) => {
+    const global = program2.opts();
+    const tier = parseTier(opts.tier);
+    await handle(
+      () => runWatch(buildContext(global), {
+        tier: tier === "prod" ? "prod" : tier === "stg" ? "stg" : "dev",
+        rebuild: opts.rebuild
+      })
+    );
+  });
+  program2.command("upload").description("Upload built HubSpot module or theme (hs cms upload)").option("--tier <tier>", "dev | stg | prod", "prod").action(async (opts) => {
+    const global = program2.opts();
+    await handle(
+      () => runUpload(buildContext(global), { tier: parseTier(opts.tier) })
+    );
+  });
+  program2.command("auth").description("Authenticate HubSpot CLI (hs auth)").action(async () => {
+    const global = program2.opts();
+    const ctx = buildContext(global);
+    const { runCommand: runCommand2 } = await import("./exec-K5C6LZP4.js");
+    runCommand2("hs", ["auth"], {
+      cwd: ctx.projectRoot,
+      logger: ctx.logger,
+      dryRun: ctx.global.dryRun
+    });
+    process.exit(ExitCode.SUCCESS);
+  });
+  return program2;
+}
+
+// src/cli/index.ts
+var program = createProgram();
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map