@sudajs/cli 0.7.0 → 0.7.2

package/dist/index.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { createHash } from 'crypto';
-import fs, { mkdir, copyFile, readdir, writeFile, stat, readFile, rm } from 'fs/promises';
+import fs, { writeFile, stat, readFile, readdir, mkdir, copyFile, rm } from 'fs/promises';
 import { createRequire } from 'module';
 import path2 from 'path';
+import { createInterface } from 'readline/promises';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createThemeAgentManifest, createAgentPageSchemaOutput, checkThemeModule, formatThemeCheckResult, validateAgentPageContentWithManifest, agentValidationResultSchema, createPageDataFromAgentContent, findAgentSection, createAgentComponentSchemaOutput, agentPageSchemaOutputSchema, agentComponentOutputSchema } from '@sudajs/theme-engine';
+import { createThemeAgentManifest, createAgentPageSchemaOutput, checkThemeModule, formatThemeCheckResult, validateAgentPageContentWithManifest, agentValidationResultSchema, findAgentSection, createAgentComponentSchemaOutput, agentPageSchemaOutputSchema, agentComponentOutputSchema } from '@sudajs/theme-engine';
 import { themeManifestSchema, FileSystemThemeRegistry } from '@sudajs/theme-engine/server';
 import { Command } from 'commander';
 import { build } from 'esbuild';
@@ -171,6 +172,9 @@ async function logout() {
 }
 
 // src/index.ts
+var __dirname$1 = path2.dirname(fileURLToPath(import.meta.url));
+var THEME_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+var THEME_KEY_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 var createPageDraftOutputSchema = z.discriminatedUnion("status", [
   z.object({
     status: z.literal("created").describe("The page draft was created."),
@@ -187,6 +191,51 @@ var createPageDraftOutputSchema = z.discriminatedUnion("status", [
     )
   })
 ]);
+var updatePageDraftOutputSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("updated").describe("The page draft was updated."),
+    pageId: z.string().describe("Existing page id.")
+  }),
+  z.object({
+    status: z.literal("invalid").describe("The page content failed validation."),
+    valid: z.literal(false),
+    issues: z.array(
+      z.object({
+        path: z.string(),
+        message: z.string()
+      })
+    )
+  })
+]);
+var destructivePageOperationOutputSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("needs_confirmation"),
+    projectId: z.string(),
+    slug: z.string(),
+    impact: z.string()
+  }),
+  z.object({
+    status: z.enum(["deleted", "published"]),
+    projectId: z.string(),
+    slug: z.string(),
+    pageId: z.string()
+  })
+]);
+var activateThemeOutputSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("needs_confirmation"),
+    projectId: z.string(),
+    themeKey: z.string(),
+    themeVersion: z.string().nullable(),
+    impact: z.string()
+  }),
+  z.object({
+    status: z.literal("activated"),
+    projectId: z.string(),
+    themeKey: z.string(),
+    themeVersion: z.string().nullable()
+  })
+]);
 var PROJECT_NAME_MIN_LENGTH = 1;
 var PROJECT_NAME_MAX_LENGTH = 80;
 var PROJECT_DESCRIPTION_MIN_LENGTH = 1;
@@ -336,6 +385,17 @@ export const { createRoot, hydrateRoot, version } = ReactDOMClient;
     }
   };
 }
+function createThemeEngineRuntimeAliasPlugin() {
+  return {
+    name: "suda-theme-engine-runtime-alias",
+    setup(build) {
+      const runtimeEntry = path2.resolve(__dirname$1, "../../theme-engine/src/runtime.ts");
+      build.onResolve({ filter: /^@sudajs\/theme-engine\/runtime$/ }, () => ({
+        path: runtimeEntry
+      }));
+    }
+  };
+}
 function safeObjectKeyPart(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "-");
 }
@@ -531,6 +591,14 @@ function toViteModuleUrl(root, absolutePath) {
 function isThemeExternal(id) {
   return id === "react" || id.startsWith("react/") || id === "react-dom" || id.startsWith("react-dom/") || id === "@puckeditor/core" || id.startsWith("@puckeditor/core/") || id === "@sudajs/theme-engine" || id.startsWith("@sudajs/theme-engine/");
 }
+function viteAssetFileNames(assetInfo) {
+  const names = assetInfo.names ?? [];
+  const isCss = names.some((name) => name.endsWith(".css"));
+  if (isCss) {
+    return "styles.css";
+  }
+  return "assets/[name]-[hash][extname]";
+}
 async function buildViteTheme(root) {
   const viteConfig = await findViteConfig(root);
   const vite = await loadThemeVite(root);
@@ -551,17 +619,22 @@ async function buildViteTheme(root) {
       emptyOutDir: false,
       outDir: path2.join(root, "dist"),
       sourcemap: false,
+      assetsInlineLimit: 0,
       ssr: serverEntry,
       rollupOptions: {
         external: isThemeExternal,
         output: {
           entryFileNames: "index.js",
           chunkFileNames: "chunks/[name]-[hash].js",
-          assetFileNames: "assets/[name]-[hash][extname]"
+          assetFileNames: viteAssetFileNames
         }
       }
     }
   });
+  await copyThemeSourceAssets(root);
+  const stylesheetEntry = path2.join(root, ".suda-build", "styles-entry.ts");
+  await mkdir(path2.dirname(stylesheetEntry), { recursive: true });
+  await writeFile(stylesheetEntry, 'import "../src/styles.css";\n', "utf8");
   await vite.build({
     root,
     configFile: viteConfig,
@@ -570,18 +643,28 @@ async function buildViteTheme(root) {
     publicDir: false,
     build: {
       emptyOutDir: false,
-      outDir: path2.join(root, ".suda-build", "styles"),
+      outDir: path2.join(root, "dist"),
       sourcemap: false,
+      assetsInlineLimit: 0,
+      cssCodeSplit: false,
       rollupOptions: {
-        input: stylesEntry,
+        input: stylesheetEntry,
         output: {
-          entryFileNames: "style-entry.js",
+          entryFileNames: "chunks/theme-styles.js",
           chunkFileNames: "chunks/[name]-[hash].js",
-          assetFileNames: "assets/[name]-[hash][extname]"
+          assetFileNames: viteAssetFileNames
         }
       }
     }
   });
+  await rm(path2.join(root, "dist", "chunks", "theme-styles.js"), { force: true });
+}
+async function copyThemeSourceAssets(root) {
+  const sourceAssets = path2.join(root, "src", "assets");
+  if (!await pathExists(sourceAssets)) {
+    return;
+  }
+  await copyDirectory(sourceAssets, path2.join(root, "dist", "assets"));
 }
 async function buildClientRuntime(root, minify) {
   const entryPoint = await findClientEntry(root);
@@ -590,6 +673,7 @@ async function buildClientRuntime(root, minify) {
   }
   await mkdir(path2.join(root, "dist"), { recursive: true });
   const hostReactShimPlugin = createHostReactShimPlugin();
+  const themeEngineRuntimeAliasPlugin = createThemeEngineRuntimeAliasPlugin();
   await build({
     bundle: true,
     entryPoints: [entryPoint],
@@ -599,16 +683,14 @@ async function buildClientRuntime(root, minify) {
       "react-dom",
       "react-dom/*",
       "@puckeditor/core",
-      "@puckeditor/core/*",
-      "@sudajs/theme-engine",
-      "@sudajs/theme-engine/*"
+      "@puckeditor/core/*"
     ],
     format: "esm",
     jsx: "automatic",
     minify,
     outfile: path2.join(root, "dist", "runtime.client.js"),
     platform: "browser",
-    plugins: [hostReactShimPlugin],
+    plugins: [hostReactShimPlugin, themeEngineRuntimeAliasPlugin],
     sourcemap: false,
     target: "es2022",
     treeShaking: true
@@ -641,24 +723,12 @@ async function finalizeTheme(root) {
   return validateTheme(root);
 }
 async function finalizeStylesheet(root) {
-  const builtStylesDir = path2.join(root, ".suda-build", "styles");
-  const cssFiles = [
-    ...await collectFiles(root, builtStylesDir),
-    ...await collectFiles(root, path2.join(root, "dist"))
-  ];
-  const cssFile = cssFiles.find((file) => file.relativePath.endsWith(".css"));
-  if (!cssFile) {
+  const expectedStylesheet = path2.join(root, "dist", "styles.css");
+  if (!await pathExists(expectedStylesheet)) {
     throw new Error(
-      `Vite did not emit a stylesheet from src/styles.css. Check ${path2.join(root, "vite.config.ts")} and Tailwind/PostCSS configuration.`
+      `Vite did not emit ${expectedStylesheet} from src/styles.css. Check ${path2.join(root, "vite.config.ts")} and Tailwind/PostCSS configuration.`
     );
   }
-  await mkdir(path2.join(root, "dist"), { recursive: true });
-  await copyFile(cssFile.absolutePath, path2.join(root, "dist", "styles.css"));
-  const assetsDir = path2.join(builtStylesDir, "assets");
-  if (await pathExists(assetsDir)) {
-    await mkdir(path2.join(root, "dist", "assets"), { recursive: true });
-    await copyDirectory(assetsDir, path2.join(root, "dist", "assets"));
-  }
 }
 async function copyDirectory(source, destination) {
   const children = await readdir(source, { withFileTypes: true });
@@ -757,8 +827,18 @@ function runFooterContractCheck(theme, renderer) {
   return issues;
 }
 var __testUtils = {
+  createRemotePageDraft,
   findAnchorTagByHref,
-  toViteModuleUrl
+  loadThemeScopedRenderer,
+  initThemeWithKey,
+  performActivateTheme,
+  performConfirmedPageOperation,
+  renderDevStarterPageHtml,
+  slugifyThemeName,
+  validateThemeKey,
+  validateThemeName,
+  toViteModuleUrl,
+  updateRemotePageDraft
 };
 async function runThemeCheck(theme) {
   const result = checkThemeModule(theme.module);
@@ -808,7 +888,7 @@ function createSudaPreviewVitePlugin(root) {
           const url = new URL(request.url ?? "/", "http://localhost");
           const assetPrefixMatch = url.pathname.match(/^\/api\/themes\/[^/]+\/[^/]+\/assets\/(.+)$/);
           if (assetPrefixMatch?.[1]) {
-            request.url = `/${assetPrefixMatch[1]}${url.search}`;
+            request.url = `/src/assets/${assetPrefixMatch[1]}${url.search}`;
             next();
             return;
           }
@@ -963,19 +1043,7 @@ function renderStarterPageHtml(theme, resolved, page, renderer) {
 function renderDevStarterPageHtml(theme, page, renderer) {
   const chrome = renderer.extractLayoutChrome(theme.module.defaultLayout);
   const metadata = {
-    resolveAssetUrl: (value) => {
-      if (!value) {
-        return value;
-      }
-      if (/^[a-z][a-z0-9+.-]*:/i.test(value) || value.startsWith("/")) {
-        return value;
-      }
-      if (value.startsWith("themes/")) {
-        const parts = value.split("/");
-        return `/${parts.slice(3).join("/")}`;
-      }
-      return value;
-    }
+    resolveAssetUrl: createPreviewAssetResolver(renderer.resolveAssetPath)
   };
   const body = renderer.renderToString(
     renderer.createElement(renderer.ThemeRender, {
@@ -1336,24 +1404,115 @@ async function createAgentPage(options) {
     process.exitCode = 1;
     return;
   }
-  const pageData = createPageDataFromAgentContent(pageContent);
   const auth = await requireCliBaseUrl();
-  const response = await fetchJson(
-    `${auth.baseUrl}/api/cli/agent/projects/${encodeURIComponent(options.projectId)}/pages`,
+  const response = await createRemotePageDraft(
+    auth,
+    {
+      projectId: options.projectId,
+      title: options.title,
+      slug: options.slug,
+      themeKey: manifest.manifest.key,
+      themeVersion: manifest.manifest.version,
+      data: pageContent
+    },
+    fetchJson
+  );
+  printJson({ success: true, ...response });
+}
+async function createRemotePageDraft(auth, input, fetcher = fetchJson) {
+  return fetcher(
+    `${auth.baseUrl}/api/cli/agent/projects/${encodeURIComponent(input.projectId)}/pages`,
     {
       method: "POST",
       token: auth.token,
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        title: options.title,
-        slug: options.slug,
-        themeKey: manifest.manifest.key,
-        themeVersion: manifest.manifest.version,
-        data: pageData
+        title: input.title,
+        slug: input.slug,
+        themeKey: input.themeKey,
+        themeVersion: input.themeVersion,
+        data: input.data
       })
     }
   );
-  printJson({ success: true, ...response });
+}
+async function updateRemotePageDraft(auth, input, fetcher = fetchJson) {
+  return fetcher(
+    `${auth.baseUrl}/api/cli/agent/projects/${encodeURIComponent(input.projectId)}/pages`,
+    {
+      method: "PATCH",
+      token: auth.token,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        slug: input.slug,
+        themeKey: input.themeKey,
+        themeVersion: input.themeVersion,
+        data: input.data
+      })
+    }
+  );
+}
+async function performConfirmedPageOperation(auth, input, fetcher = fetchJson) {
+  const impact = input.operation === "delete" ? `This will delete page "${input.slug}" from project "${input.projectId}". Deleted pages are removed from the workspace and public site.` : `This will publish the current saved draft for page "${input.slug}" in project "${input.projectId}" and make it visible on the public site.`;
+  if (input.confirm !== true) {
+    return {
+      status: "needs_confirmation",
+      projectId: input.projectId,
+      slug: input.slug,
+      impact
+    };
+  }
+  const endpoint = input.operation === "delete" ? `/api/cli/agent/projects/${encodeURIComponent(input.projectId)}/pages` : `/api/cli/agent/projects/${encodeURIComponent(input.projectId)}/pages/publish`;
+  const response = await fetcher(`${auth.baseUrl}${endpoint}`, {
+    method: input.operation === "delete" ? "DELETE" : "POST",
+    token: auth.token,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      slug: input.slug,
+      confirm: true
+    })
+  });
+  return {
+    status: input.operation === "delete" ? "deleted" : "published",
+    projectId: input.projectId,
+    slug: response.slug ?? input.slug,
+    pageId: response.pageId
+  };
+}
+async function performActivateTheme(auth, input, fetcher = fetchJson) {
+  const themeRef = input.themeVersion ? `${input.themeKey}@${input.themeVersion}` : input.themeKey;
+  const impact = `This will activate theme "${themeRef}" for project "${input.projectId}". Public pages will render with this theme after activation.`;
+  if (input.confirm !== true) {
+    return {
+      status: "needs_confirmation",
+      projectId: input.projectId,
+      themeKey: input.themeKey,
+      themeVersion: input.themeVersion ?? null,
+      impact
+    };
+  }
+  const body = {
+    themeKey: input.themeKey,
+    confirm: true
+  };
+  if (input.themeVersion !== void 0) {
+    body.themeVersion = input.themeVersion;
+  }
+  const response = await fetcher(
+    `${auth.baseUrl}/api/cli/agent/projects/${encodeURIComponent(input.projectId)}/theme/activate`,
+    {
+      method: "POST",
+      token: auth.token,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }
+  );
+  return activateThemeOutputSchema.parse({
+    status: "activated",
+    projectId: response.projectId,
+    themeKey: response.themeKey,
+    themeVersion: response.themeVersion
+  });
 }
 async function listAgentProjects() {
   const auth = await requireCliBaseUrl();
@@ -1542,7 +1701,7 @@ async function startMcpServer() {
   server.registerTool(
     "create_page_draft",
     {
-      description: "Create a workspace page draft from AI-generated Suda page content.",
+      description: "Create a new workspace page draft from AI-generated Suda page content.",
       inputSchema: {
         projectId: z.string(),
         title: z.string(),
@@ -1567,27 +1726,142 @@ async function startMcpServer() {
         );
       }
       const auth = await requireCliBaseUrl();
-      const response = await fetchJson(
-        `${auth.baseUrl}/api/cli/agent/projects/${encodeURIComponent(projectId)}/pages`,
-        {
-          method: "POST",
-          token: auth.token,
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            title,
-            slug,
-            themeKey: manifest.manifest.key,
-            themeVersion: manifest.manifest.version,
-            data: createPageDataFromAgentContent(data)
-          })
-        }
-      );
+      const response = await createRemotePageDraft(auth, {
+        projectId,
+        title,
+        slug,
+        themeKey: manifest.manifest.key,
+        themeVersion: manifest.manifest.version,
+        data
+      });
       return mcpStructured(
         "Created Suda page draft.",
         createPageDraftOutputSchema.parse({ status: "created", ...response })
       );
     }
   );
+  server.registerTool(
+    "update_page_draft",
+    {
+      description: "Update an existing workspace page draft by slug from AI-generated Suda page content.",
+      inputSchema: {
+        projectId: z.string(),
+        slug: z.string(),
+        theme: z.string(),
+        data: z.unknown(),
+        version: z.string().optional()
+      },
+      outputSchema: updatePageDraftOutputSchema
+    },
+    async ({ projectId, slug, theme, data, version }) => {
+      const manifest = await fetchAgentManifest(theme, { version, projectId });
+      const validation = validateAgentPageContentWithManifest(data, manifest);
+      if (!validation.valid) {
+        return mcpStructured(
+          "Suda page content validation failed. Fix issues before updating a draft.",
+          updatePageDraftOutputSchema.parse({
+            status: "invalid",
+            valid: false,
+            issues: validation.issues
+          })
+        );
+      }
+      const auth = await requireCliBaseUrl();
+      const response = await updateRemotePageDraft(auth, {
+        projectId,
+        slug,
+        themeKey: manifest.manifest.key,
+        themeVersion: manifest.manifest.version,
+        data
+      });
+      return mcpStructured(
+        "Updated Suda page draft.",
+        updatePageDraftOutputSchema.parse({ status: "updated", ...response })
+      );
+    }
+  );
+  server.registerTool(
+    "delete_page",
+    {
+      description: "Delete a Suda page by slug. This is destructive: first call without confirm to get the exact project, slug, and impact; only call again with confirm: true after the user explicitly agrees.",
+      inputSchema: {
+        projectId: z.string(),
+        slug: z.string(),
+        confirm: z.boolean().optional()
+      },
+      outputSchema: destructivePageOperationOutputSchema
+    },
+    async ({ projectId, slug, confirm }) => {
+      const auth = await requireCliBaseUrl();
+      const structuredContent = destructivePageOperationOutputSchema.parse(
+        await performConfirmedPageOperation(auth, {
+          operation: "delete",
+          projectId,
+          slug,
+          confirm
+        })
+      );
+      return mcpStructured(
+        structuredContent.status === "needs_confirmation" ? "Deleting this Suda page requires explicit confirmation." : "Deleted Suda page.",
+        structuredContent
+      );
+    }
+  );
+  server.registerTool(
+    "publish_page",
+    {
+      description: "Publish the current saved draft for a Suda page by slug. This affects the public site: first call without confirm to get the exact project, slug, and impact; only call again with confirm: true after the user explicitly agrees.",
+      inputSchema: {
+        projectId: z.string(),
+        slug: z.string(),
+        confirm: z.boolean().optional()
+      },
+      outputSchema: destructivePageOperationOutputSchema
+    },
+    async ({ projectId, slug, confirm }) => {
+      const auth = await requireCliBaseUrl();
+      const structuredContent = destructivePageOperationOutputSchema.parse(
+        await performConfirmedPageOperation(auth, {
+          operation: "publish",
+          projectId,
+          slug,
+          confirm
+        })
+      );
+      return mcpStructured(
+        structuredContent.status === "needs_confirmation" ? "Publishing this Suda page requires explicit confirmation." : "Published Suda page.",
+        structuredContent
+      );
+    }
+  );
+  server.registerTool(
+    "activate_theme",
+    {
+      description: "Activate a theme for a Suda project. This affects how public pages render and may seed starter content on first activation: first call without confirm to get the exact project, theme, and impact; only call again with confirm: true after the user explicitly agrees.",
+      inputSchema: {
+        projectId: z.string(),
+        themeKey: z.string(),
+        themeVersion: z.string().optional(),
+        confirm: z.boolean().optional()
+      },
+      outputSchema: activateThemeOutputSchema
+    },
+    async ({ projectId, themeKey, themeVersion, confirm }) => {
+      const auth = await requireCliBaseUrl();
+      const structuredContent = activateThemeOutputSchema.parse(
+        await performActivateTheme(auth, {
+          projectId,
+          themeKey,
+          themeVersion,
+          confirm
+        })
+      );
+      return mcpStructured(
+        structuredContent.status === "needs_confirmation" ? "Activating this Suda theme requires explicit confirmation." : "Activated Suda theme.",
+        structuredContent
+      );
+    }
+  );
   await server.connect(new StdioServerTransport());
 }
 async function writeThemeArtifacts(theme) {
@@ -1898,8 +2172,92 @@ async function replaceTemplateTokens(filePath, replacements) {
 async function loadThemeTemplateFile(relativePath) {
   return readFile(path2.join(themeTemplateRoot, relativePath), "utf8");
 }
+function validateThemeName(name) {
+  if (name.length === 0) {
+    return "Theme name is required.";
+  }
+  if (!THEME_NAME_PATTERN.test(name)) {
+    return "Theme name may only contain English letters, numbers, hyphens, and underscores.";
+  }
+  return null;
+}
+function validateThemeKey(key) {
+  if (key.length === 0) {
+    return "Theme key is required.";
+  }
+  if (!THEME_KEY_PATTERN.test(key)) {
+    return "Theme key must be kebab-case: lowercase letters, numbers, and hyphens, starting with a letter or number.";
+  }
+  return null;
+}
+function slugifyThemeName(name) {
+  return name.replaceAll("_", "-").toLowerCase();
+}
+function createThemeInitPrompt(nameProvided) {
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      nameProvided ? "Theme key confirmation is required. Re-run `suda theme init <name>` in an interactive terminal." : "Theme name is required. Usage: suda theme init <name>"
+    );
+  }
+  return createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function promptThemeName(rl) {
+  while (true) {
+    const answer = (await rl.question("Theme name: ")).trim();
+    const error = validateThemeName(answer);
+    if (error === null) {
+      return answer;
+    }
+    console.error(error);
+  }
+}
+async function promptThemeKey(rl, defaultKey) {
+  while (true) {
+    const answer = (await rl.question(`Theme key (${defaultKey}): `)).trim();
+    const key = answer.length > 0 ? answer : defaultKey;
+    const error = validateThemeKey(key);
+    if (error === null) {
+      return key;
+    }
+    console.error(error);
+  }
+}
+async function resolveThemeInitInput(name) {
+  const providedName = name?.trim();
+  if (providedName !== void 0) {
+    const nameError = validateThemeName(providedName);
+    if (nameError !== null) {
+      throw new Error(nameError);
+    }
+  }
+  const rl = createThemeInitPrompt(providedName !== void 0);
+  try {
+    const themeName = providedName ?? await promptThemeName(rl);
+    const defaultKey = slugifyThemeName(themeName);
+    return {
+      name: themeName,
+      key: await promptThemeKey(rl, defaultKey)
+    };
+  } finally {
+    rl.close();
+  }
+}
 async function initTheme(target) {
-  const key = path2.basename(target).replace(/[^a-zA-Z0-9._-]/g, "-").toLowerCase();
+  await initThemeWithKey(target, slugifyThemeName(path2.basename(target)));
+}
+async function initThemeWithKey(target, key) {
+  const themeName = path2.basename(target);
+  const nameError = validateThemeName(themeName);
+  if (nameError !== null) {
+    throw new Error(nameError);
+  }
+  const keyError = validateThemeKey(key);
+  if (keyError !== null) {
+    throw new Error(keyError);
+  }
   const cliPackageVersions = await readCliPackageVersions();
   await copyDirectory(themeTemplateRoot, target);
   const packageJson = JSON.parse(await loadThemeTemplateFile("package.json"));
@@ -1931,8 +2289,9 @@ function buildProgram() {
   const program = new Command();
   program.name("suda").description("Suda CLI for managing themes, sites, posts and AI tooling.").version("0.0.0");
   const theme = program.command("theme").description("Manage Suda theme artifacts.");
-  theme.command("init").description("Scaffold a new theme source directory.").argument("[dir]", "Theme directory to create.", "./theme").action(async (dir) => {
-    await initTheme(path2.resolve(dir));
+  theme.command("init").description("Scaffold a new theme source directory.").argument("[name]", "Theme name and directory to create. Use English letters, numbers, hyphens, or underscores.").action(async (name) => {
+    const input = await resolveThemeInitInput(name);
+    await initThemeWithKey(path2.resolve(input.name), input.key);
   });
   theme.command("validate").description("Validate a built theme artifact.").option("--theme-root <path>", "Theme source/artifact root.").action(async (options) => {
     const result = await validateTheme(resolveThemeRoot(options));