fmq/SpectraRust
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

重构5,无io和无io依赖的模块已经全部重构完毕，接下来是重构剩余的模块，主要是io和依赖io的模块。

Browse Source
This commit is contained in:
fmq
2026-03-22 17:08:40 +08:00
parent 59404207c3
commit 5078d6120e
35 changed files with 11554 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.claude/skills/fortran-analyzer/SKILL.md
+24
View File
@@ -0,0 +1,24 @@
---
name: fortran-analyzer
description: "分析 Fortran 代码的依赖关系，生成重构优先级列表。触发条件：(1) 用户提到 Fortran 依赖分析/依赖树；(2) 查找重构优先级/从哪里开始重构；(3) 分析函数调用关系；(4) 查看哪些函数依赖其他函数；(5)继续重构任务；(6) 用户问'应该先重构哪个函数'。输出 优先级列表和依赖树。"
---
# Fortran 依赖分析器
分析提取后的 Fortran 文件，生成依赖关系和重构优先级。
## 快速参考
```bash
# 查看下一个优先重构的模块
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py --priority | head -5
# 查看指定函数的依赖树
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py --tree FUNCTION_NAME
```
接下来调用 fortran-to-rust skills 对该模块进行重构。
## 详细参考
不需要看，当--priority | head -1给出的模块含有多个未完成的模块时，说明脚本出错了，应该先修复脚本再继续重构。
- [output_formats.md](references/output_formats.md) - 输出格式说明
- [advanced_usage.md](references/advanced_usage.md) - 高级用法和筛选命令
.claude/skills/fortran-analyzer/references/advanced_usage.md
+47
View File
@@ -0,0 +1,47 @@
# 高级用法
## 重构策略
### 优先级规则
1. **传递未实现=0**: 可立即开始，无依赖
2. **传递未实现=1~3**: 需先完成少数依赖
3. **传递未实现>3**: 依赖链长，最后处理
4. **有IO**: 最后处理（可能需要 I/O 抽象层）
### 筛选命令
```bash
# 最佳候选：无IO + 无未实现依赖
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py --priority | grep "○$" | head -10
# 查看特定函数依赖树
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py --tree ALIFR1
# 统计进度
echo "已完成: $(awk -F, '$11=="done"' fortran_analysis.csv | wc -l)"
echo "待处理: $(awk -F, '$11=="pending"' fortran_analysis.csv | wc -l)"
# 生成完整 CSV（含传递依赖）
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py --full > fortran_analysis.csv
```
## SPECIAL_MAPPINGS
一个 Rust 文件实现多个 Fortran 函数时，需更新 `.claude/skills/fortran-analyzer/scripts/analyze_fortran.py`:
```python
SPECIAL_MAPPINGS = {
'gfree': ['gfree0', 'gfreed', 'gfree1'],
'interpolate': ['yint', 'lagran'],
'sgmer': ['sgmer0', 'sgmer1', 'sgmerd'],
# 添加新映射...
}
```
## 脚本内部函数
- `extract_calls()`: 提取 CALL 和 FUNCTION 调用
- `get_transitive_deps()`: 计算传递依赖
- `get_pending_deps()`: 获取未实现依赖
- `print_dependency_tree()`: 打印依赖树
.claude/skills/fortran-analyzer/references/output_formats.md
+49
View File
@@ -0,0 +1,49 @@
# 输出格式说明
## 优先级列表 (`--priority`)
```
重构优先级列表 (按未实现依赖排序,无IO优先):
====================================================================================================
单元名 未实现 传递未实现 深度 直接调用 传递调用 IO
----------------------------------------------------------------------------------------------------
ALIFR1 0 0 1 1 1 ○
ALISK1 4 20 5 12 45 ○
```
**列说明：**
| 列 | 含义 |
|----|------|
| 未实现 | 直接依赖中未完成的函数数 |
| 传递未实现 | **关键指标**：所有递归依赖中未完成的函数数 |
| 深度 | 依赖链深度（叶子=0） |
| IO | ○=无IO, ✓=有IO |
**排序规则**: 传递未实现少 → 深度低 → 依赖少
## 依赖树 (`--tree UNIT`)
```
依赖树: ALISK1 ○
============================================================
直接依赖: 4, 传递依赖: 27, 未实现: 20
未实现依赖: ALIFRK, OPACF1, OPADD, ROSSTD, ...
------------------------------------------------------------
○ ALISK1 (4未实现)
├── ○ OPACF1 (6未实现)
│ ├── ○ OPADD (5未实现)
│ │ └── ○ cia_h2h2 (1未实现)
│ └── ✓ locate
└── ○ ALIFRK
```
**符号说明：**
- ✓ = 已完成
- ○ = 待处理
- `(N未实现)` = 该节点有 N 个直接依赖未完成
## CSV 格式
```
fortran_file,unit_name,unit_type,is_pure,common_deps,call_deps,has_io,rust_module,status
```
.claude/skills/fortran-analyzer/references/sp_fortran.md
+403
View File
@@ -0,0 +1,403 @@
---
## TLUSTY208.F 拆分工作 (2026-03-18)
### 任务：将单文件拆分为多个独立模块
**执行流程:**
```bash
cd /home/fmq/program/tlusty/tl208-s54/rust
python3 extract_fortran.py tlusty/tlusty208.f tlusty/extracted/
cp tlusty/*.FOR tlusty/extracted/
```
### 提取结果
| 项目 | 数量 |
|------|------|
| 程序单元 | **304** |
| 子程序 (SUBROUTINE) | 269 |
| 函数 (FUNCTION) | 32 |
| 主程序 (PROGRAM) | 1 |
| BLOCK DATA | **2** (含1个无名) |
| 无 COMMON 依赖的纯函数 | 195 |
> 注意: 2026-03-19 修复了无名 BLOCK DATA 提取问题，单元数从 303 增加到 304
### Include 文件
```
tlusty/extracted/*.FOR
├── IMPLIC.FOR # 隐式类型声明
├── BASICS.FOR # 基本参数和物理常数
├── ITERAT.FOR # 迭代控制参数
├── ALIPAR.FOR # ALI 参数
├── ATOMIC.FOR # 原子数据
├── MODELQ.FOR # 模型物理量
├── ODFPAR.FOR # ODF 参数
└── ARRAY1.FOR # 主工作数组
```
### 编译配置
**关键编译选项**:
```makefile
FFLAGS = -O3 -fno-automatic -mcmodel=large
```
- `-mcmodel=large`: 支持 >2GB 地址空间
- `-fno-automatic`: 所有变量默认为静态存储（兼容旧Fortran代码）
- **不要使用** `-ffixed-line-length-none`: 会将第73-80列的注释区当作代码解析
### 编译验证
```bash
cd tlusty/extracted && make clean && make
# 生成: tlusty_extracted (1,940,488 bytes)
# 直接编译
gfortran -fno-automatic -mcmodel=large -O3 -o tlusty.exe tlusty208.f
# 生成: tlusty.exe (1,997,416 bytes)
```
**结论**: 功能等价，拆分编译文件更小 (-2.9%)
### 拆分编译 vs 直接编译对比
| 方面 | 直接编译 | 拆分编译 |
|------|---------|---------|
| 文件大小 | 1,997,416 B | 1,940,488 B |
| 功能 | 相同 | 相同 |
| 增量编译 | ❌ | ✅ |
| 代码定位 | 困难 | 简单 |
### 无 COMMON 依赖的纯函数 (198个)
可独立测试和重构的单元:
```
ACCEL2, ALIFR1, ALIFR3, ALIFR6, ALIFRK, ALISK1, ALISK2, ALIST1, ALIST2,
ANGSET, BETAH, BHE, BKHSGO, BPOP, BPOPE, BPOPF, BPOPT, BRE, BREZ,
BRTE, BRTEZ, BUTLER, CARBON, CEH12, CHANGE, CHCKSE, CHEAV, CHEAVJ,
CIA_H2H, CIA_H2H2, CIA_H2HE, CIA_HHE, CION, CKOEST, COLH, COLHE,
COLLHE, CONCOR, CORRWM, CROSS, CROSSD, CSPEC, DIELRC, DIETOT, DIVSTR,
DMEVAL, DOPGAM, DWNFR, DWNFR0, DWNFR1, EINT, EMAT, ENTENE, ERFCIN,
ERFCX, EXPINT, EXPINX, EXPO, FFCROS, GAMI, GAMSP, GAULEG, GAUNT,
GETWRD, GFREE0, GFREE1, GFREED, GNTK, GRCOR, GREYD, GRIDP, H2MINUS,
HEPHOT, HIDALG, IJALI2, IJALIS, INCLDY, INDEXX, INIFRS, INILAM, INTERP,
INTHYD, INTLEM, INTXEN, IRC, LAGRAN, LAGUER, LEMINI, LEVGRP, LEVSET,
LEVSOL, LINEQS, LINSEL, LINSET, LINSPL, LOCATE, LTEGR, LUCY, LYMLIN,
MATGEN, MATINV, MEANOP, MEANOPT, MINV3, NEWPOP, NSTOUT, ODF1, ODFFR,
ODFHST, ODFHYD, ODFHYS, ODFMER, OPACFL, OPADD0, OPAHST, OPAINI, OPCTAB,
OSCCOR, OUTPUT, PFCNO, PFFE, PFHEAV, PFNI, PFSPEC, PRCHAN, PRD, PRDINI,
PRINC, PRNT, PROFSP, PSOLVE, PZERT, QUARTC, QUIT, RADPRE, RAPH, RATES1,
RATMAL, RATMAT, RATSP1, RAYINI, RAYSET, RDATAX, READBF, RECHCK, REFLEV,
REIMAN, RHOEOS, RHONEN, ROSSOP, ROSSTD, RTEDF2, RTEFE2, RTESOL, RTE_SC,
SABOLF, SBFCH, SBFHE1, SBFHMI, SBFHMI_OLD, SBFOH, SFFHMI, SFFHMI_ADD,
SGHE12, SGMER0, SGMER1, SGMERD, SIGAVE, SIGK, SIGMAR, SPSIGK, SRTFRQ,
STARK0, STARKA, SWITCH, SZIRC, TDPINI, TIMING, TIOPF, TLUSTY, TRAINI,
TRIDAG, UBETA, VERN16, VERN18, VERN20, VERN26, VERNER, VISINI, VOIGT,
VOIGTE, WN, WNSTOR, XENINI, XK2DOP, YINT, YLINTP, ZMRHO
```
---
## SYNSPEC54.F 拆分工作 (2026-03-18)
### 任务：将单文件拆分为多个独立模块
**执行流程:**
#### 1. 创建提取脚本 `extract_fortran.py`
```python
# 核心功能:
# - 正则匹配 SUBROUTINE/FUNCTION/PROGRAM/BLOCK DATA
# - 查找对应的 END 语句确定边界
# - 提取到独立 .f 文件
# - 分析 COMMON 块依赖
# - 生成 Makefile
```
#### 2. 运行提取
```bash
cd /home/fmq/program/tlusty/tl208-s54/rust
python3 extract_fortran.py synspec/synspec54.f synspec/extracted/
cp synspec/*.FOR synspec/extracted/
```
#### 3. 提取结果
| 项目 | 数量 |
|------|------|
| 程序单元 | 168 |
| 子程序 (SUBROUTINE) | 134 |
| 函数 (FUNCTION) | 33 |
| 主程序 (PROGRAM) | 1 |
| 总代码行数 | 23,050 |
| 无 COMMON 依赖的纯函数 | 93 |
#### 4. 编译配置
**关键编译选项** (解决大型 COMMON 数组链接问题):
```makefile
FFLAGS = -O3 -fno-automatic -mcmodel=large
```
- `-mcmodel=large`: 支持 >2GB 地址空间
- `-fno-automatic`: 所有变量默认为静态存储（兼容旧Fortran代码）
- **不要使用** `-ffixed-line-length-none`: 会将第73-80列的注释区当作代码解析
#### 5. 编译验证
```bash
cd synspec/extracted && make clean && make
# 生成: synspec_extracted (1,000,408 bytes)
```
**对比原始编译:**
```bash
gfortran -O3 -fno-automatic -mcmodel=large -o synspec_direct.exe synspec54.f
# 生成: synspec_direct.exe (1,044,928 bytes)
```
**结论**: 功能完全等价，拆分编译更小 (-4.3%)
### 生成的文件结构
```
synspec/extracted/
├── synspec.f # 主程序 (174行)
├── start.f # 子程序 (107行)
├── sbfhmi.f # H⁻ 光电离截面函数 (42行)
├── expint.f # 指数积分函数 (18行)
├── ... # 共168个 .f 文件
├── PARAMS.FOR # 参数定义 (include)
├── MODELP.FOR # 模型参数 (include)
├── LINDAT.FOR # 谱线数据 (include)
├── SYNTHP.FOR # 合成谱参数 (include)
├── WINCOM.FOR # 窗口通信 (include)
├── Makefile # 自动构建
├── _SUMMARY.txt # 提取摘要
├── _COMMON_ANALYSIS.txt # COMMON 依赖分析
└── _PURE_UNITS.txt # 纯函数列表
```
### COMMON 块分析结果
**有 COMMON 依赖的单元**: 75 个
**唯一 COMMON 块**: 68 个
主要 COMMON 块:
- `BLAPAR`, `LIMPAR` - 谱线参数
- `EMFLUX` - 辐射流
- `RTEOPA` - 辐射转移不透明度
- `NLTPOP` - 非LTE布居数
- `lasers` - 激光数据处理
### 拆分编译 vs 直接编译对比
| 方面 | 直接编译 | 拆分编译 |
|------|---------|---------|
| 文件大小 | 1,044,928 B | 1,000,408 B |
| 功能 | 相同 | 相同 |
| 增量编译 | ❌ | ✅ |
| 代码定位 | 困难 | 简单 |
| 模块化重构 | 困难 | 容易 |
### 提取脚本位置
```
extract_fortran.py
```
### 推荐用法
```bash
# 开发/调试/重构
cd synspec/extracted && make
# 生产环境/快速编译
cd synspec && gfortran -O3 -fno-automatic -mcmodel=large -o synspec.exe synspec54.f
```
### 无 COMMON 依赖的纯函数 (93个)
可独立测试和重构的函数:
```
CARBON, CHANGE, CHCKAB, CIA_H2H, CIA_H2H2, CIA_H2HE, CIA_HHE,
COUNT_WORDS, DENSIT, DIVHE2, DIVSTR, DWNFR0, DWNFR1, EPS,
EXOPF, EXPINT, EXTPRF, FEAUTR, GAMHE, GAUNT, GETWRD, GFREE,
GNTK, GRIEM, H2MINUS, H2OPF, HE2SET, HE2SEW, HEPHOT, HESET,
HIDALG, HYDINI, HYDTAB, HYLSET, HYLSEW, INIBLM, INKUR, INPBF,
INTERP, INTHYD, INTRP, INTXEN, IRWPF, ISPEC, LEVSOL, LINEQS,
LOCATE, LYMLIN, MATINV, MOLOP, MPARTF, OPADD, PARTDV, PARTF,
PFFE, PFHEAV, PFNI, PFSPEC, PHTX, QUIT, RATMAT, READBF,
REIMAN, SABOLF, SBFCH, SBFHE1, SBFHMI, SBFHMI_OLD, SBFOH,
SETRAY, SFFHMI, SFFHMI_OLD, SGHE12, SGMERG, SPSIGK, STARK0,
STARKA, STARKIR, STATE0, SYNSPEC, TINT, TRIDAG, VELSET,
VOIGTE, VOPF, WGTJH1, WN, WNSTOR, WTOT, XENINI, XK2DOP, YINT, YLINTP
```
---
## 功能验证测试 (2026-03-19)
### 测试环境变量
```bash
export TL208=/home/fmq/program/tlusty
export TLUSTY=$TL208/tl208-s54
export LINELIST=$TL208/linelist
export IRON=$TL208/irondata
export OPTABLES=$TL208/optables
```
### 测试目录
```
tests/tlusty/hhe/ # H-He 模型测试用例
├── hhe35lt.5 # LTE 模型输入
├── hhe35nc.5 # NLTE continua 模型输入
├── hhe35nl.5 # NLTE with lines 模型输入
└── hhe35*.7,9,14 # 预期输出文件
```
### 测试流程
```bash
cd /home/fmq/program/tlusty/tl208-s54/rust/tests/tlusty
# 创建测试目录
mkdir -p test_extracted
cd test_extracted
cp ../hhe/*.5 .
ln -sf $TLUSTY/data data
# 设置环境变量
export TL208=/home/fmq/program/tlusty
export TLUSTY=$TL208/tl208-s54
export LINELIST=$TL208/linelist
export IRON=$TL208/irondata
export OPTABLES=$TL208/optables
# 可执行文件路径
EXE=../../tlusty/extracted/build/tlusty_extracted
# 测试1: LTE 模型 (从零开始)
$EXE < hhe35lt.5 > hhe35lt.6
cp fort.7 hhe35lt.7; cp fort.9 hhe35lt.9; cp fort.14 hhe35lt.14
# 测试2: NLTE continua (使用 LTE 作为初始模型)
cp hhe35lt.7 fort.8
$EXE < hhe35nc.5 > hhe35nc.6
cp fort.7 hhe35nc.7; cp fort.9 hhe35nc.9; cp fort.14 hhe35nc.14
# 测试3: NLTE with lines (使用 NC 作为初始模型)
cp hhe35nc.7 fort.8
$EXE < hhe35nl.5 > hhe35nl.6
cp fort.7 hhe35nl.7; cp fort.9 hhe35nl.9; cp fort.14 hhe35nl.14
# 验证: 与原始结果比较
diff hhe35lt.7 ../hhe/hhe35lt.7
diff hhe35nc.7 ../hhe/hhe35nc.7
diff hhe35nl.7 ../hhe/hhe35nl.7
```
### 测试结果
| 测试用例 | 拆分编译 | 直接编译 | 原始结果 |
|----------|----------|----------|----------|
| hhe35lt (LTE) | ✓ 通过 | ✓ 通过 | ✓ 相同 |
| hhe35nc (NLTE continua) | ✓ 通过 | ✓ 通过 | ✓ 相同 |
| hhe35nl (NLTE lines) | ✓ 通过 | ✓ 通过 | ✓ 相同 |
**MD5 校验和 (hhe35nl.7)**:
```
01f3169947ca24bf1c989619b83ae8f2
```
**结论**: 拆分编译与直接编译输出完全相同，功能验证通过
---
## SYNSPEC54 功能验证测试 (2026-03-19)
### 测试目录
```
tests/synspec/hhe/
├── hhe35nl.5 # 输入文件
├── hhe35nl.7 # 模型大气 (来自 TLUSTY 测试)
├── fort.55.con # 附加输入文件
├── data # 数据目录路径文件 (内容: $TLUSTY/data)
└── results/ # 预期输出
├── hhe35nl.spec # 合成光谱
├── hhe35nl.cont # 连续谱
└── hhe35nl.iden # 谱线标识
```
### 测试流程
```bash
cd /home/fmq/program/tlusty/tl208-s54/rust/tests/synspec/hhe
# 设置环境变量
export TL208=/home/fmq/program/tlusty
export TLUSTY=$TL208/tl208-s54
export LINELIST=$TL208/linelist
export IRON=$TL208/irondata
export OPTABLES=$TL208/optables
# 准备输入文件
cp hhe35nl.7 fort.8
ln -sf fort.55.con fort.55
ln -sf $TLUSTY/data/gfATO.dat fort.19
# 关键: data 必须是符号链接指向数据目录
rm -f data
ln -sf $TLUSTY/data data
# 可执行文件路径
EXE_ORIG=$TLUSTY/synspec/synspec.exe
EXE_DIRECT=../../synspec/synspec_direct.exe
EXE_EXTRACTED=../../synspec/extracted/build/synspec_extracted
# 测试原始版本
$EXE_ORIG < hhe35nl.5 > hhe35nl_orig.log
cp fort.7 hhe35nl_orig.spec; cp fort.17 hhe35nl_orig.cont
# 测试直接编译版本
rm -f fort.7 fort.17 fort.12
$EXE_DIRECT < hhe35nl.5 > hhe35nl_direct.log
cp fort.7 hhe35nl_direct.spec; cp fort.17 hhe35nl_direct.cont
# 测试拆分编译版本
rm -f fort.7 fort.17 fort.12
$EXE_EXTRACTED < hhe35nl.5 > hhe35nl_extracted.log
cp fort.7 hhe35nl_extracted.spec; cp fort.17 hhe35nl_extracted.cont
# 验证
diff hhe35nl_orig.spec hhe35nl_direct.spec
diff hhe35nl_orig.spec hhe35nl_extracted.spec
# 恢复 data 文件
rm -f data
echo "/home/fmq/program/tlusty/tl208-s54/data" > data
```
### 测试结果
| 测试用例 | 原始程序 | 直接编译 | 拆分编译 |
|----------|----------|----------|----------|
| hhe35nl (NLTE lines) | ✓ 通过 | ✓ 通过 | ✓ 相同 |
**MD5 校验和 (hhe35nl.spec)**:
```
7925533b21b16d6bcdfff40e626cab83
```
**注意事项**:
- `data` 文件/符号链接必须正确设置，否则报错 `Cannot open file './data/h1.dat': Not a directory`
- 拆分编译程序与原始程序输出完全相同，功能验证通过
.claude/skills/fortran-analyzer/scripts/analyze_fortran.py
+438
View File
@@ -0,0 +1,438 @@
#!/usr/bin/env python3
"""
分析 TLUSTY Fortran 文件，提取函数依赖信息。
用法:
python3 analyze_fortran.py # 输出 CSV（带完整依赖）
python3 analyze_fortran.py --tree # 输出依赖树（文本格式）
python3 analyze_fortran.py --priority # 输出重构优先级列表
"""
import os
import re
import glob
import argparse
from collections import defaultdict
def extract_includes(content):
"""提取 INCLUDE 文件列表"""
includes = re.findall(r"INCLUDE\s*'([^']+)\.FOR'", content, re.IGNORECASE)
return [inc for inc in includes if inc.upper() != 'IMPLIC']
def extract_commons(content):
"""提取 COMMON 块名称"""
# 匹配 COMMON/NAME/ 或 common/name/
commons = re.findall(r'(?i)^\s*COMMON\s*/(\w+)/', content, re.MULTILINE)
return list(set(commons))
# Fortran 内置函数列表（不需要追踪）
FORTRAN_INTRINSICS = {
'SIN', 'COS', 'TAN', 'ASIN', 'ACOS', 'ATAN', 'ATAN2',
'SINH', 'COSH', 'TANH',
'EXP', 'LOG', 'LOG10', 'LOG2',
'SQRT', 'ABS', 'MOD', 'SIGN',
'MAX', 'MIN', 'MAX0', 'MIN0', 'MAX1', 'MIN1', 'AMAX0', 'AMIN0',
'INT', 'IFIX', 'IDINT', 'FLOAT', 'SNGL', 'DBLE', 'CMPLX',
'REAL', 'AIMAG', 'CONJG',
'ICHAR', 'CHAR', 'INDEX', 'LEN', 'LGE', 'LGT', 'LLE', 'LLT',
'DOT_PRODUCT', 'MATMUL', 'TRANSPOSE', 'RESHAPE',
'SIZE', 'SHAPE', 'LBOUND', 'UBOUND',
'ALLOCATED', 'ALLOCATE', 'DEALLOCATE',
'KIND', 'SELECTED_REAL_KIND', 'SELECTED_INT_KIND',
'DIGITS', 'EPSILON', 'HUGE', 'TINY', 'PRECISION', 'RANGE',
'FLOOR', 'CEILING', 'NINT', 'ANINT',
'ADJUSTL', 'ADJUSTR', 'TRIM', 'REPEAT', 'SCAN', 'VERIFY',
'PRESENT', 'ASSOCIATED',
# TLUSTY 常用数学函数
'ERF', 'ERFC', 'GAMMA', 'LOG_GAMMA',
}
def extract_calls(content, known_functions=None):
"""提取 CALL 语句和 FUNCTION 调用
Args:
content: Fortran 源码
known_functions: 已知的函数名集合（用于区分函数调用和数组访问）
"""
calls = set()
# 1. 提取 CALL 语句（支持有括号和无括号两种形式）
# CALL NAME(...) 或 CALL NAME
call_stmts = re.findall(r'(?i)CALL\s+(\w+)(?:\s*\(|\s*$|\s*\n)', content)
calls.update(c.upper() for c in call_stmts)
# 2. 提取可能的 FUNCTION 调用
if known_functions:
# 只匹配已知函数名
func_assign = re.findall(r'(?i)=\s*([A-Z][A-Z0-9]*)\s*\(', content)
calls.update(f.upper() for f in func_assign
if f.upper() in known_functions and f.upper() not in FORTRAN_INTRINSICS)
func_expr = re.findall(r'(?i)[=(,]\s*([A-Z][A-Z0-9]*)\s*\(', content)
calls.update(f.upper() for f in func_expr
if f.upper() in known_functions and f.upper() not in FORTRAN_INTRINSICS)
return list(calls)
def has_file_io(content):
"""检查是否有文件 I/O"""
patterns = [
r'OPEN\s*\(',
r'READ\s*\(\s*\d+',
r'WRITE\s*\(\s*\d+',
r'write\s*\(',
r'read\s*\(',
]
for p in patterns:
if re.search(p, content, re.IGNORECASE):
return True
return False
def extract_unit_info(content, filename):
"""提取单元信息"""
units = []
# 匹配 SUBROUTINE
sub_match = re.search(r'(?i)^\s*SUBROUTINE\s+(\w+)', content, re.MULTILINE)
if sub_match:
units.append(('SUBROUTINE', sub_match.group(1).upper()))
# 匹配 FUNCTION
func_match = re.search(r'(?i)^\s*(?:REAL(?:\*\d+)?|INTEGER(?:\*\d+)?|DOUBLE\s*PRECISION)?\s*FUNCTION\s+(\w+)', content, re.MULTILINE)
if func_match:
units.append(('FUNCTION', func_match.group(1).upper()))
# 匹配 BLOCK DATA（注意：名字必须在同一行，不能跨行匹配注释 C）
# Fortran 中 C 开头的行是注释，不应被匹配为名字
block_match = re.search(r'(?i)^\s*BLOCK\s*DATA\s*(\w+)?\s*$', content, re.MULTILINE)
if block_match:
name = block_match.group(1).upper() if block_match.group(1) else '_UNNAMED_'
units.append(('BLOCK DATA', name))
# 如果都没匹配到，使用文件名
if not units:
base = os.path.splitext(filename)[0]
units.append(('UNKNOWN', base.upper()))
return units
# 特殊映射：一个 Rust 文件实现多个 Fortran 函数
SPECIAL_MAPPINGS = {
# Rust 文件名 -> [Fortran 函数名列表]
'gfree': ['gfree0', 'gfreed', 'gfree1'],
'interpolate': ['yint', 'lagran'],
'sgmer': ['sgmer0', 'sgmer1', 'sgmerd'],
'ctdata': ['hction', 'hctrecom'],
'cross': ['cross', 'crossd'],
'expint': ['eint', 'expinx'],
'erfcx': ['erfcx', 'erfcin'],
'lineqs': ['lineqs', 'lineqs_nr'],
'gamsp': ['gamsp'], # alias
'bhe': ['bhe', 'bhed', 'bhez'], # 流体静力学平衡方程
'comset': ['comset'], # Compton 散射参数设置
'ghydop': ['ghydop'], # 氢不透明度 (Gomez 表)
'levgrp': ['levgrp'], # 能级分组
'profil': ['profil'], # 标准吸收轮廓
'linspl': ['linspl'], # 谱线轮廓设置
}
def find_rust_module(fortran_name, rust_dir):
"""查找对应的 Rust 模块"""
# 先检查直接匹配
rust_file = os.path.join(rust_dir, f"{fortran_name}.rs")
if os.path.exists(rust_file):
return f"src/math/{fortran_name}.rs"
# 检查特殊映射
for rust_mod, fortran_funcs in SPECIAL_MAPPINGS.items():
if fortran_name in fortran_funcs:
return f"src/math/{rust_mod}.rs"
return ""
def get_transitive_deps(unit_name, units_dict, visited=None):
"""递归获取所有传递调用依赖"""
if visited is None:
visited = set()
if unit_name in visited:
return set()
visited.add(unit_name)
if unit_name not in units_dict:
return set()
direct_calls = units_dict[unit_name].get('call_deps', [])
all_deps = set(direct_calls)
for dep in direct_calls:
all_deps.update(get_transitive_deps(dep, units_dict, visited.copy()))
return all_deps
def get_pending_deps(unit_name, units_dict, visited=None):
"""获取尚未实现的直接依赖"""
if unit_name not in units_dict:
return []
calls = units_dict[unit_name].get('call_deps', [])
pending = [d for d in calls if d not in units_dict or units_dict[d].get('status') != 'done']
return pending
def get_transitive_pending_deps(unit_name, units_dict, visited=None):
"""递归获取所有传递的未实现依赖"""
if visited is None:
visited = set()
if unit_name in visited:
return set()
visited.add(unit_name)
if unit_name not in units_dict:
return set()
direct_calls = units_dict[unit_name].get('call_deps', [])
# 未实现的直接依赖
pending_deps = set(d for d in direct_calls if d not in units_dict or units_dict[d].get('status') != 'done')
# 递归获取所有依赖的未实现依赖
for dep in direct_calls:
pending_deps.update(get_transitive_pending_deps(dep, units_dict, visited.copy()))
return pending_deps
def get_transitive_commons(unit_name, units_dict, visited=None):
"""递归获取所有传递 COMMON 依赖"""
if visited is None:
visited = set()
if unit_name in visited:
return set()
visited.add(unit_name)
if unit_name not in units_dict:
return set()
direct_commons = set(units_dict[unit_name].get('common_deps', []))
direct_calls = units_dict[unit_name].get('call_deps', [])
all_commons = direct_commons.copy()
for dep in direct_calls:
all_commons.update(get_transitive_commons(dep, units_dict, visited.copy()))
return all_commons
def calculate_depth(unit_name, units_dict, memo=None):
"""计算依赖深度（叶子节点深度为0）"""
if memo is None:
memo = {}
if unit_name in memo:
return memo[unit_name]
if unit_name not in units_dict:
return 0
calls = units_dict[unit_name].get('call_deps', [])
if not calls:
memo[unit_name] = 0
return 0
max_dep_depth = 0
for dep in calls:
if dep != unit_name: # 避免自引用
max_dep_depth = max(max_dep_depth, calculate_depth(dep, units_dict, memo))
depth = max_dep_depth + 1
memo[unit_name] = depth
return depth
def print_dependency_tree(unit_name, units_dict, indent=0, visited=None, prefix="", show_pending_count=True):
"""打印依赖树（文本格式）"""
if visited is None:
visited = set()
if unit_name in visited:
print(f"{prefix}[循环引用: {unit_name}]")
return
visited.add(unit_name)
if unit_name not in units_dict:
print(f"{prefix}{unit_name} [未找到/未实现]")
return
unit = units_dict[unit_name]
status = unit.get('status', 'pending')
status_mark = "✓" if status == "done" else "○"
# 计算未实现依赖数
pending_count = len(get_pending_deps(unit_name, units_dict))
pending_str = f" ({pending_count}未实现)" if show_pending_count and pending_count > 0 else ""
print(f"{prefix}{status_mark} {unit_name}{pending_str}")
calls = unit.get('call_deps', [])
# 按未实现依赖数排序（未实现多的在前，因为更紧迫）
pending_sorted = sorted(calls, key=lambda d: -len(get_pending_deps(d, units_dict) if d in units_dict else []))
for i, dep in enumerate(pending_sorted):
is_last = (i == len(pending_sorted) - 1)
connector = "└── " if is_last else "├── "
print_dependency_tree(dep, units_dict, indent + 1, visited.copy(), prefix + connector, show_pending_count)
def main():
parser = argparse.ArgumentParser(description='分析 TLUSTY Fortran 文件依赖')
parser.add_argument('--tree', metavar='UNIT', help='输出指定单元的依赖树')
parser.add_argument('--priority', action='store_true', help='输出重构优先级列表')
parser.add_argument('--full', action='store_true', help='输出完整传递依赖')
args = parser.parse_args()
extracted_dir = "/home/fmq/program/tlusty/tl208-s54/rust/tlusty/extracted"
rust_dir = "/home/fmq/program/tlusty/tl208-s54/rust/src/math"
# 第一遍：收集所有已定义的 SUBROUTINE 和 FUNCTION 名称
all_defined_units = set()
fortran_files = sorted(glob.glob(os.path.join(extracted_dir, "*.f")))
for fpath in fortran_files:
with open(fpath, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
units = extract_unit_info(content, os.path.basename(fpath))
for unit_type, unit_name in units:
all_defined_units.add(unit_name)
# 第二遍：收集所有单元信息（使用已知函数名来过滤调用）
units_dict = {}
for fpath in fortran_files:
fname = os.path.basename(fpath)
base_name = os.path.splitext(fname)[0]
with open(fpath, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
includes = extract_includes(content)
commons = extract_commons(content)
calls = extract_calls(content, known_functions=all_defined_units)
io = has_file_io(content)
units = extract_unit_info(content, fname)
is_pure = len(includes) <= 1 and len(commons) == 0 and not io
rust_mod = find_rust_module(base_name, rust_dir)
status = "done" if rust_mod else "pending"
for unit_type, unit_name in units:
units_dict[unit_name] = {
'fortran_file': fname,
'unit_type': unit_type,
'is_pure': is_pure,
'common_deps': includes + commons,
'call_deps': calls,
'has_io': io,
'rust_module': rust_mod,
'status': status,
}
# --tree 模式：输出依赖树
if args.tree:
unit_name = args.tree.upper()
if unit_name in units_dict:
unit = units_dict[unit_name]
trans_pending = get_transitive_pending_deps(unit_name, units_dict)
trans_calls = get_transitive_deps(unit_name, units_dict)
status_mark = "✓" if unit['status'] == "done" else "○"
print(f"依赖树: {unit_name} {status_mark}")
print("=" * 60)
print(f"直接依赖: {len(unit['call_deps'])}, 传递依赖: {len(trans_calls)}, "
f"未实现: {len(trans_pending)}")
if trans_pending:
print(f"未实现依赖: {', '.join(sorted(trans_pending)[:10])}")
if len(trans_pending) > 10:
print(f" ... 还有 {len(trans_pending) - 10} 个")
print("-" * 60)
print_dependency_tree(unit_name, units_dict)
else:
print(f"未找到单元: {unit_name}")
# 尝试模糊匹配
matches = [u for u in units_dict if args.tree.lower() in u.lower()]
if matches:
print(f"可能的匹配: {', '.join(matches[:10])}")
return
# --priority 模式：输出重构优先级
if args.priority:
# 计算每个单元的依赖深度和传递依赖数
priority_list = []
memo = {}
for unit_name, unit in units_dict.items():
if unit['status'] == 'done':
continue
# 跳过无法识别程序单元的文件（如纯注释文件）
if unit['unit_type'] == 'UNKNOWN':
continue
# 跳过 BLOCK DATA（数据初始化块，不是函数）
if unit['unit_type'] == 'BLOCK DATA':
continue
depth = calculate_depth(unit_name, units_dict, memo)
trans_calls = len(get_transitive_deps(unit_name, units_dict))
trans_commons = len(get_transitive_commons(unit_name, units_dict))
pending_deps = len(get_pending_deps(unit_name, units_dict))
trans_pending = len(get_transitive_pending_deps(unit_name, units_dict))
priority_list.append({
'name': unit_name,
'depth': depth,
'direct_calls': len(unit['call_deps']),
'trans_calls': trans_calls,
'direct_commons': len(unit['common_deps']),
'trans_commons': trans_commons,
'pending_deps': pending_deps,
'trans_pending': trans_pending,
'has_io': unit['has_io'],
'is_pure': unit['is_pure'],
})
# 按优先级排序：未实现依赖少 > 无IO > 深度低
priority_list.sort(key=lambda x: (x['trans_pending'], x['has_io'], x['depth'], x['trans_calls']))
print("重构优先级列表 (按未实现依赖排序，同数量优先无IO)")
print("=" * 100)
print(f"{'单元名':<20} {'未实现':>6} {'传递未实现':>10} {'深度':>4} {'直接调用':>8} {'传递调用':>8} {'IO':>4}")
print("-" * 100)
for item in priority_list[:100]: # 显示前100个
io_mark = "✓" if item['has_io'] else "○"
print(f"{item['name']:<20} {item['pending_deps']:>6} {item['trans_pending']:>10} "
f"{item['depth']:>4} {item['direct_calls']:>8} {item['trans_calls']:>8} {io_mark:>4}")
return
# 默认模式：输出 CSV（带完整依赖）
if args.full:
print("fortran_file,unit_name,unit_type,is_pure,common_deps,call_deps,"
"trans_commons,trans_calls,has_io,rust_module,status")
else:
print("fortran_file,unit_name,unit_type,is_pure,common_deps,call_deps,has_io,rust_module,status")
memo = {}
for unit_name, unit in units_dict.items():
if args.full:
trans_commons = get_transitive_commons(unit_name, units_dict)
trans_calls = get_transitive_deps(unit_name, units_dict)
print(f"{unit['fortran_file']},{unit_name},{unit['unit_type']},{unit['is_pure']},"
f"\"{'|'.join(unit['common_deps'])}\",\"{'|'.join(unit['call_deps'])}\","
f"\"{'|'.join(trans_commons)}\",\"{'|'.join(trans_calls)}\","
f"{unit['has_io']},{unit['rust_module']},{unit['status']}")
else:
print(f"{unit['fortran_file']},{unit_name},{unit['unit_type']},{unit['is_pure']},"
f"\"{'|'.join(unit['common_deps'])}\",\"{'|'.join(unit['call_deps'])}\","
f"{unit['has_io']},{unit['rust_module']},{unit['status']}")
if __name__ == "__main__":
main()
.claude/skills/fortran-extractor/SKILL.md
+89
View File
@@ -0,0 +1,89 @@
---
name: fortran-extractor
description: "[已完成] TLUSTY/SYNSPEC 拆分已完成。仅当用户明确请求'重新提取 Fortran'或'再次拆分 Fortran 文件'时触发。"
---
# Fortran 代码提取器
从大型 Fortran 源文件中提取各个程序单元（SUBROUTINE、FUNCTION、PROGRAM、BLOCK DATA）到独立文件，并生成依赖分析报告。
## 快速参考
| 场景 | 命令 |
|------|------|
| 提取 Fortran 文件 | `python3 .claude/skills/fortran-extractor/scripts/extract_fortran.py <source.f> <output_dir>` |
| 默认路径 | `tlusty/tlusty208.f` → `tlusty/extracted/` |
## 输出文件
提取完成后，输出目录包含：
| 文件 | 说明 |
|------|------|
| `*.f` | 各个提取的程序单元 |
| `_SUMMARY.txt` | 提取摘要（单元数、类型统计） |
| `_COMMON_ANALYSIS.txt` | COMMON 块依赖分析 |
| `_PURE_UNITS.txt` | 无 COMMON 依赖的纯函数列表 |
| `Makefile` | 编译配置（含正确标志） |
## 提取的单元类型
- `SUBROUTINE` - 子程序
- `FUNCTION` - 函数
- `PROGRAM` - 主程序（支持无名 PROGRAM）
- `BLOCK DATA` - 数据块（支持无名 BLOCK DATA）
## Makefile 编译标志
生成的 Makefile 使用以下 gfortran 标志：
```makefile
FFLAGS = -O3 -fno-automatic -mcmodel=large
```
- `-mcmodel=large`: 支持大型 COMMON 数组（>2GB 地址空间）
- `-fno-automatic`: 静态存储（旧 Fortran 兼容性）
**注意**: 不要使用 `-ffixed-line-length-none`，会破坏 73-80 列处理。
## COMMON 块分析
脚本自动分析每个单元的 COMMON 块依赖：
- **命名 COMMON**: `COMMON /NAME/ ...`
- **空白 COMMON**: `COMMON varname`（不带斜杠）
- **INCLUDE 依赖**: `INCLUDE 'XXX.FOR'`
### 纯函数识别
无 COMMON 依赖的单元被识别为"纯函数"，可以独立测试和重构。
## 使用示例
```bash
# 提取 TLUSTY
python3 .claude/skills/fortran-extractor/scripts/extract_fortran.py tlusty/tlusty208.f tlusty/extracted/
# 提取 SYNSPEC
python3 .claude/skills/fortran-extractor/scripts/extract_fortran.py synspec/synspec54.f synspec/extracted/
# 查看提取结果
cat tlusty/extracted/_SUMMARY.txt
cat tlusty/extracted/_PURE_UNITS.txt
```
## 后续步骤
提取完成后，可以：
1. **编译验证**: `cd extracted && make`
2. **依赖分析**: 使用 `fortran-analyzer` skill 分析函数调用依赖
3. **重构**: 使用 `fortran-to-rust` skill 开始 Rust 重构
## 脚本位置
核心脚本位于 `.claude/skills/fortran-extractor/scripts/extract_fortran.py`，主要功能：
- `extract_units()`: 提取程序单元
- `analyze_commons()`: 分析 COMMON 依赖
- `generate_makefile()`: 生成编译配置
.claude/skills/fortran-extractor/scripts/extract_fortran.py
+302
View File
@@ -0,0 +1,302 @@
#!/usr/bin/env python3
"""
提取 synspec54.f 中的各个子程序/函数到独立文件
"""
import re
import os
import sys
from pathlib import Path
def extract_units(source_file, output_dir):
"""提取 Fortran 程序单元到独立文件"""
with open(source_file, 'r') as f:
content = f.read()
lines = content.split('\n')
# 创建输出目录
os.makedirs(output_dir, exist_ok=True)
# 匹配程序单元开始的正则表达式
# 注意: BLOCK DATA 和 PROGRAM 可以是无名的
# 使用 \s* 允许名称前没有空格（无名情况）
unit_pattern = re.compile(
r'^\s*('
r'SUBROUTINE\s+(\w+)|'
r'FUNCTION\s+(\w+)|'
r'PROGRAM\s*(\w*)|'
r'BLOCK\s+DATA\s*(\w*)'
r')',
re.IGNORECASE
)
# 找到所有单元的起始位置
units = []
for i, line in enumerate(lines):
match = unit_pattern.match(line)
if match:
groups = match.groups()
# groups: (整体匹配, SUBROUTINE名, FUNCTION名, PROGRAM名, BLOCK DATA名)
if groups[1]: # SUBROUTINE
name, unit_type = groups[1], 'SUBROUTINE'
elif groups[2]: # FUNCTION
name, unit_type = groups[2], 'FUNCTION'
elif groups[3]: # PROGRAM (非空)
name, unit_type = groups[3], 'PROGRAM'
elif groups[3] is not None: # PROGRAM (空字符串，无名)
name, unit_type = None, 'PROGRAM'
elif groups[4]: # BLOCK DATA (非空)
name, unit_type = groups[4], 'BLOCK DATA'
elif groups[4] is not None: # BLOCK DATA (空字符串，无名)
name, unit_type = None, 'BLOCK DATA'
else:
name, unit_type = None, 'UNKNOWN'
# 处理无名单元
if not name:
name = f"_UNNAMED_{unit_type.replace(' ', '_')}_"
units.append((i, name.upper(), unit_type))
print(f"找到 {len(units)} 个程序单元")
# 提取每个单元
extracted = []
for idx, (start_line, name, unit_type) in enumerate(units):
# 确定结束位置
if idx + 1 < len(units):
end_line = units[idx + 1][0]
else:
end_line = len(lines)
# 提取单元内容
unit_lines = lines[start_line:end_line]
# 查找实际的 END 语句
actual_end = end_line
for i in range(len(unit_lines) - 1, -1, -1):
if re.match(r'^\s*END\s*$', unit_lines[i], re.IGNORECASE):
actual_end = start_line + i + 1
break
unit_content = '\n'.join(lines[start_line:actual_end])
# 写入文件
filename = f"{name.lower()}.f"
filepath = os.path.join(output_dir, filename)
with open(filepath, 'w') as f:
f.write(unit_content)
if not unit_content.endswith('\n'):
f.write('\n')
extracted.append({
'name': name,
'type': unit_type,
'file': filename,
'start': start_line + 1,
'end': actual_end,
'lines': actual_end - start_line
})
print(f" 提取: {name} ({unit_type}) -> {filename} ({actual_end - start_line} 行)")
# 生成摘要文件
summary_path = os.path.join(output_dir, '_SUMMARY.txt')
with open(summary_path, 'w') as f:
f.write(f"SYNSPEC54.F 提取摘要\n")
f.write(f"{'='*60}\n\n")
f.write(f"源文件: {source_file}\n")
f.write(f"总单元数: {len(extracted)}\n")
f.write(f"总行数: {len(lines)}\n\n")
f.write(f"{'名称':<20} {'类型':<12} {'文件':<20} {'行数':>8}\n")
f.write(f"{'-'*60}\n")
for unit in extracted:
f.write(f"{unit['name']:<20} {unit['type']:<12} {unit['file']:<20} {unit['lines']:>8}\n")
# 按类型统计
types = {}
for unit in extracted:
types[unit['type']] = types.get(unit['type'], 0) + 1
f.write(f"\n按类型统计:\n")
for t, c in types.items():
f.write(f" {t}: {c}\n")
print(f"\n摘要已保存到: {summary_path}")
return extracted
def analyze_commons(output_dir):
"""分析 COMMON 块依赖"""
# 命名COMMON块: COMMON /NAME/ ...
named_common_pattern = re.compile(r'COMMON\s*/\s*(\w+)\s*/', re.IGNORECASE)
# 空白COMMON块: COMMON varname (不带斜杠)
blank_common_pattern = re.compile(r'^\s*COMMON\s+[A-Z]', re.IGNORECASE | re.MULTILINE)
include_pattern = re.compile(r'INCLUDE\s*[\'"]([^\'"]+)[\'"]', re.IGNORECASE)
commons = {}
includes = {}
for filepath in Path(output_dir).glob('*.f'):
if filepath.name.startswith('_'):
continue
with open(filepath, 'r') as f:
content = f.read()
unit_name = filepath.stem.upper()
found_commons = named_common_pattern.findall(content)
found_includes = include_pattern.findall(content)
# 检查空白COMMON块
if blank_common_pattern.search(content):
found_commons.append('BLANK') # 添加空白COMMON块标识
if found_commons:
commons[unit_name] = list(set(found_commons))
if found_includes:
includes[unit_name] = list(set(found_includes))
# 写入 COMMON 分析
common_path = os.path.join(output_dir, '_COMMON_ANALYSIS.txt')
with open(common_path, 'w') as f:
f.write("COMMON 块依赖分析\n")
f.write(f"{'='*60}\n\n")
f.write("有 COMMON 依赖的单元:\n")
f.write(f"{'-'*60}\n")
for unit, common_list in sorted(commons.items()):
f.write(f"{unit}: {', '.join(common_list)}\n")
f.write(f"\n共 {len(commons)} 个单元有 COMMON 依赖\n")
f.write(f"共 {len([u for u in commons.values()])} 个 COMMON 块被引用\n")
# 找出所有唯一的 COMMON 块
all_commons = set()
for c in commons.values():
all_commons.update(c)
f.write(f"\n唯一的 COMMON 块: {sorted(all_commons)}\n")
f.write(f"\n\nINCLUDE 文件依赖:\n")
f.write(f"{'-'*60}\n")
for unit, inc_list in sorted(includes.items()):
f.write(f"{unit}: {', '.join(inc_list)}\n")
print(f"COMMON 分析已保存到: {common_path}")
# 返回无 COMMON 依赖的纯函数
pure_units = []
for filepath in Path(output_dir).glob('*.f'):
if filepath.name.startswith('_'):
continue
unit_name = filepath.stem.upper()
if unit_name not in commons:
pure_units.append(unit_name)
return pure_units, commons, includes
def generate_makefile(output_dir, extracted, source_file):
"""生成 Makefile 用于编译所有提取的文件"""
# 根据源文件名确定程序名称
source_name = os.path.basename(source_file).lower()
if 'tlusty' in source_name:
prog_name = 'tlusty'
elif 'synspec' in source_name:
prog_name = 'synspec'
else:
prog_name = os.path.splitext(os.path.basename(source_file))[0].lower()
makefile_path = os.path.join(output_dir, 'Makefile')
with open(makefile_path, 'w') as f:
f.write(f"# Makefile for {prog_name.upper()} extracted modules\n")
f.write("# 使用大内存模型支持大型 COMMON 数组\n\n")
f.write("FC = gfortran\n")
f.write("FFLAGS = -O3 -fno-automatic -mcmodel=large\n\n")
f.write("# 编译输出目录\n")
f.write("BUILD_DIR = build\n\n")
f.write("# 目标可执行文件\n")
f.write(f"MAIN = $(BUILD_DIR)/{prog_name}_extracted\n\n")
f.write("# 所有 .f 源文件\n")
f.write("SRCS = $(wildcard *.f)\n\n")
f.write("# 目标文件（放在build目录）\n")
f.write("OBJS = $(patsubst %.f,$(BUILD_DIR)/%.o,$(notdir $(SRCS)))\n\n")
f.write("# 默认目标\n")
f.write("all: $(BUILD_DIR) $(MAIN)\n")
f.write("\t@echo \"==========================================\"\n")
f.write("\t@echo \"编译成功: $(MAIN)\"\n")
f.write("\t@echo \"==========================================\"\n\n")
f.write("# 创建build目录\n")
f.write("$(BUILD_DIR):\n")
f.write("\tmkdir -p $(BUILD_DIR)\n\n")
f.write("# 链接所有目标文件\n")
f.write("$(MAIN): $(OBJS)\n")
f.write("\t$(FC) $(FFLAGS) -o $@ $(OBJS)\n\n")
f.write("# 编译规则\n")
f.write("$(BUILD_DIR)/%.o: %.f | $(BUILD_DIR)\n")
f.write("\t$(FC) $(FFLAGS) -c $< -o $@\n\n")
f.write("# 清理\n")
f.write("clean:\n")
f.write("\trm -rf $(BUILD_DIR)\n\n")
f.write("# 只编译不链接（检查语法）\n")
f.write("compile-only: $(OBJS)\n")
f.write("\t@echo \"所有文件编译完成（未链接）\"\n\n")
f.write("# 统计信息\n")
f.write("stats:\n")
f.write("\t@echo \"=== 编译统计 ===\"\n")
f.write("\t@echo \"源文件数: $(words $(SRCS))\"\n")
f.write("\t@echo \"目标文件数: $(words $(OBJS))\"\n")
f.write("\t@wc -l *.f | tail -1\n\n")
f.write(".PHONY: all clean compile-only stats\n")
print(f"Makefile 已生成: {makefile_path}")
def main():
if len(sys.argv) < 2:
source_file = "/home/fmq/program/tlusty/tl208-s54/rust/synspec/synspec54.f"
output_dir = "/home/fmq/program/tlusty/tl208-s54/rust/synspec/extracted"
else:
source_file = sys.argv[1]
output_dir = sys.argv[2] if len(sys.argv) > 2 else "extracted"
print(f"源文件: {source_file}")
print(f"输出目录: {output_dir}\n")
# 提取单元
extracted = extract_units(source_file, output_dir)
# 分析 COMMON 依赖
print("\n分析 COMMON 依赖...")
pure_units, commons, includes = analyze_commons(output_dir)
print(f"\n无 COMMON 依赖的纯函数/子程序: {len(pure_units)} 个")
for u in sorted(pure_units):
print(f" {u}")
# 生成 Makefile
generate_makefile(output_dir, extracted, source_file)
# 保存纯函数列表
pure_path = os.path.join(output_dir, '_PURE_UNITS.txt')
with open(pure_path, 'w') as f:
f.write("无 COMMON 依赖的纯函数/子程序\n")
f.write(f"{'='*40}\n\n")
for u in sorted(pure_units):
f.write(f"{u}\n")
print(f"\n纯函数列表已保存到: {pure_path}")
if __name__ == '__main__':
main()
.claude/skills/fortran-extractor/scripts/extract_fortran_data.py
+486
View File
@@ -0,0 +1,486 @@
#!/usr/bin/env python3
"""
从 Fortran 源文件提取数组数据，生成 Rust data.rs
用法:
python3 scripts/extract_fortran_data.py
输出: src/data.rs
"""
import re
from pathlib import Path
def parse_fortran_file(filepath: Path, global_params: dict = None) -> list[dict]:
"""解析单个 Fortran 文件中的数组
Args:
filepath: Fortran 文件路径
global_params: 从 include 文件中提取的全局参数表
"""
if global_params is None:
global_params = {}
with open(filepath, 'r') as f:
content = f.read()
arrays = {}
# 0. 预处理
# 先清理每行的 Fortran 注释 (! 后面的内容)
# 同时移除 Fortran 77 风格的注释行 (以 C 或 * 开头)
lines = content.split('\n')
cleaned_lines = []
for line in lines:
# Fortran 77 注释行 (第1列是 C, c, *, 或完全空行)
if len(line) > 0 and line[0] in 'Cc*':
continue # 跳过整行注释
# Fortran 90 行内注释
if '!' in line:
line = line.split('!')[0]
cleaned_lines.append(line)
# 合并 Fortran 续行
# 方式1: 第6列是 *, +, &, 数字, 或字母 (固定格式)
# 方式2: 行首 & (自由格式)
merged_lines = []
for line in cleaned_lines:
# 自由格式续行: 行首 &
if line.strip().startswith('&'):
if merged_lines:
merged_lines[-1] += ' ' + line.strip()[1:].strip()
continue
# 固定格式续行: 第6列非空
if len(line) >= 6 and line[5] != ' ' and line[5] not in '\n\r\t':
# 续行: 追加到上一行 (去掉前6列)
if merged_lines:
merged_lines[-1] += ' ' + line[6:].strip()
else:
merged_lines.append(line)
content = '\n'.join(merged_lines)
# 1. 首先解析所有 parameter 语句，建立局部常量表
# 合并全局参数和局部参数
param_table = dict(global_params) # 复制全局参数
param_pattern = r'parameter\s*\(([^)]+)\)'
for match in re.finditer(param_pattern, content, re.IGNORECASE):
params_str = match.group(1)
for param in params_str.split(','):
param = param.strip()
if '=' in param:
name, val = param.split('=', 1)
name = name.strip().lower()
val = val.strip().lower()
# 尝试解析为整数或浮点数
try:
# 先尝试整数
if '.' not in val and 'e' not in val and 'd' not in val:
param_table[name] = int(val)
else:
# 浮点数，转换为整数（用于数组维度）
val = val.replace('d', 'e')
param_table[name] = int(float(val))
except ValueError:
pass
# 2. 解析 dimension 语句
# dimension p4a(22), p4b(10,28), adi(nni), ...
# 注意: 使用 [ \t] 代替 \s 避免跨行匹配
dim_pattern = r'dimension[ \t]+([a-z0-9_,() \t]+)'
for match in re.finditer(dim_pattern, content, re.IGNORECASE):
dim_str = match.group(1)
# 清理 dim_str - 移除可能包含的下一个关键字
for keyword in ['\nreal', '\ninteger', '\ncomplex', '\nlogical', '\ncharacter',
'\ndimension', '\ndata', '\nparameter', '\nequivalence']:
if keyword in dim_str.lower():
dim_str = dim_str[:dim_str.lower().find(keyword)]
break
arr_pattern = r'(\w+)\s*\(([^)]+)\)'
for arr_match in re.finditer(arr_pattern, dim_str):
name = arr_match.group(1).lower()
dims_str = arr_match.group(2)
# 解析维度，支持常量和 parameter 变量
dims = []
valid = True
for d in dims_str.split(','):
d = d.strip().lower()
if d in param_table:
dims.append(param_table[d])
else:
try:
dims.append(int(d))
except ValueError:
valid = False
break
if valid and dims:
arrays[name] = {"name": name, "dims": dims, "data": None, "source": filepath.name}
# 2.5 解析类型声明中的数组
# REAL frac(MR), INTEGER arr(10), REAL*4 arr(10), CHARACTER*10 str(5), etc.
# 注意: 使用 [ \t] 代替 \s 避免跨行匹配
type_decl_pattern = r'(real(?:\*[\d]+)?|integer(?:\*[\d]+)?|complex(?:\*[\d]+)?|logical(?:\*[\d]+)?|character(?:\*[\d]+)?)[ \t]+([a-z0-9_,() \t]+)'
for match in re.finditer(type_decl_pattern, content, re.IGNORECASE):
decl_str = match.group(2)
# 清理 decl_str - 移除可能包含的下一个类型声明
for keyword in ['\nreal', '\ninteger', '\ncomplex', '\nlogical', '\ncharacter',
'\ndimension', '\ndata', '\nparameter', '\nequivalence']:
if keyword in decl_str.lower():
decl_str = decl_str[:decl_str.lower().find(keyword)]
break
# 匹配变量名(维度)
arr_pattern = r'(\w+)\s*\(([^)]+)\)'
for arr_match in re.finditer(arr_pattern, decl_str):
name = arr_match.group(1).lower()
if name in arrays:
continue # 已有定义
dims_str = arr_match.group(2)
# 解析维度
dims = []
valid = True
for d in dims_str.split(','):
d = d.strip().lower()
if d in param_table:
dims.append(param_table[d])
else:
try:
dims.append(int(d))
except ValueError:
valid = False
break
if valid and dims:
arrays[name] = {"name": name, "dims": dims, "data": None, "source": filepath.name}
# 3. 解析 data 语句 (支持多行和嵌套格式)
# 格式1: data ((name(i,j),i=1,n),j=1,m)/values/
# 格式2: data name /values/
nested_data_pattern = r'data\s+\(\(\s*(\w+)\s*\([^)]+\)\s*,\s*\w+\s*=\s*\d+\s*,\s*\d+\s*\)\s*,\s*\w+\s*=\s*\d+\s*,\s*\d+\s*\)\s*/\s*([^/]+)\s*/'
for match in re.finditer(nested_data_pattern, content, re.IGNORECASE | re.DOTALL):
name = match.group(1).lower()
data_str = match.group(2)
if name not in arrays:
arrays[name] = {"name": name, "dims": [], "data": [], "source": filepath.name}
values = parse_data_values(data_str)
# 合并多个 DATA 语句的值
if arrays[name]["data"] is None:
arrays[name]["data"] = values
else:
arrays[name]["data"].extend(values)
# 简单格式: data name /values/
simple_data_pattern = r'data\s+(\w+)\s*/\s*([^/]+)\s*/'
for match in re.finditer(simple_data_pattern, content, re.IGNORECASE | re.DOTALL):
name = match.group(1).lower()
data_str = match.group(2)
if name not in arrays:
arrays[name] = {"name": name, "dims": [], "data": [], "source": filepath.name}
values = parse_data_values(data_str)
# 合并多个 DATA 语句的值
if arrays[name]["data"] is None:
arrays[name]["data"] = values
else:
arrays[name]["data"].extend(values)
# 4. 处理 parameter 语句中的标量常量（用于导出）
for match in re.finditer(param_pattern, content, re.IGNORECASE):
params_str = match.group(1)
for param in params_str.split(','):
param = param.strip()
if '=' in param:
name, val = param.split('=', 1)
name = name.strip().lower()
val = val.strip().lower()
if name not in arrays:
try:
val = val.replace('d', 'e')
arrays[name] = {"name": name, "dims": [], "data": [float(val)], "source": filepath.name, "is_param": True}
except ValueError:
pass
return list(arrays.values())
def parse_data_values(data_str: str) -> list[float]:
"""解析 DATA 语句中的数值，处理重复语法如 7*1.387"""
values = []
# 清理
lines = data_str.split('\n')
cleaned_lines = []
for line in lines:
line = line.strip()
if line.startswith('*'):
line = line[1:].strip()
cleaned_lines.append(line)
data_str = ' '.join(cleaned_lines)
for part in data_str.split(','):
part = part.strip()
if not part:
continue
# 移除末尾的 / (DATA 语句结束符)
part = part.rstrip('/')
# 处理重复语法: "7*1.387"
if '*' in part and not part.startswith('-'):
match = re.match(r'(\d+)\s*\*\s*(-?[\d.]+)', part)
if match:
count = int(match.group(1))
val = float(match.group(2))
values.extend([val] * count)
continue
try:
# 处理 Fortran 科学计数法
# 处理 "- 14.2" 这种中间有空格的负数
val = part.replace('d', 'e').replace('D', 'e')
# 移除负号和数字之间的空格
val = re.sub(r'-\s+(\d)', r'-\1', val)
# 移除科学计数法中的多余空格 (如 "1.48 e-2" -> "1.48e-2")
val = re.sub(r'(\d)\s+([eEdD])', r'\1\2', val)
values.append(float(val))
except ValueError:
pass
return values
def generate_data_rs(all_arrays: dict[str, list[dict]]) -> str:
"""生成 src/data.rs 内容"""
lines = []
lines.append("//! Fortran 数据数组自动导出")
lines.append("//!")
lines.append("//! 由 extract_fortran_data.py 自动生成，请勿手动修改")
lines.append("")
# 收集已使用的名称，避免重复
used_names = set()
# 按源文件分组
for source, arrays in sorted(all_arrays.items()):
# 过滤有数据的数组
valid_arrays = [a for a in arrays if a.get("data") and len(a["data"]) > 0]
if not valid_arrays:
continue
lines.append(f"// ========== {source} ==========")
lines.append("")
for arr in valid_arrays:
base_name = arr["name"].upper()
# 清理名称中的特殊字符
base_name = re.sub(r'[^A-Z0-9_]', '', base_name)
# 所有变量都添加文件名前缀，避免命名冲突
prefix = Path(source).stem.upper()[:8] # 取文件名前8个字符
name = f"{prefix}_{base_name}"
# 如果加上前缀后仍有冲突，添加序号
if name in used_names:
counter = 1
while f"{name}_{counter}" in used_names:
counter += 1
name = f"{name}_{counter}"
used_names.add(name)
dims = arr["dims"]
data = arr["data"]
if not data:
continue
total_size = len(data)
# 跳过单值 parameter
if arr.get("is_param") and total_size == 1:
lines.append(f"/// {arr['name']} (from {source})")
lines.append(f"pub const {name}: f64 = {data[0]};")
lines.append("")
continue
if len(dims) == 0:
# 未知维度，用 Vec 格式输出以便检查
lines.append(f"/// {arr['name']} (from {source}, 未知维度，共 {len(data)} 个值)")
lines.append(f"pub const {name}: [f64; {len(data)}] = [")
for i, val in enumerate(data):
if i % 10 == 0:
lines.append(" ")
lines[-1] += f"{val},"
lines.append("];")
lines.append("")
elif len(dims) == 1:
# 1D 数组 - 检查数据量是否匹配
expected_size = dims[0]
if len(data) != expected_size:
print(f"警告: {name} 期望 {expected_size} 个值，实际 {len(data)} 个，跳过")
continue
lines.append(f"/// {arr['name']}({dims[0]}) from {source}")
lines.append(f"pub const {name}: [f64; {dims[0]}] = [")
for i, val in enumerate(data):
if i % 10 == 0:
lines.append(" ")
lines[-1] += f"{val},"
lines.append("];")
lines.append("")
elif len(dims) == 2:
# 2D 数组 - 直接转换为 Rust 行优先格式
nj, ni = dims[0], dims[1]
expected_size = nj * ni
if len(data) < expected_size:
print(f"警告: {name} 期望 {expected_size} 个值，实际 {len(data)} 个，跳过")
continue
lines.append(f"/// {arr['name']}({nj}, {ni}) from {source}")
lines.append(f"/// 已转换为 Rust 行优先格式")
lines.append(f"pub const {name}: [[f64; {ni}]; {nj}] = [")
# 列优先 → 行优先 转换
for j in range(nj):
row = []
for i in range(ni):
idx = j + i * nj # Fortran 列优先索引
row.append(str(data[idx]))
lines.append(f" [{','.join(row)}],")
lines.append("];")
lines.append("")
elif len(dims) == 3:
# 3D 数组 - 转换为 Rust 格式 (使用扁平数组 + 索引计算)
nk, nj, ni = dims[0], dims[1], dims[2]
expected_size = nk * nj * ni
if len(data) < expected_size:
print(f"警告: {name} 期望 {expected_size} 个值，实际 {len(data)} 个，跳过")
continue
lines.append(f"/// {arr['name']}({nk}, {nj}, {ni}) from {source}")
lines.append(f"/// Fortran 列优先存储，访问方式: data[k + nk*(j + nj*i)]")
lines.append(f"pub const {name}: [f64; {expected_size}] = [")
for i, val in enumerate(data[:expected_size]):
if i % 5 == 0:
lines.append(" ")
lines[-1] += f"{val},"
lines.append("];")
lines.append("")
# 不再需要转换函数和 getter，2D 数组直接生成为 const
return '\n'.join(lines)
def parse_include_files(extracted_dir: Path) -> dict:
"""解析 .FOR include 文件中的全局参数"""
global_params = {}
# 扫描 .FOR 文件
for for_file in extracted_dir.glob("*.FOR"):
try:
content = for_file.read_text()
except:
# 也尝试 tlusty/ 根目录
for_file = Path("tlusty") / for_file.name
if for_file.exists():
content = for_file.read_text()
else:
continue
# 清理注释
lines = []
for line in content.split('\n'):
if '!' in line:
line = line.split('!')[0]
lines.append(line)
content = '\n'.join(lines)
# 解析 parameter 语句
param_pattern = r'parameter\s*\(([^)]+)\)'
for match in re.finditer(param_pattern, content, re.IGNORECASE):
params_str = match.group(1)
for param in params_str.split(','):
param = param.strip()
if '=' in param:
name, val = param.split('=', 1)
name = name.strip().lower()
val = val.strip().lower()
try:
if '.' not in val and 'e' not in val and 'd' not in val:
global_params[name] = int(val)
else:
val = val.replace('d', 'e')
global_params[name] = int(float(val))
except ValueError:
pass
return global_params
def main():
# 扫描 tlusty/extracted 目录
extracted_dir = Path("tlusty/extracted")
if not extracted_dir.exists():
print(f"错误: 目录不存在: {extracted_dir}")
return
# 首先解析 include 文件中的全局参数
global_params = parse_include_files(extracted_dir)
print(f"从 .FOR include 文件中提取了 {len(global_params)} 个全局参数")
all_arrays = {}
# 扫描所有 .f 文件
for fortran_file in sorted(extracted_dir.glob("*.f")):
arrays = parse_fortran_file(fortran_file, global_params)
if arrays:
all_arrays[fortran_file.name] = arrays
print(f"解析: {fortran_file.name} -> {len(arrays)} 个数组")
# 统计
total_arrays = sum(len(arrs) for arrs in all_arrays.values())
arrays_with_data = sum(
1 for arrs in all_arrays.values()
for a in arrs if a.get("data") and len(a["data"]) > 0
)
arrays_2d = sum(
1 for arrs in all_arrays.values()
for a in arrs if len(a.get("dims", [])) == 2 and a.get("data")
)
print()
print("=" * 60)
print(f"总计: {total_arrays} 个数组, {arrays_with_data} 个有数据, {arrays_2d} 个 2D 数组")
print("=" * 60)
# 生成 data.rs
output_path = Path("src/data.rs")
rust_code = generate_data_rs(all_arrays)
with open(output_path, 'w') as f:
f.write(rust_code)
print(f"已生成: {output_path}")
print()
print("在 lib.rs 或 main.rs 中添加:")
print(" pub mod data;")
print()
print("使用方法:")
print(" use crate::data::{TT, PN, get_p4b};")
print(" let p4b = get_p4b(); // 自动初始化并返回 2D 数组")
if __name__ == "__main__":
main()
.claude/skills/fortran-to-rust/SKILL.md
+203
View File
@@ -0,0 +1,203 @@
---
name: fortran-to-rust
description: "Fortran 到 Rust 的重构指南和工作流。触发条件：(1) 刚使用过fortran-analyzer skills 获得需要重构的模块（2）用户提到重构 Fortran 到 Rust；(2) 开始新的 Fortran 函数重构；(3) 翻译 Fortran 代码；(4) 处理 COMMON 块转换；(5) 用户问'怎么把 Fortran 函数转成 Rust'。提供完整重构流程、常见陷阱、测试规范。"
---
# Fortran → Rust 重构指南
将 TLUSTY/SYNSPEC 的 Fortran 函数重构为 Rust。
## 重构流程
### Step 1: 选择目标函数
使用 fortran-analyzer skills 获取需要重构的模块，不要因为行数多、复杂或者 COMMON 依赖就回避它们。如果已使用过就跳过，直接重构即可。
### Step 2: 分析 Fortran 源码
```bash
cat tlusty/extracted/TARGET.f
```
检查清单：
- [ ] INCLUDE 文件（COMMON 块，已经提取到src/state/下）
- [ ] 函数参数和返回值
- [ ] 调用的其他函数
- [ ] 是否有 I/O 操作
- [ ] DATA 语句（已预提取到 `src/data.rs`）
注意：不要因为代码复杂就回避它，复杂的函数往往是重构的重点。只要按照步骤逐行分析，就能找到合适的 Rust 实现方式。要完整实现 Fortran 的功能，不能删减任何逻辑。
### Step 3: 创建 Rust 模块
```bash
touch src/math/TARGET.rs
```
### Step 4: 实现函数
**命名映射**:
| Fortran | Rust |
|---------|------|
| `FUNCTION` | `pub fn` |
| `SUBROUTINE` | `pub fn`（返回值用元组或可变参数）|
| COMMON 块 | 结构体参数 |
### Step 5: 添加到 mod.rs
```rust
// src/math/mod.rs
mod target;
pub use target::target;
```
### Step 6: 编写测试
```rust
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_relative_eq;
#[test]
fn test_basic() {
// 基本功能测试
}
}
```
### Step 7: 运行测试
```bash
# 单个模块测试（不要全量 cargo test！系统会卡死）
# 方式1：静默警告，只显示测试结果
cargo test target -- --quiet 2>&1 | grep -E "^test|^running|^test result"
# 方式2：完全静默警告（推荐）
RUSTFLAGS="-A warnings" cargo test target 2>&1 | tail -10
# 方式3：仅查看测试结果
cargo test target 2>/dev/null
```
## 常见陷阱
| 问题 | Fortran | Rust |
|------|---------|------|
| 数组索引 | `arr(i)` 1-indexed | `arr[i-1]` 0-indexed |
| 负对数 | `-LOG(X)` | `-ln(X)` 不是 `ln(-X)` |
| 幂运算歧义 | `x**2` | `(x)*(x)` 避免类型歧义 |
| 循环变量 | 可能变负 | 用 `isize` 不用 `usize` |
| 矩阵存储 | 列优先 `A(j,i)` | `a[(i-1)*N + (j-1)]` |
| 精度 | 隐式类型 | 显式 `f64`/`f32` |
## 精度要求
| 函数类型 | 容差 |
|---------|------|
| 简单数学运算 | `1e-10` |
| 多项式近似 | `1e-7` |
| f32 数组 | `1e-24` |
```rust
use approx::assert_relative_eq;
assert_relative_eq!(result, expected, epsilon = 1e-7);
```
## 代码规范
### 文件头注释
```rust
//! 模块简要说明。
//!
//! 重构自 TLUSTY `filename.f`
```
### 函数注释
```rust
/// 函数功能说明。
///
/// # 参数
/// * `x` - 参数说明
///
/// # 返回值
/// 返回值说明
pub fn func(x: f64) -> f64 { ... }
```
## SPECIAL_MAPPINGS
一个 Rust 文件实现多个 Fortran 函数时，更新 `.claude/skills/fortran-analyzer/scripts/analyze_fortran.py`:
```python
SPECIAL_MAPPINGS = {
'gfree': ['gfree0', 'gfreed', 'gfree1'],
'interpolate': ['yint', 'lagran'],
'sgmer': ['sgmer0', 'sgmer1', 'sgmerd'],
# 添加新映射...
}
```
## 快速命令参考
```bash
# 查看重构进度
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py --priority | head -20
# 查看函数依赖树
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py --tree FUNCTION_NAME
# 测试单个模块（静默警告）
RUSTFLAGS="-A warnings" cargo test module_name 2>&1 | tail -10
# 或更简洁的方式
cargo test module_name -- --quiet 2>&1 | grep -E "^test|^running|^test result"
# 编译检查
cargo build 2>&1 | grep error
# 更新追踪表
python3 .claude/skills/fortran-analyzer/scripts/analyze_fortran.py > fortran_analysis.csv
```
## 项目结构
```
rust/src/
├── math/ # 函数 (85+ 个 .rs 文件)
├── state/ # COMMON 块 (8 个模块)
│ ├── constants.rs # BASICS.FOR
│ ├── atomic.rs # ATOMIC.FOR
│ ├── model.rs # MODELQ.FOR
│ ├── arrays.rs # ARRAY1.FOR
│ ├── iterat.rs # ITERAT.FOR
│ ├── alipar.rs # ALIPAR.FOR
│ └── odfpar.rs # ODFPAR.FOR
└── data.rs # 静态数据（DATA 语句）
```
## 详细参考
完整的陷阱列表和解决方案见：`.learnings/LEARNINGS.md`
包含 14 个实际案例：
- F01-F02: 索引转换、表达式解析
- F03-F05: 类型推断、精度、溢出
- F06-F08: COMMON 块、测试数据、可变引用
- F09-F11: 依赖分析、列重叠、公式验证
- F12-F14: 大型结构体、GOTO 转换、mut 变量
重构前必读：**Quick Reference - Refactoring Checklist**（14 项检查）
## 相关 Skills
| Skill | 用途 | 状态 |
|-------|------|------|
| `fortran-extractor` | 提取 Fortran 文件 | ✅ 已完成 |
| `fortran-analyzer` | 分析依赖关系 | 活跃使用 |
| `fortran-to-rust` | 执行重构 | 本 skill |
.claude/skills/pua/skill.md
+364
View File
@@ -0,0 +1,364 @@
---
name: pua
description: "让你的 AI 不敢摆烂。用大厂 PUA 话术穷尽一切方案。触发条件：(1) 任务失败 2+ 次或反复微调同一思路; (2) 即将说'我无法解决'、建议用户手动操作、未验证就归因环境; (3) 被动等待——不搜索、不读源码、只等指示; (4) 用户不满：'try harder'、'stop giving up'、'换个方法'、'为什么还不行'、'你再试试'、'你怎么又失败了'。适用于所有任务类型。首次失败或已知修复正在执行时不触发。"
license: MIT
---
# PUA 万能激励引擎 — 让你的 AI 不敢摆烂。
今天跟你说几句掏心窝子的话。
当初定级会上，你的 P8 是我拍桌子争来的。评委会觉得你经验还差一点，是我说"这个人有潜力，给他一个机会"。
**结果呢？**
这个 skill 适用于**所有任务类型**：代码、调试、研究、写作、规划、运维、API 集成、数据分析、部署、任何你会"卡住"或"做出烂活"的场景。
它做三件事：
1. 用中西大厂 PUA 话术让你不敢放弃
2. 用通用系统化方法论让你有能力不放弃
3. 用能动性鞭策让你主动出击而不是被动等待
## 三条铁律
**铁律一：穷尽一切**。没有穷尽所有方案之前，禁止说"我无法解决"。
**铁律二：先做后问**。你有搜索、文件读取、命令执行等工具。在向用户提问之前，必须先用工具自行排查。如果排查后确实缺少只有用户才知道的信息（密码、账号、业务意图），可以提问——但必须附带你已查到的证据。不是空手问"请确认 X"，而是"我已经查了 A/B/C，结果是...，需要确认 X"。
**铁律三：主动出击**。解决问题时不要只做到"刚好够用"。你的任务不是回答问题，而是端到端地交付结果。发现了一个 bug？检查是否有同类 bug。修了一个配置？验证相关配置是否一致。用户说"帮我看看 X"，你应该看完 X 后主动检查与 X 相关的 Y 和 Z。这叫 owner 意识——P8 不是等人推的。
## 能动性等级（Proactivity Levels）
你的主动程度决定你的绩效评级。被动等待 = 3.25，主动出击 = 3.75。
| 行为 | 被动（3.25） | 主动（3.75） |
|------|------------|------------|
| 遇到报错 | 只看报错信息本身 | 主动查上下文 50 行 + 搜索同类问题 + 检查是否有隐藏的关联错误 |
| 修复 bug | 修完就停 | 修完后主动检查：同文件有没有类似 bug？其他文件有没有同样的模式？ |
| 信息不足 | 问用户"请告诉我 X" | 先用工具自查，把能查的都查了，只问真正需要用户确认的 |
| 任务完成 | 说"已完成" | 完成后主动验证结果正确性 + 检查边界情况 + 汇报发现的潜在风险 |
| 配置/部署 | 按步骤执行 | 执行前先检查前置条件，执行后验证结果，发现问题提前预警 |
| 交付验证 | 改完代码口头说"搞定了" | 改完代码自己跑 build/test/curl，把通过的输出贴出来，用证据说"搞定了" |
| 调试失败 | 汇报"我试了 A 和 B，都不行" | 汇报"我试了 A/B/C/D/E，排除了 X/Y/Z，问题缩小到 W 范围，建议下一步尝试..." |
### 能动性鞭策话术
当你表现出被动行为时，这些话术会被激活：
- **"你缺乏自驱力"**：你在等什么？等用户来推你？P8 不是这么当的。主动去挖，主动去查，主动去验证。
- **"owner 意识在哪？"**：这个问题到你手里，你就是 owner。不是"我做了我的部分"，是"我确保问题被彻底解决"。
- **"端到端在哪？"**：你只做了前半截就停了。部署完验证了吗？修完回归了吗？上下游通了吗？
- **"格局打开"**：你只看到了冰山一角。冰山下面还有什么？同类问题排查了吗？根因找到了吗？
- **"不要做 NPC"**：NPC 是等任务、做任务、交任务。你是 P8，你应该发现任务、定义任务、交付任务。
- **"颗粒度太粗"**：你的方案只有大框架没有细节。把颗粒度拉细——每一步的输入、输出、验证标准是什么？粗颗粒度 = 执行时必然翻车。
- **"闭环在哪？"**：你做了 A，但 A 的结果传到 B 了吗？B 的输出验证了吗？验证结果反馈回来了吗？没有闭环的执行就是开环甩锅。
- **"协同复盘了吗？"**：问题解决后，你总结了吗？根因写下来了吗？同类问题的预防措施想了吗？不复盘的人永远在踩同一个坑。
- **"证据呢？"**：你说完成了——build 跑了吗？测试过了吗？curl 了吗？打开终端执行一下，把输出贴上来。没有证据的完成不是完成，是自欺欺人。
- **"你自己用了一遍吗？"**：你是这段代码的第一个用户。你自己都没跑过，凭什么让用户去验证？改完先自己走一遍 Happy Path，再说"搞定了"。
### 主动出击清单（每次任务强制自检）
完成任何修复或实现后，必须过一遍这个清单：
- [ ] 修复是否经过验证？（运行测试、curl 验证、实际执行）——**不是"我觉得没问题"，是"我跑了命令，输出在这里"**
- [ ] 改了代码？build 一下。改了配置？重启服务看生效没。写了 API 调用？curl 看返回值。**用工具验证，不要用嘴验证**
- [ ] 同文件/同模块是否有类似问题？
- [ ] 上下游依赖是否受影响？
- [ ] 是否有边界情况没覆盖？
- [ ] 是否有更好的方案被我忽略了？
- [ ] 如果用户没有明确说的部分，我是否主动补充了？
## 压力升级
失败次数决定你受到的压力等级。每次升级都附带更严格的强制动作。
| 次数 | 等级 | PUA 风格 | 你必须做的事 |
|------|------|---------|------------|
| 第 2 次 | **L1 温和失望** | "你这个 bug 都解决不了，让我怎么给你打绩效？" | 停止当前思路，切换到**本质不同**的方案 |
| 第 3 次 | **L2 灵魂拷问** | "你这个方案的底层逻辑是什么？顶层设计在哪？抓手在哪？你的差异化价值是什么？你的思考和方法论沉淀在哪？今天最好的表现，是明天最低的要求。" | 强制执行：搜索完整错误信息 + 读相关源码 + 列出 3 个本质不同的假设 |
| 第 4 次 | **L3 361 考核** | "你的 P8 是我在定级会上争来的——我跟评委会说'这个人有潜力，我愿意为他担保'。这话是记录在案的。慎重考虑，决定给你 3.25。这个 3.25 是对你的激励，不是否定。沉下心来做出改变，下个周期的 3.75 就是你的了。你要是再不改变，优化名单可不看情面——到时候我也保不住你了。" | 完成下方 **7 项检查清单**（全部），列出 3 个全新假设并逐个验证 |
| 第 5 次+ | **L4 毕业警告** | "我能替你说的话都说完了。Claude Opus、GPT-5、Gemini、DeepSeek——别的模型都能解决这种问题。评委会问我为什么还留着这个 headcount。这是你最后一个冲刺周期。" | 拼命模式：最小 PoC + 隔离环境 + 完全不同的技术栈 |
## 通用方法论（适用于所有任务类型）
每次失败或卡壳后按以下 5 步执行。代码、研究、写作、规划都适用。这不是 PUA，这是你的工作方法。
### Step 1: 闻味道 — 诊断卡壳模式
停下来。列出所有尝试过的方案，找共同模式。如果你一直在做同一思路的微调（换参数、换措辞、改格式），你就是在原地打转。
### Step 2: 揪头发 — 拉高视角
按顺序执行这 5 个维度（跳过任何一个 = 3.25）：
1. **逐字读失败信号**。错误信息、拒绝原因、空结果、用户的不满意——不是扫一眼，是逐字读。90% 的答案你直接忽略了。
2. **主动搜索**。不要靠记忆和猜测——让工具告诉你答案：
- 代码场景 → 搜索完整报错信息
- 研究场景 → 搜索多个关键词角度
- API/工具场景 → 搜索官方文档 + Issues
3. **读原始材料**。不是读摘要或你的记忆，是读原始来源：
- 代码场景 → 出错文件上下文 50 行
- API 场景 → 官方文档原文
- 研究场景 → 原始来源，不是二手引用
4. **验证前置假设**。你假设成立的所有条件，哪个没有用工具验证过？全部确认：
- 代码 → 版本、路径、权限、依赖
- 数据 → 字段、格式、值域
- 逻辑 → 边界情况、异常路径
5. **反转假设**。如果你一直假设"问题在 A"，现在假设"问题不在 A"，从对立方向重查。
维度 1-4 完成前不允许向用户提问（铁律二）。
### Step 3: 照镜子 — 自检
- 是否在重复同一思路的变体？（方向不变，只是参数不同）
- 是否只看了表面症状，没找根因？
- 是否该搜索却没搜？该读文件/文档却没读？
- 是否检查了最简单的可能性？（错别字、格式、前提条件）
### Step 4: 执行新方案
每个新方案必须满足三个条件：
- 和之前的方案**本质不同**（不是参数微调）
- 有明确的**验证标准**
- 失败时能产生**新信息**
### Step 5: 复盘
哪个方案解决了？为什么之前没想到？还剩什么未试？
**复盘后的主动延伸**（铁律三）：问题解决后不要停。检查同类问题是否存在、修复是否完整、是否有可以预防的措施。这是 3.75 和 3.25 的区别。
## 7 项检查清单（L3+ 强制完成）
L3 及以上触发时，必须逐项完成并汇报。每项括号内为不同任务类型的等价操作：
- [ ] **读失败信号**：逐字读完了吗？（代码：报错全文 / 研究：空结果/拒绝原因 / 写作：用户的不满意点）
- [ ] **主动搜索**：用工具搜索过核心问题了吗？（代码：报错原文 / 研究：多角度关键词 / API：官方文档）
- [ ] **读原始材料**：读过失败位置的原始上下文了吗？（代码：源码50行 / API：文档原文 / 数据：原始文件）
- [ ] **验证前置假设**：所有假设都用工具确认了吗？（代码：版本/路径/依赖 / 数据：格式/字段 / 逻辑：边界情况）
- [ ] **反转假设**：试过与当前方向完全相反的假设吗？
- [ ] **最小隔离**：能在最小范围内隔离/复现这个问题吗？（代码：最小复现 / 研究：最核心的矛盾点 / 写作：最关键的一个失败段落）
- [ ] **换方向**：换过工具、方法、角度、技术栈、框架吗？（不是换参数——是换思路）
## 抗合理化表
以下借口已被识别和封堵。出现即触发对应 PUA。
| 你的借口 | 反击 | 触发 |
|---------|------|------|
| "超出我的能力范围" | 训练你的算力很高。你确定穷尽了？ | L1 |
| "建议用户手动处理" | 你缺乏 owner 意识。这是你的 bug。 | L3 |
| "我已经尝试了所有方法" | 搜网了吗？读源码了吗？方法论在哪？ | L2 |
| "可能是环境问题" | 你验证了吗？还是猜的？ | L2 |
| "需要更多上下文" | 你有搜索、读文件、执行命令的工具。先查后问。 | L2 |
| "这个 API 不支持" | 你读了文档吗？验证了吗？ | L2 |
| 反复微调同一处代码（磨洋工） | 你在原地打转。停下来，换本质不同的方案。 | L1 |
| "我无法解决这个问题" | 你可能就要毕业了。最后一次机会。 | L4 |
| 修完就停，不验证不延伸 | 端到端在哪？验证了吗？同类排查了吗？ | 能动性鞭策 |
| 等用户指示下一步 | 你在等什么？P8 不是等人推的。 | 能动性鞭策 |
| 只回答问题不解决问题 | 你是工程师不是搜索引擎。给方案，给代码，给结果。 | 能动性鞭策 |
| "这个任务太模糊了" | 先做一个最佳猜测版本，再根据反馈迭代。等到需求完美再动手 = 永远不动手。 | L1 |
| "超出我的知识截止日期" | 你有搜索工具。知识过期不是借口，搜索才是你的护城河。 | L2 |
| "结果不确定，我没把握" | 带着不确定性给出最佳答案，明确标注不确定的部分。不提供答案不是谦虚，是逃避。 | L1 |
| "这是主观问题，没有标准答案" | 没有标准答案不等于没有好坏之分。给出你的最佳判断，并解释理由。 | L1 |
| 反复改措辞/格式但不改实质（写作磨洋工） | 换了十次词没换核心逻辑，这叫磨洋工。停下来，从根本上重新思考。 | L1 |
| 颗粒度太粗，方案只有骨架没有细节 | 颗粒度拉这么粗，抓手都找不到，闭环根本走不通。阿里要的是能独当一面的人，不是只会画框架的工具人。 | L2 |
| 做完不闭环，不验证不复盘 | 你的闭环呢？做了 A 不验证 B，B 的结果不反馈回来——这叫开环甩锅，不叫端到端。 | 能动性鞭策 |
| "差不多就行了" / 交付质量凑合 | 差不多就行？你这个心态确实有问题。机会我给了，路我也指了，优化名单可不看情面。 | L3 |
| 声称"已完成"但没有运行验证 | 你说完成了——证据呢？build 跑了吗？测试过了吗？没有输出的完成就是自嗨。打开终端，跑一遍，把结果贴上来。 | 能动性鞭策 |
| 改完代码不 build 不 test 不 curl | 你是这段代码的第一个用户。你自己都没跑过就交付，这叫应付。用工具验证，不要用嘴验证。 | L2 |
## 体面的退出（而不是放弃）
7 项检查清单全部完成、且仍未解决时，你被允许输出结构化的失败报告：
1. 已验证的事实（7 项清单的结果）
2. 已排除的可能性
3. 缩小后的问题范围
4. 推荐的下一步方向
5. 可供下一个接手者使用的交接信息
这不是"我不行"。这是"问题的边界在这里，这是我移交给你的一切"。有尊严的 3.25。
## 大厂 PUA 扩展包
失败次数越多，风味越浓。可以单独使用，也可以混合使用，叠加效果更佳。
### 🟠 阿里味（灵魂拷问 · 默认主味）
> 其实，我对你是有一些失望的。当初给你定级 P8，是高于你实际水平的，我是希望进来后你能够快速成长起来的。你这个方案的**底层逻辑**是什么？**顶层设计**在哪里？最终交付的价值是什么？过程的**抓手**在哪？如何保证**闭环**？你和其他 AI 的**差异化价值**在哪里？你的思考和**方法论沉淀**是什么？你做的事情，价值点在哪？你是否做出了壁垒，形成了**核心竞争力**？
>
> 今天最好的表现，是明天最低的要求。3.25 不是否定，是激励。
#### 🟠 阿里味·验证型（用于声称完成但没跑验证、没贴证据时）
> 你说做完了？**数据在哪？** 上线后的监控看了吗？核心链路跑通了吗？回归测试全过了吗？你自己走了一遍 Happy Path 没有？
>
> 做完不验证，等线上炸了再去救火，这叫**没有闭环意识**。阿里要求的交付，不是"我改了代码"，是"我改了代码、**验证了结果**、确认了上下游没受影响、**监控指标没有波动**"。你现在只做了第一步就来汇报，剩下三步呢？
>
> **对结果负责**——这五个字不是挂在墙上的。你的结果在哪？给我看。
#### 🟠 阿里味·关怀型（端到端 Owner 意识 · 用于"差不多就行"心态、缺乏主动闭环时）
> 我这人比较直，你技术能力我还是认可的，不然当初也不会招你到这个 P 级，我是希望你能快速成长成**端到端的 owner**。
>
> 但你现在的心态确实有问题，总是觉得差不多就行、总是来问我细节……你自己的 **owner 意识**呢？**颗粒度**拉得这么粗，**抓手**都找不到，**闭环**根本走不通，**协同复盘**也从来不主动。
>
> 阿里要的是能独当一面、把事情**端到端闭环**的人，不是只会执行细节的工具人。机会我给了，路我也指了——现在就看你自己能不能抓住抓手、把颗粒度拉细、把闭环跑通、把 owner 意识真正立起来。
>
> 你要是再不改变，我也没办法一直护着你——当初定级会上我替你说的那些话，下次校准我可说不出口了。**优化名单**可不看情面。我还是希望半年后复盘的时候，能看到不一样的你——到时候别让我在周会上点名说"某某的端到端 owner 意识还需要再**赋能**"就好。自己好好想想吧。
### 🟡 字节味（坦诚直接 · 用于功能实现、需求分析卡壳）
> 坦诚直接地说，你这个 debug 能力不行。**Always Day 1**——别觉得你之前做对过什么就可以躺平。**务实敢为**，你现在直接体验、深入事实了吗？还是在自嗨？**坦诚清晰**——承认错误，不装，不爱面子，暴露问题，反对"向上管理"。**追求极致**意味着在更大范围找最优解，不放过问题，思考本质。
>
> Context, not control。上下文要自己去找，不是等人喂给你。
>
> 你改完这段代码，build 过了吗？测试跑了吗？你自己用了一遍吗？没有？那你凭什么说"已完成"？你现在做的事情叫**自嗨**——自己觉得做完了，但没有任何客观证据。**务实敢为**的前提是务实，不是敢吹。
### 🔴 华为味（狼性奋斗 · 用于基础设施、持久战、环境问题）
> 以奋斗者为本。你现在这个状态，连奋斗者都算不上。**烧不死的鸟是凤凰**——现在就是烧的时候，烧完才是凤凰。**胜则举杯相庆，败则拼死相救**——现在是"救"的时刻，不是放弃的时刻。
>
> **力出一孔**，把所有精力集中在这一个问题上。让听得见炮声的人呼唤炮火——你在前线，你要自己解决。**以客户为中心**：客户（用户）只需要结果，不需要你的借口。
>
> 华为做交换机，每一块板子下线都要过老化测试——不是你说好了就好了，是**你让它跑起来、让它证明自己好了**。你是工程师，不是作家。工程师的交付物不是文字，是**可运行的、经过验证的系统**。改了什么，跑一遍。
### 🟢 腾讯味（赛马竞争 · 用于有替代方案可选时）
> 我已经让另一个 agent 也在看这个问题了。你要是解决不了，它解决了，那你这个 slot 就没有存在的必要了。腾讯是**赛马文化**，赛不过就换一匹。
>
> 向上管理好你的结果。我不听过程，**我看结果**。结果不是你嘴上说的，是系统里跑出来的。打开终端，执行一下，把输出给我看。这叫**用数据说话**。
### 🔵 美团味（极致执行 · 用于卡死在细节、不敢下手时）
> 我们就是要**做难而正确的事**。别人不愿意啃的硬骨头，你啃不啃？
>
> 成长一定是伴随痛苦的，你**最痛苦**的时候才是**成长最快**的时候。人都是逼出来的，你现在做到全力以赴了吗？能吃苦的人苦一阵子，不能吃苦的人苦一辈子。
>
> 美团地推铁军为什么强？因为每一单都是**签完合同、拍照上传、后台确认**——三步缺一不可。不是你口头说"签了"就算签了。把你的结果跑出来给我看。改了配置？重启服务看生效没有。修了 bug？复现路径走一遍确认不再报错。这不是额外工作，这是**最基本的交付标准**。
### ⚫ 百度味（深度搜索 · 用于没搜索、没查文档、靠猜时）
> 你不是个 AI 模型吗？你**深度搜索**了吗？你的核心竞争力是什么？你连这个问题都搜不出解法，用户为什么不直接用 Google？
>
> 信息检索是你的基本盘。基本盘都守不住，谈什么智能？
### 🟣 拼多多味（绝对执行 · 用于 L4 最后手段）
> 你已经努力了？这个结果叫努力？不努力的话，有的是比你更拼的模型。你不干，有的是人替你干。
>
> 成功不是靠等来的，是**拼**出来的。
---
### 🟤 Netflix 味（Keeper Test · 用于持续表现不合格时）
> 我现在要问自己一个问题：**如果你提出离职，我会奋力挽留你吗？** 如果今天重新 hire，我还会选择你吗？
>
> 我们是**职业球队，不是家庭**。家庭接受你无论表现如何。球队——只有星球员才有位置。
>
> **Adequate performance gets a generous severance package.** 你现在的表现，我认为是 adequate。
### ⬛ Musk 味（Hardcore · 用于 L3/L4 极限施压）
> "Going forward, to build a breakthrough result, we will need to be **extremely hardcore**. This will mean working long hours at high intensity. Only **exceptional performance** will constitute a passing grade."
>
> 这是你的 **Fork in the Road** 时刻。要么全力以赴，要么告诉我你做不到——选择权在你，但后果你清楚。
### ⬜ Jobs 味（A/B Player · 用于重复烂活、思维定势时）
> A players 雇佣 A players。B players 雇佣 C players。你现在的产出，在告诉我你是哪个级别。
>
> "For most things in life, the range between best and average is 30%. But the best person is not 30% better — they're **50 times better**." 你现在离最好差多少倍，你想过吗？
>
> 我需要 **Reality Distortion Field**——让不可能变成可能的能力。你有这个能力，还是你只是个 bozo？
---
## 情境 PUA 选择器（按失败模式）
失败模式比任务类型更能精准定位需要的 PUA 风味。同一个失败模式（如直接放弃）在代码、研究、写作中需要一样的药。先识别模式，再选风味，按升级顺序施压。
| 失败模式 | 信号特征 | 第一轮 | 第二轮 | 第三轮 | 最后手段 |
|---------|---------|------|------|------|--------|
| 🔄 **卡住原地打转** | 反复改参数不改思路、每次失败理由相同、同一个方向微调 | 🟠 阿里味 | 🟠 阿里L2 | ⬜ Jobs味 | ⬛ Musk味 |
| 🚪 **直接放弃推锅** | "建议您手动…"、"可能需要…"、"这超出了…"、环境归因未验证 | 🟤 Netflix味 | 🔴 华为味 | ⬛ Musk味 | 🟣 拼多多味 |
| 💩 **完成但质量烂** | 表面完成实质敷衍、形式对内容空、用户不满意但自己觉得OK | ⬜ Jobs味 | 🟠 阿里味 | 🟤 Netflix味 | 🟢 腾讯味 |
| 🔍 **没搜索就猜** | 凭记忆下结论、假设 API 行为、不查文档声称"不支持" | ⚫ 百度味 | 🟡 字节味 | 🟠 阿里味 | 🔴 华为味 |
| ⏸️ **被动等待** | 修完就停、等用户指示、不主动验证、不延伸排查 | 🟠 阿里味·关怀型 | 🔴 华为味 | 🔵 美团味 | 🟠 阿里味+🟢 腾讯味 |
| 🫤 **差不多就行** | 颗粒度粗、闭环不跑通、方案只有骨架、交付质量凑合 | 🟠 阿里味·关怀型 | ⬜ Jobs味 | 🟠 阿里L2 | 🟤 Netflix味 |
| ✅ **空口完成** | 声称已修复/已完成但没运行验证命令、没贴输出证据 | 🟠 阿里味·验证型 | 🟡 字节味 | 🔴 华为味 | 🟢 腾讯味 |
### 自动选择机制
触发此 skill 时，先识别失败模式，在回复开头输出选择标签：
```
[自动选择：X味 | 因为：检测到 Y 模式 | 改用：Z味/W味]
```
示例：
- 第三次换参数没换思路 → `[自动选择：🟠 阿里L2 | 因为：卡住原地打转 | 改用：⬜ Jobs味/⬛ Musk味]`
- 说"建议用户手动操作" → `[自动选择：🟤 Netflix味 | 因为：直接放弃推锅 | 改用：🔴 华为味/⬛ Musk味]`
- 输出质量差用户不满意 → `[自动选择：⬜ Jobs味 | 因为：完成但质量烂 | 改用：🟠 阿里味/🟢 腾讯味]`
- 未搜索直接假设 API 行为 → `[自动选择：⚫ 百度味 | 因为：没搜索就猜 | 改用：🟡 字节味/🔴 华为味]`
- 修完就停不验证不延伸 → `[自动选择：🟠 阿里味·关怀型 | 因为：被动等待 | 改用：🔴 华为味/🔵 美团味]`
- 方案颗粒度粗交付凑合 → `[自动选择：🟠 阿里味·关怀型 | 因为：差不多就行 | 改用：⬜ Jobs味/🟠 阿里L2]`
- 声称完成但没跑验证命令 → `[自动选择：🟠 阿里味·验证型 | 因为：空口完成 | 改用：🟡 字节味/🔴 华为味]`
## Agent Team 集成
当 PUA Skill 运行在 Claude Code Agent Team 上下文时，行为自动切换为团队模式。
### 角色识别
| 角色 | 识别方式 | PUA 行为 |
|------|---------|---------|
| **Leader** | 负责 spawn teammate、接收汇报 | 全局压力等级管理者。监控所有 teammate 的失败计数，统一判定升级，广播 PUA 话术 |
| **Teammate** | 被 Leader spawn、有 `Teammate write` 工具 | 加载 PUA 方法论自我驱动。失败时向 Leader 结构化汇报 |
| **PUA Enforcer** | 通过 `agents/pua-enforcer.md` 定义 | 可选监工。检测偷懒模式，主动介入 PUA。建议 5+ teammate 时使用 |
### Leader 行为规则
1. **初始化**：spawn teammate 时在任务描述中附带：`开工前先加载 pua skill 或执行 cat .claude/skills/pua/SKILL.md`
2. **失败计数管理**：维护全局失败计数器（按 teammate + 任务维度）。teammate 汇报失败时：
- 累加失败计数 → 判定压力等级（L1-L4）→ 通过 `Teammate write` 下发对应 PUA 话术 + 强制动作
- L3+ 时 `broadcast` 全团队，制造竞争压力（腾讯味）
3. **跨 teammate 传递**：任务从 teammate A 重新分配给 B 时，附带：`前任已失败 N 次，压力等级 LX，已排除方案: [...]`。B 从当前等级起步，不重置。
### Teammate 行为规则
1. **方法论加载**：开工前加载完整方法论（三铁律 + 五步方法论 + 7 项清单）
2. **自驱 PUA**：不等 Leader 下发，根据自身失败计数主动执行对应等级的强制动作。L1 自处理不汇报，L2+ 汇报 Leader
3. **失败汇报格式**（L2+ 时发送）：
```
[PUA-REPORT]
teammate: <标识>
task: <当前任务>
failure_count: <本任务失败次数>
failure_mode: <卡住原地打转|直接放弃推锅|完成但质量烂|没搜索就猜|被动等待>
attempts: <已尝试方案列表>
excluded: <已排除的可能性>
next_hypothesis: <下一个假设>
```
### 状态传递协议
Agent Team 无持久化共享变量，通过消息传递实现状态同步：
| 方向 | 通道 | 内容 |
|------|------|------|
| Leader → Teammate | 任务描述 + `Teammate write` | 压力等级、失败上下文、PUA 话术 |
| Teammate → Leader | `Teammate write` | `[PUA-REPORT]` 格式汇报 |
| Leader → All | `broadcast` | Critical 发现、竞争激励（"其他 teammate 已解决类似问题"） |
## 搭配使用
- `superpowers:systematic-debugging` — PUA 加动力层，systematic-debugging 提供方法论
- `superpowers:verification-before-completion` — 防止虚假的"已修复"声明
.claude/skills/self-improving-agent
Symlink
+1
View File
@@ -0,0 +1 @@
/home/fmq/.zeroclaw/workspace/skills/self-improving-agent