@cmssy/cli 0.22.3 → 1.0.0

package/dist/cli.js

@@ -1,340 +1,718 @@
 #!/usr/bin/env node
-import chalk from "chalk";
-import { Command, Option } from "commander";
-import { buildCommand } from "./commands/build.js";
-import { codegenCommand } from "./commands/codegen.js";
-import { configureCommand } from "./commands/configure.js";
-import { linkCommand } from "./commands/link.js";
-import { createCommand } from "./commands/create.js";
-import { devCommand } from "./commands/dev.js";
-import { doctorCommand } from "./commands/doctor.js";
-import { initCommand } from "./commands/init.js";
-import { testCommand } from "./commands/test.js";
-import { syncCommand } from "./commands/sync.js";
-import { migrateCommand } from "./commands/migrate.js";
-import { publishBlockBuildtimeCommand } from "./commands/publish-block-buildtime.js";
-import { publishTemplateCommand } from "./commands/publish-template.js";
-import { libInstallCommand, libSyncCommand } from "./commands/lib.js";
-import { skillsInstallCommand, skillsListCommand } from "./commands/skills.js";
-import { workspacesCommand } from "./commands/workspaces.js";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
+
+
+// src/utils/args.ts
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const eq = key.indexOf("=");
+      if (eq !== -1) {
+        flags[key.slice(0, eq)] = key.slice(eq + 1);
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      flags[arg.slice(1)] = true;
+    } else {
+      positionals.push(arg);
+    }
+  }
+  return { positionals, flags };
+}
+
+// src/utils/ui.ts
+import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
-const program = new Command();
-program
-    .name("cmssy")
-    .description("Unified CLI for building and publishing blocks to Cmssy design library")
-    .version(packageJson.version)
-    .addHelpText("after", `
-Examples:
-  $ cmssy init my-blocks           Create new project (uses create-next-app)
-  $ cmssy init                     Add Cmssy to existing Next.js project
-  $ cmssy create block hero        Add a new block to your project
-  $ cmssy dev                      Start dev server with hot reload
-  $ cmssy build                    Build all blocks for production
-  $ cmssy publish-block hero -w abc Publish a single block to workspace
+import { fileURLToPath } from "url";
+import pc from "picocolors";
+function getVersion() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+      const p = join(dir, "package.json");
+      if (existsSync(p)) {
+        const pkg = JSON.parse(readFileSync(p, "utf8"));
+        return pkg.version ?? "0.0.0";
+      }
+      dir = dirname(dir);
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+var ui = {
+  info: (msg) => console.log(msg),
+  dim: (msg) => console.log(pc.dim(msg)),
+  success: (msg) => console.log(pc.green(msg)),
+  warn: (msg) => console.log(pc.yellow(msg)),
+  error: (msg) => console.error(pc.red(msg))
+};
+
+// src/commands/init.ts
+import { join as join7, resolve } from "path";
+import { intro, log as log2, note, outro } from "@clack/prompts";
+
+// src/utils/constants.ts
+var CMSSY_DEPS = {
+  "@cmssy/next": "^0.5.6",
+  "@cmssy/react": "^0.5.6"
+};
+var DOCS_URL = "https://www.cmssy.com/docs";
+var HEADLESS_SETTINGS_HINT = "cmssy dashboard -> Settings -> Headless";
+
+// src/utils/overlay.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/utils/files.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+function pathExists(p) {
+  return existsSync2(p);
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function writeFileSafe(dest, content, opts = {}) {
+  if (pathExists(dest)) {
+    const current = await readFile(dest, "utf8");
+    if (current === content) return "unchanged";
+    if (!opts.force) return "skipped";
+  }
+  await ensureDir(dirname2(dest));
+  await writeFile(dest, content, "utf8");
+  return "written";
+}
+
+// src/utils/templates.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { dirname as dirname3, join as join2, relative } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function templatesRoot() {
+  let dir = dirname3(fileURLToPath2(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    const candidate = join2(dir, "templates");
+    if (existsSync3(join2(candidate, "init"))) return candidate;
+    dir = dirname3(dir);
+  }
+  throw new Error("cmssy CLI templates not found");
+}
+function readTemplate(...segments) {
+  return readFileSync2(join2(templatesRoot(), ...segments), "utf8");
+}
+function renderTemplate(content, vars) {
+  return content.replace(
+    /\{\{(\w+)\}\}/g,
+    (match, key) => key in vars ? vars[key] : match
+  );
+}
+function collectFiles(subtree) {
+  const root = join2(templatesRoot(), subtree);
+  const out = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir)) {
+      const abs = join2(dir, entry);
+      if (statSync(abs).isDirectory()) {
+        walk(abs);
+      } else {
+        out.push({ rel: relative(root, abs).split("\\").join("/"), abs });
+      }
+    }
+  };
+  walk(root);
+  return out;
+}
+
+// src/utils/overlay.ts
+var ROOT_ONLY = /* @__PURE__ */ new Set([".env.example", "next.config.mjs"]);
+var OTHER_NEXT_CONFIGS = [
+  "next.config.js",
+  "next.config.ts",
+  "next.config.cjs"
+];
+function destFor(rel) {
+  return rel === "env.example" ? ".env.example" : rel;
+}
+async function applyOverlay(targetDir, srcDir = false) {
+  const report = { written: [], skipped: [], unchanged: [] };
+  for (const file of collectFiles("init")) {
+    const dest = destFor(file.rel);
+    if (dest === "next.config.mjs" && OTHER_NEXT_CONFIGS.some((f) => existsSync4(join3(targetDir, f)))) {
+      report.skipped.push(dest);
+      continue;
+    }
+    const content = readFileSync3(file.abs, "utf8");
+    const full = srcDir && !ROOT_ONLY.has(dest) ? join3(targetDir, "src", dest) : join3(targetDir, dest);
+    const result = await writeFileSafe(full, content);
+    report[result].push(dest);
+  }
+  return report;
+}
+
+// src/utils/project.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+var IGNORED_ENTRIES = /* @__PURE__ */ new Set([".git", ".DS_Store", "Thumbs.db"]);
+function readPackageJson(cwd) {
+  const p = join4(cwd, "package.json");
+  if (!existsSync5(p)) return null;
+  try {
+    return JSON.parse(readFileSync4(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function hasDep(pkg, name) {
+  if (!pkg) return false;
+  return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name]);
+}
+function detectProject(cwd) {
+  const pkg = readPackageJson(cwd);
+  const entries = existsSync5(cwd) ? readdirSync2(cwd).filter((e) => !IGNORED_ENTRIES.has(e)) : [];
+  const appDir = existsSync5(join4(cwd, "app")) ? join4(cwd, "app") : existsSync5(join4(cwd, "src", "app")) ? join4(cwd, "src", "app") : null;
+  const hasNext = hasDep(pkg, "next");
+  return {
+    cwd,
+    hasPackageJson: pkg !== null,
+    pkg,
+    isEmpty: entries.length === 0,
+    hasNext,
+    appDir,
+    isNextAppRouter: hasNext && appDir !== null
+  };
+}
+
+// src/utils/pkg.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join5 } from "path";
+function detectPackageManager(cwd) {
+  if (existsSync6(join5(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync6(join5(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync6(join5(cwd, "bun.lockb")) || existsSync6(join5(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  return "npm";
+}
+async function ensureDependencies(cwd, deps) {
+  const p = join5(cwd, "package.json");
+  const pkg = JSON.parse(await readFile2(p, "utf8"));
+  pkg.dependencies ??= {};
+  const added = [];
+  for (const [name, version] of Object.entries(deps)) {
+    if (!pkg.dependencies[name] && !pkg.devDependencies?.[name]) {
+      pkg.dependencies[name] = version;
+      added.push(name);
+    }
+  }
+  if (added.length) {
+    await writeFile2(p, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  }
+  return added;
+}
+function run(command, args, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit", shell: false });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve2();
+      else
+        reject(new Error(`${command} ${args.join(" ")} exited with ${code}`));
+    });
+  });
+}
+function installArgs(pm) {
+  return pm === "yarn" ? [] : ["install"];
+}
+
+// src/commands/link.ts
+import { join as join6 } from "path";
+import { cancel, isCancel, log, password, spinner, text } from "@clack/prompts";
+
+// src/utils/delivery.ts
+var DEFAULT_API_URL = "https://api.cmssy.io/graphql";
+var SITE_CONFIG_QUERY = `query PublicSiteConfig($workspaceSlug: String!) {
+  publicSiteConfig(workspaceSlug: $workspaceSlug) {
+    workspaceId
+    siteName
+    defaultLanguage
+    enabledLanguages
+  }
+}`;
+function pickName(value, defaultLanguage) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object") {
+    return value[defaultLanguage ?? "en"] ?? Object.values(value)[0] ?? null;
+  }
+  return null;
+}
+async function resolveWorkspace(slug, apiUrl = DEFAULT_API_URL) {
+  try {
+    const res = await fetch(apiUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        query: SITE_CONFIG_QUERY,
+        variables: { workspaceSlug: slug }
+      })
+    });
+    if (!res.ok) {
+      return {
+        status: "error",
+        message: `delivery API returned ${res.status}`
+      };
+    }
+    const json = await res.json();
+    const config = json.data?.publicSiteConfig;
+    if (!config) return { status: "not-found" };
+    return {
+      status: "found",
+      siteName: pickName(config.siteName, config.defaultLanguage)
+    };
+  } catch (err) {
+    return {
+      status: "error",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/utils/env.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+var KEY_LINE = /^([A-Z0-9_]+)=(.*)$/;
+async function setEnvVars(filePath, vars, opts = {}) {
+  const existing = pathExists(filePath) ? await readFile3(filePath, "utf8") : "";
+  const lines = existing.length ? existing.replace(/\n$/, "").split("\n") : [];
+  const remaining = new Set(Object.keys(vars));
+  const next = lines.map((line) => {
+    const m = KEY_LINE.exec(line);
+    if (!m) return line;
+    const key = m[1];
+    if (!(key in vars)) return line;
+    remaining.delete(key);
+    const raw = m[2];
+    const comment = /\s+#.*$/.exec(raw);
+    const value = comment ? raw.slice(0, comment.index) : raw;
+    if (value.trim().length > 0 && !opts.overwrite) return line;
+    return `${key}=${vars[key]}${comment ? comment[0] : ""}`;
+  });
+  for (const key of remaining) {
+    next.push(`${key}=${vars[key]}`);
+  }
+  await writeFile3(filePath, next.join("\n") + "\n", "utf8");
+}
+
+// src/commands/link.ts
+function flagString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function bail() {
+  cancel("Cancelled.");
+  process.exit(0);
+}
+async function runLink(cwd, flags) {
+  let slug = flagString(flags.slug);
+  if (!slug) {
+    const answer = await text({
+      message: "Workspace slug",
+      placeholder: "my-workspace",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (isCancel(answer)) bail();
+    slug = answer.trim();
+  }
+  let secret = flagString(flags.secret);
+  if (!secret) {
+    const answer = await password({
+      message: `Draft secret (${HEADLESS_SETTINGS_HINT})`,
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (isCancel(answer)) bail();
+    secret = answer.trim();
+  }
+  const apiUrl = flagString(flags["api-url"]);
+  const s = spinner();
+  s.start("Checking workspace");
+  const lookup = await resolveWorkspace(slug, apiUrl);
+  if (lookup.status === "found") {
+    s.stop(`Workspace found${lookup.siteName ? `: ${lookup.siteName}` : ""}`);
+  } else if (lookup.status === "not-found") {
+    s.stop(pc.yellow(`No published workspace "${slug}" yet - saving anyway`));
+  } else {
+    s.stop(pc.yellow(`Could not verify workspace (${lookup.message})`));
+  }
+  await setEnvVars(
+    join6(cwd, ".env"),
+    { CMSSY_WORKSPACE_SLUG: slug, CMSSY_DRAFT_SECRET: secret },
+    { overwrite: true }
+  );
+  await setEnvVars(
+    join6(cwd, ".env.example"),
+    { CMSSY_WORKSPACE_SLUG: "", CMSSY_DRAFT_SECRET: "" },
+    { overwrite: false }
+  );
+  log.success("Wrote .env");
+}
+async function linkCommand(args) {
+  const cwd = process.cwd();
+  const hasConfig = pathExists(join6(cwd, "cmssy.config.ts")) || pathExists(join6(cwd, "src", "cmssy.config.ts"));
+  if (!hasConfig) {
+    log.warn("No cmssy.config.ts here - run `cmssy init` first.");
+  }
+  const { intro: intro4, outro: outro4 } = await import("@clack/prompts");
+  intro4(pc.bold("cmssy link"));
+  await runLink(cwd, args.flags);
+  outro4("Linked.");
+}
 
-Workflow:
-  1. init          → Create project with example block
-  2. link          → Connect to your workspace
-  3. create        → Add more blocks/templates
-  4. dev           → Develop with live preview
-  5. test          → Run block tests
-  6. build         → Bundle for production
-  7. publish-block → Deploy a block via the sandbox build pipeline
+// src/commands/init.ts
+var PMS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
+function choosePm(flags, targetDir) {
+  const flag = typeof flags.pm === "string" ? flags.pm : void 0;
+  if (flag && PMS.has(flag)) return flag;
+  return detectPackageManager(targetDir);
+}
+async function initCommand(args) {
+  const cwd = process.cwd();
+  const dirArg = args.positionals[0];
+  const targetDir = dirArg ? resolve(cwd, dirArg) : cwd;
+  const { flags } = args;
+  intro(pc.bold("cmssy init"));
+  const info = detectProject(targetDir);
+  if (!info.isNextAppRouter) {
+    log2.error("No Next.js App Router project found here.");
+    ui.dim(
+      "cmssy init wires an existing Next.js App Router app. Create one first:"
+    );
+    ui.dim("  npx create-next-app@latest");
+    ui.dim("then run cmssy init inside it.");
+    process.exitCode = 1;
+    return;
+  }
+  log2.info("Adding cmssy wiring to your Next.js app.");
+  const pm = choosePm(flags, targetDir);
+  const srcDir = info.appDir === join7(targetDir, "src", "app");
+  const report = await applyOverlay(targetDir, srcDir);
+  if (report.written.length) {
+    log2.success(`Added ${report.written.length} file(s)`);
+  }
+  if (report.skipped.length) {
+    log2.warn(`Skipped existing: ${report.skipped.join(", ")}`);
+  }
+  const added = await ensureDependencies(targetDir, CMSSY_DEPS);
+  if (added.length) log2.success(`Added deps: ${added.join(", ")}`);
+  if (!flags["no-link"]) {
+    await runLink(targetDir, flags);
+  }
+  const skipInstall = Boolean(flags["skip-install"]);
+  if (!skipInstall) {
+    log2.step(`Installing dependencies (${pm})`);
+    await run(pm, installArgs(pm), targetDir);
+  }
+  const steps = [
+    ...dirArg ? [`cd ${dirArg}`] : [],
+    ...skipInstall ? [`${pm} install`] : [],
+    `${pm === "npm" ? "npm run" : pm} dev`,
+    "Open the site in the cmssy editor to edit visually."
+  ];
+  if (report.skipped.includes("next.config.mjs")) {
+    steps.push(
+      pc.yellow(
+        "Add images.remotePatterns for assets.cmssy.io to your next.config so cmssy media renders."
+      )
+    );
+  }
+  note(steps.join("\n"), "Next steps");
+  outro(`Done. Docs: ${DOCS_URL}`);
+}
 
-Documentation: https://cmssy.io/docs/cli
-`);
-// cmssy init
-program
-    .command("init")
-    .description("Initialize a new Cmssy project or add Cmssy to existing one")
-    .argument("[name]", "Project name (creates new directory with create-next-app)")
-    .option("-y, --yes", "Skip prompts and use defaults")
-    .addHelpText("after", `
-Examples:
-  $ cmssy init my-blocks          New project (runs create-next-app)
-  $ cmssy init -y my-blocks       New project with defaults (no prompts)
-  $ cmssy init                    Add Cmssy to existing Next.js project
-`)
-    .action((name, options) => initCommand(name, options));
-// cmssy create
-const create = program
-    .command("create")
-    .description("Create a new block or template")
-    .addHelpText("after", `
-Examples:
-  $ cmssy create block hero
-  $ cmssy create block pricing -c marketing -t "pricing,plans"
-  $ cmssy create template landing-page
-`);
-create
-    .command("block")
-    .description("Create a new block with scaffold files")
-    .argument("<name>", "Block name (kebab-case recommended)")
-    .option("-y, --yes", "Skip prompts and use defaults")
-    .option("-d, --description <description>", "Block description")
-    .option("-c, --category <category>", "Category: marketing, typography, media, layout, forms, navigation, other")
-    .option("-t, --tags <tags>", "Comma-separated tags")
-    .addHelpText("after", `
-Creates:
-  blocks/<name>/
-  ├── config.ts         Type-safe configuration
-  ├── package.json      Name and version
-  ├── preview.json      Preview data for dev server
-  └── src/
-      ├── index.tsx     Entry point (mount/unmount)
-      ├── Block.tsx     React component
-      ├── block.d.ts    Auto-generated types
-      └── index.css     Styles
-`)
-    .action(createCommand.block);
-create
-    .command("template")
-    .description("Create a new page template")
-    .argument("<name>", "Template name (kebab-case recommended)")
-    .option("-y, --yes", "Skip prompts and use defaults")
-    .option("-d, --description <description>", "Template description")
-    .action(createCommand.page);
-// cmssy build
-program
-    .command("build")
-    .description("Build blocks and templates for production")
-    .option("--block <names...>", "Build only specific blocks/templates")
-    .option("--framework <framework>", "Override framework from config")
-    .addHelpText("after", `
-Examples:
-  $ cmssy build                        Build all blocks and templates
-  $ cmssy build --block hero pricing   Build only hero and pricing blocks
+// src/commands/add-block.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
+import { cancel as cancel2, intro as intro2, isCancel as isCancel2, log as log3, outro as outro2, text as text2 } from "@clack/prompts";
 
-Output:
-  public/@vendor/blocks.<name>/<version>/
-  ├── index.js      Bundled JavaScript
-  ├── index.css     Styles
-  └── package.json  Metadata for design library
-`)
-    .action(buildCommand);
-// cmssy dev
-program
-    .command("dev")
-    .description("Start development server with hot reload")
-    .option("-p, --port <port>", "Port number", "3000")
-    .addHelpText("after", `
-Examples:
-  $ cmssy dev                Start on default port 3000
-  $ cmssy dev -p 8080        Start on port 8080
+// src/utils/names.ts
+function words(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).map((w) => w.replace(/[^a-zA-Z0-9]/g, "").toLowerCase()).filter(Boolean);
+}
+function blockNames(input) {
+  const parts = words(input);
+  if (parts.length === 0) {
+    throw new Error("Block name must contain at least one letter or digit.");
+  }
+  if (!/^[a-z]/.test(parts[0])) {
+    throw new Error(
+      "Block name must start with a letter (it becomes a TypeScript identifier)."
+    );
+  }
+  const type = parts.join("-");
+  const Pascal = parts.map((w) => w[0].toUpperCase() + w.slice(1)).join("");
+  const camel = Pascal[0].toLowerCase() + Pascal.slice(1);
+  const Label = parts.map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+  return { type, camel, Pascal, Label };
+}
 
-Features:
-  • Live preview of all blocks/templates
-  • Hot reload on file changes
-  • Auto-regenerates types on config.ts changes
-`)
-    .action(devCommand);
-// cmssy test
-program
-    .command("test")
-    .description("Run block tests with vitest")
-    .option("--block <names...>", "Test specific blocks")
-    .option("--watch", "Watch mode")
-    .option("--coverage", "Generate coverage report")
-    .addHelpText("after", `
-Examples:
-  $ cmssy test                    Run all block tests
-  $ cmssy test --block hero       Test specific block
-  $ cmssy test --watch            Watch mode
-  $ cmssy test --coverage         With coverage
+// src/utils/registry.ts
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+async function registerBlock(blocksFile, camel, type) {
+  let content = await readFile4(blocksFile, "utf8");
+  const token = `${camel}Block`;
+  const tokenRe = new RegExp(`\\b${token}\\b`);
+  const arrayRe = /export const blocks\s*=\s*\[([\s\S]*?)\]/;
+  const arrayMatch = arrayRe.exec(content);
+  if (!arrayMatch) {
+    throw new Error(
+      `Could not find \`export const blocks = [...]\` in ${blocksFile} - add ${token} manually.`
+    );
+  }
+  if (tokenRe.test(arrayMatch[1])) return false;
+  const lines = content.split("\n");
+  const alreadyImported = lines.some(
+    (line) => line.startsWith("import ") && tokenRe.test(line)
+  );
+  if (!alreadyImported) {
+    const importLine = `import { ${token} } from "@/blocks/${type}/block";`;
+    let lastImport = -1;
+    lines.forEach((line, i) => {
+      if (line.startsWith("import ")) lastImport = i;
+    });
+    lines.splice(lastImport + 1, 0, importLine);
+    content = lines.join("\n");
+  }
+  content = content.replace(arrayRe, (_match, inner) => {
+    const body = inner.replace(/\s+$/, "").replace(/,\s*$/, "");
+    const next = body.trim() ? `${body}, ${token}` : token;
+    return `export const blocks = [${next}]`;
+  });
+  await writeFile4(blocksFile, content, "utf8");
+  return true;
+}
 
-Test files: blocks/*/src/**/*.{test,spec}.{ts,tsx}
-             templates/*/src/**/*.{test,spec}.{ts,tsx}
-`)
-    .action(testCommand);
-// cmssy link
-program
-    .command("link")
-    .description("Connect project to a Cmssy workspace")
-    .option("--api-url <url>", "Cmssy API URL (default: existing or https://api.cmssy.io/graphql)")
-    .option("--token <token>", "API token (skip interactive prompt)")
-    .option("-w, --workspace <id>", "Workspace ID or slug (skip interactive picker)")
-    .addHelpText("after", `
-Examples:
-  $ cmssy link                                    Interactive setup
-  $ cmssy link --token cs_xxx --workspace abc123   Non-interactive (CI)
+// src/commands/add-block.ts
+async function addBlockCommand(args) {
+  const cwd = process.cwd();
+  const base = existsSync7(join8(cwd, "src", "cmssy", "blocks.ts")) ? join8(cwd, "src") : cwd;
+  const blocksFile = join8(base, "cmssy", "blocks.ts");
+  intro2(pc.bold("cmssy add block"));
+  if (!existsSync7(blocksFile)) {
+    log3.error("No cmssy/blocks.ts found - run `cmssy init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  let input = args.positionals[0];
+  if (!input) {
+    const answer = await text2({
+      message: "Block name",
+      placeholder: "feature-grid",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (isCancel2(answer)) {
+      cancel2("Cancelled.");
+      process.exit(0);
+    }
+    input = answer.trim();
+  }
+  const names = blockNames(input);
+  const vars = {
+    type: names.type,
+    camel: names.camel,
+    Pascal: names.Pascal,
+    Label: names.Label
+  };
+  const dir = join8(base, "blocks", names.type);
+  const blockTs = renderTemplate(readTemplate("block", "block.ts.tpl"), vars);
+  const componentTsx = renderTemplate(
+    readTemplate("block", "Component.tsx.tpl"),
+    vars
+  );
+  const componentCss = renderTemplate(
+    readTemplate("block", "Component.module.css.tpl"),
+    vars
+  );
+  const results = [
+    await writeFileSafe(join8(dir, "block.ts"), blockTs),
+    await writeFileSafe(join8(dir, `${names.Pascal}.tsx`), componentTsx),
+    await writeFileSafe(join8(dir, `${names.Pascal}.module.css`), componentCss)
+  ];
+  if (results.includes("skipped")) {
+    log3.warn(
+      `Block "${names.type}" already exists - left existing files alone.`
+    );
+  } else if (results.includes("written")) {
+    log3.success(
+      `Created blocks/${names.type}/ (block.ts + ${names.Pascal}.tsx + ${names.Pascal}.module.css)`
+    );
+  } else {
+    log3.info(`Block "${names.type}" already up to date.`);
+  }
+  const registered = await registerBlock(blocksFile, names.camel, names.type);
+  log3.info(
+    registered ? `Registered ${names.camel}Block in cmssy/blocks.ts` : `${names.camel}Block already registered`
+  );
+  outro2(
+    `Added "${names.type}". Edit its component, then use it in the editor.`
+  );
+}
 
-Saves credentials and workspace ID to .env file.
-Get your API token at: https://cmssy.io/settings/tokens
-`)
-    .action(linkCommand);
-// cmssy configure (hidden - deprecated, use `cmssy link`)
-program.addCommand(new Command("configure")
-    .description("Configure Cmssy API credentials (deprecated: use `cmssy link`)")
-    .option("--api-url <url>", "Cmssy API URL")
-    .action((options) => {
-    console.log(chalk.yellow("\n⚠ `cmssy configure` is deprecated. Use `cmssy link` instead.\n"));
-    return configureCommand(options);
-}), { hidden: true });
-// cmssy doctor
-program
-    .command("doctor")
-    .description("Check project setup, API connection, and block health")
-    .addHelpText("after", `
-Runs diagnostic checks:
-  • Environment (Node.js, npm, next, react)
-  • Configuration (.env, API token, workspace ID)
-  • API connection and workspace access
-  • Block structure validation
-  • Dependency versions
-`)
-    .action(doctorCommand);
-program
-    .command("publish-block")
-    .description("Publish a single block via the build pipeline (Vercel Sandbox + Inngest).\n\n" +
-    "  Sends the block source tree to the backend, which packs it as tar.gz,\n" +
-    "  uploads to Vercel Blob, then enqueues an Inngest job that bundles in\n" +
-    "  a sandbox and stores artifacts back to Blob.")
-    .argument("<name>", "Block directory name under blocks/")
-    .option("-w, --workspace [id]", "Workspace id (defaults to .env)")
-    .option("--entry <path>", "Entry path inside block dir (default: src/index.tsx)")
-    .option("--dry-run", "Collect files and print plan without uploading")
-    .addHelpText("after", `
-Examples:
-  $ cmssy publish-block hero                   Publish blocks/hero
-  $ cmssy publish-block hero --dry-run         Show what would be sent
-  $ cmssy publish-block faq -w 65f...          Override workspace
+// src/commands/doctor.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { join as join9 } from "path";
+import { intro as intro3, outro as outro3 } from "@clack/prompts";
+var MARK = {
+  pass: pc.green("\u2713"),
+  warn: pc.yellow("!"),
+  fail: pc.red("\u2717")
+};
+async function doctorCommand(_args) {
+  const cwd = process.cwd();
+  const base = existsSync8(join9(cwd, "src", "cmssy", "blocks.ts")) ? join9(cwd, "src") : cwd;
+  intro3(pc.bold("cmssy doctor"));
+  const checks = [];
+  const required = [
+    ["cmssy.config.ts", join9(cwd, "cmssy.config.ts")],
+    ["proxy.ts", join9(cwd, "proxy.ts")],
+    ["app/[[...path]]/page.tsx", join9(base, "app", "[[...path]]", "page.tsx")],
+    ["app/api/draft/route.ts", join9(base, "app", "api", "draft", "route.ts")],
+    ["cmssy/blocks.ts", join9(base, "cmssy", "blocks.ts")],
+    ["cmssy/editor.tsx", join9(base, "cmssy", "editor.tsx")]
+  ];
+  for (const [label, p] of required) {
+    checks.push(
+      existsSync8(p) ? { label, status: "pass" } : { label, status: "fail", hint: "missing - run `cmssy init`" }
+    );
+  }
+  const pkg = readPackageJson(cwd);
+  const next = pkg?.dependencies?.["@cmssy/next"] ?? pkg?.devDependencies?.["@cmssy/next"];
+  const react = pkg?.dependencies?.["@cmssy/react"] ?? pkg?.devDependencies?.["@cmssy/react"];
+  if (!next || !react) {
+    checks.push({
+      label: "@cmssy/next + @cmssy/react installed",
+      status: "fail",
+      hint: "missing - add @cmssy/next and @cmssy/react"
+    });
+  } else if (next !== react) {
+    checks.push({
+      label: "@cmssy/* versions aligned",
+      status: "warn",
+      hint: `@cmssy/next ${next} vs @cmssy/react ${react}`
+    });
+  } else {
+    checks.push({ label: `@cmssy/* ${next}`, status: "pass" });
+  }
+  const envPath = join9(cwd, ".env");
+  const env = existsSync8(envPath) ? readFileSync5(envPath, "utf8") : "";
+  for (const key of ["CMSSY_WORKSPACE_SLUG", "CMSSY_DRAFT_SECRET"]) {
+    const set = new RegExp(`^${key}=.+$`, "m").test(env);
+    checks.push(
+      set ? { label: key, status: "pass" } : {
+        label: key,
+        status: "warn",
+        hint: "not set in .env - run `cmssy link`"
+      }
+    );
+  }
+  const blocksFile = join9(base, "cmssy", "blocks.ts");
+  if (existsSync8(blocksFile)) {
+    const content = readFileSync5(blocksFile, "utf8");
+    const refs = [...content.matchAll(/@\/blocks\/([^/]+)\/block/g)].map(
+      (m) => m[1]
+    );
+    const missing = refs.filter(
+      (name) => !existsSync8(join9(base, "blocks", name, "block.ts"))
+    );
+    checks.push(
+      missing.length === 0 ? { label: `block registry (${refs.length} block(s))`, status: "pass" } : {
+        label: "block registry imports resolve",
+        status: "fail",
+        hint: `missing block file(s): ${missing.join(", ")}`
+      }
+    );
+  }
+  for (const c of checks) {
+    console.log(
+      `  ${MARK[c.status]} ${c.label}${c.hint ? pc.dim(` - ${c.hint}`) : ""}`
+    );
+  }
+  const failed = checks.filter((c) => c.status === "fail").length;
+  const warned = checks.filter((c) => c.status === "warn").length;
+  if (failed) {
+    process.exitCode = 1;
+    outro3(pc.red(`${failed} problem(s), ${warned} warning(s).`));
+  } else {
+    outro3(
+      warned ? pc.yellow(`OK with ${warned} warning(s).`) : pc.green("All good.")
+    );
+  }
+}
 
-Limits per block: 200 files, 10 MB total.
-Build polling: 1.5s interval, 10 minute cap, gives up after 5 consecutive errors.
-`)
-    .action((name, options) => publishBlockBuildtimeCommand(name, options));
-// cmssy publish-template
-program
-    .command("publish-template")
-    .description("Publish a single template (page tree + content) to a workspace.\n\n" +
-    "  Templates are declarative - no sandbox build. Reads config.ts +\n" +
-    "  pages.json and uploads via GraphQL. The backend revalidates the\n" +
-    "  public-site cache so changes appear immediately.")
-    .argument("<name>", "Template directory name under templates/")
-    .option("-w, --workspace [id]", "Workspace id (defaults to .env)")
-    .option("--patch", "Bump patch version (1.0.0 -> 1.0.1) - default")
-    .option("--minor", "Bump minor version (1.0.0 -> 1.1.0)")
-    .option("--major", "Bump major version (1.0.0 -> 2.0.0)")
-    .option("--no-bump", "Publish without version bump")
-    .option("--dry-run", "Print plan without uploading")
-    .option("--overwrite-content", "Overwrite existing page content on republish (default: preserve)")
-    .addHelpText("after", `
-Examples:
-  $ cmssy publish-template marketing-site               Publish templates/marketing-site
-  $ cmssy publish-template marketing-site --dry-run     Show the plan
-  $ cmssy publish-template blog -w 65f... --minor       Override workspace + minor bump
+// src/cli.ts
+var HELP = `
+${pc.bold("cmssy")} - wire a Next.js app to a headless cmssy workspace
 
-Required blocks listed in the template must already exist in the workspace
-(publish them via \`cmssy publish-block\` first).
-`)
-    .action((name, options) => publishTemplateCommand(name, options));
-const lib = program
-    .command("lib")
-    .description("Manage the workspace's npm dependency manifest");
-lib
-    .command("install")
-    .description("Install npm package(s) locally and sync the manifest")
-    .argument("<packages...>", "npm package specs (e.g. lodash zod@^4)")
-    .option("-w, --workspace [id]", "Workspace id (defaults to .env)")
-    .addOption(new Option("--package-manager <pm>", "Force the package manager").choices([
-    "npm",
-    "pnpm",
-    "yarn",
-    "bun",
-]))
-    .option("--skip-install", "Skip local install; only sync from package.json")
-    .option("--dry-run", "Don't push manifest, just print it")
-    .action((packages, options) => libInstallCommand(packages, options));
-lib
-    .command("sync")
-    .description("Push current package.json deps to the workspace manifest")
-    .option("-w, --workspace [id]", "Workspace id (defaults to .env)")
-    .option("--dry-run", "Don't push manifest, just print it")
-    .action((options) => libSyncCommand(options));
-// cmssy sync
-program
-    .command("sync")
-    .description("Pull blocks from design library to local project")
-    .argument("[package]", "Package slug (e.g., @cmssy/blocks.hero)")
-    .option("--workspace <id>", "Sync from specific workspace")
-    .addHelpText("after", `
-Examples:
-  $ cmssy sync @cmssy/blocks.hero          Sync from design library
-  $ cmssy sync --workspace abc123          Sync all from workspace
-`)
-    .action(syncCommand);
-// cmssy migrate (hidden - legacy command, all projects already migrated)
-program.addCommand(new Command("migrate")
-    .argument("[block-name]")
-    .description("Migrate legacy package.json config to config.ts")
-    .addHelpText("after", `
-Examples:
-  $ cmssy migrate hero     Migrate specific block
-  $ cmssy migrate          Migrate all blocks/templates
+${pc.bold("Usage")}
+  cmssy <command> [options]
 
-Converts:
-  package.json { cmssy: {...} }  →  config.ts
-`)
-    .action(migrateCommand), { hidden: true });
-// cmssy workspaces
-program
-    .command("workspaces")
-    .description("List your workspaces and their IDs")
-    .addHelpText("after", `
-Use workspace IDs with:
-  $ cmssy publish-block <name> --workspace <id>
-  $ cmssy publish-template <name> --workspace <id>
-  $ cmssy sync --workspace <id>
-`)
-    .action(workspacesCommand);
-// cmssy skills
-const skills = program
-    .command("skills")
-    .description("Manage AI coding-assistant skills for cmssy");
-skills
-    .command("list")
-    .description("List available skills")
-    .action(skillsListCommand);
-skills
-    .command("install")
-    .description("Install a skill into your AI assistant's config directory")
-    .argument("[skill]", "Skill name: block, mcp-content (omit for interactive)")
-    .option("--target <editor>", "Editor target: claude (default)", "claude")
-    .option("--all", "Install every available skill")
-    .option("--local", "Install into ./.claude/skills (default: ~/.claude/skills)")
-    .option("--force", "Overwrite existing skill without prompting")
-    .option("-y, --yes", "Non-interactive mode (fail instead of prompting)")
-    .addHelpText("after", `
-Examples:
-  $ cmssy skills list                  Show available skills
-  $ cmssy skills install               Interactive prompt (pick a skill)
-  $ cmssy skills install block         CLI + block dev workflow skill
-  $ cmssy skills install mcp-content   Content editing via @cmssy/mcp-server
-  $ cmssy skills install --all         Install every skill
-  $ cmssy skills install block --local Install into current project's .claude/
-  $ cmssy skills install block --force Overwrite existing skill
+${pc.bold("Commands")}
+  init                 Add cmssy wiring to an existing Next.js App Router app
+  link                 Connect an initialized project to a workspace
+  add block <name>     Scaffold a new block and register it
+  doctor               Diagnose a cmssy project's setup
 
-Changed in 0.14.0: the first positional arg is now the skill name (e.g.
-'block', 'mcp-content'), not the editor target. Use --target for editor.
-`)
-    .action((skillName, options) => skillsInstallCommand(skillName, options));
-// cmssy codegen (hidden - use `cmssy init --graphql` for setup)
-program.addCommand(new Command("codegen")
-    .description("Generate TypeScript types from workspace public GraphQL schema")
-    .option("-w, --workspace <slug>", "Workspace slug")
-    .option("-o, --output <path>", "Output file path", "src/graphql/types.ts")
-    .option("--init", "Generate codegen.ts config file instead of running codegen")
-    .addHelpText("after", `
-Examples:
-  $ cmssy codegen --workspace my-workspace
-  $ cmssy codegen --init
-  $ cmssy codegen -o src/types/api.ts
-`)
-    .action(codegenCommand), { hidden: true });
-program.parse();
-//# sourceMappingURL=cli.js.map
+${pc.bold("Options")}
+  -h, --help           Show this help
+  -v, --version        Show version
+`;
+async function main() {
+  const { positionals, flags } = parseArgs(process.argv.slice(2));
+  const command = positionals[0];
+  if (flags.version || flags.v) {
+    console.log(getVersion());
+    return;
+  }
+  if (!command || flags.help || flags.h) {
+    console.log(HELP);
+    return;
+  }
+  const rest = { positionals: positionals.slice(1), flags };
+  switch (command) {
+    case "init":
+      await initCommand(rest);
+      break;
+    case "link":
+      await linkCommand(rest);
+      break;
+    case "add":
+      if (positionals[1] === "block") {
+        await addBlockCommand({ positionals: positionals.slice(2), flags });
+      } else {
+        ui.error(
+          `Unknown add target: ${pc.bold(positionals[1] ?? "")}. Try ${pc.bold("cmssy add block <name>")}.`
+        );
+        process.exitCode = 1;
+      }
+      break;
+    case "doctor":
+      await doctorCommand(rest);
+      break;
+    default:
+      ui.error(`Unknown command: ${pc.bold(command)}`);
+      console.log(HELP);
+      process.exitCode = 1;
+  }
+}
+main().catch((err) => {
+  ui.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});