@micropress/theme-sdk 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,714 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// cli/commands/build.ts
+var build_exports = {};
+__export(build_exports, {
+  buildCommand: () => buildCommand
+});
+async function buildCommand(options) {
+  const cwd = process.cwd();
+  const outputDir = path2.resolve(cwd, options.output);
+  console.log("Building theme...");
+  console.log(`Output: ${outputDir}`);
+  console.log();
+  const manifestPath = path2.join(cwd, "manifest.json");
+  const tsconfigPath = path2.join(cwd, "tsconfig.json");
+  if (!fs2.existsSync(manifestPath)) {
+    console.error("Error: manifest.json not found");
+    console.error("Run this command from your theme directory");
+    process.exit(1);
+  }
+  if (!fs2.existsSync(outputDir)) {
+    fs2.mkdirSync(outputDir, { recursive: true });
+  }
+  fs2.copyFileSync(manifestPath, path2.join(outputDir, "manifest.json"));
+  console.log("  Copied: manifest.json");
+  const srcDir = path2.join(cwd, "src");
+  if (fs2.existsSync(srcDir)) {
+    const cssFiles = findFiles(srcDir, ".css");
+    for (const cssFile of cssFiles) {
+      const relativePath = path2.relative(srcDir, cssFile);
+      const destPath = path2.join(outputDir, relativePath);
+      const destDir = path2.dirname(destPath);
+      if (!fs2.existsSync(destDir)) {
+        fs2.mkdirSync(destDir, { recursive: true });
+      }
+      fs2.copyFileSync(cssFile, destPath);
+      console.log(`  Copied: ${relativePath}`);
+    }
+  }
+  const assetsDir = path2.join(cwd, "assets");
+  if (fs2.existsSync(assetsDir)) {
+    const destAssetsDir = path2.join(outputDir, "assets");
+    copyDirectory(assetsDir, destAssetsDir);
+    console.log("  Copied: assets/");
+  }
+  if (fs2.existsSync(tsconfigPath)) {
+    console.log("  Compiling TypeScript...");
+    try {
+      (0, import_child_process2.execSync)(`npx tsc --outDir "${outputDir}"`, { cwd, stdio: "pipe" });
+      console.log("  TypeScript compiled successfully");
+    } catch (error) {
+      const err = error;
+      if (err.stderr) {
+        console.error("TypeScript compilation failed:");
+        console.error(err.stderr.toString());
+      }
+      process.exit(1);
+    }
+  } else {
+    const jsFiles = findFiles(srcDir, ".js");
+    for (const jsFile of jsFiles) {
+      const relativePath = path2.relative(srcDir, jsFile);
+      const destPath = path2.join(outputDir, relativePath);
+      const destDir = path2.dirname(destPath);
+      if (!fs2.existsSync(destDir)) {
+        fs2.mkdirSync(destDir, { recursive: true });
+      }
+      fs2.copyFileSync(jsFile, destPath);
+      console.log(`  Copied: ${relativePath}`);
+    }
+  }
+  console.log();
+  console.log("Build complete!");
+  if (options.watch) {
+    console.log();
+    console.log("Watching for changes... (press Ctrl+C to stop)");
+    watchDirectory(cwd, async () => {
+      console.log();
+      console.log("Changes detected, rebuilding...");
+      await buildCommand({ ...options, watch: false });
+    });
+  }
+}
+function findFiles(dir, extension) {
+  const files = [];
+  if (!fs2.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findFiles(fullPath, extension));
+    } else if (entry.name.endsWith(extension)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function copyDirectory(src, dest) {
+  if (!fs2.existsSync(dest)) {
+    fs2.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs2.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs2.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function watchDirectory(dir, callback) {
+  const watchDirs = ["src", "assets"];
+  let debounceTimer = null;
+  const debouncedCallback = () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(callback, 100);
+  };
+  for (const watchDir of watchDirs) {
+    const fullPath = path2.join(dir, watchDir);
+    if (fs2.existsSync(fullPath)) {
+      fs2.watch(fullPath, { recursive: true }, debouncedCallback);
+    }
+  }
+  const manifestPath = path2.join(dir, "manifest.json");
+  if (fs2.existsSync(manifestPath)) {
+    fs2.watch(manifestPath, debouncedCallback);
+  }
+}
+var fs2, path2, import_child_process2;
+var init_build = __esm({
+  "cli/commands/build.ts"() {
+    "use strict";
+    fs2 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
+    import_child_process2 = require("child_process");
+  }
+});
+
+// cli/index.ts
+var import_commander = require("commander");
+
+// cli/commands/init.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_child_process = require("child_process");
+var MANIFEST_TEMPLATE = `{
+  "id": "{{name}}",
+  "name": "{{displayName}}",
+  "version": "1.0.0",
+  "description": "A custom MicroPress theme",
+  "author": "Your Name",
+  "homepage": "",
+  "breakpoints": {
+    "sm": "640px",
+    "md": "768px",
+    "lg": "1024px",
+    "xl": "1280px"
+  },
+  "customizable": {
+    "primaryColor": {
+      "type": "color",
+      "label": "Primary Color",
+      "default": "#3b82f6"
+    },
+    "fontFamily": {
+      "type": "select",
+      "label": "Font Family",
+      "default": "system-ui",
+      "options": ["system-ui", "Georgia", "Helvetica"]
+    }
+  }
+}`;
+var THEME_CSS_TEMPLATE = `/* {{displayName}} - Main Styles */
+
+:root {
+  --primary: var(--theme-primaryColor, #3b82f6);
+  --font-family: var(--theme-fontFamily, system-ui);
+}
+
+/* Base styles */
+body {
+  font-family: var(--font-family), sans-serif;
+  line-height: 1.6;
+  color: #1f2937;
+}
+
+/* Header */
+.theme-header {
+  padding: 1rem 2rem;
+  border-bottom: 1px solid #e5e7eb;
+}
+
+.theme-header__brand {
+  font-weight: 600;
+  font-size: 1.25rem;
+  text-decoration: none;
+  color: inherit;
+}
+
+/* Navigation */
+.theme-nav {
+  padding: 0.5rem 2rem;
+}
+
+.theme-nav__list {
+  display: flex;
+  gap: 1.5rem;
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+.theme-nav__link {
+  color: #6b7280;
+  text-decoration: none;
+  transition: color 0.2s;
+}
+
+.theme-nav__link:hover,
+.theme-nav__link.is-active {
+  color: var(--primary);
+}
+
+/* Main content */
+.theme-content {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+
+/* Footer */
+.theme-footer {
+  padding: 2rem;
+  background: #f9fafb;
+  text-align: center;
+  color: #6b7280;
+  font-size: 0.875rem;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+  .theme-nav__list {
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+}
+`;
+var RENDERERS_TEMPLATE = `import { defineTheme, html, css, raw, when } from '@micropress/theme-sdk';
+import type { HeaderDTO, NavigationDTO, FooterDTO } from '@micropress/theme-sdk';
+
+export default defineTheme({
+  config: {
+    id: '{{name}}',
+    name: '{{displayName}}',
+    version: '1.0.0',
+  },
+
+  renderers: {
+    // Custom header renderer
+    header: {
+      render: (data: HeaderDTO) => html\`
+        <header class="theme-header">
+          <a href="/" class="theme-header__brand">
+            \${data.logo
+              ? html\`<img src="\${data.logo.src}" alt="\${data.logo.alt}" />\`
+              : html\`<span>\${data.siteName}</span>\`
+            }
+          </a>
+          \${when(data.showMenuToggle, html\`
+            <button class="theme-header__toggle" aria-label="Toggle menu">
+              <span></span>
+            </button>
+          \`)}
+        </header>
+      \`.html,
+    },
+
+    // Custom navigation renderer
+    navigation: {
+      render: (data: NavigationDTO) => html\`
+        <nav class="theme-nav">
+          <ul class="theme-nav__list">
+            \${raw(data.items.map(item => html\`
+              <li class="theme-nav__item">
+                <a
+                  href="\${item.href}"
+                  class="theme-nav__link \${item.active ? 'is-active' : ''}"
+                >
+                  \${item.label}
+                </a>
+              </li>
+            \`.html).join(''))}
+          </ul>
+        </nav>
+      \`.html,
+    },
+
+    // Custom footer renderer
+    footer: {
+      render: (data: FooterDTO) => html\`
+        <footer class="theme-footer">
+          <p>&copy; \${data.year} \${data.copyright}</p>
+          \${when(data.links.length > 0, html\`
+            <nav>
+              \${raw(data.links.map(link => html\`
+                <a href="\${link.href}">\${link.label}</a>
+              \`.html).join(' \xB7 '))}
+            </nav>
+          \`)}
+        </footer>
+      \`.html,
+    },
+  },
+});
+`;
+var PACKAGE_JSON_TEMPLATE = `{
+  "name": "{{name}}",
+  "version": "1.0.0",
+  "description": "A custom MicroPress theme",
+  "main": "dist/renderers.js",
+  "types": "dist/renderers.d.ts",
+  "scripts": {
+    "build": "micropress-theme build",
+    "validate": "micropress-theme validate",
+    "package": "micropress-theme package"
+  },
+  "devDependencies": {
+    "@micropress/theme-sdk": "^1.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": ["micropress", "theme"],
+  "license": "MIT"
+}`;
+var TSCONFIG_TEMPLATE = `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}`;
+var GITIGNORE_TEMPLATE = `node_modules/
+dist/
+*.zip
+.DS_Store
+`;
+function toDisplayName(name) {
+  return name.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function replaceTemplateVars(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] || "");
+}
+async function initCommand(name, options) {
+  const targetDir = path.resolve(options.directory === "." ? name : path.join(options.directory, name));
+  console.log(`Creating theme: ${name}`);
+  console.log(`Location: ${targetDir}`);
+  console.log();
+  if (fs.existsSync(targetDir)) {
+    console.error(`Error: Directory already exists: ${targetDir}`);
+    process.exit(1);
+  }
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.mkdirSync(path.join(targetDir, "src"));
+  fs.mkdirSync(path.join(targetDir, "assets"));
+  const vars = {
+    name,
+    displayName: toDisplayName(name)
+  };
+  const files = [
+    { path: "manifest.json", content: replaceTemplateVars(MANIFEST_TEMPLATE, vars) },
+    { path: "src/theme.css", content: replaceTemplateVars(THEME_CSS_TEMPLATE, vars) },
+    { path: "src/renderers.ts", content: replaceTemplateVars(RENDERERS_TEMPLATE, vars) },
+    { path: "package.json", content: replaceTemplateVars(PACKAGE_JSON_TEMPLATE, vars) },
+    { path: "tsconfig.json", content: TSCONFIG_TEMPLATE },
+    { path: ".gitignore", content: GITIGNORE_TEMPLATE }
+  ];
+  for (const file of files) {
+    const filePath = path.join(targetDir, file.path);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, file.content);
+    console.log(`  Created: ${file.path}`);
+  }
+  if (options.git) {
+    try {
+      (0, import_child_process.execSync)("git init", { cwd: targetDir, stdio: "ignore" });
+      console.log("  Initialized git repository");
+    } catch {
+      console.log("  Warning: Could not initialize git repository");
+    }
+  }
+  console.log();
+  console.log("Theme created successfully!");
+  console.log();
+  console.log("Next steps:");
+  console.log(`  cd ${name}`);
+  console.log("  npm install");
+  console.log("  npm run build");
+  console.log();
+}
+
+// cli/index.ts
+init_build();
+
+// cli/commands/validate.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+async function validateCommand(options) {
+  const cwd = process.cwd();
+  console.log("Validating theme...");
+  console.log();
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  const manifestPath = path3.join(cwd, "manifest.json");
+  if (!fs3.existsSync(manifestPath)) {
+    result.errors.push("manifest.json not found");
+    result.valid = false;
+  } else {
+    const manifestResult = validateManifest(manifestPath, options.fix);
+    result.errors.push(...manifestResult.errors);
+    result.warnings.push(...manifestResult.warnings);
+    if (!manifestResult.valid) {
+      result.valid = false;
+    }
+  }
+  const srcDir = path3.join(cwd, "src");
+  if (!fs3.existsSync(srcDir)) {
+    result.errors.push("src/ directory not found");
+    result.valid = false;
+  }
+  const cssFiles = findFiles2(srcDir, ".css");
+  if (cssFiles.length === 0) {
+    result.warnings.push("No CSS files found in src/");
+  }
+  const renderersTs = path3.join(srcDir, "renderers.ts");
+  const renderersJs = path3.join(srcDir, "renderers.js");
+  if (!fs3.existsSync(renderersTs) && !fs3.existsSync(renderersJs)) {
+    result.warnings.push("No renderers.ts or renderers.js found in src/");
+  }
+  const packagePath = path3.join(cwd, "package.json");
+  if (!fs3.existsSync(packagePath)) {
+    result.warnings.push("package.json not found");
+  } else {
+    const packageResult = validatePackageJson(packagePath);
+    result.warnings.push(...packageResult.warnings);
+  }
+  if (result.errors.length > 0) {
+    console.log("Errors:");
+    for (const error of result.errors) {
+      console.log(`  \x1B[31m\u2717\x1B[0m ${error}`);
+    }
+    console.log();
+  }
+  if (result.warnings.length > 0) {
+    console.log("Warnings:");
+    for (const warning of result.warnings) {
+      console.log(`  \x1B[33m!\x1B[0m ${warning}`);
+    }
+    console.log();
+  }
+  if (result.valid && result.errors.length === 0) {
+    console.log("\x1B[32m\u2713\x1B[0m Theme is valid!");
+    if (result.warnings.length > 0) {
+      console.log(`  (${result.warnings.length} warning${result.warnings.length === 1 ? "" : "s"})`);
+    }
+  } else {
+    console.log("\x1B[31m\u2717\x1B[0m Theme validation failed");
+    process.exit(1);
+  }
+}
+function validateManifest(manifestPath, fix) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  let manifest;
+  try {
+    const content = fs3.readFileSync(manifestPath, "utf-8");
+    manifest = JSON.parse(content);
+  } catch (error) {
+    result.errors.push(`Invalid JSON in manifest.json: ${error.message}`);
+    result.valid = false;
+    return result;
+  }
+  const requiredFields = ["id", "name", "version", "description", "author"];
+  for (const field of requiredFields) {
+    if (!manifest[field]) {
+      result.errors.push(`Missing required field in manifest.json: ${field}`);
+      result.valid = false;
+    }
+  }
+  if (manifest.id && !/^[a-z][a-z0-9-]*$/.test(manifest.id)) {
+    result.errors.push("Invalid theme ID: must start with a letter and contain only lowercase letters, numbers, and hyphens");
+    result.valid = false;
+  }
+  if (manifest.version && !/^\d+\.\d+\.\d+(-[a-z0-9.]+)?$/.test(manifest.version)) {
+    result.warnings.push("Version should follow semver format (e.g., 1.0.0)");
+  }
+  if (manifest.customizable) {
+    for (const [key, field] of Object.entries(manifest.customizable)) {
+      if (!field.type) {
+        result.errors.push(`Missing type for customizable field: ${key}`);
+        result.valid = false;
+      } else if (!["color", "font", "size", "select"].includes(field.type)) {
+        result.errors.push(`Invalid type for customizable field ${key}: ${field.type}`);
+        result.valid = false;
+      }
+      if (!field.label) {
+        result.warnings.push(`Missing label for customizable field: ${key}`);
+      }
+      if (field.default === void 0) {
+        result.warnings.push(`Missing default value for customizable field: ${key}`);
+      }
+      if (field.type === "select" && (!field.options || field.options.length === 0)) {
+        result.errors.push(`Select field ${key} must have options array`);
+        result.valid = false;
+      }
+    }
+  }
+  return result;
+}
+function validatePackageJson(packagePath) {
+  const result = {
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  try {
+    const content = fs3.readFileSync(packagePath, "utf-8");
+    const pkg = JSON.parse(content);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (!deps["@micropress/theme-sdk"]) {
+      result.warnings.push("@micropress/theme-sdk not found in dependencies");
+    }
+  } catch (error) {
+    result.warnings.push(`Could not parse package.json: ${error.message}`);
+  }
+  return result;
+}
+function findFiles2(dir, extension) {
+  const files = [];
+  if (!fs3.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findFiles2(fullPath, extension));
+    } else if (entry.name.endsWith(extension)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+// cli/commands/package.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+async function packageCommand(options) {
+  const cwd = process.cwd();
+  console.log("Packaging theme...");
+  console.log();
+  const manifestPath = path4.join(cwd, "manifest.json");
+  if (!fs4.existsSync(manifestPath)) {
+    console.error("Error: manifest.json not found");
+    console.error("Run this command from your theme directory");
+    process.exit(1);
+  }
+  let manifest;
+  try {
+    const content = fs4.readFileSync(manifestPath, "utf-8");
+    manifest = JSON.parse(content);
+  } catch (error) {
+    console.error("Error: Invalid manifest.json");
+    process.exit(1);
+  }
+  if (!manifest.id || !manifest.version) {
+    console.error("Error: manifest.json must have id and version fields");
+    process.exit(1);
+  }
+  const distDir = path4.join(cwd, "dist");
+  if (!fs4.existsSync(distDir)) {
+    console.log("Build directory not found. Running build first...");
+    console.log();
+    try {
+      const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+      await buildCommand2({ watch: false, output: "dist" });
+      console.log();
+    } catch (error) {
+      console.error("Build failed");
+      process.exit(1);
+    }
+  }
+  const requiredFiles = ["manifest.json"];
+  for (const file of requiredFiles) {
+    if (!fs4.existsSync(path4.join(distDir, file))) {
+      console.error(`Error: ${file} not found in dist/`);
+      console.error("Please run build first");
+      process.exit(1);
+    }
+  }
+  const outputFile = options.output || `${manifest.id}-${manifest.version}.zip`;
+  const outputPath = path4.resolve(cwd, outputFile);
+  console.log(`Creating: ${outputFile}`);
+  try {
+    const files = getAllFiles(distDir);
+    const fileList = files.map((f) => path4.relative(distDir, f)).join(" ");
+    (0, import_child_process3.execSync)(`zip -r "${outputPath}" ${fileList}`, {
+      cwd: distDir,
+      stdio: "pipe"
+    });
+  } catch {
+    console.log("Native zip not available, creating package manually...");
+    createZipManually(distDir, outputPath);
+  }
+  const stats = fs4.statSync(outputPath);
+  const sizeKB = (stats.size / 1024).toFixed(1);
+  console.log();
+  console.log(`\x1B[32m\u2713\x1B[0m Package created: ${outputFile} (${sizeKB} KB)`);
+  console.log();
+  console.log("Upload this file to MicroPress to install your theme.");
+}
+function getAllFiles(dir) {
+  const files = [];
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...getAllFiles(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function createZipManually(sourceDir, outputPath) {
+  try {
+    (0, import_child_process3.execSync)(`tar -czf "${outputPath.replace(".zip", ".tar.gz")}" -C "${sourceDir}" .`, {
+      stdio: "pipe"
+    });
+    console.log("Note: Created tar.gz instead of zip (zip command not available)");
+    fs4.renameSync(outputPath.replace(".zip", ".tar.gz"), outputPath);
+  } catch (error) {
+    const files = getAllFiles(sourceDir);
+    const listing = files.map((f) => path4.relative(sourceDir, f)).join("\n");
+    fs4.writeFileSync(outputPath.replace(".zip", ".txt"), listing);
+    console.error("Warning: Could not create archive. Created file listing instead.");
+    console.error("Please install zip or tar to create proper packages.");
+  }
+}
+
+// cli/index.ts
+var VERSION = "0.0.1";
+var program = new import_commander.Command();
+program.name("micropress-theme").description("CLI for building MicroPress themes").version(VERSION);
+program.command("init <name>").description("Initialize a new theme project").option("-d, --directory <dir>", "Directory to create theme in", ".").option("--no-git", "Skip git initialization").action(initCommand);
+program.command("build").description("Build the theme for distribution").option("-w, --watch", "Watch for changes").option("-o, --output <dir>", "Output directory", "dist").action(buildCommand);
+program.command("validate").description("Validate theme structure and manifest").option("--fix", "Attempt to fix simple issues").action(validateCommand);
+program.command("package").description("Create a distributable ZIP file").option("-o, --output <file>", "Output file path").action(packageCommand);
+program.parse();
+//# sourceMappingURL=index.js.map