@wsxjs/cli 0.0.18

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WSXJS Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# @wsxjs/cli
+
+CLI tool for WSXJS initialization and configuration with beautiful Ink-based UI.
+
+## Installation
+
+```bash
+npm install -D @wsxjs/cli
+```
+
+## Usage
+
+### Initialize WSXJS
+
+```bash
+npx wsx init
+```
+
+This command will interactively guide you through setting up WSXJS in your project:
+
+- ✅ Configure TypeScript (`tsconfig.json`)
+- ✅ Configure Vite (`vite.config.ts`)
+- ✅ Generate `wsx.d.ts` type declarations
+- ✅ Configure ESLint with WSX rules
+
+The CLI uses [Ink](https://github.com/vadimdemedes/ink) to provide a beautiful, interactive terminal UI with real-time progress updates.
+
+### Check Configuration
+
+```bash
+npx wsx check
+```
+
+Check your current WSXJS configuration and get suggestions for improvements.
+
+## Commands
+
+### `wsx init`
+
+Initialize WSXJS in your project with an interactive setup wizard.
+
+**Options:**
+- `--skip-tsconfig`: Skip TypeScript configuration
+- `--skip-vite`: Skip Vite configuration
+- `--skip-eslint`: Skip ESLint configuration
+- `--skip-types`: Skip `wsx.d.ts` generation
+- `--use-tsconfig-package`: Use `@wsxjs/wsx-tsconfig` package
+- `--use-decorators`: Enable decorator support (`@state`)
+- `--no-interactive`: Skip interactive prompts (use command-line options only)
+
+**Examples:**
+
+```bash
+# Full interactive setup
+npx wsx init
+
+# Skip TypeScript config
+npx wsx init --skip-tsconfig
+
+# Use @wsxjs/wsx-tsconfig package
+npx wsx init --use-tsconfig-package
+
+# Non-interactive mode
+npx wsx init --skip-types --skip-eslint --no-interactive
+```
+
+### `wsx check`
+
+Check your WSXJS configuration and display any issues or suggestions.
+
+**Example:**
+
+```bash
+npx wsx check
+```
+
+Output:
+```
+🔍 WSX Configuration Check
+
+Status:
+  wsx.d.ts: ✓ Found
+  tsconfig.json: ✓ Valid
+  vite.config: ✓ Valid
+
+✅ All checks passed! Your WSX configuration looks good.
+```
+
+## Features
+
+### 🎨 Beautiful Terminal UI
+
+The CLI uses [Ink](https://github.com/vadimdemedes/ink) to provide a React-based terminal UI with:
+- Real-time progress indicators
+- Spinner animations
+- Color-coded status messages
+- Step-by-step progress tracking
+
+### ⚙️ Smart Configuration
+
+- **TypeScript**: Automatically configures `tsconfig.json` with WSX-compatible settings
+- **Vite**: Adds `@wsxjs/wsx-vite-plugin` to your Vite configuration
+- **ESLint**: Configures ESLint with WSX-specific rules
+- **Type Declarations**: Generates `wsx.d.ts` for `.wsx` file type support
+
+### 🔍 Configuration Validation
+
+The `check` command validates your setup and provides:
+- Issue detection
+- Actionable suggestions
+- Configuration status overview
+
+## Examples
+
+### Basic Setup
+
+```bash
+# Install WSXJS packages
+npm install @wsxjs/wsx-core @wsxjs/wsx-vite-plugin
+
+# Install CLI tool
+npm install -D @wsxjs/cli
+
+# Initialize with interactive UI
+npx wsx init
+```
+
+### Advanced Setup
+
+```bash
+# Use @wsxjs/wsx-tsconfig package
+npx wsx init --use-tsconfig-package --use-decorators
+
+# Skip certain configurations
+npx wsx init --skip-vite --skip-eslint
+
+# Non-interactive mode
+npx wsx init --no-interactive --use-decorators
+```
+
+## Architecture
+
+The CLI is built with:
+- **[Commander.js](https://github.com/tj/commander.js)**: Command-line interface
+- **[Ink](https://github.com/vadimdemedes/ink)**: React for CLI apps
+- **[Inquirer](https://github.com/SBoudrias/Inquirer.js)**: Interactive prompts
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,892 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync4, mkdirSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+import React2 from "react";
+import { render } from "ink";
+import inquirer from "inquirer";
+
+// src/ui/InitUI.tsx
+import { useState, useEffect, useRef } from "react";
+import { Box, Text, Newline } from "ink";
+import Spinner from "ink-spinner";
+import { jsx, jsxs } from "react/jsx-runtime";
+var InitUI = ({ onComplete, configSteps }) => {
+  const [steps, setSteps] = useState(
+    configSteps.map((step) => ({
+      name: step.name,
+      status: step.skip ? "skipped" : "pending",
+      message: step.skip ? "\u5DF2\u8DF3\u8FC7" : void 0
+    }))
+  );
+  const [allComplete, setAllComplete] = useState(false);
+  const executingRef = useRef(false);
+  useEffect(() => {
+    const allSkipped = steps.every((s) => s.status === "skipped");
+    if (allSkipped) {
+      setAllComplete(true);
+      setTimeout(() => onComplete(), 1e3);
+      return;
+    }
+    if (executingRef.current) {
+      return;
+    }
+    executingRef.current = true;
+    const runSteps = async () => {
+      const stepsToExecute = configSteps.filter((step) => !step.skip);
+      for (let i = 0; i < stepsToExecute.length; i++) {
+        const step = stepsToExecute[i];
+        setSteps((prev) => {
+          const newSteps = [...prev];
+          const index = newSteps.findIndex((s) => s.name === step.name);
+          if (index !== -1) {
+            newSteps[index] = {
+              ...newSteps[index],
+              status: "running"
+            };
+          }
+          return newSteps;
+        });
+        try {
+          const result = await step.execute();
+          setSteps((prev) => {
+            const newSteps = [...prev];
+            const index = newSteps.findIndex((s) => s.name === step.name);
+            if (index !== -1) {
+              newSteps[index] = {
+                ...newSteps[index],
+                status: result.success ? "completed" : "error",
+                message: result.message
+              };
+            }
+            return newSteps;
+          });
+        } catch (error) {
+          setSteps((prev) => {
+            const newSteps = [...prev];
+            const index = newSteps.findIndex((s) => s.name === step.name);
+            if (index !== -1) {
+              newSteps[index] = {
+                ...newSteps[index],
+                status: "error",
+                message: `\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`
+              };
+            }
+            return newSteps;
+          });
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      setAllComplete(true);
+      setTimeout(() => onComplete(), 1500);
+    };
+    const timer = setTimeout(() => {
+      runSteps().catch((error) => {
+        setSteps((prev) => {
+          const newSteps = [...prev];
+          const errorStep = newSteps.find((s) => s.status === "running");
+          if (errorStep) {
+            const index = newSteps.findIndex((s) => s.name === errorStep.name);
+            if (index !== -1) {
+              newSteps[index] = {
+                ...newSteps[index],
+                status: "error",
+                message: `\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`
+              };
+            }
+          }
+          return newSteps;
+        });
+        setAllComplete(true);
+        setTimeout(() => onComplete(), 1500);
+      });
+    }, 300);
+    return () => {
+      clearTimeout(timer);
+      executingRef.current = false;
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "blue", children: "\u{1F680} \u6B63\u5728\u521D\u59CB\u5316 WSXJS..." }),
+    /* @__PURE__ */ jsx(Newline, {}),
+    steps.map((step) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+      step.status === "pending" && /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "\u23F3 ",
+        step.name,
+        ": \u7B49\u5F85\u4E2D..."
+      ] }),
+      step.status === "running" && /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        /* @__PURE__ */ jsx(Spinner, { type: "dots" }),
+        " ",
+        step.name,
+        ": \u914D\u7F6E\u4E2D..."
+      ] }),
+      step.status === "completed" && /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+        "\u2713 ",
+        step.name,
+        ": ",
+        step.message || "\u5B8C\u6210"
+      ] }),
+      step.status === "skipped" && /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        "\u2298 ",
+        step.name,
+        ": ",
+        step.message || "\u5DF2\u8DF3\u8FC7"
+      ] }),
+      step.status === "error" && /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+        "\u2717 ",
+        step.name,
+        ": ",
+        step.message || "\u5931\u8D25"
+      ] })
+    ] }, step.name)),
+    allComplete && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Newline, {}),
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "green", children: "\u2705 WSXJS \u521D\u59CB\u5316\u5B8C\u6210\uFF01" }),
+      /* @__PURE__ */ jsx(Newline, {}),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u4E0B\u4E00\u6B65\uFF1A" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "1. \u5B89\u88C5\u4F9D\u8D56: npm install" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "2. \u5F00\u59CB\u5F00\u53D1: npm run dev" })
+    ] })
+  ] });
+};
+
+// src/config/configure-typescript.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+async function configureTypeScript(projectRoot, options = {}) {
+  const tsconfigPath = join(projectRoot, "tsconfig.json");
+  const { useTsConfigPackage = false, useDecorators = true } = options;
+  if (useTsConfigPackage) {
+    const config = {
+      extends: "@wsxjs/wsx-tsconfig/tsconfig.base.json",
+      compilerOptions: {
+        outDir: "./dist"
+      },
+      include: ["src/**/*"]
+    };
+    if (existsSync(tsconfigPath)) {
+      try {
+        const existing = JSON.parse(readFileSync(tsconfigPath, "utf-8"));
+        const merged = mergeTsConfig(existing, config);
+        writeFileSync(tsconfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        return {
+          success: true,
+          message: "\u5DF2\u66F4\u65B0 tsconfig.json\uFF08\u4F7F\u7528 @wsxjs/wsx-tsconfig\uFF09",
+          created: false
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `\u65E0\u6CD5\u89E3\u6790\u73B0\u6709 tsconfig.json: ${error}`,
+          created: false
+        };
+      }
+    } else {
+      writeFileSync(tsconfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      return {
+        success: true,
+        message: "\u5DF2\u521B\u5EFA tsconfig.json\uFF08\u4F7F\u7528 @wsxjs/wsx-tsconfig\uFF09",
+        created: true
+      };
+    }
+  } else {
+    const compilerOptions = {
+      jsx: "react-jsx",
+      jsxImportSource: "@wsxjs/wsx-core",
+      types: ["@wsxjs/wsx-core"]
+    };
+    if (useDecorators) {
+      compilerOptions.experimentalDecorators = true;
+      compilerOptions.useDefineForClassFields = false;
+    }
+    const config = {
+      compilerOptions,
+      include: ["src/**/*"]
+    };
+    if (existsSync(tsconfigPath)) {
+      try {
+        const existing = JSON.parse(readFileSync(tsconfigPath, "utf-8"));
+        const merged = mergeTsConfig(existing, config);
+        writeFileSync(tsconfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        return {
+          success: true,
+          message: "\u5DF2\u66F4\u65B0 tsconfig.json",
+          created: false
+        };
+      } catch (error) {
+        return {
+          success: false,
+          message: `\u65E0\u6CD5\u89E3\u6790\u73B0\u6709 tsconfig.json: ${error}`,
+          created: false
+        };
+      }
+    } else {
+      writeFileSync(tsconfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      return {
+        success: true,
+        message: "\u5DF2\u521B\u5EFA tsconfig.json",
+        created: true
+      };
+    }
+  }
+}
+function mergeTsConfig(existing, newConfig) {
+  const merged = { ...existing };
+  if (newConfig.compilerOptions) {
+    merged.compilerOptions = {
+      ...existing.compilerOptions,
+      ...newConfig.compilerOptions
+    };
+  }
+  if (newConfig.include) {
+    const existingInclude = existing.include || [];
+    const newInclude = newConfig.include || [];
+    merged.include = [.../* @__PURE__ */ new Set([...existingInclude, ...newInclude])];
+  }
+  if (existing.extends && !newConfig.extends) {
+  } else if (newConfig.extends) {
+    merged.extends = newConfig.extends;
+  }
+  return merged;
+}
+
+// src/config/configure-vite.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+async function configureVite(projectRoot) {
+  const viteConfigPaths = [
+    { path: join2(projectRoot, "vite.config.ts"), ext: "ts" },
+    { path: join2(projectRoot, "vite.config.js"), ext: "js" },
+    { path: join2(projectRoot, "vite.config.mts"), ext: "mts" },
+    { path: join2(projectRoot, "vite.config.mjs"), ext: "mjs" }
+  ];
+  let existingConfig = null;
+  for (const configPath of viteConfigPaths) {
+    if (existsSync2(configPath.path)) {
+      existingConfig = configPath;
+      break;
+    }
+  }
+  if (existingConfig) {
+    try {
+      const content = readFileSync2(existingConfig.path, "utf-8");
+      const hasWsxImport = content.includes("@wsxjs/wsx-vite-plugin");
+      const hasWsxPlugin = content.includes("wsx()") || content.includes("wsx(");
+      if (hasWsxImport && hasWsxPlugin) {
+        return {
+          success: true,
+          message: "vite.config \u5DF2\u5305\u542B WSX \u63D2\u4EF6",
+          created: false
+        };
+      }
+      const updated = addWsxPluginToViteConfig(content, existingConfig.ext);
+      writeFileSync2(existingConfig.path, updated, "utf-8");
+      return {
+        success: true,
+        message: `\u5DF2\u66F4\u65B0 ${existingConfig.path}`,
+        created: false
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `\u65E0\u6CD5\u8BFB\u53D6/\u66F4\u65B0 vite.config: ${error}`,
+        created: false
+      };
+    }
+  } else {
+    const configContent = `import { defineConfig } from "vite";
+import { wsx } from "@wsxjs/wsx-vite-plugin";
+
+export default defineConfig({
+    plugins: [wsx()],
+});
+`;
+    const newConfigPath = join2(projectRoot, "vite.config.ts");
+    writeFileSync2(newConfigPath, configContent, "utf-8");
+    return {
+      success: true,
+      message: "\u5DF2\u521B\u5EFA vite.config.ts",
+      created: true
+    };
+  }
+}
+function addWsxPluginToViteConfig(content, _ext) {
+  const hasWsxImport = content.includes("@wsxjs/wsx-vite-plugin");
+  const hasDefineConfigImport = content.includes("defineConfig");
+  let updated = content;
+  if (!hasWsxImport) {
+    const importRegex = /^import\s+.*?from\s+['"].*?['"];?$/gm;
+    const imports = content.match(importRegex);
+    if (imports && imports.length > 0) {
+      const lastImport = imports[imports.length - 1];
+      const lastImportIndex = content.lastIndexOf(lastImport);
+      const insertIndex = lastImportIndex + lastImport.length;
+      const wsxImport = hasDefineConfigImport ? `import { wsx } from "@wsxjs/wsx-vite-plugin";
+` : `import { defineConfig } from "vite";
+import { wsx } from "@wsxjs/wsx-vite-plugin";
+`;
+      updated = content.slice(0, insertIndex) + "\n" + wsxImport + content.slice(insertIndex);
+    } else {
+      const wsxImport = hasDefineConfigImport ? `import { wsx } from "@wsxjs/wsx-vite-plugin";
+
+` : `import { defineConfig } from "vite";
+import { wsx } from "@wsxjs/wsx-vite-plugin";
+
+`;
+      updated = wsxImport + content;
+    }
+  }
+  if (!updated.includes("wsx()") && !updated.includes("wsx(")) {
+    const pluginsArrayRegex = /plugins:\s*\[([^\]]*)\]/s;
+    const match = updated.match(pluginsArrayRegex);
+    if (match) {
+      const pluginsContent = match[1].trim();
+      const newPluginsContent = pluginsContent ? `${pluginsContent}
+        wsx(),` : `wsx(),`;
+      updated = updated.replace(
+        pluginsArrayRegex,
+        `plugins: [
+        ${newPluginsContent}
+    ]`
+      );
+    } else {
+      const defineConfigRegex = /defineConfig\s*\(\s*\{([^}]*)\}\s*\)/s;
+      const defineMatch = updated.match(defineConfigRegex);
+      if (defineMatch) {
+        const configContent = defineMatch[1].trim();
+        const newConfigContent = configContent ? `${configContent}
+    plugins: [wsx()],` : `plugins: [wsx()],`;
+        updated = updated.replace(
+          defineConfigRegex,
+          `defineConfig({
+    ${newConfigContent}
+})`
+        );
+      }
+    }
+  }
+  return updated;
+}
+
+// src/config/configure-eslint.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+async function configureESLint(projectRoot, options = {}) {
+  const flatConfigPath = join3(projectRoot, "eslint.config.js");
+  const flatConfigMjsPath = join3(projectRoot, "eslint.config.mjs");
+  const legacyConfigPath = join3(projectRoot, ".eslintrc.js");
+  const legacyConfigJsonPath = join3(projectRoot, ".eslintrc.json");
+  const hasFlatConfig = existsSync3(flatConfigPath) || existsSync3(flatConfigMjsPath);
+  const hasLegacyConfig = existsSync3(legacyConfigPath) || existsSync3(legacyConfigJsonPath);
+  const useFlatConfig = options.useFlatConfig ?? (hasFlatConfig || !hasLegacyConfig);
+  if (useFlatConfig) {
+    return await configureFlatESLint(projectRoot);
+  } else {
+    return await configureLegacyESLint(projectRoot);
+  }
+}
+async function configureFlatESLint(projectRoot) {
+  const configPath = existsSync3(join3(projectRoot, "eslint.config.js")) ? join3(projectRoot, "eslint.config.js") : join3(projectRoot, "eslint.config.mjs");
+  if (existsSync3(configPath)) {
+    try {
+      const content = readFileSync3(configPath, "utf-8");
+      const hasWsxImport = content.includes("@wsxjs/eslint-plugin-wsx");
+      const hasWsxPlugin = content.includes("wsx:") || content.includes("wsxPlugin");
+      if (hasWsxImport && hasWsxPlugin) {
+        return {
+          success: true,
+          message: "eslint.config \u5DF2\u5305\u542B WSX \u63D2\u4EF6",
+          created: false
+        };
+      }
+      const updated = addWsxPluginToFlatConfig(content);
+      writeFileSync3(configPath, updated, "utf-8");
+      return {
+        success: true,
+        message: `\u5DF2\u66F4\u65B0 ${configPath}`,
+        created: false
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `\u65E0\u6CD5\u8BFB\u53D6/\u66F4\u65B0 eslint.config: ${error}`,
+        created: false
+      };
+    }
+  } else {
+    const configContent = `import wsxPlugin from "@wsxjs/eslint-plugin-wsx";
+
+export default [
+    {
+        files: ["**/*.{ts,tsx,js,jsx,wsx}"],
+        plugins: { wsx: wsxPlugin },
+        rules: {
+            "wsx/no-react-imports": "error",
+            "wsx/render-method-required": "error",
+            "wsx/state-requires-initial-value": "error",
+            "wsx/require-jsx-import-source": "error",
+        },
+    },
+];
+`;
+    writeFileSync3(configPath, configContent, "utf-8");
+    return {
+      success: true,
+      message: `\u5DF2\u521B\u5EFA ${configPath}`,
+      created: true
+    };
+  }
+}
+async function configureLegacyESLint(projectRoot) {
+  const configPath = existsSync3(join3(projectRoot, ".eslintrc.js")) ? join3(projectRoot, ".eslintrc.js") : join3(projectRoot, ".eslintrc.json");
+  if (existsSync3(configPath)) {
+    try {
+      const content = readFileSync3(configPath, "utf-8");
+      const hasWsxPlugin = content.includes("@wsxjs/eslint-plugin-wsx") || content.includes("@wsxjs/wsx");
+      if (hasWsxPlugin) {
+        return {
+          success: true,
+          message: ".eslintrc \u5DF2\u5305\u542B WSX \u63D2\u4EF6",
+          created: false
+        };
+      }
+      return {
+        success: false,
+        message: "\u68C0\u6D4B\u5230 Legacy ESLint \u914D\u7F6E\uFF0C\u5EFA\u8BAE\u8FC1\u79FB\u5230 Flat Config \u683C\u5F0F",
+        created: false
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `\u65E0\u6CD5\u8BFB\u53D6/\u66F4\u65B0 .eslintrc: ${error}`,
+        created: false
+      };
+    }
+  } else {
+    const configContent = `module.exports = {
+    plugins: ["@wsxjs/wsx"],
+    rules: {
+        "@wsxjs/wsx/no-react-imports": "error",
+        "@wsxjs/wsx/render-method-required": "error",
+        "@wsxjs/wsx/state-requires-initial-value": "error",
+    },
+};
+`;
+    writeFileSync3(join3(projectRoot, ".eslintrc.js"), configContent, "utf-8");
+    return {
+      success: true,
+      message: "\u5DF2\u521B\u5EFA .eslintrc.js\uFF08\u5EFA\u8BAE\u4F7F\u7528 Flat Config\uFF09",
+      created: true
+    };
+  }
+}
+function addWsxPluginToFlatConfig(content) {
+  const hasWsxImport = content.includes("@wsxjs/eslint-plugin-wsx");
+  let updated = content;
+  if (!hasWsxImport) {
+    const importRegex = /^import\s+.*?from\s+['"].*?['"];?$/gm;
+    const imports = content.match(importRegex);
+    if (imports && imports.length > 0) {
+      const lastImport = imports[imports.length - 1];
+      const lastImportIndex = content.lastIndexOf(lastImport);
+      const insertIndex = lastImportIndex + lastImport.length;
+      const wsxImport = `import wsxPlugin from "@wsxjs/eslint-plugin-wsx";
+`;
+      updated = content.slice(0, insertIndex) + "\n" + wsxImport + content.slice(insertIndex);
+    } else {
+      updated = `import wsxPlugin from "@wsxjs/eslint-plugin-wsx";
+
+` + content;
+    }
+  }
+  if (!updated.includes("wsx:") && !updated.includes("wsxPlugin")) {
+    const configObjectRegex = /\{\s*files:\s*\[([^\]]+)\],([^}]*)\}/s;
+    const match = updated.match(configObjectRegex);
+    if (match) {
+      const configContent = match[2].trim();
+      let newConfigContent = configContent;
+      if (!configContent.includes("plugins:")) {
+        newConfigContent = `plugins: { wsx: wsxPlugin },
+        ${newConfigContent}`;
+      } else {
+        const pluginsRegex = /plugins:\s*\{([^}]*)\}/s;
+        const pluginsMatch = newConfigContent.match(pluginsRegex);
+        if (pluginsMatch) {
+          const pluginsContent = pluginsMatch[1].trim();
+          newConfigContent = newConfigContent.replace(
+            pluginsRegex,
+            `plugins: { ${pluginsContent}
+            wsx: wsxPlugin,
+        }`
+          );
+        }
+      }
+      if (!configContent.includes("rules:")) {
+        newConfigContent = `${newConfigContent}
+        rules: {
+            "wsx/no-react-imports": "error",
+            "wsx/render-method-required": "error",
+            "wsx/state-requires-initial-value": "error",
+            "wsx/require-jsx-import-source": "error",
+        },`;
+      } else {
+        const rulesRegex = /rules:\s*\{([^}]*)\}/s;
+        const rulesMatch = newConfigContent.match(rulesRegex);
+        if (rulesMatch) {
+          const rulesContent = rulesMatch[1].trim();
+          const newRules = `"wsx/no-react-imports": "error",
+            "wsx/render-method-required": "error",
+            "wsx/state-requires-initial-value": "error",
+            "wsx/require-jsx-import-source": "error",`;
+          newConfigContent = newConfigContent.replace(
+            rulesRegex,
+            `rules: {
+            ${newRules}
+            ${rulesContent}
+        }`
+          );
+        }
+      }
+      updated = updated.replace(
+        configObjectRegex,
+        `{
+        files: [${match[1]}],
+        ${newConfigContent}
+    }`
+      );
+    } else {
+      const exportDefaultRegex = /export\s+default\s*\[([^\]]*)\]/s;
+      const exportMatch = updated.match(exportDefaultRegex);
+      if (exportMatch) {
+        const existingConfigs = exportMatch[1].trim();
+        const newConfig = `    {
+        files: ["**/*.{ts,tsx,js,jsx,wsx}"],
+        plugins: { wsx: wsxPlugin },
+        rules: {
+            "wsx/no-react-imports": "error",
+            "wsx/render-method-required": "error",
+            "wsx/state-requires-initial-value": "error",
+            "wsx/require-jsx-import-source": "error",
+        },
+    },`;
+        updated = updated.replace(
+          exportDefaultRegex,
+          `export default [
+    ${existingConfigs ? existingConfigs + ",\n    " : ""}${newConfig}
+]`
+        );
+      }
+    }
+  }
+  return updated;
+}
+
+// src/commands/init.ts
+async function initWSX(options = {}) {
+  const projectRoot = process.cwd();
+  let finalOptions = { ...options };
+  if (options.interactive !== false) {
+    finalOptions = await promptUserOptions(options);
+  }
+  const results = [];
+  let resolveComplete;
+  const completePromise = new Promise((resolve) => {
+    resolveComplete = resolve;
+  });
+  const configSteps = [
+    {
+      name: "TypeScript",
+      skip: finalOptions.skipTsconfig ?? false,
+      execute: async () => {
+        const tsOptions = {
+          useTsConfigPackage: finalOptions.useTsconfigPackage,
+          useDecorators: finalOptions.useDecorators ?? true
+        };
+        const result = await configureTypeScript(projectRoot, tsOptions);
+        results.push({ name: "TypeScript", ...result });
+        return result;
+      }
+    },
+    {
+      name: "Vite",
+      skip: finalOptions.skipVite ?? false,
+      execute: async () => {
+        const result = await configureVite(projectRoot);
+        results.push({ name: "Vite", ...result });
+        return result;
+      }
+    },
+    {
+      name: "wsx.d.ts",
+      skip: finalOptions.skipTypes ?? false,
+      execute: async () => {
+        const result = await generateWsxTypes(projectRoot);
+        const stepResult = {
+          success: result.success,
+          message: result.message,
+          created: result.created
+        };
+        results.push({ name: "wsx.d.ts", ...stepResult });
+        return stepResult;
+      }
+    },
+    {
+      name: "ESLint",
+      skip: finalOptions.skipEslint ?? false,
+      execute: async () => {
+        const eslintOptions = {
+          useFlatConfig: void 0
+          // 自动检测
+        };
+        const result = await configureESLint(projectRoot, eslintOptions);
+        results.push({ name: "ESLint", ...result });
+        return result;
+      }
+    }
+  ];
+  const { unmount } = render(
+    React2.createElement(InitUI, {
+      onComplete: () => {
+        resolveComplete();
+      },
+      options: finalOptions,
+      // Keep for potential future use
+      configSteps
+    })
+  );
+  await completePromise;
+  unmount();
+  console.log("\n\u914D\u7F6E\u5B8C\u6210\u6458\u8981:");
+  results.forEach((result) => {
+    const status = result.success ? "\u2713" : "\u2717";
+    console.log(`  ${status} ${result.name}: ${result.message}`);
+  });
+}
+async function promptUserOptions(existingOptions) {
+  const answers = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "useDecorators",
+      message: "\u662F\u5426\u4F7F\u7528\u88C5\u9970\u5668\uFF08@state\uFF09\uFF1F",
+      default: existingOptions.useDecorators ?? true,
+      when: existingOptions.useDecorators === void 0
+    },
+    {
+      type: "confirm",
+      name: "useTsconfigPackage",
+      message: "\u662F\u5426\u4F7F\u7528 @wsxjs/wsx-tsconfig \u5305\uFF1F",
+      default: existingOptions.useTsconfigPackage ?? false,
+      when: existingOptions.useTsconfigPackage === void 0
+    },
+    {
+      type: "confirm",
+      name: "configureTsconfig",
+      message: "\u662F\u5426\u914D\u7F6E TypeScript\uFF1F",
+      default: !existingOptions.skipTsconfig,
+      when: existingOptions.skipTsconfig === void 0
+    },
+    {
+      type: "confirm",
+      name: "configureVite",
+      message: "\u662F\u5426\u914D\u7F6E Vite\uFF1F",
+      default: !existingOptions.skipVite,
+      when: existingOptions.skipVite === void 0
+    },
+    {
+      type: "confirm",
+      name: "configureEslint",
+      message: "\u662F\u5426\u914D\u7F6E ESLint\uFF1F",
+      default: !existingOptions.skipEslint,
+      when: existingOptions.skipEslint === void 0
+    },
+    {
+      type: "confirm",
+      name: "generateTypes",
+      message: "\u662F\u5426\u751F\u6210 wsx.d.ts\uFF1F",
+      default: !existingOptions.skipTypes,
+      when: existingOptions.skipTypes === void 0
+    }
+  ]);
+  return {
+    ...existingOptions,
+    useDecorators: answers.useDecorators ?? existingOptions.useDecorators,
+    useTsconfigPackage: answers.useTsconfigPackage ?? existingOptions.useTsconfigPackage,
+    skipTsconfig: !answers.configureTsconfig,
+    skipVite: !answers.configureVite,
+    skipEslint: !answers.configureEslint,
+    skipTypes: !answers.generateTypes
+  };
+}
+async function generateWsxTypes(projectRoot) {
+  const typesDir = join4(projectRoot, "src", "types");
+  const wsxDtsPath = join4(typesDir, "wsx.d.ts");
+  if (existsSync4(wsxDtsPath)) {
+    return {
+      success: true,
+      message: "wsx.d.ts \u5DF2\u5B58\u5728",
+      created: false
+    };
+  }
+  if (!existsSync4(typesDir)) {
+    mkdirSync(typesDir, { recursive: true });
+  }
+  const wsxDtsContent = `// Type declaration for .wsx files
+// Auto-generated by @wsxjs/cli
+// You can modify this file if needed
+
+declare module "*.wsx" {
+    import { WebComponent, LightComponent } from "@wsxjs/wsx-core";
+    const Component: new (...args: unknown[]) => WebComponent | LightComponent;
+    export default Component;
+}
+`;
+  writeFileSync4(wsxDtsPath, wsxDtsContent, "utf-8");
+  return {
+    success: true,
+    message: "\u5DF2\u751F\u6210 wsx.d.ts",
+    created: true
+  };
+}
+
+// src/commands/check-config.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+import chalk from "chalk";
+async function checkConfig(projectRoot = process.cwd()) {
+  const result = {
+    hasWsxTypes: false,
+    hasTsConfig: false,
+    hasViteConfig: false,
+    tsConfigValid: false,
+    viteConfigValid: false,
+    issues: [],
+    suggestions: []
+  };
+  const wsxDtsPath = join5(projectRoot, "src", "types", "wsx.d.ts");
+  result.hasWsxTypes = existsSync5(wsxDtsPath);
+  if (!result.hasWsxTypes) {
+    result.issues.push("Missing src/types/wsx.d.ts");
+    result.suggestions.push("Run: npx wsx init");
+  }
+  const tsconfigPath = join5(projectRoot, "tsconfig.json");
+  result.hasTsConfig = existsSync5(tsconfigPath);
+  if (result.hasTsConfig) {
+    try {
+      const tsconfigContent = readFileSync4(tsconfigPath, "utf-8");
+      const tsconfig = JSON.parse(tsconfigContent);
+      const compilerOptions = tsconfig.compilerOptions || {};
+      result.tsConfigValid = true;
+      if (compilerOptions.jsx !== "react-jsx") {
+        result.issues.push('tsconfig.json: jsx should be "react-jsx"');
+        result.suggestions.push(
+          'Add to tsconfig.json: "compilerOptions": { "jsx": "react-jsx" }'
+        );
+        result.tsConfigValid = false;
+      }
+      if (compilerOptions.jsxImportSource !== "@wsxjs/wsx-core") {
+        result.issues.push('tsconfig.json: jsxImportSource should be "@wsxjs/wsx-core"');
+        result.suggestions.push(
+          'Add to tsconfig.json: "compilerOptions": { "jsxImportSource": "@wsxjs/wsx-core" }'
+        );
+        result.tsConfigValid = false;
+      }
+      if (compilerOptions.experimentalDecorators !== true) {
+        result.suggestions.push(
+          "Recommended: Enable experimentalDecorators for @state decorator support"
+        );
+      }
+      if (compilerOptions.useDefineForClassFields !== false) {
+        result.suggestions.push(
+          "Recommended: Set useDefineForClassFields to false for @state decorator support"
+        );
+      }
+    } catch {
+      result.issues.push("tsconfig.json: Invalid JSON format");
+      result.tsConfigValid = false;
+    }
+  } else {
+    result.issues.push("Missing tsconfig.json");
+    result.suggestions.push("Create a tsconfig.json with WSX-compatible settings");
+  }
+  const viteConfigPaths = [
+    join5(projectRoot, "vite.config.ts"),
+    join5(projectRoot, "vite.config.js"),
+    join5(projectRoot, "vite.config.mts"),
+    join5(projectRoot, "vite.config.mjs")
+  ];
+  for (const viteConfigPath of viteConfigPaths) {
+    if (existsSync5(viteConfigPath)) {
+      result.hasViteConfig = true;
+      try {
+        const viteConfigContent = readFileSync4(viteConfigPath, "utf-8");
+        const hasWsxImport = viteConfigContent.includes("@wsxjs/wsx-vite-plugin");
+        const hasWsxPlugin = viteConfigContent.includes("wsx()");
+        if (!hasWsxImport || !hasWsxPlugin) {
+          result.issues.push("vite.config: Missing @wsxjs/wsx-vite-plugin");
+          result.suggestions.push(
+            'Add to vite.config: import { wsx } from "@wsxjs/wsx-vite-plugin" and use wsx() in plugins array'
+          );
+          result.viteConfigValid = false;
+        } else {
+          result.viteConfigValid = true;
+        }
+      } catch {
+        result.issues.push("vite.config: Unable to read file");
+      }
+      break;
+    }
+  }
+  if (!result.hasViteConfig) {
+    result.suggestions.push("Recommended: Create vite.config.ts with @wsxjs/wsx-vite-plugin");
+  }
+  return result;
+}
+async function displayCheckResults(result) {
+  console.log(chalk.blue.bold("\n\u{1F50D} WSX Configuration Check\n"));
+  console.log(chalk.bold("Status:"));
+  console.log(
+    `  wsx.d.ts: ${result.hasWsxTypes ? chalk.green("\u2713 Found") : chalk.red("\u2717 Missing")}`
+  );
+  console.log(
+    `  tsconfig.json: ${result.hasTsConfig ? result.tsConfigValid ? chalk.green("\u2713 Valid") : chalk.yellow("\u26A0 Needs update") : chalk.red("\u2717 Missing")}`
+  );
+  console.log(
+    `  vite.config: ${result.hasViteConfig ? result.viteConfigValid ? chalk.green("\u2713 Valid") : chalk.yellow("\u26A0 Needs update") : chalk.gray("- Not found")}`
+  );
+  if (result.issues.length > 0) {
+    console.log(chalk.red.bold("\n\u274C Issues:"));
+    result.issues.forEach((issue) => {
+      console.log(chalk.red(`  \u2022 ${issue}`));
+    });
+  }
+  if (result.suggestions.length > 0) {
+    console.log(chalk.yellow.bold("\n\u{1F4A1} Suggestions:"));
+    result.suggestions.forEach((suggestion) => {
+      console.log(chalk.yellow(`  \u2022 ${suggestion}`));
+    });
+  }
+  if (result.issues.length === 0) {
+    console.log(
+      chalk.green.bold("\n\u2705 All checks passed! Your WSX configuration looks good.\n")
+    );
+  } else {
+    console.log(chalk.yellow.bold("\n\u26A0\uFE0F  Some issues need attention.\n"));
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("wsx").description("WSXJS CLI tool").version("0.0.17");
+program.command("init").description("Initialize WSXJS in your project").option("--skip-tsconfig", "Skip TypeScript configuration").option("--skip-vite", "Skip Vite configuration").option("--skip-eslint", "Skip ESLint configuration").option("--skip-types", "Skip wsx.d.ts generation").option("--use-tsconfig-package", "Use @wsxjs/wsx-tsconfig package").option("--use-decorators", "Enable decorator support (@state)").option("--no-interactive", "Skip interactive prompts").action(async (options) => {
+  await initWSX(options);
+});
+program.command("check").description("Check WSX configuration").action(async () => {
+  const result = await checkConfig();
+  await displayCheckResults(result);
+});
+program.parse();

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@wsxjs/cli",
+  "version": "0.0.18",
+  "description": "CLI tool for WSXJS initialization and configuration",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "wsx": "./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wsxjs/wsxjs.git",
+    "directory": "packages/cli"
+  },
+  "author": "Albert Li <albert.li@wsxjs.com>",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "wsx",
+    "cli",
+    "web-components",
+    "typescript",
+    "init"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "ink": "^4.4.1",
+    "ink-spinner": "^5.0.0",
+    "inquirer": "^10.2.2",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.0",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.2.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "typecheck": "tsc --noEmit"
+  }
+}