@appthen/cli 1.1.32 → 1.2.1

package/bin/main.js

@@ -7,6 +7,7 @@
  * 导入包信息，用于获取版本号
  */
 var pkg = require('../package.json');
+var path = require('path');
 
 /**
  * 导入commander用于构建CLI命令行工具
@@ -14,8 +15,7 @@ var pkg = require('../package.json');
 var program = require('commander');
 
 // 设置版本信息命令
-program
-  .version(pkg.version, '-v, --version', 'display version information');
+program.version(pkg.version, '-v, --version', 'display version information');
 
 /**
  * generate命令 - 默认命令
@@ -208,12 +208,20 @@ program
   .description('Sync backend code from remote')
   .requiredOption('-p, --id <id>', 'project id')
   .requiredOption('-a, --auth <auth>', 'auth token')
-  .option('-f, --framework <framework>', 'backend language framework', 'fastify')
+  .option(
+    '-f, --framework <framework>',
+    'backend language framework',
+    'fastify'
+  )
   .option('-o, --output <output>', 'specify the output directory', 'src/types')
   .option('-m, --mapping <mapping>', 'path mapping configuration')
   .option('-cc, --clear <clear>', 'clear cache')
   .option('-c, --cwd <cwd>', 'specify the working directory', '.')
-  .option('-q, --quiet', 'be quiet, do not output anything unless get error', false)
+  .option(
+    '-q, --quiet',
+    'be quiet, do not output anything unless get error',
+    false
+  )
   .option('-vb, --verbose', 'be verbose, output more information', false)
   .option('--nocheck', 'add @ts-nocheck to cloud function files', false)
   .action(function doSync(command) {
@@ -261,7 +269,7 @@ program
     // 处理环境变量
     const env = {};
     if (options.env) {
-      options.env.forEach(item => {
+      options.env.forEach((item) => {
         const [key, value] = item.split('=');
         if (key && value) {
           env[key] = value;
@@ -276,7 +284,7 @@ program
       name: options.projectName,
       target: options.prod ? 'production' : 'preview',
       outputDir: options.output,
-      env
+      env,
     };
 
     require('../dist/index.js')
@@ -313,6 +321,7 @@ program
   .option('-vb, --verbose', 'be verbose, output more information', false)
   .option('--daemon', 'run as daemon process', false)
   .option('--debug', 'debug mode, process will not exit automatically', false)
+  .option('--workspace', 'enable shadow space workspace features', false)
   .action(async function doConnect(command) {
     var options = command.opts();
     if (options.cwd) {
@@ -323,7 +332,8 @@ program
       const retCode = await require('../dist/index.js').startConnecting({
         ...options,
         daemon: options.daemon,
-        debug: options.debug
+        debug: options.debug,
+        workspace: options.workspace,
       });
       if (!options.debug) {
         process.exit(retCode);
@@ -372,8 +382,13 @@ program
  */
 program
   .command('proxy')
-  .description('start local proxy server to solve CORS and private network access')
-  .requiredOption('--target <target>', 'target server address, e.g. http://localhost:3000')
+  .description(
+    'start local proxy server to solve CORS and private network access'
+  )
+  .requiredOption(
+    '--target <target>',
+    'target server address, e.g. http://localhost:3000'
+  )
   .requiredOption('--port <port>', 'local listen port, e.g. 9000')
   .option('--daemon', 'run as daemon process', false)
   .option('--debug', 'debug mode, process will not exit automatically', false)
@@ -381,9 +396,13 @@ program
   .on('--help', function () {
     console.log('\n用法示例：');
     console.log('  # 启动本地代理，将9000端口转发到目标服务');
-    console.log('  $ yourcli proxy --target http://192.168.1.100:8080 --port 9000');
+    console.log(
+      '  $ yourcli proxy --target http://192.168.1.100:8080 --port 9000'
+    );
     console.log('\n  # 以守护进程方式运行');
-    console.log('  $ yourcli proxy --target http://192.168.1.100:8080 --port 9000 --daemon');
+    console.log(
+      '  $ yourcli proxy --target http://192.168.1.100:8080 --port 9000 --daemon'
+    );
     console.log('\n  # 停止代理服务');
     console.log('  $ yourcli proxy --stop');
     console.log('\n参数说明：');
@@ -416,5 +435,204 @@ program
     });
   });
 
-// 解析命令行参数
+/**
+ * shadow-space命令
+ * 影子空间调试工具
+ */
+program
+  .command('shadow-space')
+  .description('shadow space debugging tool')
+  .option(
+    '-a, --operation <operation>',
+    'operation to perform: init|info|changes|sync|reset|cleanup',
+    'info'
+  )
+  .option('-r, --project-root <path>', 'project root directory', '.')
+  .option('-i, --project-id <id>', 'project ID', 'debug-project')
+  .option('-u, --user-id <id>', 'user ID', 'debug-user')
+  .option('-s, --space-id <id>', 'space ID', 'debug')
+  .option('-f, --files <files>', 'comma-separated list of files to sync')
+  .option('-v, --verbose', 'verbose output', false)
+  .on('--help', function () {
+    console.log('\n用法示例：');
+    console.log('  # 初始化影子空间');
+    console.log(
+      '  $ appthen shadow-space --operation init --project-id my-project --user-id user123'
+    );
+    console.log('\n  # 查看空间信息');
+    console.log('  $ appthen shadow-space --operation info');
+    console.log('\n  # 检测文件变更');
+    console.log('  $ appthen shadow-space --operation changes --verbose');
+    console.log('\n  # 同步指定文件');
+    console.log(
+      '  $ appthen shadow-space --operation sync --files "src/index.ts,package.json"'
+    );
+    console.log('\n  # 重置影子空间');
+    console.log('  $ appthen shadow-space --operation reset');
+    console.log('\n  # 清理影子空间');
+    console.log('  $ appthen shadow-space --operation cleanup');
+    console.log('\n支持的操作：');
+    console.log('  init     - 初始化影子空间');
+    console.log('  info     - 显示空间信息');
+    console.log('  changes  - 检测文件变更');
+    console.log('  sync     - 同步文件到影子空间');
+    console.log('  reset    - 重置影子空间');
+    console.log('  cleanup  - 清理影子空间');
+  })
+  .action(async function doShadowSpace(command) {
+    const options = command.opts();
+
+    try {
+      const { executeShadowSpaceDebug } = require('../dist/index.js');
+
+      await executeShadowSpaceDebug({
+        projectRoot: path.resolve(options.projectRoot),
+        projectId: options.projectId,
+        userId: options.userId,
+        spaceId: options.spaceId,
+        action: options.operation,
+        files: options.files
+          ? options.files.split(',').map((f) => f.trim())
+          : undefined,
+        verbose: options.verbose,
+      });
+    } catch (error) {
+      console.error('Shadow space command failed:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * check-tsx命令
+ * 检查 TSX 文件是否符合平台规范
+ * 可选参数:
+ * -f, --files: 要检查的文件模式，默认为所有 tsx 文件
+ * -c, --cwd: 指定工作目录
+ * -r, --recursive: 递归检查子目录
+ * -e, --errors-only: 只显示错误
+ * -v, --verbose: 详细输出
+ * --format: 输出格式 (text|json)
+ * --exit-on-error: 发现错误时退出
+ */
+program
+  .command('check-tsx')
+  .description('Check TSX files compliance with platform standards')
+  .option('-f, --files <files...>', 'file patterns to check')
+  .option('-c, --cwd <cwd>', 'specify the working directory', '.')
+  .option('-r, --recursive', 'recursively check subdirectories', true)
+  .option('-e, --errors-only', 'only show errors', false)
+  .option('-v, --verbose', 'verbose output', false)
+  .option('--format <format>', 'output format (text|json)', 'text')
+  .option('--exit-on-error', 'exit with error code if issues found', false)
+  .on('--help', function () {
+    console.log('\n用法示例：');
+    console.log('  # 检查当前目录下所有 TSX 文件');
+    console.log('  $ appthen check-tsx');
+    console.log('\n  # 检查指定文件');
+    console.log('  $ appthen check-tsx -f "src/**/*.tsx"');
+    console.log('\n  # 只显示错误，不显示警告');
+    console.log('  $ appthen check-tsx --errors-only');
+    console.log('\n  # 输出 JSON 格式结果');
+    console.log('  $ appthen check-tsx --format json');
+    console.log('\n  # 发现错误时退出（用于 CI/CD）');
+    console.log('  $ appthen check-tsx --exit-on-error');
+    console.log('\n检查规则：');
+    console.log('  - 文件结构完整性（JSDoc、IProps、IState、Document 类）');
+    console.log('  - render() 方法约束（无变量声明、无逻辑语句）');
+    console.log('  - TypeScript 语法限制（方法中禁用类型注解）');
+    console.log('  - JSX 语法限制（只有 render() 方法可以包含 JSX）');
+    console.log('  - 对象安全访问（推荐使用可选链）');
+  })
+  .action(async function doCheckTSX(command) {
+    const options = command.opts();
+    if (options.cwd) {
+      process.chdir(options.cwd);
+    }
+
+    try {
+      const { checkTSX } = require('../dist/index.js');
+
+      const result = await checkTSX({
+        files: options.files || ['**/*.tsx'], // 设置默认值
+        cwd: options.cwd,
+        recursive: options.recursive,
+        errorsOnly: options.errorsOnly,
+        verbose: options.verbose,
+        format: options.format,
+        exitOnError: options.exitOnError,
+      });
+
+      // 如果是 JSON 格式，不需要额外处理，checkTSX 已经输出了
+      if (options.format !== 'json') {
+        if (result.nonCompliantFiles > 0 && options.exitOnError) {
+          process.exit(1);
+        }
+      }
+    } catch (error) {
+      console.error('TSX 检查失败:', error);
+      process.exit(1);
+    }
+  });
+
+// init-claude-hooks 命令
+program
+  .command('init-claude-hooks')
+  .description('初始化 Claude Code TSX 检查器配置')
+  .option('-f, --force', '覆盖已存在的配置文件')
+  .option('-p, --project-only', '只初始化项目配置，不修改全局配置')
+  .option('-v, --verbose', '显示详细输出')
+  .option('-c, --cwd <cwd>', '工作目录', process.cwd())
+  .action(async function doInitClaudeHooks(command) {
+    const options = command.opts();
+
+    try {
+      const { initClaudeHooks } = require('../dist/index.js');
+
+      const result = await initClaudeHooks({
+        force: options.force,
+        projectOnly: options.projectOnly,
+        verbose: options.verbose,
+        cwd: options.cwd,
+      });
+
+      if (!result.success) {
+        console.error('❌ 初始化失败:', result.error);
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ 初始化失败:', error.message);
+      process.exit(1);
+    }
+  });
+
+// analyze-tsx-hooks 命令
+program
+  .command('analyze-tsx-hooks')
+  .description('分析 TSX Hook 日志，排查误判问题')
+  .option('-r, --recent <number>', '显示最近的 N 条记录', '50')
+  .option('-b, --blocked-only', '只显示被阻止的文件')
+  .option('-p, --passed-only', '只显示通过的文件')
+  .option('-v, --verbose', '显示详细信息')
+  .option('-f, --file <filename>', '分析特定文件')
+  .option('-c, --cleanup', '清理旧日志')
+  .action(async function doAnalyzeTSXHooks(command) {
+    const options = command.opts();
+
+    try {
+      const { analyzeTSXHooks } = require('../dist/index.js');
+
+      await analyzeTSXHooks({
+        recent: parseInt(options.recent),
+        blockedOnly: options.blockedOnly,
+        passedOnly: options.passedOnly,
+        verbose: options.verbose,
+        file: options.file,
+        cleanup: options.cleanup,
+      });
+    } catch (error) {
+      console.error('❌ 分析失败:', error.message);
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);

package/dist/TSXComplianceChecker-AST.js

@@ -0,0 +1,321 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSXComplianceChecker = void 0;
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+class TSXComplianceChecker {
+    /**
+     * 使用 AST 检查 TSX 规范
+     */
+    static checkTSXCompliance(content, filename) {
+        const issues = [];
+        try {
+            // 使用 Babel 解析 TSX 代码
+            const ast = (0, parser_1.parse)(content, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript', 'decorators-legacy', 'classProperties'],
+                errorRecovery: true,
+            });
+            // 遍历 AST 进行检查
+            (0, traverse_1.default)(ast, {
+                // 检查变量声明
+                VariableDeclarator(path) {
+                    TSXComplianceChecker.checkVariableDeclaration(path, content, issues);
+                },
+                // 检查方法定义
+                ClassMethod(path) {
+                    TSXComplianceChecker.checkMethodDefinition(path, content, issues);
+                },
+                // 检查 JSX 使用
+                JSXElement(path) {
+                    TSXComplianceChecker.checkJSXUsage(path, content, issues);
+                },
+                // 检查类型注解
+                TSTypeAnnotation(path) {
+                    TSXComplianceChecker.checkTypeAnnotation(path, content, issues);
+                },
+            });
+            // 检查必需的结构
+            this.checkRequiredStructures(ast, content, issues);
+        }
+        catch (error) {
+            issues.push({
+                type: 'error',
+                code: 'PARSE_ERROR',
+                message: `代码解析失败: ${error.message}`,
+                suggestion: '检查代码语法是否正确',
+            });
+        }
+        return {
+            isCompliant: issues.filter((issue) => issue.type === 'error').length === 0,
+            issues,
+        };
+    }
+    /**
+     * 检查变量声明
+     */
+    static checkVariableDeclaration(path, content, issues) {
+        const node = path.node;
+        // 检查是否在 render 方法中
+        const renderMethod = path.findParent((p) => p.isClassMethod() &&
+            t.isIdentifier(p.node.key) &&
+            p.node.key.name === 'render');
+        if (!renderMethod)
+            return;
+        // 检查是否在事件处理函数中
+        const isInEventHandler = this.isInEventHandler(path);
+        if (isInEventHandler)
+            return;
+        // 检查是否在非 JSX 返回的回调函数中
+        const isInNonJSXCallback = this.isInNonJSXCallback(path);
+        if (isInNonJSXCallback)
+            return;
+        // 检查是否在返回 JSX 的回调函数中（如 .map()）
+        const isInJSXCallback = this.isInJSXCallback(path);
+        if (isInJSXCallback) {
+            // 这种情况需要报错
+            const { line, column } = this.getLocation(path, content);
+            const snippet = this.extractCodeSnippet(content, line);
+            issues.push({
+                type: 'error',
+                code: 'CALLBACK_VARIABLE_DECLARATION',
+                message: '返回 JSX 的回调函数中不能包含变量声明',
+                suggestion: '将变量声明移到回调函数外部，或使用内联表达式',
+                line,
+                column,
+                codeSnippet: snippet.snippet,
+                snippetStartLine: snippet.startLine,
+                snippetEndLine: snippet.endLine,
+            });
+            return;
+        }
+        // 其他在 render 方法中的变量声明都是错误的
+        const { line, column } = this.getLocation(path, content);
+        const snippet = this.extractCodeSnippet(content, line);
+        issues.push({
+            type: 'error',
+            code: 'RENDER_VARIABLE_DECLARATION',
+            message: 'render() 方法中不能包含变量声明',
+            suggestion: '移除所有 const/let/var 声明，直接使用 this.state.xxx',
+            line,
+            column,
+            codeSnippet: snippet.snippet,
+            snippetStartLine: snippet.startLine,
+            snippetEndLine: snippet.endLine,
+        });
+    }
+    /**
+     * 检查是否在事件处理函数中
+     */
+    static isInEventHandler(path) {
+        // 查找父级 JSX 属性
+        const jsxAttribute = path.findParent((p) => p.isJSXAttribute());
+        if (jsxAttribute && t.isJSXIdentifier(jsxAttribute.node.name)) {
+            const attrName = jsxAttribute.node.name.name;
+            // 检查是否是事件处理属性（onXxx）
+            if (/^on[A-Z]/.test(attrName)) {
+                return true;
+            }
+        }
+        // 检查是否在 addEventListener 回调中
+        const callExpression = path.findParent((p) => p.isCallExpression());
+        if (callExpression && t.isMemberExpression(callExpression.node.callee)) {
+            const memberExpr = callExpression.node.callee;
+            if (t.isIdentifier(memberExpr.property) &&
+                memberExpr.property.name === 'addEventListener') {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 检查是否在非 JSX 返回的回调函数中
+     */
+    static isInNonJSXCallback(path) {
+        // 查找父级函数
+        const parentFunction = path.findParent((p) => p.isArrowFunctionExpression() || p.isFunctionExpression());
+        if (!parentFunction)
+            return false;
+        // 检查函数是否返回 JSX
+        const returnsJSX = this.functionReturnsJSX(parentFunction);
+        // 如果不返回 JSX，则认为是非 JSX 回调
+        return !returnsJSX;
+    }
+    /**
+     * 检查是否在返回 JSX 的回调函数中
+     */
+    static isInJSXCallback(path) {
+        // 查找父级函数
+        const parentFunction = path.findParent((p) => p.isArrowFunctionExpression() || p.isFunctionExpression());
+        if (!parentFunction)
+            return false;
+        // 检查函数是否返回 JSX
+        return this.functionReturnsJSX(parentFunction);
+    }
+    /**
+     * 检查函数是否返回 JSX
+     */
+    static functionReturnsJSX(functionPath) {
+        let returnsJSX = false;
+        functionPath.traverse({
+            ReturnStatement(path) {
+                if (path.node.argument && t.isJSXElement(path.node.argument)) {
+                    returnsJSX = true;
+                }
+            },
+            JSXElement(path) {
+                // 如果函数体直接包含 JSX（箭头函数的隐式返回）
+                if (path.parent === functionPath.node.body) {
+                    returnsJSX = true;
+                }
+            },
+        });
+        return returnsJSX;
+    }
+    /**
+     * 检查方法定义
+     */
+    static checkMethodDefinition(path, content, issues) {
+        const node = path.node;
+        // 跳过 render 方法和渲染相关方法
+        if (t.isIdentifier(node.key)) {
+            const methodName = node.key.name;
+            const renderMethods = [
+                'render',
+                'renderItem',
+                'renderContent',
+                'renderHeader',
+                'renderFooter',
+            ];
+            if (renderMethods.includes(methodName))
+                return;
+            // 检查方法中是否包含 JSX
+            let containsJSX = false;
+            path.traverse({
+                JSXElement() {
+                    containsJSX = true;
+                },
+            });
+            if (containsJSX) {
+                const { line, column } = this.getLocation(path, content);
+                const snippet = this.extractCodeSnippet(content, line);
+                issues.push({
+                    type: 'error',
+                    code: 'METHOD_CONTAINS_JSX',
+                    message: `方法 ${methodName} 不能包含 JSX 语法`,
+                    suggestion: '只有 render() 方法可以包含 JSX，其他方法只处理逻辑',
+                    line,
+                    column,
+                    codeSnippet: snippet.snippet,
+                    snippetStartLine: snippet.startLine,
+                    snippetEndLine: snippet.endLine,
+                });
+            }
+        }
+    }
+    /**
+     * 检查 JSX 使用
+     */
+    static checkJSXUsage(path, content, issues) {
+        // 暂时不实现，专注于变量声明检查
+    }
+    /**
+     * 检查类型注解
+     */
+    static checkTypeAnnotation(path, content, issues) {
+        // 暂时不实现，专注于变量声明检查
+    }
+    /**
+     * 检查必需的结构
+     */
+    static checkRequiredStructures(ast, content, issues) {
+        // 这里可以添加对必需结构的检查
+        // 如 IProps, IState, Document 类等
+    }
+    /**
+     * 获取节点在源码中的位置
+     */
+    static getLocation(path, content) {
+        const loc = path.node.loc;
+        return {
+            line: loc ? loc.start.line : 1,
+            column: loc ? loc.start.column : 0,
+        };
+    }
+    /**
+     * 提取代码片段
+     */
+    static extractCodeSnippet(content, lineNumber, contextLines = 3) {
+        const lines = content.split('\n');
+        const startLine = Math.max(1, lineNumber - contextLines);
+        const endLine = Math.min(lines.length, lineNumber + contextLines);
+        const snippetLines = [];
+        for (let i = startLine; i <= endLine; i++) {
+            const line = lines[i - 1] || '';
+            const prefix = i === lineNumber ? '>>> ' : '    ';
+            snippetLines.push(`${prefix}${i.toString().padStart(3)}: ${line}`);
+        }
+        return {
+            snippet: snippetLines.join('\n'),
+            startLine,
+            endLine,
+        };
+    }
+    /**
+     * 生成检查报告
+     */
+    static generateReport(result, filename) {
+        const { isCompliant, issues } = result;
+        let report = '=== TSX 规范检查报告 ===\n';
+        report += `文件: ${filename}\n`;
+        if (isCompliant) {
+            report += '✅ 检查通过：文件符合 TSX 规范\n';
+        }
+        else {
+            const errorCount = issues.filter((issue) => issue.type === 'error').length;
+            report += `❌ 检查失败：发现 ${errorCount} 个错误\n\n`;
+            report += '--- 问题详情 ---\n';
+            issues.forEach((issue, index) => {
+                const icon = issue.type === 'error' ? '❌' : '⚠️';
+                report += `${index + 1}. ${icon} [${issue.code}] ${issue.message}\n`;
+                if (issue.line) {
+                    report += `   📍 位置: 第 ${issue.line} 行\n`;
+                }
+                report += `   💡 建议: ${issue.suggestion}\n`;
+                if (issue.codeSnippet) {
+                    report += `   📝 代码片段:\n${issue.codeSnippet}\n`;
+                }
+                report += '\n';
+            });
+        }
+        return report;
+    }
+}
+exports.TSXComplianceChecker = TSXComplianceChecker;