@yorha2b-lab/autodev 2.2.1 → 3.1.0

package/bin/autodev.js

@@ -2,9 +2,10 @@
 const fs = require('fs')
 const path = require('path')
 const chalk = require('chalk')
+const pkg = require('../package.json')
 const { program } = require('commander')
-const pkg = require(path.join(__dirname, '../package.json'))
-const { language, matrixEffect, bootSequence } = require(path.join(__dirname, '../src/utils/utils.js'))
+const bunker = require('../src/core/context')
+const { language, matrixEffect, bootSequence } = require('../src/utils/utils.js')
 
 program
     .version(pkg.version)
@@ -52,8 +53,12 @@ program
     .description(language('开启全频道联动监控：支持 Page/Part/API 协同构筑', 'Start full-channel linked monitoring: Coordinated Page/Part/API construction'))
     .action(() => {
         bootSequence(pkg.version)
-        const watch = require('../src/commands/watch')
-        watch(program.opts())
+        bunker.init(program.opts())
+        require('../src/commands/watch.js')()
+        const { config } = bunker.get()
+        if (config.proxyTarget && !config.needMock && config.enableAutoAlignment) {
+            require('../src/services/proxy-tower.js')()
+        }
         process.on('SIGINT', () => {
             console.log('\n')
             console.log(chalk.gray('--------------------------------------------------'))

package/config.js

@@ -7,6 +7,8 @@ module.exports = {
 
     useDemo: true,
     needMock: false,
+    // 是否开启自动联调对齐协议 (42153 拦截塔)
+    enableAutoAlignment: false,
 
     textModel: 'qwen-turbo',
     visionModel: 'qwen3.5-plus',
@@ -17,5 +19,6 @@ module.exports = {
     componentsDir: 'src/components',
 
     responseSuccess: `response?.code === 200`,
+    proxyTarget: 'http://id:port',// 代理目标，例如 http://localhost:3000
 
 }

package/example/example.json

@@ -1,75 +1,75 @@
 {
     "tabs": [
         {
-            "tab": "鬼剑士",
+            "label": "鬼剑士",
             "key": "ghostSwordsman"
         },
         {
-            "tab": "格斗家",
+            "label": "格斗家",
             "key": "fighter"
         },
         {
-            "tab": "神枪手",
+            "label": "神枪手",
             "key": "gunner"
         },
         {
-            "tab": "魔法师",
+            "label": "魔法师",
             "key": "mage"
         }
     ],
-    "staticInfo": {
-        "has": false,
-        "text": ""
-    },
     "table": {
-        "pagination": true,
-        "expandable": true,
-        "rowSelection": true,
-        "operation": [
-            {
-                "label": "查看",
-                "action": "viewByRecord"
-            },
-            {
-                "label": "编辑",
-                "action": "editByRecord"
-            },
-            {
-                "label": "删除",
-                "action": "deleteByRecord"
-            }
-        ],
         "columns": [
             {
                 "title": "职业",
-                "dataIndex": "job"
+                "dataIndex": "jobName",
+                "type": "text"
             },
             {
                 "title": "一觉",
-                "dataIndex": "firstAwakening"
+                "dataIndex": "firstAwakening",
+                "type": "text"
             },
             {
                 "title": "二觉",
-                "dataIndex": "secondAwakening"
+                "dataIndex": "secondAwakening",
+                "type": "text"
             },
             {
                 "title": "三觉",
-                "dataIndex": "thirdAwakening"
+                "dataIndex": "thirdAwakening",
+                "type": "text"
             },
             {
                 "title": "武器类型",
                 "dataIndex": "weaponType",
-                "render": "_CODE_text=>weaponTypeOptions.find(item=>item.value===text)?.label_CODE_"
+                "type": "enum"
             },
             {
                 "title": "职业类型",
                 "dataIndex": "jobType",
-                "render": "_CODE_text=>jobTypeOptions.find(item=>item.value===text)?.label_CODE_"
+                "type": "enum"
             },
             {
                 "title": "登场时间",
-                "dataIndex": "releaseDate",
-                "render": "_CODE_text=>timeRender({time:text})_CODE_"
+                "dataIndex": "launchDate",
+                "type": "date"
+            }
+        ],
+        "pagination": true,
+        "expandable": true,
+        "rowSelection": true,
+        "operation": [
+            {
+                "label": "查看",
+                "action": "viewByRecord"
+            },
+            {
+                "label": "编辑",
+                "action": "editByRecord"
+            },
+            {
+                "label": "删除",
+                "action": "deleteByRecord"
             }
         ]
     },
@@ -77,34 +77,44 @@
         {
             "label": "转职职业",
             "name": "transferJob",
-            "type": "select",
-            "options": "_CODE_transferJobOptions_CODE_"
+            "type": "select"
         },
         {
             "label": "武器类型",
             "name": "weaponType",
-            "type": "select",
-            "options": "_CODE_weaponTypeOptions_CODE_"
+            "type": "select"
         },
         {
             "label": "职业类型",
             "name": "jobType",
-            "type": "select",
-            "options": "_CODE_jobTypeOptions_CODE_"
+            "type": "select"
         },
         {
             "label": "觉醒名称关键词",
-            "name": "awakeningKeyword"
+            "name": "awakeningNameKeyword"
         },
         {
             "label": "登场时间",
-            "name": "releaseDateStart,releaseDateEnd",
+            "name": "launchDateStart,launchDateEnd",
             "type": "daterange"
         }
     ],
+    "staticInfo": {
+        "has": false,
+        "text": ""
+    },
     "optionDict": {
-        "_CODE_transferJobOptions_CODE_": [],
-        "_CODE_weaponTypeOptions_CODE_": [
+        "transferJobOptions": [
+            {
+                "label": "剑魂",
+                "value": "soulBender"
+            },
+            {
+                "label": "狂战士",
+                "value": "berserker"
+            }
+        ],
+        "weaponTypeOptions": [
             {
                 "label": "光剑",
                 "value": "lightSword"
@@ -118,33 +128,25 @@
                 "value": "greatSword"
             }
         ],
-        "_CODE_jobTypeOptions_CODE_": [
+        "jobTypeOptions": [
             {
                 "label": "物理",
                 "value": "physical"
             },
             {
                 "label": "魔法",
-                "value": "magical"
+                "value": "magic"
             }
         ]
     },
     "functionButton": [
         {
             "btn": "批量删除",
-            "action": "batchDeleteBySelected"
+            "action": "deleteBySelected"
         },
         {
             "btn": "批量导出",
-            "action": "exportData"
-        },
-        {
-            "btn": "查询",
-            "action": "search"
-        },
-        {
-            "btn": "重置",
-            "action": "reset"
+            "action": "exportJobData"
         }
     ],
     "pageStruct": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yorha2b-lab/autodev",
-  "version": "2.2.1",
+  "version": "3.1.0",
   "description": "基于视觉大模型的前端(react+Antd)全自动 CRUD 代码生成器",
   "bin": {
     "autodev": "bin/autodev.js"
@@ -46,5 +46,8 @@
     "openai": "^6.24.0",
     "ora": "^5.4.1",
     "sharp": "^0.34.5"
+  },
+  "devDependencies": {
+    "http-proxy": "^1.18.1"
   }
 }

package/src/commands/handlers/api-handler.js

@@ -3,18 +3,19 @@ const ora = require('ora')
 const path = require('path')
 const chalk = require('chalk')
 
-module.exports = async (filePath, context) => {
+module.exports = async (filePath, liveResponse = null) => {
 
-    const { config, options, language, alignResponseFields } = context
+    const { get } = require('../../core/context')
+    const { config, options, language, unwrapSignal, alignResponseFields } = get()
 
     const startTime = Date.now()
-    const fileName = path.basename(filePath, path.extname(filePath))
+    const fileName = liveResponse?.fileName ?? path.basename(filePath, path.extname(filePath))
     const resourcePath = path.join(process.cwd(), config.pagesDir, fileName, 'resource.js')
 
     const spinner = ora({
         text: chalk.yellow(language(
-            `🤖 Pod 153: [侦察] 发现加密数据源 [${fileName}]。正在尝试执行语义对齐协议...`,
-            `🤖 Pod 153: [Recon] Encrypted data source [${fileName}] detected. Initiating semantic alignment...`
+            `🤖 Pod 153: [侦察] 发现加密数据源 [${fileName}]。正在尝试执行语义对齐协议...\n`,
+            `🤖 Pod 153: [Recon] Encrypted data source [${fileName}] detected. Initiating semantic alignment...\n`
         )),
         color: 'yellow'
     }).start()
@@ -27,28 +28,36 @@ module.exports = async (filePath, context) => {
             ))
         }
 
-        const responseRaw = fs.readFileSync(filePath, 'utf8')
-        let responseStr = responseRaw
+        let rawJson = liveResponse ? liveResponse.data : JSON.parse(fs.readFileSync(filePath, 'utf8'))
         let resourceStr = fs.readFileSync(resourcePath, 'utf8')
 
-        try {
-            const parsed = JSON.parse(responseRaw)
-            const normalizedData = Array.isArray(parsed) ? parsed : [parsed]
-            responseStr = JSON.stringify(normalizedData.slice(0, 1))
-        } catch (e) {
+        const coreArray = unwrapSignal(rawJson)
+
+        if (!coreArray || coreArray.length === 0) {
             console.log(chalk.gray(language(
                 ` [System] 数据格式非标准 JSON，将尝试原始字符对齐。`,
                 ` [System] Data format is not standard JSON, will try to align by character.`)
             ))
         }
 
+        const sampleData = coreArray && coreArray.length > 0 ? [coreArray[0]] : rawJson
+
         spinner.text = chalk.yellow(language(
             `🧑‍💻 9S: 正在扫描前后端字段差异... 执行语义桥接任务。`,
             `🧑‍💻 9S: Scanning field differences... Bridging semantic gaps.`
         ))
 
-        const result = await alignResponseFields(options, responseStr, resourceStr)
+        const extractKeys = str => {
+            const keys = []
+            const regex = /(dataIndex|name)\s*:\s*['"]([^'"]+)['"]/g
+            let match
+            while ((match = regex.exec(str)) !== null) {
+                keys.push(match[2])
+            }
+            return Array.from(new Set(keys))
+        }
 
+        const result = await alignResponseFields(options, JSON.stringify(sampleData), extractKeys(resourceStr).join(','))
         let changeCount = 0
         const resultMapping = {}
         Object.entries(result).forEach(([oldField, newField]) => {
@@ -63,10 +72,27 @@ module.exports = async (filePath, context) => {
         const endTime = Date.now()
 
         spinner.succeed(chalk.green(language(
-            `🤖 Pod 153: [肯定] 结果映射完成${JSON.stringify(resultMapping)}。已更正 ${changeCount} 处语义偏差。耗时: ${(endTime - startTime) / 1000}s`,
-            `🤖 Pod 153: [Affirmative] Result mapping completed${JSON.stringify(resultMapping)}. Corrected ${changeCount} semantic deviations. Elapsed: ${(endTime - startTime) / 1000}s`
+            `🤖 Pod 153: [肯定] 语义桥接协议执行完毕。已物理修正 ${changeCount} 处字段偏差。耗时: ${(endTime - startTime) / 1000}s`,
+            `🤖 Pod 153: [Affirmative] Semantic bridge protocol complete. Corrected ${changeCount} field deviations. Elapsed: ${(endTime - startTime) / 1000}s`
         )))
 
+        if (changeCount > 0) {
+            console.log(chalk.magenta(`\n┌────── [ YoRHa Autonomous Backend Alignment ] ──────┐`))
+            Object.entries(resultMapping).forEach(([oldField, newField]) => {
+                // 💡 物理校准：计算空格数量，让箭头对齐在第 15 个字符位
+                // 中文字符长度 * 2 是为了抵消它在终端占的双倍宽度
+                const padding = " ".repeat(Math.max(1, 15 - oldField.length * 2))
+                console.log(
+                    chalk.gray(` │  `) +
+                    chalk.yellow(oldField) +
+                    padding +
+                    chalk.cyan(` ->  `) +
+                    chalk.white(newField)
+                )
+            })
+            console.log(chalk.magenta(`└───────────────────────────────────────────────────────┘\n`))
+        }
+
         if (fs.existsSync(filePath)) {
             fs.unlinkSync(filePath)
         }

package/src/commands/handlers/page-handler.js

@@ -4,13 +4,15 @@ const path = require('path')
 const chalk = require('chalk')
 const stringify = require('json-stringify-pretty-compact')
 
-module.exports = async (filePath, context) => {
+module.exports = async filePath => {
+
+    const { get } = require('../../core/context')
 
     const {
         config, language, menus,
         pagePrompt, resourceTpl, indexTpl,
         recognizePage, generateMock, resource, index
-    } = context
+    } = get()
 
     const startTime = Date.now()
     const fileName = path.basename(filePath, path.extname(filePath))
@@ -44,11 +46,11 @@ module.exports = async (filePath, context) => {
                 `\n🤖 Pod 042: [报告] 拦截到实弹请求。正在空投标准模拟包: example.json\n`,
                 `\n🤖 Pod 042: [Report] Real-fire request intercepted. Dropping simulation package: example.json\n`
             )))
-            pageConfig = require(path.join(__dirname, '../../../example/example.json'))
+            pageConfig = require('../../../example/example.json')
         } else {
             spinner.text = chalk.cyan(language(
-                `🤖 Pod 042: 正在上传视觉元数据至司令部进行语义分析...`,
-                `🤖 Pod 042: Uploading visual metadata to Command for semantic analysis...`
+                `🤖 Pod 042: 正在上传视觉元数据至司令部进行语义分析...\n`,
+                `🤖 Pod 042: Uploading visual metadata to Command for semantic analysis...\n`
             ))
             pageConfig = await recognizePage(pagePrompt, filePath)
         }

package/src/commands/handlers/part-handler.js

@@ -2,10 +2,12 @@ const fs = require('fs')
 const ora = require('ora')
 const chalk = require('chalk')
 const stringify = require('json-stringify-pretty-compact')
+const { cleanCode, formatFormItemAndColumns } = require('../../utils/utils')
 
-module.exports = async (filePath, context) => {
+module.exports = async filePath => {
 
-    const { language, partPrompt, recognizePage } = context
+    const { get } = require('../../core/context')
+    const { language, partPrompt, recognizePage } = get()
 
     const startTime = Date.now()
 
@@ -19,27 +21,23 @@ module.exports = async (filePath, context) => {
 
     try {
         spinner.text = chalk.cyan(language(
-            `🤖 Pod 042: 正在从神经云网络提取 UI 元数据...`,
-            `🤖 Pod 042: Extracting UI metadata from neural cloud network...`
+            `🤖 Pod 042: 正在从神经云网络提取 UI 元数据...\n`,
+            `🤖 Pod 042: Extracting UI metadata from neural cloud network...\n`
         ))
 
         const pageConfig = await recognizePage(partPrompt, filePath)
 
-        const optionDict = pageConfig.optionDict || {}
-        delete pageConfig.optionDict
+        const { formItems, dictBlocks, processedColumns } = formatFormItemAndColumns({ pageConfig })
 
-        let mainConfigStr = stringify.default(pageConfig, { indent: 4, maxLength: 200 })
-            .replace(/"(\w+)":/g, '$1:') // 去掉 key 的双引号
-            .replace(/"/g, "'")           // 全量替换为单引号
-            .replace(/['"]_CODE_([\s\S]*?)_CODE_['"]/g, '$1') // 还原代码片段
-            .replace(/_CODE_/g, '')
+        const result = Object.fromEntries(Object.entries({ formItems, processedColumns }).filter(([key, value]) => value?.length > 0))
+
+        let mainConfigStr = cleanCode(stringify.default(result, { indent: 4, maxLength: 200 }))
 
         let optionsCodeStr = ''
-        Object.keys(optionDict).forEach(key => {
-            const varName = key.replaceAll('_CODE_', '')
-            const optionsArray = optionDict[key]
+        dictBlocks.forEach(key => {
+            const optionsArray = pageConfig.optionDict?.[key] ?? []
             const arrayItemsStr = optionsArray.map(opt => `    { label: '${opt.label}', value: '${opt.value}' }`).join(',\n')
-            optionsCodeStr += `\nexport const ${varName} = [\n${arrayItemsStr}\n]\n`
+            optionsCodeStr += `\nexport const ${key} = [\n${arrayItemsStr}\n]\n`
         })
 
         const finalResult = `${mainConfigStr}\n${optionsCodeStr}`
@@ -61,7 +59,7 @@ module.exports = async (filePath, context) => {
             `│ 命令：请手动将上述代码块物理装配至您的目标文件中。`,
             `│ Command: Please manually assemble the above code block into your target file.`
         )))
-        console.log(chalk.magenta(`└────────────────────────────────────────────────────────────────────┘\n`))
+        console.log(chalk.magenta(`└───────────────────────────────────────────────────────────────────┘\n`))
 
         if (fs.existsSync(filePath)) {
             fs.unlinkSync(filePath)

package/src/commands/watch.js

@@ -2,19 +2,15 @@ const fs = require('fs')
 const path = require('path')
 const chalk = require('chalk')
 const chokidar = require('chokidar')
-const Handlebars = require('handlebars')
 const stringify = require('json-stringify-pretty-compact')
 
-const { createTaskQueue } = require('../core/task-queue')
-const { recognizePage, generateMock, alignResponseFields } = require('../services/llm.js')
-const { language, getConfig, getExistingMenus, copyTemplateDir } = require('../utils/utils.js')
+const { get } = require('../core/context')
+const { copyTemplateDir } = require('../utils/utils.js')
+const { createTaskQueue } = require('../core/task-queue.js')
 
-const watch = options => {
+const watch = () => {
 
-    const config = getConfig()
-    const template = options.template
-    const queue = createTaskQueue(2)
-    const menus = getExistingMenus()
+    const { menus, config, options, template, language, apiHandler, pageHandler, partHandler } = get()
 
     const compilerPath = path.join(__dirname, `../core/${template}-compiler.js`)
     if (!fs.existsSync(compilerPath)) {
@@ -22,8 +18,6 @@ const watch = options => {
         return
     }
 
-    const { index, resource } = require(compilerPath)
-
     try {
         if (config.hbsDir === '') {
             copyTemplateDir(options, 'hooks', config.hooksDir)
@@ -34,23 +28,7 @@ const watch = options => {
         console.error(language('❌ 模板构筑失败:', '❌ Template construction failed:'), error)
     }
 
-    const tplDir = config.hbsDir !== '' ? path.join(process.cwd(), config.hbsDir) : path.join(__dirname, `../../templates/${template}`)
-    const indexTpl = Handlebars.compile(fs.readFileSync(path.join(tplDir, 'index.hbs'), 'utf-8'))
-    const resourceTpl = Handlebars.compile(fs.readFileSync(path.join(tplDir, 'resource.hbs'), 'utf-8'))
-
-    const context = {
-        menus, language,
-        config, options,
-        resource, index,
-        resourceTpl, indexTpl,
-        recognizePage, generateMock, alignResponseFields,
-        pagePrompt: require(path.join(__dirname, `../prompts/${template}/watch-page.js`)),
-        partPrompt: require(path.join(__dirname, `../prompts/${template}/watch-part.js`))
-    }
-
-    const apiHandler = require('./handlers/api-handler')
-    const pageHandler = require('./handlers/page-handler')
-    const partHandler = require('./handlers/part-handler')
+    const queue = createTaskQueue(2)
 
     queue.onIdle(() => {
         console.log(chalk.green(language(
@@ -73,8 +51,8 @@ const watch = options => {
     })
 
     console.log(chalk.magenta(language(
-        '📡 Operator 6O: 呼叫 2B，地堡全频道联动监控已就绪！\n',
-        '📡 Operator 6O: Calling 2B, all-channel linked monitoring is ready!\n'
+        '📡 Operator 6O: 呼叫 2B，地堡全频道联动监控已就绪！',
+        '📡 Operator 6O: Calling 2B, all-channel linked monitoring is ready!'
     )))
 
     watcher.on('add', filePath => {
@@ -82,13 +60,13 @@ const watch = options => {
         const absolutePath = path.resolve(filePath)
 
         if (absolutePath.includes('screenShot')) {
-            queue.add(() => pageHandler(filePath, context))
+            queue.add(() => pageHandler(filePath))
         }
         else if (absolutePath.includes('screenPart')) {
-            queue.add(() => partHandler(filePath, context))
+            queue.add(() => partHandler(filePath))
         }
         else if (absolutePath.includes('response')) {
-            queue.add(() => apiHandler(filePath, context))
+            queue.add(() => apiHandler(filePath))
         }
     })
 }

package/src/core/context.js

@@ -0,0 +1,51 @@
+const fs = require('fs')
+const path = require('path')
+const Handlebars = require('handlebars')
+const apiHandler = require('../commands/handlers/api-handler')
+const pageHandler = require('../commands/handlers/page-handler')
+const partHandler = require('../commands/handlers/part-handler')
+const { recognizePage, generateMock, alignResponseFields } = require('../services/llm')
+const { language, getConfig, unwrapSignal, isQuerySignal, getExistingMenus } = require('../utils/utils')
+
+let instance = null // 💡 物理封存的全局实例
+
+module.exports = {
+    /**
+     * @description 执行中枢神经元初始化
+     */
+    init: options => {
+
+        const config = getConfig()
+        const menus = getExistingMenus()
+        const template = options.template
+
+        const compilerPath = path.join(__dirname, `./${template}-compiler.js`)
+        const { index, resource } = require(compilerPath)
+
+        const tplDir = config.hbsDir !== ''
+            ? path.join(process.cwd(), config.hbsDir)
+            : path.join(__dirname, `../../templates/${template}`)
+
+        instance = {
+            resource, index, template,
+            apiHandler, pageHandler, partHandler,
+            recognizePage, generateMock, alignResponseFields,
+            pagePrompt: require(`../prompts/${template}/watch-page.js`),
+            partPrompt: require(`../prompts/${template}/watch-part.js`),
+            menus, config, options, language, unwrapSignal, isQuerySignal,
+            indexTpl: Handlebars.compile(fs.readFileSync(path.join(tplDir, 'index.hbs'), 'utf-8')),
+            resourceTpl: Handlebars.compile(fs.readFileSync(path.join(tplDir, 'resource.hbs'), 'utf-8')),
+        }
+        return instance
+    },
+
+    /**
+     * @description 全频道信号接入：获取全局上下文
+     */
+    get: () => {
+        if (!instance) {
+            throw new Error(language('🤖 Pod 042 报警：中枢神经元尚未初始化，无法建立信号连接。', '🤖 Pod 042 Warnning：Central neuron not initialized, cannot establish signal connection.'))
+        }
+        return instance
+    }
+}

package/src/core/react-compiler.js

@@ -2,7 +2,7 @@ const fs = require('fs')
 const path = require('path')
 const Handlebars = require('handlebars')
 const stringify = require('json-stringify-pretty-compact')
-const { cleanCode, generateSmartImports } = require('../utils/utils.js')
+const { cleanCode, generateSmartImports, formatFormItemAndColumns } = require('../utils/utils.js')
 
 Handlebars.registerHelper('raw', options => options.fn())
 Handlebars.registerHelper('stringify', (context, maxLength = 200) => context ? new Handlebars.SafeString(stringify.default(context, { indent: 4, maxLength })) : '[]')
@@ -18,15 +18,15 @@ const resource = ({ pageConfig, resourceTpl }) => {
 
     const hasTabs = pageConfig.tabs?.length > 0
 
+    const { formItems, processedColumns, dictBlocks } = formatFormItemAndColumns({ pageConfig })
+
     const viewData = {
         hasTabs,
+        formItems,
         tabs: pageConfig.tabs,
-        formItems: pageConfig.formItems,
-        formItemsData: hasTabs ? Object.fromEntries(pageConfig.tabs.map(tab => [tab.key, pageConfig.formItems])) : pageConfig.formItems,
-        columnsData: hasTabs ? Object.fromEntries(pageConfig.tabs.map(tab => [tab.key, pageConfig.table.columns])) : pageConfig.table.columns,
-        dictBlocks: pageConfig.formItems
-            ?.filter(item => item.type === 'select')
-            ?.map(item => ({ name: item.options.replaceAll('_CODE_', ''), data: pageConfig.optionDict[item.options] ?? [] }))
+        dictBlocks: dictBlocks.map(item => ({ name: item, data: pageConfig.optionDict[item] ?? [] })),
+        formItemsData: hasTabs ? Object.fromEntries(pageConfig.tabs.map(tab => [tab.key, formItems])) : formItems,
+        columnsData: hasTabs ? Object.fromEntries(pageConfig.tabs.map(tab => [tab.key, processedColumns])) : processedColumns,
     }
 
     const rawCode = resourceTpl(viewData)
@@ -68,7 +68,7 @@ const index = ({ config, fileName, indexTpl, pageConfig }) => {
         hasPagination: pageConfig.table.pagination,
         operations: pageConfig.table.operation || [],
         hasRowSelection: pageConfig.table.rowSelection,
-        formItems: hasTabs ? 'formItems[activeKey]' : 'formItems',
+        formItems: hasFormItems ? (hasTabs ? 'formItems[activeKey]' : 'formItems') : '[]',
         pageStruct: hasFunctionButtons ? pageConfig.pageStruct : pageConfig.pageStruct?.filter(item => item !== 'FunctionButtonsBlock'),
     }
 
@@ -94,7 +94,7 @@ const index = ({ config, fileName, indexTpl, pageConfig }) => {
     Handlebars.registerPartial('handleBlock', `${fs.readFileSync(path.join(__dirname, '../../templates/react/handlebars/handleBlock.hbs'), 'utf-8')}\n`)
 
     const bodyCode = indexTpl(viewData)
-    const importsStr = generateSmartImports(bodyCode, hasTabs)
+    const importsStr = generateSmartImports({ bodyCode, hasTabs, hasFormItems })
     return cleanCode(`${importsStr}\n\n${bodyCode}`)
 }
 

package/src/prompts/react/watch-api.js

@@ -1,12 +1,32 @@
 module.exports = (responseStr, resourceStr) => `
-responseStr: ${responseStr}
-resourceStr: ${resourceStr}
-resourceStr是前端目前猜测的字段名(请从resourceStr中提取dataIndex和name)，
-responseStr是后端的真实响应。
-请比对两者，找出现有前端字段名应该被替换为哪个真实的后端字段名。
-匹配规则: 1.完全相同 2.下划线/驼峰转换 3.语义相似。
-请只输出一个JSON对象, Key为前端猜测的旧名字, Value为Response里的真实新名字。
-例如：{"key_1": "key1"}
-如果没有找到对应的，请不要包含在结果中。
-注意：⚠️⚠️如果有语义相近的两个字段优先取中文字段，比如"createByName"和"createBy"，则取"createByName"
-。`.trim()
+目标：执行【前端虚拟字段】与【后端真实响应】的物理重组与对账。
+
+## 1. 核心输入 (Signal Capture)
+- **前端现状 (Source Keys)**:
+${resourceStr}
+
+- **后端样本 (Target Data)**:
+${responseStr}
+
+## 2. 匹配算法优先级 (Alignment Protocol)
+请严格按以下优先级执行逻辑映射，直到找到唯一目标：
+1. **L1 - 物理全等**: 字符完全一致 (例: userId == userId)。
+2. **L2 - 格式重组**: 下划线与驼峰转换 (例: user_id == userId)。
+3. **L3 - 语义穿透**: 业务含义高度一致 (例: amount == price, phone == mobile)。
+
+## 3. ⚠️ 强制冲突修正 (Conflict Resolution)
+若存在多个潜在目标，执行以下强制判定：
+- **中文字义优先**: 优先匹配能解释前端视觉标签含义的字段。
+- **长度优先**: 若 "createByName" 与 "createBy" 同时存在，强制选择 "createByName"。
+
+## 4. 输出约束 (Output Restrictions)
+- **严禁输出解释性文字、严禁 Markdown 标签**。
+- **仅输出合法的 JSON 对象**。
+- **过滤机制**: 若某字段在后端响应中完全找不到对应映射，物理拦截（不输出）。
+
+## 5. 示例参考 (Example)
+Input:
+  Source: { dataIndex: 'userName' }, Response: { name: '2B' }
+Output:
+  {"userName": "name"}
+`.trim()

package/src/prompts/react/watch-page.js

@@ -1,45 +1,60 @@
 module.exports = `
-识别图片内容（搜索项，表格列，是否有勾选框，查询下拉选项，统计条等页面组件，并按照从上到下的结构把识别出来的组件按顺序组织成型）
-⚠️⚠️⚠️注意:
-1.变量使用驼峰命名法
-    【严禁中文】绝对不允许使用中文作为变量名或函数名
-    【严禁js关键字】绝对不允许使用js关键字作为变量名或函数名(export/delete/const...)
-2.标签页:
-    tabs: [{tab:'tab1',key:'tab1'}]
-    表格上方的Button请务必归类为functionButton,只有当一组水平排列的项下方有明显的长横线(Ink Bar),或者呈现明显的'卡片包裹感'(Card style)时才识别为tabs
-3.搜索项：
-    formItems: [{ label: '文本', name: '对应的英文名词' }],
-    ⚠️⚠️⚠️注意：
-    如果是下拉框,请加入type:'select',options:_CODE_对应的英文名词Options_CODE_
-    如果是时间范围查询,请加入type:'daterange',name:'对应的英文名词start,对应的英文名词end'
-4.统计条:
-    staticInfo:{has:true/false,text:'具体统计内容'},
-5.表格:
-    {
-        pagination: true/false,
-        expandable: true/false,
-        rowSelection: true/false,
-        operation: [{label:'操作',action:'操作动词+ByRecord'}],
-        columns: [{ title: '普通列', dataIndex:'对应的英文名词' }],
-    }
-    ⚠️⚠️⚠️注意：
-    请不要在columns里加上操作列
-    如果列需要排序请加上sorter:true
-    如果是时间列,请加入render:_CODE_text=>timeRender({time:text})_CODE_
-    如果是序号列直接渲染为{ title: '序号',render: _CODE_(_, record, index) => index + 1_CODE_ }
-    如果是下拉框列(所对应的查询项明确是下拉框),请加入render:_CODE_text=>对应的options.find(item=>item.value===text)?.label_CODE_
-    如果列需要过滤请加上filters:[],onFilter: _CODE_(value, record) => record[对应的英文名词].includes(value)_CODE_
-6.功能按钮
-    functionButton:[{btn:'btn',action:'操作动词+模块英文名词'}]
-    如果和表格行操作重复请在action加上BySelected前缀
-    如果是导出功能,对应的动词为export+对应的英文名词,没有名词则为exportData
-7.下拉选项字典
-    optionDict:{_CODE_对应的英文名词Options_CODE_:[]]}
-    ⚠️⚠️⚠️注意：数组值为对应列展示的内容组成的类似{label:'',value:''}的数组
-8.pageStruct
-    从上至下的页面结构组成
-    ⚠️⚠️⚠️注意:这里只能从AlertInfo,MySearchForm,FunctionButtonsBlock,MyTable中选择,并且只有真的存在才加入，绝对禁止加入其他组件
-    ⚠️⚠️⚠️另外这里不要加入tabs组件
-最后输出一个JSON对象,不要包含任何Markdown标签,格式如下
-    { tabs: [], table: {}, formItems: [],staticInfo:{}, optionDict: {}, functionButton: [],pageStruct:[]}
-`
+# Task: Full-Page UI Analysis & Structural Assembly
+执行全页面视觉特征提取，并按照物理布局顺序输出标准的构筑协议。
+
+## 1. 核心命名协议 (Naming Convention)
+- **驼峰命名**: 所有变量及函数名必须遵循 camelCase。
+- **⚠️ 严禁中文**: 绝对禁止在变量名、键名中使用中文字符。
+- **物理屏蔽关键字**: 禁止使用 JS 保留字 (export, delete, const, let, class, default 等)。
+
+## 2. 零部件构筑规范 (Component Specifications)
+
+### 标签页 (Tabs)
+- **识别条件**: 仅当下部有显著长横线 (Ink Bar) 或呈现包裹感 (Card style) 时判定。
+- **排除项**: 表格上方的独立按钮必须归类为 [functionButton]。
+
+### 搜索项 (FormItems)
+- **基础格式**: [{ label: '文本', name: 'englishName',type:'' }]
+- ⚠️ 属性精简规则:
+    - 默认输入框: 仅保留 [label, name] 属性。**严禁出现 type 属性**。
+    - 非默认组件: 仅当类型为 [auto, date, radio, select, upload, checkbox, textarea, daterange] 时才允许添加 type 属性。
+**标准定义 (Columns)**:
+    - date: 单日期
+    - daterange: 日期范围
+    - enum: 枚举类型
+    - text: 普通文本（默认）
+- 命名规范:
+    - daterange: name 必须设为 '字段英文名start,字段英文名end'。
+
+### 统计条 (StaticInfo)
+- **独立存在**: 位于表格外周的汇总信息。输出格式: { has: true, text: '具体内容' }。
+
+### 表格主体 (Table)
+- **标准项**: {title:'列名', dataIndex:'列名英文名词',type:''}。
+- **配置项**: [pagination, expandable, rowSelection] 均为布尔值。
+- **标准定义 (Columns)**:
+    - ⚠️ **操作锁定**: 严禁在 columns 数组中包含“操作”列。
+    - date: 时间/日期列
+    - money: 金额列
+    - index: 序号列
+    - enum: 枚举列
+    - text: 普通文本（默认）
+    - **行操作 (Operation)**: [{label:'操作名', action:'动词ByRecord'}]。
+
+### 全局功能按钮 (FunctionButton)
+- **格式**: [{btn:'显示文本', action:'动作名'}]。
+- **联动命名**: 若与行操作重复，action 必须加上 'BySelected' 前缀。
+- **导出协议**: action 设为 'exportData' 或 'export+模块名'。
+
+## 3. 布局逻辑编排 (Page Structure)
+- **字段**: [pageStruct] 定义从上至下的物理堆叠顺序。
+- **白名单**: 只能从 [AlertInfo, MySearchForm, FunctionButtonsBlock, MyTable] 中选择。
+- **⚠️ 约束**: 严禁在 pageStruct 中包含 Tabs 或其他未定义组件；并且只有真实存在的组件才能被包含。
+
+## 4. 输出约束 (Output Format)
+- **格式**: 纯 JSON 对象，严禁 Markdown 标签包围。
+- **字典映射 (OptionDict)**: 必须包含所有 select 类型所需的 Options 数组，键名格式为 字段英文名+Options ，元素格式为 {label:'', value:''}。
+
+**JSON 骨架要求**:
+{ "tabs": [], "table": {}, "formItems": [], "staticInfo": {}, "optionDict": {}, "functionButton": [], "pageStruct": [] }
+`.trim();

package/src/prompts/react/watch-part.js

@@ -8,31 +8,39 @@ module.exports = `
 3. 必须严格遵守以下字段规范。
 
 ## 1. 表格 (Table)
-- 结构: { columns: [{ title: '', dataIndex: '' }] }
+- 结构: { columns: [{ title: '列名', dataIndex: '列名英文名词', type: '' }] }
 - ⚠️ 字段白名单: [title, dataIndex, sorter, render, filters, onFilter]
 - 禁止输出:
     - 严禁在 columns 中包含“操作”列。
     - ***⚠️⚠️⚠️严禁输出formItems,只允许输出coloumns⚠️⚠️⚠️***
-- 特殊逻辑:
-    - 时间列: render 必须为 _CODE_text=>timeRender({time:text})_CODE_
-    - 序号列: render 必须为 _CODE_(_, record, index) => index + 1_CODE_
-    - 下拉映射列: render 必须为 _CODE_text=>字段英文名Options.find(item=>item.value===text)?.label_CODE_
+- **标准定义 (Columns)**:
+    - ⚠️ **操作锁定**: 严禁在 columns 数组中包含“操作”列。
+    - date: 时间/日期列
+    - money: 金额列
+    - index: 序号列
+    - enum: 枚举列
+    - text: 普通文本（默认）
+    - **行操作 (Operation)**: [{label:'操作名', action:'动词ByRecord'}]
 
 ## 2. 表单 (Form)
-- 结构: formItems: [{label:'',name:'',type:'',options:[]}]
+- **基础格式**: [{ label: '文本', name: 'englishName',type:'' }]
 - 禁止输出:
     - ***⚠️⚠️⚠️严禁输出columns,只允许输出formItems⚠️⚠️⚠️***
 - ⚠️ 属性精简规则:
     - 默认输入框: 仅保留 [label, name] 属性。**严禁出现 type 属性**。
     - 非默认组件: 仅当类型为 [auto, date, radio, select, upload, checkbox, textarea, daterange] 时才允许添加 type 属性。
+**标准定义 (Columns)**:
+    - date: 单日期
+    - daterange: 日期范围
+    - enum: 枚举类型
+    - text: 普通文本（默认）
 - 命名规范:
     - daterange: name 必须设为 '字段英文名start,字段英文名end'。
-    - 选择类 (radio/select/checkbox): options 必须设为 _CODE_字段英文名Options_CODE_。
 - 增强属性:
     - 必填校验: 若图片中 label 前有红色星号，必须加入 rules:[{required:true,message:'xxx不能为空'}]。
     - 文字单位: 若项末尾有单位（如 元/kg），必须存入 unit 属性。
 
 ## 3. 下拉选项字典 (OptionDict)
-- 结构: optionDict: { _CODE_字段英文名Options_CODE_: [] }
+- 结构: optionDict: { 字段英文名Options: [] }
 - 内容: 数组元素必须为 {label: '', value: ''} 格式。
 `

package/src/services/llm.js

@@ -19,6 +19,7 @@ const getOpenAI = () => {
 }
 
 const askAI = async (model, messages, retryCount = 0) => {
+
     if (retryCount > 3) {
         throw new Error(language(
             'YoRHa 司令部连接中断：请检查网络状态或黑盒共鸣情况。',
@@ -31,6 +32,8 @@ const askAI = async (model, messages, retryCount = 0) => {
         const response = await openai.chat.completions.create({
             model,
             messages,
+            top_p: 0.1,
+            temperature: 0.01,
             response_format: { type: 'json_object' }
         })
         let raw = response.choices[0].message.content.trim()
@@ -38,7 +41,6 @@ const askAI = async (model, messages, retryCount = 0) => {
         const match = raw.match(/[\{\[][\s\S]*[\}\]]/)
         const JSON5 = require('json5')
         return JSON5.parse(match ? match[0] : raw)
-
     } catch (err) {
         const statusCode = err.status || err.response?.status
         const isAuthError = err.message.includes('401') || err.message.includes('402') || [401, 402].includes(statusCode)

package/src/services/proxy-tower.js

@@ -0,0 +1,92 @@
+const http = require('http')
+const zlib = require('zlib')
+const chalk = require('chalk')
+const httpProxy = require('http-proxy')
+const { get } = require('../core/context')
+
+/**
+ * @function startProxyTower
+ * @description [地堡 42153 联合波段] 启动流量拦截塔。
+ * 独立运行于后台，监听 42153 端口，物理截获联调过程中的 JSON 信号并触发语义对齐。
+ */
+module.exports = () => {
+
+    const { config, language, apiHandler, unwrapSignal, isQuerySignal } = get()
+
+    const TOWER_PORT = 42153
+    const hackedRegistry = new Map()
+    const proxy = httpProxy.createProxyServer({})
+
+
+    // 简单的辅助函数：提取 JSON 的所有 Key 作为“指纹”
+    const getJsonFingerprint = obj => {
+        if (!obj || typeof obj !== 'object') return ''
+        return Object.keys(Array.isArray(obj) ? (obj[0] || {}) : obj).sort().join(',')
+    }
+
+    const server = http.createServer((req, res) => {
+
+        const target = config.proxyTarget
+
+        if (!target) {
+            // 静默模式：如果不配置 proxyTarget，拦截塔只转发不处理（或报错提示）
+            return
+        }
+
+        // 💡 物理监控：劫持响应流
+        proxy.on('proxyRes', function (proxyRes, req, res) {
+            let body = []
+            proxyRes.on('data', chunk => body.push(chunk))
+            proxyRes.on('end', async () => {
+                const buffer = Buffer.concat(body)
+                const encoding = proxyRes.headers['content-encoding']
+                try {
+                    const rawBody = encoding === 'gzip' ? zlib.gunzipSync(buffer) : buffer
+                    const json = JSON.parse(rawBody.toString())
+
+                    const coreData = unwrapSignal(json) // 先脱水
+
+                    // 💡 这一步就是地堡的“火控系统”
+                    if (!isQuerySignal(req, json, coreData)) {
+                        return // 增删改信号，直接丢弃，保持静默
+                    }
+
+                    const referer = req.headers.referer || ''
+                    const fileName = referer.split('?')[0].split('/').filter(Boolean).at(-1)
+
+                    const fingerprint = getJsonFingerprint(unwrapSignal(json)) // 获取数据指纹
+                    const lastFingerprint = hackedRegistry.get(fileName)
+
+                    // 如果指纹没变，说明字段结构是一样的，无需再次骇入
+                    if (lastFingerprint === fingerprint) {
+                        return
+                    }
+
+                    console.log(chalk.cyan(language(
+                        `\n📡 Pod 153: 截获运行时信号 [${fileName}]。执行自动对齐协议...`,
+                        `\n📡 Pod 153: Captured runtime signal [${fileName}]. Executing semantic alignment protocol...`
+                    )))
+                    // 💡 直接调用 api-handler 物理更新 resource.js
+                    await apiHandler(null, { fileName, data: json })
+                    hackedRegistry.set(fileName, fingerprint)
+                } catch (e) {
+                    console.log(e)
+                    // 非 JSON 信号，保持静默
+                }
+            })
+        })
+        // 转发至真实后端
+        proxy.web(req, res, { target, changeOrigin: true })
+    })
+
+    server.listen(TOWER_PORT, () => {
+        console.log(chalk.magenta(language(
+            `✨ YoRHa 联合基站：信号拦截塔已在线 [波段: ${TOWER_PORT}]`,
+            `✨ YoRHa Joint Station: Signal Intercept Tower Online [Band: ${TOWER_PORT}]`
+        )))
+        console.log(chalk.gray(language(
+            `💡 指令：请将您的代理目标指向 http://localhost:${TOWER_PORT}`,
+            `💡 Command: Please point your local proxy target to http://localhost:${TOWER_PORT}`
+        )))
+    })
+}

package/src/utils/utils.js

@@ -46,16 +46,45 @@ const getConfig = () => {
  */
 const cleanCode = str => {
     return str
+        // 物理超度 Markdown 糖衣（解决```json 报错）
+        .replace(/```[a-z]*\n?/gi, '')
+        .replace(/```/g, '')
+        // 逻辑自愈 处理 AI 错误转义的引号（把 \" 还原回 "）
+        .replace(/\\"/g, '"')
+        .replace(/['"]?_CODE_([\s\S]*?)_CODE_['"]?/g, '$1') // 去掉 _CODE_ 包裹的代码
+        .replace(/_CODE_/g, '')      // 兜底清理
         .replace(/"(\w+)":/g, '$1:') // 去掉 key 的双引号
         .replace(/"/g, "'")          // 双引号全部转单引号
-        .replace(/['"]_CODE_([\s\S]*?)_CODE_['"]/g, '$1') // 去掉 _CODE_ 包裹的代码
-        .replace(/_CODE_/g, '')      // 兜底清理
         .replace(/[ \t]+$/gm, '')    // 去除每一行行尾的多余空格
         .replace(/\n{3,}/g, '\n\n')  // 将3个或以上的换行符压缩成2个换行符
         .replace(/^\s+/, '')         // 去掉文件头部的空行
         .trim() + '\n'
 }
 
+/**
+ * @function unwrapSignal
+ * @description [地堡数据脱水机] 物理扫描 JSON 结构，剥离业务外壳（code/msg/total 等）。
+ * 目标：精准定位到核心的 Array。
+ */
+const unwrapSignal = json => {
+    if (Array.isArray(json)) return json
+
+    // 💡 扫描常见的数据仓库 Key
+    const dataKeys = ['data', 'list', 'items', 'datas', 'rows', 'result', 'payload', 'results', 'dataList']
+    for (const key of dataKeys) {
+        if (json[key] && Array.isArray(json[key])) return json[key]
+    }
+
+    // 💡 递归侦察：处理 data: { list: [...] } 这种二级套娃
+    for (const key in json) {
+        if (json[key] && typeof json[key] === 'object') {
+            const nested = unwrapSignal(json[key])
+            if (Array.isArray(nested)) return nested
+        }
+    }
+    return null
+}
+
 /**
  * 引导序列
  * 模拟系统引导过程中的动画效果
@@ -79,6 +108,31 @@ const bootSequence = async version => {
     }
 }
 
+/**
+ * @function isQuerySignal
+ * @description [语义雷达]
+ * 核心逻辑：不纠结请求是怎么发的，只看带回来的货（Response）长什么样。
+ */
+const isQuerySignal = (req, json, coreData) => {
+
+    const url = req.url.toLowerCase()
+    // 💡 1. 物理红区：只要 URL 包含这些动作，无论返回什么都视为“非列表”
+    const actionKeywords = ['add', 'delete', 'update', 'save', 'remove', 'edit', 'insert', 'create', 'export', 'upload']
+    if (actionKeywords.some(key => url.includes(key))) return false
+    // 💡 2. 物理金标准：脱壳后的核心物资是一个【非空数组】
+    // 只要带回了一堆长得一样的对象，那它 99.9% 就是列表页
+    const hasListData = Array.isArray(coreData) && coreData.length > 0
+    // 💡 3. 语义辅助：如果响应里包含“分页指纹”
+    // 有时候第一页刚好没数据（coreData 是空数组），但 JSON 里带有 total, page 等字段
+    const hasPaginationFingerprint = ['total', 'records', 'page', 'size', 'count'].some(key => {
+        const k = key.toLowerCase()
+        // 在原始 JSON 的第一层寻找分页相关的 key
+        return Object.keys(json).some(rawKey => rawKey.toLowerCase().includes(k))
+    })
+    // 结论：具备列表特征或者是分页指纹的，判定为查询信号
+    return hasListData || hasPaginationFingerprint
+}
+
 /**
  * 矩阵效果
  * 模拟数据物理封存过程中的矩阵效果
@@ -113,12 +167,15 @@ const matrixEffect = async (duration = 1500) => {
         '5f 43 4f 44 45 5f' // _CODE_
     ]
 
+    const threshold = 3000
     const endTime = Date.now() + duration
-    const isLegendary = currentTotal >= 3000
     const width = process.stdout.columns || 80
+    const isLegendary = currentTotal >= threshold
 
     if (isLegendary) {
-        coreFragments.push(chalk.yellow.bold('33 30 30 30 2b')) // "3000+" 的十六进制
+        const achievement = `${threshold}+`
+        const hex = achievement.split('').map(char => char.charCodeAt(0).toString(16)).join(' ')
+        coreFragments.push(chalk.yellow.bold(hex))
         coreFragments.push(chalk.yellow.bold('4c 45 47 45 4e 44')) // "LEGEND"
     }
 
@@ -128,10 +185,10 @@ const matrixEffect = async (duration = 1500) => {
             console.log(chalk.white(' [System] ') + chalk.green(language('所有构筑数据已同步至 Bunker 存储节点。', 'All data synced to Bunker storage nodes.')))
             if (currentTotal !== 0) {
                 if (isLegendary) {
-                    console.log(chalk.yellow.bold(language(` [Achievement] 物理克隆总数已超越 3000 战略阈值！当前战力：${currentTotal}`, ` [Achievement] Physical clone count has exceeded 3000 strategic threshold! Current power: ${currentTotal}`)))
+                    console.log(chalk.yellow.bold(language(` [Achievement] 物理克隆总数已超越 ${threshold} 战略阈值！当前战力：${currentTotal}`, ` [Achievement] Physical clone count has exceeded ${threshold} strategic threshold! Current power: ${currentTotal}`)))
                     console.log(chalk.yellow(language(' [Bunker] 恭喜指挥官，您的构筑协议已成为人类荣光的一部分。', ' [Bunker] Congratulations, your construction protocol is now part of humanity.')))
                 } else {
-                    console.log(chalk.cyan(language(` [System] 当前构筑总数：${currentTotal}。距离 3000 勋章还剩 ${3000 - currentTotal} 次。`, ` [System] Current clones: ${currentTotal}. ${3000 - currentTotal} to Achievement.`)))
+                    console.log(chalk.cyan(language(` [System] 当前构筑总数：${currentTotal}。距离 ${threshold} 勋章还剩 ${threshold - currentTotal} 次。`, ` [System] Current clones: ${currentTotal}. ${threshold - currentTotal} to Achievement.`)))
                 }
             }
             console.log(chalk.cyan(language(' [System] 如果它能帮您节省时间，请在 GitHub 上给它点个赞 ⭐。', ' [System] If it saves you time, feel free to give it a ⭐ on GitHub.')))
@@ -168,34 +225,54 @@ const getExistingMenus = (dir = 'src/pages') => {
 }
 
 /**
- * 生成智能导入语句
- * 根据代码中实际使用的依赖，自动生成对应的 import 语句
- * @param {string} codeStr - 生成的代码字符串
- * @param {boolean} hasTabs - 是否包含标签页
- * @returns {string} 拼接后的 import 语句
+ * @function formatFormItemAndColumns
+ * @description [地堡逻辑转录引擎] 执行核心的语义对齐与代码物理注入协议。
+ * 该函数负责将 AI 识别出的视觉类型标签（money/date/enum等）转化为标准的 React 渲染逻辑，
+ * 并自动提取全频道所需的字典引用（Dictionary Blocks）。
+ *
+ * @param {Object} params - 构筑参数包
+ * @param {Object} params.pageConfig - 由 Pod 042 扫描出的原始页面配置对象
+ *
+ * @returns {Object} 返回物理装配完成的数据包：
+ * @returns {Array} .formItems - 已注入 Options 指令的表单零部件清单
+ * @returns {Array} .processedColumns - 已执行逻辑注入（Render 补丁）的表格列清单
+ * @returns {Array} .dictBlocks - 全频道去重后的字典（Options）变量名清单
  */
-const generateSmartImports = (codeStr, hasTabs) => {
-    const hooksLib = ['useTableQuery']
-    const reactLib = ['useState', 'useEffect', 'useRef', 'useMemo']
-    const componentsLib = ['MyTable', 'MyModalForm', 'MySearchForm']
-    const antdLib = ['Card', 'Space', 'Modal', 'Button', 'Alert', 'Table', 'Input', 'Select']
+const formatFormItemAndColumns = ({ pageConfig }) => {
 
-    const usedAntd = antdLib.filter(name => new RegExp(`\\b${name}\\b`).test(codeStr))
-    const usedHooks = hooksLib.filter(name => new RegExp(`\\b${name}\\b`).test(codeStr))
-    const usedReact = reactLib.filter(name => new RegExp(`\\b${name}\\b`).test(codeStr))
-    const usedComps = componentsLib.filter(name => new RegExp(`\\b${name}\\b`).test(codeStr))
+    const codePresets = {
+        money: 'text => moneyRender(text)',
+        date: 'text => timeRender({time: text})',
+        index: '(_, record, index) => index + 1',
+        enum: dataIndex => `text => ${dataIndex}Options.find(item => item.value === text)?.label??text`
+    }
 
-    const imports = [
-        usedReact.length && `import { ${usedReact.join(', ')} } from 'react'`,
-        `import { request } from '../../utils/request'`,
-        `import { formatQuery } from '../../utils/utils'`,
-        `import { ${hasTabs ? 'tabs, ' : ''}formItems, modalItems, tableColumns} from './resource'`,
-        ...usedHooks.map(hook => `import { ${hook} } from '../../hooks/${hook}'`),
-        ...usedComps.map(comp => `import { ${comp} } from '../../components/${comp}'`),
-        usedAntd.length && `import { Form, ${usedAntd.join(', ')} } from 'antd'`
-    ].sort((a, b) => a.length - b.length)
+    const columns = pageConfig.table?.columns ?? pageConfig?.columns ?? []
 
-    return imports.filter(Boolean).join('\n')
+    const tableDicts = columns?.filter(item => item.type === 'enum')?.map(item => `${item.dataIndex}Options`) ?? []
+    const formDicts = pageConfig.formItems?.filter(item => item.type === 'select')?.map(item => `${item.name}Options`) ?? []
+    const dictBlocks = Array.from(new Set([...formDicts, ...tableDicts]))
+
+    const formItems = pageConfig.formItems?.map(item => ({
+        ...item,
+        ...(item.type === 'select' ? { options: `_CODE_${item.name}Options_CODE_` } : {})
+    }))
+
+    const processedColumns = columns?.map(col => {
+        if (col.type && codePresets[col.type]) {
+            // 💡 物理注入：根据标签，强行塞入标准化的 JS 代码字符串
+            const renderCode = typeof codePresets[col.type] === 'function' ? codePresets[col.type](col.dataIndex) : codePresets[col.type]
+            delete col.type
+            return {
+                ...col,
+                render: `_CODE_${renderCode}_CODE_` // 重新打标，交给 cleanCode 处理
+            }
+        }
+        delete col.type
+        return col
+    })
+
+    return { formItems, dictBlocks, processedColumns }
 }
 
 /**
@@ -218,4 +295,35 @@ const copyTemplateDir = (options, templateSubDir, targetSubDir) => {
     })
 }
 
-module.exports = { language, getConfig, cleanCode, matrixEffect, bootSequence, getExistingMenus, copyTemplateDir, generateSmartImports }
+/**
+ * 生成智能导入语句
+ * 根据代码中实际使用的依赖，自动生成对应的 import 语句
+ * @param {string} codeStr - 生成的代码字符串
+ * @param {boolean} hasTabs - 是否包含标签页
+ * @returns {string} 拼接后的 import 语句
+ */
+const generateSmartImports = ({ bodyCode, hasTabs, hasFormItems }) => {
+    const hooksLib = ['useTableQuery']
+    const reactLib = ['useState', 'useEffect', 'useRef', 'useMemo']
+    const componentsLib = ['MyTable', 'MyModalForm', 'MySearchForm']
+    const antdLib = ['Card', 'Space', 'Modal', 'Button', 'Alert', 'Table', 'Input', 'Select']
+
+    const usedAntd = antdLib.filter(name => new RegExp(`\\b${name}\\b`).test(bodyCode))
+    const usedHooks = hooksLib.filter(name => new RegExp(`\\b${name}\\b`).test(bodyCode))
+    const usedReact = reactLib.filter(name => new RegExp(`\\b${name}\\b`).test(bodyCode))
+    const usedComps = componentsLib.filter(name => new RegExp(`\\b${name}\\b`).test(bodyCode))
+
+    const imports = [
+        usedReact.length && `import { ${usedReact.join(', ')} } from 'react'`,
+        `import { request } from '../../utils/request'`,
+        `import { formatQuery } from '../../utils/utils'`,
+        ...usedHooks.map(hook => `import { ${hook} } from '../../hooks/${hook}'`),
+        ...usedComps.map(comp => `import { ${comp} } from '../../components/${comp}'`),
+        usedAntd.length && `import { ${hasFormItems ? 'Form, ' : ''}${usedAntd.join(', ')} } from 'antd'`,
+        `import { ${hasTabs ? 'tabs, ' : ''}${hasFormItems ? 'formItems, ' : ''}modalItems, tableColumns} from './resource'`,
+    ].sort((a, b) => a.length - b.length)
+
+    return imports.filter(Boolean).join('\n')
+}
+
+module.exports = { language, getConfig, cleanCode, unwrapSignal, matrixEffect, bootSequence, isQuerySignal, getExistingMenus, copyTemplateDir, generateSmartImports, formatFormItemAndColumns }

package/templates/react/components/index.js

@@ -40,6 +40,7 @@ const AliyunOSSUpload = ({ value, onChange, ...restProps }) => {
         try {
             const result = await initOSS(url, options)
             setOSSData(result)
+            return result
         } catch (err) {
             console.log(err)
         }
@@ -79,12 +80,13 @@ const AliyunOSSUpload = ({ value, onChange, ...restProps }) => {
      * 若令牌已失效（过期），则强行拦截并执行同步刷新协议，同时执行物理路径归一化。
      */
     const beforeUpload = async file => {
+        let currentOSS = OSSData
         const expire = Number(OSSData.expire) * 1000
         if (expire < Date.now()) {
-            await init()
+            currentOSS = await init()
         }
         // 💡 物理路径重组：通过正则清除多余的路径分隔符，确保存储节点坐标唯一
-        file.url = `${OSSData?.dir ?? path}/${file.uid}_${file.name}`.replace(/\/\//g, '/')
+        file.url = `${currentOSS?.dir ?? path}/${file.uid}_${file.name}`.replace(/\/\//g, '/')
         return file
     }
 

package/templates/react/handlebars/handleBlock.hbs

@@ -1,7 +1,3 @@
-{{!--
-   📡 [地堡战术响应模组]
-   负责物理封存所有交互事件：包含行级操作、全局按钮、页签切换及弹窗构筑提交。
---}}
 {{#each operations}}
 const {{this.action}} = async record => {
     const response = await request('/api')

package/templates/react/handlebars/hookBlock.hbs

@@ -1,9 +1,3 @@
-{{!--
-   📡 [地堡核心驱动引擎]：逻辑链路全自动构筑
-   1. 执行“传感器对齐”：从 URL 中提取历史信号，实现状态持久化
-   2. 激活“useTableQuery”：物理封存分页、搜索、及动态列加载逻辑
---}}
-
 const initParams = {{#if hasTabs}}{ type: tabs[0].key }{{else}}{}{{/if}}
 
 const query = formatQuery(Object.fromEntries(new URLSearchParams(location.search).entries()),  {{formItems}})

package/templates/react/handlebars/stateBlock.hbs

@@ -1,8 +1,8 @@
 
-{{!-- 📡 [地堡状态模组] 物理信号初始化：驱动弹窗、页签及数据勾选等核心交互单元 --}}
 const rowKey = 'id'
+{{#if hasFormItems}}
 const [form] = Form.useForm()
-const [modal, setModal] = useState({ visible:false, title:'', formItems:modalItems })
+{{/if}}
 {{#if hasRowSelection}}
 const [selectedRows, setSelectedRows] = useState([])
 {{/if}}
@@ -11,4 +11,5 @@ const [activeKey, setActiveKey] = useState(tabs[0].key)
 {{/if}}
 {{#if hasExpandable}}
 const [expandedRowKeys, setExpandedRowKeys] = useState([])
-{{/if}}
+{{/if}}
+const [modal, setModal] = useState({ visible:false, title:'', formItems:modalItems })