tha-cli 0.1.2 → 0.1.4

package/ARCHITECTURE.md

@@ -1,8 +1,8 @@
 # THA 架构设计
 
 > 本文讲**为什么这么设计**：要解决什么、靠什么结构解决、代价是什么。
-> 怎么安装、`config.ts` 怎么写、命令怎么用，见 [README.md](https://gitee.com/JonnyWen6699/tha-cli/blob/main/README.md)。
-> 每条约束的原话在 `tha/verify/rules.mjs`，本文引用的都是那里的 `basis`。
+> 怎么安装、`config.ts` 怎么写、命令怎么用，见 README.md。
+> 每条边界规则的实现见 `tha/eslint-rules/`，本文引用的都是规则的设计依据。
 
 ---
 
@@ -103,30 +103,53 @@ view → hub → executor → step
 
 ---
 
-## 5. 边界不靠人记，靠工具查
+## 5. 边界不靠人记，靠 ESLint 实时查
 
-架构约束写在文档里，没人会读；写成可执行的检查，才有约束力。三个机制：
+架构约束写在文档里，没人会读；写成可执行的检查，才有约束力。而且，**事后检查不如实时检查**——写错的那一刻编辑器就有红线，比提交前跑一遍 CLI 有效得多。
 
-### 5.1 规则表与判断逻辑分离
+因此边界检查全部交给 ESLint，CLI 只负责自动装和写配置。
 
-`tha/verify/rules.mjs` 只保留规则的自然语言描述——`id` / `level` / `title` / `basis` / `fix`；
-判断逻辑在 `tha/verify/boundary.mjs`。改文案不动逻辑，改逻辑不动文案。
+### 5.1 为什么选 ESLint，不自己写检查器
 
-### 5.2 每条规则带 `basis`
+| 方案 | 优点 | 缺点 |
+|---|---|---|
+| 自己写检查器 | 依赖少，完全可控 | 编辑器要自己写插件，VSCode / WebStorm 都得写一套；热更新要自己做 |
+| ESLint | 编辑器原生支持（VSCode / WebStorm 都有扩展），实时红线；生态成熟 | 依赖包多，要手动装 |
 
-`basis` 直接引用架构原话。输出违规时，能回溯到「哪条约束被破了」，而不是「工具说不行」。
+选 ESLint 的原因：**不干扰开发者现有习惯**。开发者已经在用 ESLint，不需要再学新工具；VSCode / WebStorm 的 ESLint 扩展已经装好，打开项目就生效。
 
-违规条目按这个形状输出：
+代价是依赖包多，但这个问题由 `tha init` 自动解决——一行命令装完所有依赖、写好配置，开发者不用动手。
 
-```
-src/domains/doc/index.ts:1  HUB-03
-  问题：模块入口不是单例，被重复创建
-  没找到缓存的实例（每次调用都会新建一个）
-  应该：在模块顶层用 let 缓存：if (!module) module = createXxxModule()
-  依据：每个领域全局唯一实例，视图不能各造一个「私人大脑」
-```
+### 5.2 8 条边界规则
+
+每条规则是一个独立的 ESLint 插件文件，放在 `tha/eslint-rules/` 目录下：
+
+| 规则 ID | 层级 | 检查内容 |
+|---|---|---|
+| `tha/hub-no-import-steps` | HUB-01 | 中枢不许 import 执行器内部步骤 |
+| `tha/executor-no-cross-import` | EXE-01 | 执行器之间不许互相 import |
+| `tha/executor-no-import-api` | EXE-02 | 执行器不许 import 网络层、状态层、路由 |
+| `tha/executor-no-import-utils` | EXE-03 | 执行器不许 import 传输工具，必须经 ctx 注入 |
+| `tha/view-no-import-api` | VIEW-01 | 视图不许直接 import api 层、传输工具、执行器内部 |
+| `tha/view-no-create-module` | VIEW-02 | 视图不许自己创建中枢实例 |
+| `tha/store-no-import-api` | STORE-01 | 状态层不许发请求 |
+| `tha/util-no-import-ui` | UTIL-01 | 基础工具不许 import UI 组件 |
+
+规则只检查单文件内的 import 语句，不做跨文件分析——ESLint 擅长这个，跨文件规则交给 `tha check` 做。
 
-### 5.3 `import type` 一律放行
+### 5.3 `tha init` 自动完成一切
+
+`tha init` 做五件事：
+
+1. **检测环境**：项目里有没有 ESLint、有没有 Vue
+2. **自动装依赖**：缺什么装什么（eslint、@typescript-eslint、eslint-plugin-vue）
+3. **自动写配置**：生成 `eslint.config.js`，把 8 条规则写进去
+4. **自动跑 sync**：生成标准代码
+5. **自动改 dev script**：把 `tha watch` 加进 `npm run dev`
+
+开发者不需要手动装任何包、不需要手动写任何配置。一行 `tha init` 之后，编辑器里就有实时红线了。
+
+### 5.4 `import type` 一律放行
 
 类型不构成运行时依赖。只查值导入，规则才不至于因噎废食。
 
@@ -167,20 +190,22 @@ src/domains/doc/index.ts:1  HUB-03
 
 ## 9. 规则索引
 
-| id | 级别 | 约束原话（`basis`） |
-|---|---|---|
-| HUB-01 | error | 中枢只做分发：把意图交给执行器；禁止直接依赖执行器内部步骤 |
-| HUB-03 | warn | 每个领域全局唯一实例，视图不能各造一个「私人大脑」 |
-| EXE-01 | error | 执行器之间互不引用：共用逻辑下沉成零件，用例顺序留在各自执行器里 |
-| EXE-02 | error | 执行器只认 ctx：网络走 ctx.api，状态走 ctx.state |
-| EXE-03 | error | 执行器只认 ctx：日志 / 时钟 / 流 / 鉴权走 ctx.ports，判定走 ctx.errors |
-| STEP-01 | warn | 零件是「同一段步骤被第二个用例用到」才下沉的；只有一个使用者是过度设计 |
-| VIEW-01 | error | 视图只表达意图：动作走域中枢，数据直读状态层 |
-| VIEW-02 | error | 每个领域全局唯一实例：视图只能经 useXxxModule() 取，不能自己 create |
-| STORE-01 | error | 状态层只存状态，不发请求 |
-| UTIL-01 | error | 传输层只上报不越权：不感知业务模块，不做展示 |
-
-规则真源：[`tha/verify/rules.mjs`](https://gitee.com/JonnyWen6699/tha-cli/blob/main/tha/verify/rules.mjs)　判断逻辑：[`tha/verify/boundary.mjs`](https://gitee.com/JonnyWen6699/tha-cli/blob/main/tha/verify/boundary.mjs)
+| id | 级别 | 约束原话（`basis`） | 实现位置 |
+|---|---|---|---|
+| HUB-01 | error | 中枢只做分发：把意图交给执行器；禁止直接依赖执行器内部步骤 | ESLint |
+| HUB-03 | warn | 每个领域全局唯一实例，视图不能各造一个「私人大脑」 | 待实现 |
+| EXE-01 | error | 执行器之间互不引用：共用逻辑下沉成零件，用例顺序留在各自执行器里 | ESLint |
+| EXE-02 | error | 执行器只认 ctx：网络走 ctx.api，状态走 ctx.state | ESLint |
+| EXE-03 | error | 执行器只认 ctx：日志 / 时钟 / 流 / 鉴权走 ctx.ports，判定走 ctx.errors | ESLint |
+| STEP-01 | warn | 零件是「同一段步骤被第二个用例用到」才下沉的；只有一个使用者是过度设计 | 待实现 |
+| VIEW-01 | error | 视图只表达意图：动作走域中枢，数据直读状态层 | ESLint |
+| VIEW-02 | error | 每个领域全局唯一实例：视图只能经 useXxxModule() 取，不能自己 create | ESLint |
+| STORE-01 | error | 状态层只存状态，不发请求 | ESLint |
+| UTIL-01 | error | 传输层只上报不越权：不感知业务模块，不做展示 | ESLint |
+
+ESLint 规则实现：`tha/eslint-rules/`　配置自动生成：`tha/utils/eslint.mjs`
+
+`HUB-03` 和 `STEP-01` 是跨文件规则，ESLint 单文件检查不好做，后续版本会补回 `tha check` 里。
 
 `EXE-03` 提到的 `ctx.ports` / `ctx.errors` 是架构原话里的完整形态；生成器当前的 `context.ts` 只给最小集（`state` / `api` / `ui` / `run` / `can`），需要时按 3.2 往上下文里加。
 
@@ -188,6 +213,6 @@ src/domains/doc/index.ts:1  HUB-03
 
 ## 10. 相关文档
 
-- [README.md](https://gitee.com/JonnyWen6699/tha-cli/blob/main/README.md)——安装、命令、`config.ts` 全量配置项、契约与退出码
+- README.md——安装、命令、`config.ts` 全量配置项、契约与退出码
 - `tha/generate/domain/`——每一类生成物的模板，是「形状」的可执行版本
 - `tha/verify/rules.mjs`——规则真源，改架构先改这里

package/README.md

@@ -1,12 +1,13 @@
 # tha-cli
 
-THA 架构的构建期工具。**生成器负责产出标准代码，检查器负责保障分层边界不被破坏。**
+THA 架构的构建期工具。**一行 init 完成全部配置：自动装依赖、自动写 ESLint 规则、自动生成代码、自动接入开发流程。**
 
 - **生成器**：读 `domains/<域>/config.ts`，生成标准文件（基线 5 个，按 `pages` 追加详情 / 表单）和全局注册表。
-- **检查器**：没有 `config.ts` 的手写模块，不生成，只按层查边界。
+- **边界检查**：内置 8 条 ESLint 规则，`init` 自动安装 ESLint 并写好配置，编辑器里实时红线提示。
+- **热更新**：`tha watch` 监听配置文件变化，改完自动跑 sync，无需手动执行命令。
 - **自带基线**：`init` 自动补齐生成物所需的组件和工具，空项目也可直接使用。
 
-设计思想、取舍与代价见 [ARCHITECTURE.md](https://gitee.com/JonnyWen6699/tha-cli/blob/main/ARCHITECTURE.md)；本文只讲怎么用。
+设计思想、取舍与代价见 ARCHITECTURE.md；本文只讲怎么用。
 
 ---
 
@@ -30,7 +31,7 @@ utils       基础    纯函数、远端传输
 
 这套约束的目的很单一：业务逻辑集中维护，边界由工具保障，无需人工记忆。
 
-为什么这么切分、每条约束的原话和代价，见 [ARCHITECTURE.md](https://gitee.com/JonnyWen6699/tha-cli/blob/main/ARCHITECTURE.md)。
+为什么这么切分、每条约束的原话和代价，见 ARCHITECTURE.md。
 
 ---
 
@@ -39,7 +40,8 @@ utils       基础    纯函数、远端传输
 | 模式 | 输入 | 产物 |
 |---|---|---|
 | 生成器 | `config.ts` | 标准 CRUD 的 api / store / context / 执行器 / 页面 / 路由 / 菜单 |
-| 检查器 | 任意源码 | 违规清单（10 条边界规则 + 契约比对） |
+| ESLint 规则 | 内置 8 条边界规则 | `init` 自动写进 `eslint.config.js`，编辑器实时检查 |
+| 配置检查 | 项目源码 | 契约比对 + 文件一致性 + ESLint 配置完整性 |
 
 它不生成业务逻辑。`config.ts` 声明模块的字段与动作范围，工具据此生成标准代码；复杂逻辑由开发者编写，置于自定义执行器中，工具不覆盖。
 
@@ -62,12 +64,21 @@ npx tha-cli check
 ## 快速开始
 
 ```bash
-tha init doc        # 建 config 模板，不生成代码
+tha init doc        # 自动装 ESLint + 写配置 + 生成代码 + 改 dev script
 # 编辑 src/domains/doc/config.ts
-tha sync            # 生成 5 个文件；中枢缺失时补一次骨架
-tha check           # 检查：配置 + 契约 + 边界检查 + 文件一致性
+# 保存后 tha watch 会自动跑 sync，无需手动执行
 ```
 
+一行 `tha init` 完成全部初始化：
+
+1. 检测项目环境（有没有 ESLint、有没有 Vue）
+2. 自动安装所需依赖（eslint、@typescript-eslint、eslint-plugin-vue）
+3. 自动写 `eslint.config.js`，内置 8 条边界规则
+4. 自动生成标准代码
+5. 自动改 `package.json` 的 dev script，把 `tha watch` 加进去
+
+编辑器打开项目后，VSCode / WebStorm 的 ESLint 扩展会自动识别配置，写错 import 立刻有红线提示。
+
 CI：
 
 ```bash
@@ -82,9 +93,10 @@ tha check --json     # 机器可消费
 
 | 命令 | 作用 |
 |---|---|
-| `tha init <域>` | 建 config 模板 + 补齐基线（`--bare` 只写 config） |
+| `tha init <域>` | 一键初始化：自动装 ESLint + 写配置 + 生成代码 + 改 dev script |
 | `tha sync [<域>]` | 生成 / 更新标准 CRUD 与注册表；补一次中枢骨架 |
-| `tha check` | 只检查不写：配置 + 契约（响应与请求体）+ 边界检查 + 文件一致性 |
+| `tha watch` | 监听 `domains/*/config.ts` 变化，自动跑 sync（debounce 500ms） |
+| `tha check` | 只检查不写：配置 + 契约（响应与请求体）+ 文件一致性 + ESLint 配置完整性 |
 | `tha diff` | 显示将要发生的文件变化 |
 | `tha remove <域>` | 删模块：生成物清掉，手写文件保留；保留的文件若还引用已删生成物会明确报出来 |
 | `tha adopt <文件...>` | 这个文件以后你自己维护：不再自动生成，但分层规则照样查 |
@@ -298,29 +310,31 @@ api: { base: '/docs', contract: 'docs/openapi.json' }   // 接后端契约比对
 
 ---
 
-## 护栏：10 条边界规则
+## 边界检查：ESLint 实时红线
 
-规则唯一真源在 `tha/verify/rules.mjs`，每条带 `id` / `level` / `basis`（架构原话）/ `fix`。
+边界检查全部交给 ESLint，`tha init` 自动完成全部配置。编辑器打开项目后，写错 import 立刻有红线提示，不需要等提交前跑 CLI。
 
-| id | 级别 | 判据 |
+8 条单文件规则，每条对应一个 ESLint 插件文件：
+
+| 规则 | 级别 | 检查内容 |
 |---|---|---|
-| HUB-01 | error | 中枢直接 import `./steps/*` |
-| HUB-03 | warn | 中枢不是模块级单例 |
-| EXE-01 | error | 执行器之间互相 import |
-| EXE-02 | error | 执行器 / 零件值导入网络层、状态层、路由 |
-| EXE-03 | error | 执行器 / 零件值导入 `@/utils/*`（纯函数白名单除外） |
-| STEP-01 | warn | 零件只被 0 或 1 个执行器使用 |
-| VIEW-01 | error | 视图值导入网络层 / 传输层 / 执行器内部 |
-| VIEW-02 | error | 视图直接 `createXxxModule()`，绕开单例 |
-| STORE-01 | error | 状态层 import 网络层 |
-| UTIL-01 | error | 基础设施 import UI 库或业务模块 |
+| `tha/hub-no-import-steps` | error | 中枢直接 import `./steps/*` |
+| `tha/executor-no-cross-import` | error | 执行器之间互相 import |
+| `tha/executor-no-import-api` | error | 执行器值导入网络层、状态层、路由 |
+| `tha/executor-no-import-utils` | error | 执行器值导入 `@/utils/*`（纯函数白名单除外） |
+| `tha/view-no-import-api` | error | 视图值导入网络层 / 传输层 / 执行器内部 |
+| `tha/view-no-create-module` | error | 视图直接 `createXxxModule()`，绕开单例 |
+| `tha/store-no-import-api` | error | 状态层 import 网络层 |
+| `tha/util-no-import-ui` | error | 基础设施 import UI 库或业务模块 |
 
 约定：
 
 - `import type` 一律放行（类型不构成运行时依赖）。
-- 检查**按层扫**：`views/`、`stores/`、`utils/` 全局一遍，`domains/<域>/` 按模块。
-- 手写模块靠目录形状识别：有 `index.ts` / `executors/` / `context.ts`，但没有 `config.ts`。
-- `PURE_UTILS` 白名单在 `rules.mjs` 里声明，不再靠 eslint 注释豁免。
+- 规则实现：`tha/eslint-rules/` 目录下，每条规则一个文件。
+- 配置自动生成：`tha init` 检测项目环境，自动装依赖、自动写 `eslint.config.js`。
+- VSCode / WebStorm 的 ESLint 扩展原生支持，不需要额外装插件。
+
+跨文件规则（中枢单例检查、零件复用数检查）是 warn 级别，后续版本会补回 `tha check` 命令里。
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tha-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "THA 架构的构建期工具：产线生成标准增删改查，护栏守住分层边界。",
   "type": "module",
   "author": "温强 <373601967@qq.com>",

package/tha/cli.mjs

@@ -6,6 +6,7 @@ import { runDiff } from './commands/diff.mjs'
 import { runSync } from './commands/sync.mjs'
 import { runRemove } from './commands/remove.mjs'
 import { runAdopt } from './commands/adopt.mjs'
+import { runWatch } from './commands/watch.mjs'
 import { configureStyle, ui } from './utils/style.mjs'
 
 const COMMANDS = {
@@ -13,6 +14,7 @@ const COMMANDS = {
   check: runCheck,
   diff: runDiff,
   sync: runSync,
+  watch: runWatch,
   remove: runRemove,
   adopt: runAdopt
 }

package/tha/commands/check.mjs

@@ -4,10 +4,10 @@ import { buildPlan } from '../generate/plan.mjs'
 import { comparePlan } from '../utils/compare.mjs'
 import { parseArgs } from '../utils/args.mjs'
 import { printErrors, printHeader } from '../utils/output.mjs'
-import { checkBoundaries } from '../verify/boundary.mjs'
 import { checkContracts } from '../verify/contract.mjs'
 import { checkOpenApiContracts } from '../verify/openapi.mjs'
 import { describeConfigured } from '../verify/scan.mjs'
+import { checkEslintConfig } from '../utils/eslint.mjs'
 import { glyph, ui } from '../utils/style.mjs'
 
 export function runCheck({ root, args }) {
@@ -49,17 +49,19 @@ export function runCheck({ root, args }) {
   ]
   const contractErrors = contracts.filter((item) => (item.level ?? 'error') === 'error')
   const contractWarns = contracts.filter((item) => item.level === 'warn')
-  const guards = checkBoundaries(modules, root, project.dirs)
-  const guardErrors = guards.filter((item) => item.level === 'error')
-  const guardWarns = guards.filter((item) => item.level === 'warn')
 
-  // 契约违约、漂移、手改、护栏 error，都让 CI 红；warn 只在 --strict 时红
+  // ESLint 配置完整性检查
+  const eslintProblems = checkEslintConfig(root)
+  const eslintErrors = eslintProblems.filter((item) => item.level === 'error')
+  const eslintWarns = eslintProblems.filter((item) => item.level === 'warn')
+
+  // 契约违约、漂移、手改、ESLint 配置错误，都让 CI 红；warn 只在 --strict 时红
   const failed =
     drift.length > 0 ||
     blocked > 0 ||
     contractErrors.length > 0 ||
-    guardErrors.length > 0 ||
-    (flags.strict && (contractWarns.length > 0 || guardWarns.length > 0))
+    eslintErrors.length > 0 ||
+    (flags.strict && (contractWarns.length > 0 || eslintWarns.length > 0))
 
   if (failed) process.exitCode = 1
 
@@ -118,21 +120,18 @@ export function runCheck({ root, args }) {
     }
   }
 
-  if (guards.length > 0) {
+  if (eslintProblems.length > 0) {
     console.log('')
     console.log(
-      `  ${ui.danger(glyph.err)} ${ui.label(
-        `分层规则被破坏：${guardErrors.length} 处错误、${guardWarns.length} 处提醒`,
-        `Layering rules broken: ${guardErrors.length} errors, ${guardWarns.length} warnings`
+      `  ${ui.warning(glyph.warn)} ${ui.label(
+        `ESLint 配置：${eslintErrors.length} 处错误、${eslintWarns.length} 处提醒`,
+        `ESLint config: ${eslintErrors.length} errors, ${eslintWarns.length} warnings`
       )}`
     )
-    for (const item of guards) {
-      const badge = item.level === 'error' ? ui.danger(item.rule) : ui.warning(item.rule)
-      console.log(`    ${ui.path(`${item.file}:${item.line}`)} ${badge}`)
-      console.log(`      问题：${item.message}`)
-      if (item.note) console.log(`      ${ui.muted(item.note)}`)
-      console.log(`      应该：${item.fix}`)
-      console.log(`      ${ui.muted(`依据：${item.basis}`)}`)
+    for (const item of eslintProblems) {
+      const badge = item.level === 'error' ? ui.danger(glyph.err) : ui.warning(glyph.warn)
+      console.log(`    ${badge} ${ui.path(item.file)}`)
+      console.log(`      ${ui.muted(item.message)}`)
     }
   }
 

package/tha/commands/init.mjs

@@ -9,6 +9,8 @@ import { parseArgs } from '../utils/args.mjs'
 import { absolute, exists, read, writeAtomic } from '../utils/files.mjs'
 import { glyph, ui } from '../utils/style.mjs'
 import { printNextSteps } from '../utils/output.mjs'
+import { detectEslintEnv, installEslintDeps, writeEslintConfig, verifyEslintRules } from '../utils/eslint.mjs'
+import { runSync } from './sync.mjs'
 
 // 生成物会 import 的基线文件：空项目里没有，init 时补上（不覆盖已有文件）
 const BASELINE = [
@@ -145,6 +147,48 @@ export async function runInit({ root, args }) {
     const baseline = flags.bare ? { created: [], skipped: [] } : ensureBaseline(root, dirs)
     const dirsConfig = flags.config ? ensureDirsConfig(root) : null
 
+    // ESLint 自动配置：检测 → 装依赖 → 写配置 → 验证
+    let eslintResult = null
+    if (!flags.bare && !flags['dry-run']) {
+      const env = detectEslintEnv(root)
+      let installed = []
+      let installFailed = []
+
+      if (!env.hasEslint) {
+        console.log('')
+        console.log(`  ${ui.label('检测到项目没有 ESLint，自动安装...', 'Installing ESLint...')}`)
+        const result = installEslintDeps(root, env)
+        installed = result.installed
+        installFailed = result.failed
+      }
+
+      const configResult = writeEslintConfig(root, env)
+      const verifyResult = env.hasEslint || installed.length > 0
+        ? verifyEslintRules(root)
+        : { ok: false, message: '' }
+
+      eslintResult = { env, installed, installFailed, configResult, verifyResult }
+    }
+
+    // 自动跑一次 sync，直接生成全套文件
+    let syncResult = null
+    if (!flags.bare && !flags['dry-run'] && !flags.json) {
+      console.log('')
+      console.log(`  ${ui.label('自动生成代码...', 'Generating code...')}`)
+      try {
+        await runSync({ root, args: [name, '--yes'] })
+        syncResult = { ok: true }
+      } catch (error) {
+        syncResult = { ok: false, message: error.message }
+      }
+    }
+
+    // 自动改 package.json 的 dev script，加上 tha watch
+    let packageJsonResult = null
+    if (!flags.bare && !flags['dry-run']) {
+      packageJsonResult = updateDevScript(root)
+    }
+
     if (flags.json) {
       console.log(
         JSON.stringify(
@@ -179,6 +223,46 @@ export async function runInit({ root, args }) {
       console.log(`  ${ui.muted(`目录映射示例已写入 ${dirsConfig}，改完删掉即回默认`)}`)
     }
 
+    // ESLint 配置结果
+    if (eslintResult) {
+      console.log('')
+      if (eslintResult.installed.length > 0) {
+        console.log(`  ${ui.success(glyph.ok)} ${ui.label('ESLint 依赖已安装', 'ESLint installed')}`)
+        console.log(`    ${ui.muted(eslintResult.installed.join(', '))}`)
+      }
+      if (eslintResult.installFailed.length > 0) {
+        console.log(`  ${ui.warning(glyph.warn)} ${ui.label('ESLint 部分依赖安装失败', 'Some ESLint deps failed')}`)
+        console.log(`    ${ui.muted('请手动安装：npm i -D ' + eslintResult.installFailed.join(' '))}`)
+      }
+      if (eslintResult.configResult.written) {
+        console.log(`  ${ui.success(glyph.ok)} ${ui.label('ESLint 配置已生成', 'ESLint config created')}`)
+        console.log(`    ${ui.path(eslintResult.configResult.written)}`)
+      }
+      if (eslintResult.configResult.skipped) {
+        console.log(`  ${ui.muted('已有 ESLint 配置，未覆盖（可手动加 tha 规则）')}`)
+      }
+      if (eslintResult.verifyResult.ok) {
+        console.log(`  ${ui.success(glyph.ok)} ${ui.label('THA 规则已生效', 'THA rules active')}`)
+      }
+    }
+
+    // sync 结果
+    if (syncResult) {
+      console.log('')
+      if (syncResult.ok) {
+        console.log(`  ${ui.success(glyph.ok)} ${ui.label('代码已自动生成', 'Code generated')}`)
+      } else {
+        console.log(`  ${ui.warning(glyph.warn)} ${ui.label('自动生成失败，可手动跑 tha sync', 'Auto sync failed')}`)
+        console.log(`    ${ui.muted(syncResult.message)}`)
+      }
+    }
+
+    // package.json 结果
+    if (packageJsonResult && packageJsonResult.updated) {
+      console.log(`  ${ui.success(glyph.ok)} ${ui.label('已加入 dev script', 'Added to dev script')}`)
+      console.log(`    ${ui.muted('npm run dev 现在会自动跑 tha watch')}`)
+    }
+
     console.log('')
     printNextSteps()
   } finally {
@@ -221,6 +305,34 @@ function ensureDirsConfig(root) {
   return CONFIG_FILE
 }
 
+/**
+ * 自动改 package.json 的 dev script，加上 tha watch
+ */
+function updateDevScript(root) {
+  const pkgPath = path.join(root, 'package.json')
+  if (!exists(pkgPath)) return null
+
+  try {
+    const pkg = JSON.parse(read(pkgPath))
+    if (!pkg.scripts) pkg.scripts = {}
+
+    const currentDev = pkg.scripts.dev || ''
+    if (currentDev.includes('tha watch')) {
+      return { updated: false, reason: 'already has tha watch' }
+    }
+
+    // 把 tha watch 加到 dev 命令前面
+    pkg.scripts.dev = currentDev
+      ? `tha watch & ${currentDev}`
+      : 'tha watch'
+
+    writeAtomic(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+    return { updated: true, script: pkg.scripts.dev }
+  } catch {
+    return { updated: false, reason: 'package.json parse failed' }
+  }
+}
+
 async function ask(rl, { cn, en, hint, fallback }) {
   const suffix = fallback ? ` ${ui.muted(`[${fallback}]`)}` : ''
   const answer = (

package/tha/commands/watch.mjs

@@ -0,0 +1,67 @@
+// ============ tha watch：监听 config.ts 变化，自动跑 sync ============
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { loadDirs, relPath } from '../config/paths.mjs'
+import { runSync } from './sync.mjs'
+import { glyph, ui } from '../utils/style.mjs'
+
+const DEBOUNCE_MS = 500
+let timer = null
+let running = false
+
+export async function runWatch({ root, args }) {
+  const { dirs } = loadDirs(root)
+  const domainsDir = path.join(root, dirs.domains)
+
+  if (!fs.existsSync(domainsDir)) {
+    throw new Error(`没有 ${dirs.domains} 目录：先运行 tha init <模块>`)
+  }
+
+  console.log('')
+  console.log(`  ${ui.heading('监听模式', 'watch · auto sync on config change')}`)
+  console.log(`  ${ui.rule(40)}`)
+  console.log(`  ${ui.muted('监听目录：')} ${ui.path(dirs.domains)}`)
+  console.log(`  ${ui.muted('改 config.ts 会自动跑 sync，按 Ctrl+C 退出')}`)
+  console.log('')
+
+  // 监听整个 domains 目录
+  fs.watch(domainsDir, { recursive: true }, (eventType, filename) => {
+    if (!filename) return
+
+    // 只关心 config.ts 文件
+    if (!filename.endsWith('config.ts')) return
+
+    // debounce：500ms 内只跑一次
+    clearTimeout(timer)
+    timer = setTimeout(() => {
+      handleConfigChange(root, dirs, filename)
+    }, DEBOUNCE_MS)
+  })
+
+  // 保持进程运行
+  await new Promise(() => {})
+}
+
+async function handleConfigChange(root, dirs, filename) {
+  if (running) {
+    console.log(`  ${ui.muted('sync 正在跑，等跑完再触发...')}`)
+    return
+  }
+
+  running = true
+  console.log(`  ${ui.accent(glyph.dot)} config 变化：${ui.path(filename)}`)
+
+  try {
+    // 从路径里提取模块名
+    // filename 是相对 domainsDir 的路径，比如 user/config.ts
+    const moduleName = filename.split('/')[0]
+
+    await runSync({ root, args: [moduleName, '--yes'] })
+    console.log(`  ${ui.success(glyph.ok)} 已同步\n`)
+  } catch (error) {
+    console.log(`  ${ui.danger(glyph.err)} 同步失败：${error.message}\n`)
+  } finally {
+    running = false
+  }
+}

package/tha/eslint-rules/executor-no-cross-import.js

@@ -0,0 +1,53 @@
+/**
+ * EXE-01：执行器之间不许互相 import
+ * 共用逻辑应该下沉成零件（steps/），不应该横向依赖
+ */
+
+import path from 'node:path'
+
+const DEFAULT_DIRS = {
+  domains: 'src/domains'
+}
+
+function getDirs(context) {
+  return { ...DEFAULT_DIRS, ...(context.settings?.tha?.dirs || {}) }
+}
+
+function isExecutorFile(filename, dirs) {
+  const domainsDir = dirs.domains.replace(/\\/g, '/')
+  const normalized = filename.replace(/\\/g, '/')
+  // 文件在 domains/<模块>/executors/ 下
+  return new RegExp(`/${domainsDir}/[^/]+/executors/`).test(normalized)
+}
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '执行器之间不许互相 import，共用逻辑请下沉成零件',
+      recommended: true
+    },
+    schema: []
+  },
+
+  create(context) {
+    const dirs = getDirs(context)
+    const filename = context.filename
+
+    if (!isExecutorFile(filename, dirs)) return {}
+
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value
+
+        // import 了另一个执行器（相对路径指向 executors/）
+        if (/^(\.\.?\/)+executors\//.test(importPath) || importPath.startsWith('./')) {
+          context.report({
+            node,
+            message: '执行器之间不许互相 import，共用逻辑请下沉成零件（steps/）'
+          })
+        }
+      }
+    }
+  }
+}