@object-ui/cli 0.3.0

package/dist/cli.js

@@ -0,0 +1,708 @@
+#!/usr/bin/env node
+import {
+  createTempApp,
+  createTempAppWithRouting,
+  init,
+  parseSchemaFile,
+  scanPagesDirectory,
+  serve
+} from "./chunk-WOV6EOMH.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk11 from "chalk";
+
+// src/commands/dev.ts
+import { createServer } from "vite";
+import react from "@vitejs/plugin-react";
+import { existsSync, mkdirSync, unlinkSync, statSync } from "fs";
+import { join, resolve, dirname } from "path";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import { createRequire } from "module";
+async function dev(schemaPath, options) {
+  const cwd = process.cwd();
+  let _projectRoot = cwd;
+  const targetSchemaPath = schemaPath;
+  let hasPagesDir = false;
+  let pagesDir = "";
+  let appConfig = null;
+  const absoluteSchemaPath = resolve(cwd, schemaPath);
+  if (existsSync(absoluteSchemaPath) && statSync(absoluteSchemaPath).isFile()) {
+    const fileDir = dirname(absoluteSchemaPath);
+    const potentialPagesDir = join(fileDir, "pages");
+    if (existsSync(potentialPagesDir)) {
+      console.log(chalk.blue(`\u{1F4C2} Detected project structure at ${fileDir}`));
+      _projectRoot = fileDir;
+      hasPagesDir = true;
+      pagesDir = potentialPagesDir;
+      try {
+        appConfig = parseSchemaFile(absoluteSchemaPath);
+        console.log(chalk.blue("\u2699\uFE0F  Loaded App Config from app.json"));
+      } catch (_e) {
+        console.warn("Failed to parse app config");
+      }
+    }
+  }
+  if (!hasPagesDir) {
+    const localPagesDir = join(cwd, "pages");
+    if (existsSync(localPagesDir)) {
+      hasPagesDir = true;
+      pagesDir = localPagesDir;
+    }
+  }
+  const require2 = createRequire(join(cwd, "package.json"));
+  let routes = [];
+  let schema = null;
+  let useFileSystemRouting = false;
+  if (hasPagesDir) {
+    console.log(chalk.blue(`\u{1F4C1} Using file-system routing from ${pagesDir}`));
+    routes = scanPagesDirectory(pagesDir);
+    useFileSystemRouting = true;
+    if (routes.length === 0) {
+      throw new Error(`No schema files found in ${pagesDir}`);
+    }
+    console.log(chalk.green(`\u2713 Found ${routes.length} route(s)`));
+    routes.forEach((route) => {
+      console.log(chalk.dim(`  ${route.path} \u2192 ${route.filePath.replace(cwd, ".")}`));
+    });
+  } else {
+    const fullSchemaPath = resolve(cwd, schemaPath);
+    if (!existsSync(fullSchemaPath)) {
+      throw new Error(`Schema file not found: ${schemaPath}
+Run 'objectui init' to create a sample schema.`);
+    }
+    console.log(chalk.blue("\u{1F4CB} Loading schema:"), chalk.cyan(schemaPath));
+    try {
+      schema = parseSchemaFile(fullSchemaPath);
+    } catch (error) {
+      throw new Error(`Invalid schema file: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  const tmpDir = join(cwd, ".objectui-tmp");
+  mkdirSync(tmpDir, { recursive: true });
+  if (useFileSystemRouting) {
+    createTempAppWithRouting(tmpDir, routes, appConfig);
+  } else {
+    createTempApp(tmpDir, schema);
+  }
+  const isMonorepo = existsSync(join(cwd, "pnpm-workspace.yaml"));
+  if (isMonorepo) {
+    console.log(chalk.blue("\u{1F4E6} Detected monorepo - using root node_modules"));
+  } else {
+    console.log(chalk.blue("\u{1F4E6} Installing dependencies..."));
+    console.log(chalk.dim("  This may take a moment on first run..."));
+    try {
+      execSync("npm install --silent --prefer-offline", {
+        cwd: tmpDir,
+        stdio: "inherit"
+      });
+      console.log(chalk.green("\u2713 Dependencies installed"));
+    } catch {
+      throw new Error("Failed to install dependencies. Please check your internet connection and try again.");
+    }
+  }
+  console.log(chalk.green("\u2713 Schema loaded successfully"));
+  console.log(chalk.blue("\u{1F680} Starting development server...\n"));
+  const viteConfig = {
+    root: tmpDir,
+    server: {
+      port: parseInt(options.port),
+      host: options.host,
+      open: options.open !== false,
+      fs: {
+        // Allow serving files from workspace root
+        allow: [cwd]
+      }
+    },
+    resolve: {
+      alias: {}
+    },
+    plugins: [react()]
+  };
+  if (isMonorepo) {
+    console.log(chalk.blue("\u{1F4E6} Detected monorepo - configuring workspace aliases"));
+    const postcssPath = join(tmpDir, "postcss.config.js");
+    if (existsSync(postcssPath)) {
+      unlinkSync(postcssPath);
+    }
+    viteConfig.resolve.alias = {
+      "@object-ui/react": join(cwd, "packages/react/src/index.ts"),
+      "@object-ui/components": join(cwd, "packages/components/src/index.ts"),
+      "@object-ui/core": join(cwd, "packages/core/src/index.ts"),
+      "@object-ui/types": join(cwd, "packages/types/src/index.ts")
+    };
+    try {
+      const lucidePath = require2.resolve("lucide-react", { paths: [join(cwd, "packages/components")] });
+      viteConfig.resolve.alias["lucide-react"] = lucidePath;
+    } catch (e) {
+      console.warn("\u26A0\uFE0F Could not resolve lucide-react automatically:", e);
+    }
+    try {
+      const tailwindcss = require2("tailwindcss");
+      const autoprefixer = require2("autoprefixer");
+      viteConfig.css = {
+        postcss: {
+          plugins: [
+            tailwindcss(join(tmpDir, "tailwind.config.js")),
+            autoprefixer()
+          ]
+        }
+      };
+    } catch (_e) {
+      console.warn(chalk.yellow("\u26A0\uFE0F Failed to load PostCSS plugins from root node_modules. Styles might not work correctly."));
+    }
+  }
+  const server = await createServer(viteConfig);
+  await server.listen();
+  const { port, host } = server.config.server;
+  const protocol = server.config.server.https ? "https" : "http";
+  const displayHost = host === "0.0.0.0" ? "localhost" : host;
+  console.log();
+  console.log(chalk.green("\u2713 Development server started successfully!"));
+  console.log();
+  console.log(chalk.bold("  Local:   ") + chalk.cyan(`${protocol}://${displayHost}:${port}`));
+  console.log();
+  console.log(chalk.dim("  Press Ctrl+C to stop the server"));
+  console.log();
+}
+
+// src/commands/build.ts
+import { build as viteBuild } from "vite";
+import react2 from "@vitejs/plugin-react";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, cpSync, rmSync } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import chalk2 from "chalk";
+import { execSync as execSync2 } from "child_process";
+async function buildApp(schemaPath, options) {
+  const cwd = process.cwd();
+  const outDir = options.outDir || "dist";
+  const outputPath = resolve2(cwd, outDir);
+  console.log(chalk2.blue("\u{1F528} Building application for production..."));
+  console.log();
+  const pagesDir = join2(cwd, "pages");
+  const hasPagesDir = existsSync2(pagesDir);
+  let routes = [];
+  let schema = null;
+  let useFileSystemRouting = false;
+  if (hasPagesDir) {
+    console.log(chalk2.blue("\u{1F4C1} Using file-system routing"));
+    routes = scanPagesDirectory(pagesDir);
+    useFileSystemRouting = true;
+    if (routes.length === 0) {
+      throw new Error("No schema files found in pages/ directory");
+    }
+    console.log(chalk2.green(`\u2713 Found ${routes.length} route(s)`));
+  } else {
+    const fullSchemaPath = resolve2(cwd, schemaPath);
+    if (!existsSync2(fullSchemaPath)) {
+      throw new Error(`Schema file not found: ${schemaPath}
+Run 'objectui init' to create a sample schema.`);
+    }
+    console.log(chalk2.blue("\u{1F4CB} Loading schema:"), chalk2.cyan(schemaPath));
+    try {
+      schema = parseSchemaFile(fullSchemaPath);
+    } catch (error) {
+      throw new Error(`Invalid schema file: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+  const tmpDir = join2(cwd, ".objectui-tmp");
+  mkdirSync2(tmpDir, { recursive: true });
+  if (useFileSystemRouting) {
+    createTempAppWithRouting(tmpDir, routes);
+  } else {
+    createTempApp(tmpDir, schema);
+  }
+  console.log(chalk2.blue("\u{1F4E6} Installing dependencies..."));
+  try {
+    execSync2("npm install --silent --prefer-offline", {
+      cwd: tmpDir,
+      stdio: "pipe"
+    });
+    console.log(chalk2.green("\u2713 Dependencies installed"));
+  } catch {
+    throw new Error("Failed to install dependencies. Please check your internet connection and try again.");
+  }
+  console.log(chalk2.blue("\u2699\uFE0F  Building with Vite..."));
+  console.log();
+  if (options.clean && existsSync2(outputPath)) {
+    console.log(chalk2.dim(`  Cleaning ${outDir}/ directory...`));
+    rmSync(outputPath, { recursive: true, force: true });
+  }
+  try {
+    await viteBuild({
+      root: tmpDir,
+      build: {
+        outDir: join2(tmpDir, "dist"),
+        emptyOutDir: true,
+        reportCompressedSize: true
+      },
+      plugins: [react2()],
+      logLevel: "info"
+    });
+    mkdirSync2(outputPath, { recursive: true });
+    cpSync(join2(tmpDir, "dist"), outputPath, { recursive: true });
+    console.log();
+    console.log(chalk2.green("\u2713 Build completed successfully!"));
+    console.log();
+    console.log(chalk2.bold("  Output: ") + chalk2.cyan(outDir + "/"));
+    console.log();
+    console.log(chalk2.dim("  To serve the production build, run:"));
+    console.log(chalk2.cyan(`  objectui start --dir ${outDir}`));
+    console.log();
+  } catch (error) {
+    throw new Error(`Build failed: ${error instanceof Error ? error.message : error}`);
+  }
+}
+
+// src/commands/start.ts
+import express from "express";
+import rateLimit from "express-rate-limit";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
+import chalk3 from "chalk";
+async function start(options) {
+  const cwd = process.cwd();
+  const distDir = options.dir || "dist";
+  const distPath = resolve3(cwd, distDir);
+  if (!existsSync3(distPath)) {
+    throw new Error(
+      `Build directory not found: ${distDir}
+Run 'objectui build' first to create a production build.`
+    );
+  }
+  const indexPath = join3(distPath, "index.html");
+  if (!existsSync3(indexPath)) {
+    throw new Error(
+      `index.html not found in ${distDir}/
+Make sure you have a valid production build.`
+    );
+  }
+  console.log(chalk3.blue("\u{1F680} Starting production server...\n"));
+  const app = express();
+  const port = parseInt(options.port);
+  const host = options.host;
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1e3,
+    // 15 minutes
+    max: 1e3,
+    // Limit each IP to 1000 requests per windowMs
+    message: "Too many requests from this IP, please try again later.",
+    standardHeaders: true,
+    // Return rate limit info in the `RateLimit-*` headers
+    legacyHeaders: false
+    // Disable the `X-RateLimit-*` headers
+  });
+  app.use(limiter);
+  app.use(express.static(distPath));
+  app.get("*", (req, res) => {
+    res.sendFile(indexPath);
+  });
+  app.listen(port, host, () => {
+    const protocol = "http";
+    const displayHost = host === "0.0.0.0" ? "localhost" : host;
+    console.log(chalk3.green("\u2713 Production server started successfully!"));
+    console.log();
+    console.log(chalk3.bold("  Local:   ") + chalk3.cyan(`${protocol}://${displayHost}:${port}`));
+    console.log(chalk3.bold("  Serving: ") + chalk3.dim(distDir + "/"));
+    console.log();
+    console.log(chalk3.dim("  Press Ctrl+C to stop the server"));
+    console.log();
+  });
+}
+
+// src/commands/lint.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import chalk4 from "chalk";
+async function lint(options) {
+  const cwd = process.cwd();
+  console.log(chalk4.blue("\u{1F50D} Running linter...\n"));
+  const tmpDir = join4(cwd, ".objectui-tmp");
+  const hasTempApp = existsSync4(tmpDir);
+  if (!hasTempApp) {
+    throw new Error(
+      "No Object UI application found. Run 'objectui dev' first to generate the application."
+    );
+  }
+  const packageJsonPath = join4(tmpDir, "package.json");
+  const nodeModulesPath = join4(tmpDir, "node_modules");
+  if (!existsSync4(packageJsonPath) || !existsSync4(nodeModulesPath)) {
+    throw new Error(
+      "Dependencies not installed. Run 'objectui dev' first to set up the application."
+    );
+  }
+  try {
+    const fixFlag = options.fix ? "--fix" : "";
+    const command = `npx eslint "src/**/*.{js,jsx,ts,tsx}" ${fixFlag}`.trim();
+    console.log(chalk4.dim(`  Running: ${command}
+`));
+    execSync3(command, {
+      cwd: tmpDir,
+      stdio: "inherit"
+    });
+    console.log();
+    console.log(chalk4.green("\u2713 Linting completed successfully!"));
+    console.log();
+  } catch {
+    console.log();
+    console.log(chalk4.yellow("\u26A0 Linting found issues."));
+    if (!options.fix) {
+      console.log(chalk4.dim("  Run 'objectui lint --fix' to automatically fix some issues."));
+    }
+    console.log();
+    process.exit(1);
+  }
+}
+
+// src/commands/test.ts
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import chalk5 from "chalk";
+async function test(options) {
+  const cwd = process.cwd();
+  console.log(chalk5.blue("\u{1F9EA} Running tests...\n"));
+  const tmpDir = join5(cwd, ".objectui-tmp");
+  const hasTempApp = existsSync5(tmpDir);
+  if (!hasTempApp) {
+    throw new Error(
+      "No Object UI application found. Run 'objectui dev' first to generate the application."
+    );
+  }
+  const packageJsonPath = join5(tmpDir, "package.json");
+  const nodeModulesPath = join5(tmpDir, "node_modules");
+  if (!existsSync5(packageJsonPath) || !existsSync5(nodeModulesPath)) {
+    throw new Error(
+      "Dependencies not installed. Run 'objectui dev' first to set up the application."
+    );
+  }
+  try {
+    let command = "npx vitest";
+    if (options.watch) {
+      command += " --watch";
+    } else if (options.ui) {
+      command += " --ui";
+    } else {
+      command += " run";
+    }
+    if (options.coverage) {
+      command += " --coverage";
+    }
+    console.log(chalk5.dim(`  Running: ${command}
+`));
+    execSync4(command, {
+      cwd: tmpDir,
+      stdio: "inherit"
+    });
+    if (!options.watch && !options.ui) {
+      console.log();
+      console.log(chalk5.green("\u2713 Tests completed successfully!"));
+      console.log();
+    }
+  } catch {
+    console.log();
+    console.log(chalk5.red("\u2717 Some tests failed."));
+    console.log();
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+import chalk6 from "chalk";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync } from "fs";
+import { join as join6 } from "path";
+async function generate(type, name) {
+  const cwd = process.cwd();
+  switch (type) {
+    case "resource":
+    case "object":
+      generateResource(cwd, name);
+      break;
+    case "page":
+      generatePage(cwd, name);
+      break;
+    case "plugin":
+      generatePlugin(cwd, name);
+      break;
+    default:
+      console.log(chalk6.red(`Unknown type: ${type}`));
+      console.log(`Available types: resource, page, plugin`);
+      process.exit(1);
+  }
+}
+function generateResource(cwd, name) {
+  const dir = join6(cwd, "objects");
+  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  const fileName = `${name.toLowerCase()}.json`;
+  const filePath = join6(dir, fileName);
+  if (existsSync6(filePath)) {
+    console.log(chalk6.yellow(`Object ${name} already exists at ${filePath}`));
+    return;
+  }
+  const content = {
+    name,
+    fields: {
+      name: { type: "text", label: "Name", required: true }
+    }
+  };
+  writeFileSync(filePath, JSON.stringify(content, null, 2));
+  console.log(chalk6.green(`\u2713 Generated resource schema: ${filePath}`));
+}
+function generatePage(cwd, name) {
+  const dir = join6(cwd, "pages");
+  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  const fileName = `${name.toLowerCase()}.json`;
+  const filePath = join6(dir, fileName);
+  if (existsSync6(filePath)) {
+    console.log(chalk6.yellow(`Page ${name} already exists at ${filePath}`));
+    return;
+  }
+  const content = {
+    type: "page",
+    title: name,
+    body: [
+      {
+        type: "markdown",
+        content: `# Welcome to ${name}`
+      }
+    ]
+  };
+  writeFileSync(filePath, JSON.stringify(content, null, 2));
+  console.log(chalk6.green(`\u2713 Generated page schema: ${filePath}`));
+}
+function generatePlugin(cwd, name) {
+  const dir = join6(cwd, "plugins", name);
+  if (existsSync6(dir)) {
+    console.log(chalk6.yellow(`Plugin ${name} already exists`));
+    return;
+  }
+  mkdirSync3(dir, { recursive: true });
+  const content = `
+export const ${name}Plugin = {
+  name: '${name}',
+  install(app) {
+    console.log('${name} plugin installed');
+  }
+};
+`;
+  writeFileSync(join6(dir, "index.ts"), content.trim());
+  console.log(chalk6.green(`\u2713 Generated plugin: ${dir}`));
+}
+
+// src/commands/doctor.ts
+import chalk7 from "chalk";
+import { existsSync as existsSync7, readFileSync } from "fs";
+import { join as join7 } from "path";
+async function doctor() {
+  console.log(chalk7.bold("Object UI Doctor"));
+  console.log("Diagnosis in progress...\n");
+  const cwd = process.cwd();
+  let issues = 0;
+  const pkgPath = join7(cwd, "package.json");
+  if (existsSync7(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const reactVer = pkg.dependencies?.react || pkg.devDependencies?.react;
+      if (reactVer) {
+        console.log(chalk7.green("\u2713 React installed"));
+      } else {
+        console.log(chalk7.yellow("\u26A0\uFE0F React not found in dependencies"));
+        issues++;
+      }
+      const tailwindVer = pkg.dependencies?.tailwindcss || pkg.devDependencies?.tailwindcss;
+      if (tailwindVer) {
+        console.log(chalk7.green("\u2713 Tailwind CSS installed"));
+      } else {
+        console.log(chalk7.yellow("\u26A0\uFE0F Tailwind CSS not found"));
+        issues++;
+      }
+    } catch (e) {
+      console.log(chalk7.red("x Failed to read package.json"));
+      issues++;
+    }
+  } else {
+    console.log(chalk7.red("x package.json not found"));
+    issues++;
+  }
+  const tailwindConfigPath = join7(cwd, "tailwind.config.js");
+  if (existsSync7(tailwindConfigPath)) {
+    console.log(chalk7.green("\u2713 tailwind.config.js found"));
+  } else {
+    console.log(chalk7.yellow("\u26A0\uFE0F tailwind.config.js not found"));
+    issues++;
+  }
+  console.log("\nResult:");
+  if (issues === 0) {
+    console.log(chalk7.green("Everything looks good! \u2728"));
+  } else {
+    console.log(chalk7.yellow(`Found ${issues} issue(s).`));
+  }
+}
+
+// src/commands/add.ts
+import chalk8 from "chalk";
+async function add(component) {
+  console.log(chalk8.bold(`Object UI Add: ${component}`));
+  console.log(chalk8.yellow("Feature not implemented yet."));
+  console.log(`This command will download the source code for ${component}Renderer to your project.`);
+}
+
+// src/commands/studio.ts
+import chalk9 from "chalk";
+async function studio() {
+  console.log(chalk9.bold("Starting Object UI Studio..."));
+  console.log(chalk9.yellow("Studio mode is experimental."));
+}
+
+// src/commands/check.ts
+import chalk10 from "chalk";
+import { globSync } from "glob";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join8 } from "path";
+async function check() {
+  console.log(chalk10.bold("Object UI Schema Check"));
+  const cwd = process.cwd();
+  const files = globSync("**/*.{json,yaml,yml}", {
+    cwd,
+    ignore: ["node_modules/**", "dist/**", ".git/**"]
+  });
+  console.log(`Analyzing ${files.length} files...`);
+  let errors = 0;
+  for (const file of files) {
+    try {
+      if (file.endsWith(".json")) {
+        JSON.parse(readFileSync2(join8(cwd, file), "utf-8"));
+      }
+    } catch (e) {
+      console.log(chalk10.red(`x Invalid JSON in ${file}: ${e.message}`));
+      errors++;
+    }
+  }
+  if (errors === 0) {
+    console.log(chalk10.green("\u2713 All checks passed"));
+  } else {
+    console.log(chalk10.red(`Found ${errors} errors`));
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join9 } from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+var packageJson = JSON.parse(
+  readFileSync3(join9(__dirname, "../package.json"), "utf-8")
+);
+var program = new Command();
+program.name("objectui").description("CLI tool for Object UI - Build applications from JSON schemas").version(packageJson.version);
+program.command("serve").description("Start a development server with your JSON/YAML schema").argument("[schema]", "Path to JSON/YAML schema file", "app.json").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "localhost").action(async (schema, options) => {
+  try {
+    await serve(schema, options);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("dev").description("Start development server (alias for serve)").argument("[schema]", "Path to JSON/YAML schema file", "app.json").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "localhost").option("--no-open", "Do not open browser automatically").action(async (schema, options) => {
+  try {
+    await dev(schema, options);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("build").description("Build application for production").argument("[schema]", "Path to JSON/YAML schema file", "app.json").option("-o, --out-dir <dir>", "Output directory", "dist").option("--clean", "Clean output directory before build", false).action(async (schema, options) => {
+  try {
+    await buildApp(schema, options);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("start").description("Start production server").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "0.0.0.0").option("-d, --dir <dir>", "Directory to serve", "dist").action(async (options) => {
+  try {
+    await start(options);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("init").description("\u521D\u59CB\u5316\u65B0\u7684Object UI\u5E94\u7528 / Initialize a new Object UI application with sample schema").argument("[name]", "\u5E94\u7528\u540D\u79F0 / Application name", "my-app").option("-t, --template <template>", "\u4F7F\u7528\u7684\u6A21\u677F / Template to use (dashboard, form, simple)", "dashboard").action(async (name, options) => {
+  try {
+    await init(name, options);
+  } catch (error) {
+    console.error(chalk11.red("\u9519\u8BEF Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("lint").description("Lint the generated application code").option("--fix", "Automatically fix linting issues").action(async (options) => {
+  try {
+    await lint(options);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("test").description("Run tests for the application").option("-w, --watch", "Run tests in watch mode").option("-c, --coverage", "Generate test coverage report").option("--ui", "Run tests with Vitest UI").action(async (options) => {
+  try {
+    await test(options);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("generate").alias("g").description("Generate new resources (objects, pages, plugins)").argument("<type>", "Type of resource to generate (resource/object, page, plugin)").argument("<name>", "Name of the resource").action(async (type, name) => {
+  try {
+    await generate(type, name);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("doctor").description("Diagnose and fix common issues").action(async () => {
+  try {
+    await doctor();
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("add").description("Add a new component renderer to your project").argument("<component>", "Component name (e.g. Input, Grid)").action(async (component) => {
+  try {
+    await add(component);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("studio").description("Start the visual designer").action(async () => {
+  try {
+    await studio();
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("check").description("Validate schema files").action(async () => {
+  try {
+    await check();
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("showcase").description("Start the built-in showcase example").option("-p, --port <port>", "Port to run the server on", "3000").option("-h, --host <host>", "Host to bind the server to", "localhost").option("--no-open", "Do not open browser automatically").action(async (options) => {
+  try {
+    const showcaseSchema = join9(__dirname, "../../..", "examples", "showcase", "app.json");
+    await dev(showcaseSchema, options);
+  } catch (error) {
+    console.error(chalk11.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map