Files
ssw-platform/scripts/check-arch.sh
T
admin 6d6e0ee329 feat(platform): 标准平台包 v0.3.0 —— 业务自带状态的可组合装配
- Db 暴露同一个 Arc<PGlite>(Db::pg());Platform 两阶段装配 Assembled/Finish
- Extras 加自带状态路由 / 可替换兜底 / 全局层,with_state 前移;默认路径行为不变
- 新增探针 business_composition_it 与闸门 AR19(反自证 14/14)
- 文档:CHANGELOG / known-limitations / 需求稿实施记录与勘误
2026-11-04 18:20:03 +08:00

1397 lines
66 KiB
Bash
Executable File
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env bash
# sspf 架构边界自检 —— crate 依赖纪律 + 内存红线
#
# 目的:把 PLAN.md 判断 ②/⑥ 的架构约束变成**可执行的尺子**。
# 靠人读 Cargo.toml 守不住 —— 加依赖的人不会想到「这会让所有业务包背锅」。
#
# 🔴 **纯静态**:不编译、不启动。只需要 bash + python3(macOS 自带)。
#
# 用法:
# bash scripts/check-arch.sh # 全查
# bash scripts/check-arch.sh --self-test # 反自证:造已知违规,必须被抓到
#
# 退出码:0 全过 / 1 有 ❌ / 2 用法错
#
# ── 判据 ──
# AR1 `crates/sspf-sdk` 依赖只能有 `sspf-contract`
# —— 业务包只依赖 sdk ⇒ sdk 多一个依赖 = 所有业务包都要背
# AR2 `packs/*/Cargo.toml` 依赖 ⊆ {sspf-sdk, serde}
# —— 业务包必须能整目录搬走 ⇒ 不许挂在 axum / tokio / pglite 上
# AR3 `crates/sspf-contract` 源码不许 `use axum|tokio|pglite|sqlx`
# —— 契约层一旦有 IO,业务包就再也不是「轻依赖」
# AR4 `crates/sspf-contract` 依赖 ⊆ {serde, serde_json, uuid, http}
# AR5 `crates/sspf-mcp`(若已存在)依赖 ⊆ {sspf-contract, serde, serde_json, tokio, async-trait}
# —— MCP 层要能同时接「进程内内核」和「远端 Java 后端」⇒ **不许依赖内核内部**
# —— tokio / async-trait 是协议实现(stdio 异步读写)所需,不是业务依赖
# AR6 `crates/sspf-adapter-baseline` 依赖 ⊆ {sspf-mcp, sspf-contract, serde, serde_json,
# tokio, http, hyper, hyper-util, http-body-util, bytes}
# —— 适配器只认工具契约层;依赖内核 store 就等于把第二种后端钉死在本进程旁
# AR7 `crates/sspf-lowcode` 依赖 ⊆ {sspf-contract, serde, serde_json}
# —— 低代码引擎是纯计算;依赖 DB/HTTP 会让它只能在内核里跑,且测试必须起库
# AR9 平台层(真源 `crates/sspf-core/src/**` + 转发壳 `src/backend/src/platform/**`)
# 里不许出现 `use sspf_pack_*`
# —— 平台层不许认识任何业务包(业务知识隔离)
# AR10 平台层(同上两处,不含 compat/)里不许出现
# `crate::platform::compat` —— 平台层不许**反向依赖**契约面
# —— M1 解开的环 A;拆 crate 时它就是循环依赖(编译器当天才报错 ⇒ 必须提前钉住)
# AR11 `src/backend/src/platform/compat/helper.rs` 里不许 `use super::<别的模块>`
# —— 契约面底座不许反向依赖契约面业务模块(helper 被 14 个模块依赖 ⇒ 即成环)
# —— M1 解开的环 B/C
# MEM1 非注释代码里不许出现 `SELECT *`
# —— 终端产品内存预算 ≤ 120MB(PLAN.md 判断 ⑥)⇒ 全表读进 Vec 直接爆
# MEM2 `crates/**` 与 `src/backend/src/**` 里不许出现无界 `HashMap` 缓存
# (近似检查:`static` + `Mutex<HashMap` 必须有 `MAX` 常量同文件出现)
# AR14 `crates/sspf-mcp-adapter` 依赖 ⊆ 白名单 + 源码不许 `use sspf_pack_*`
# —— M6 把 MCP 适配层下沉成独立 crate;它是「全仓唯一知道全部包的汇聚点」
# ⇒ 依赖面必须锁死,否则它会变成第二个「什么都认识」的黑洞
# AR15 旧平台路径不许复活:全仓不许 `crate::platform::` / `ssw_platform::platform::`,
# 且 `src/backend/src/platform/` 目录不许存在
# —— M7 删掉了 38 个转发壳;重建壳 + 改回 import 会**一切照常编译、测试全绿**
# ⇒ 没有这条闸门,M2–M7 的架构收益会**静默蒸发**
# AR16 内核只有 lib(`src/backend/Cargo.toml` 不许 `[[bin]]`)、集成测试不许回流
# 到 `src/backend/tests/`、`crates/sspf-admin` 必须存在且产出 bin
# —— 「内核是库、装配是应用、测试是消费者」这三条边界都是**文件位置**
# ⇒ 没有任何编译错误会提示你踩线,只有结构慢慢退回原样
# AR17 内核默认 feature 下不得编译期依赖 `packs/*`
# —— `crates/sspf` 是业务仓唯一依赖的**标准平台包**;示例包一硬依赖,
# `cargo add sspf` 就等于把 asset/demo/shop/books 拖进业务二进制
# AR18 `crates/sspf/src/**` 不得出现业务字面量(业务仓名 / 业务表名 / `/api/ssw/`)
# —— 门面是平台与业务的**唯一汇聚点**,两边都碰得到 ⇒ 「顺手写一句业务」
# 的成本最低,而这类代码**不会让任何测试变红**
#
# 🔴 AR1–AR5 是 PLAN.md §3.2 的分层纪律;MEM1–MEM2 是判断 ⑥ 的四条内存红线的静态部分。
# AR19 唯一装配链:`routes.rs` 只允许一个 `pub fn build_app_with`、一处
# `.layer(catch_all())` 与恰好 2 处互斥的 fallback 调用;`Extras.router_owned`
# 注释必须写明「不许自带 fallback」—— 业务自带状态路由若抄第二遍链,
# 404 兜底会静默错位且测试全绿(S25)。
# 🔴 AR17/AR18 是「sspf 标准平台包」(2026-11-04 P0)的边界:平台包里零业务。
# 🔴 AR19 是「业务自带状态的可组合装配」(2026-11-04 P1)的边界:装配链仍然只有一份。
set -u
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
CRATES="$ROOT/crates"
KERNEL="$ROOT/src/backend"
MODULES_DIR="$KERNEL/src/modules"
# 🔴 **平台侧真源目录表**(M2/M3/M4 逐步扩):
# - `sspf-core/src` 平台核心(M2)
# - `sspf-compat-*/src` 契约面 7 个包(M3 底座 + M4 六个域包)
# 🔴 **动态收集**(`crates/sspf-compat-*/src`)⇒ 新增契约面包时**不会漏扫** ——
# 写死列表必然在某次新增包时漏掉 ⇒ 尺子静默失效(实测踩过)。
# 🔴🔴 **M7 起:`src/backend/src/platform/` 已删除**(38 个转发壳全部清空)⇒
# 平台层**只有真源**,没有壳 ⇒ 扫描面里**不再有**转发壳目录。
# ⇒ 旧路径(`crate::platform::…` / `ssw_platform::platform::…`)**必须**由
# **AR15** 单独钉住(见下)—— 否则删壳之后旧路径无人看管,
# 哪天有人写回 `crate::platform::sys::` ⇒ 编译不过(好的),
# 但若同时又建了个壳目录 ⇒ 就等于**复活了被删掉的架构**(坏的)。
PLAT_SRC_DIRS=()
[ -d "$CRATES/sspf-core/src" ] && PLAT_SRC_DIRS+=("$CRATES/sspf-core/src")
for d in "$CRATES"/sspf-compat-*/src; do
[ -d "$d" ] && PLAT_SRC_DIRS+=("$d")
done
PASS=0
FAIL=0
SKIP=0
ok() { PASS=$((PASS + 1)); printf '✅ %s\n' "$1"; }
bad() { FAIL=$((FAIL + 1)); printf '❌ %s\n' "$1"; }
skip() { SKIP=$((SKIP + 1)); printf '⏭ %s\n' "$1"; }
usage() {
echo "用法: bash scripts/check-arch.sh [--self-test]"
echo " 静态检查 crate 依赖纪律(AR1–AR19)与内存红线(MEM1–MEM2)"
echo "退出码: 0 全过 / 1 有 ❌ / 2 用法错"
}
# 取出 Cargo.toml 里 [dependencies] 段的包名(一行一个,已去空白)
deps_of() {
awk '
/^\[dependencies\]/ { f = 1; next }
/^\[/ { f = 0 }
f && /^[A-Za-z0-9_-]+[[:space:]]*=/ { sub(/[[:space:]]*=.*/, ""); print }
' "$1"
}
# 判断集合 A 是否 ⊆ 集合 B(两者都是空格分隔串)
subset_of() {
local need="$1" allowed=" $2 "
local x
for x in $need; do
case "$allowed" in
*" $x "*) : ;;
*) return 1 ;;
esac
done
return 0
}
# ---------------------------------------------------------------- AR1
check_ar1() {
local f="$CRATES/sspf-sdk/Cargo.toml"
[ -f "$f" ] || { skip "AR1 sspf-sdk 不存在(尚未拆分)"; return; }
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
if subset_of "$deps" "sspf-contract"; then
ok "AR1 sspf-sdk 依赖干净([$deps])"
else
bad "AR1 sspf-sdk 依赖越界:[$deps] —— 只允许 sspf-contract"
fi
}
# ---------------------------------------------------------------- AR2
check_ar2() {
local found=0 n=0
for f in "$ROOT"/packs/*/Cargo.toml; do
[ -f "$f" ] || continue
n=$((n + 1))
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
if subset_of "$deps" "sspf-sdk serde"; then
ok "AR2 $(basename "$(dirname "$f")") 依赖干净([$deps])"
else
bad "AR2 $(basename "$(dirname "$f")") 依赖越界:[$deps] —— 只允许 sspf-sdk / serde"
found=1
fi
done
[ "$n" -eq 0 ] && skip "AR2 尚无 packs/*(P3 才落地)"
return $found
}
# ---------------------------------------------------------------- AR3
check_ar3() {
local dir="$CRATES/sspf-contract/src"
[ -d "$dir" ] || { skip "AR3 sspf-contract 不存在"; return; }
local hits
hits="$(grep -rnE '^[[:space:]]*(pub )?use (axum|tokio|pglite|sqlx)' "$dir" 2>/dev/null || true)"
if [ -z "$hits" ]; then
ok "AR3 sspf-contract 无 IO 依赖(无 axum/tokio/pglite/sqlx 的 use)"
else
bad "AR3 sspf-contract 出现 IO 依赖:"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR4
check_ar4() {
local f="$CRATES/sspf-contract/Cargo.toml"
[ -f "$f" ] || { skip "AR4 sspf-contract 不存在"; return; }
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
if subset_of "$deps" "serde serde_json uuid http"; then
ok "AR4 sspf-contract 依赖在白名单内([$deps])"
else
bad "AR4 sspf-contract 依赖越界:[$deps] —— 白名单 serde/serde_json/uuid/http"
fi
}
# ---------------------------------------------------------------- AR5
check_ar5() {
local f="$CRATES/sspf-mcp/Cargo.toml"
[ -f "$f" ] || { skip "AR5 sspf-mcp 不存在(P1 才落地)"; return; }
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
if subset_of "$deps" "sspf-contract serde serde_json tokio async-trait"; then
ok "AR5 sspf-mcp 依赖干净([$deps])"
else
bad "AR5 sspf-mcp 依赖越界:[$deps] —— 只允许 sspf-contract/serde/serde_json/tokio/async-trait"
fi
}
# ---------------------------------------------------------------- AR6
check_ar6() {
local f="$CRATES/sspf-adapter-baseline/Cargo.toml"
[ -f "$f" ] || { skip "AR6 sspf-adapter-baseline 不存在"; return; }
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
# 🔴 适配器只许依赖「工具契约层 + HTTP 客户端」。
# 一旦依赖 sspf-store / axum,第二种后端就只能跑在同一个内核旁边 —— 双轨失效。
if subset_of "$deps" "sspf-mcp sspf-contract serde serde_json tokio http hyper hyper-util http-body-util bytes"; then
ok "AR6 sspf-adapter-baseline 依赖干净([$deps])"
else
bad "AR6 sspf-adapter-baseline 依赖越界:[$deps] —— 只许工具契约层 + HTTP 客户端,不许依赖内核 store"
fi
}
# ---------------------------------------------------------------- AR7
check_ar7() {
local f="$CRATES/sspf-lowcode/Cargo.toml"
[ -f "$f" ] || { skip "AR7 sspf-lowcode 不存在"; return; }
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
# 🔴 低代码引擎必须是**纯计算**:解析 / 校验 / SQL 生成。
# 一旦依赖 pglite / axum,它就只能在内核里跑 —— CLI、MCP、离线校验工具都用不了,
# 而且测试必须起数据库(现在 38 个测试 0 依赖、毫秒级)。
if subset_of "$deps" "sspf-contract serde serde_json"; then
ok "AR7 sspf-lowcode 依赖干净([$deps])"
else
bad "AR7 sspf-lowcode 依赖越界:[$deps] —— 只许契约层 + 序列化,不许 DB / HTTP"
fi
}
# ---------------------------------------------------------------- AR8
# 业务包装载器(`crates/sspf-plugin`)的依赖白名单。
#
# 🔴 **为什么单列一条**:装载器是「业务包 ⇄ 内核」的唯一中介。
# 它一旦依赖 axum / tokio / pglite,业务包就**间接背上 web 框架**(AR2 的精神废掉),
# 而且「包可整目录搬走」这个承诺再也证不了。
# 装载器只做「读清单 + 校验兼容区间 + 收集 entities/menus/routes」⇒ 纯数据。
check_ar8() {
local f="$CRATES/sspf-plugin/Cargo.toml"
[ -f "$f" ] || { skip "AR8 sspf-plugin 不存在(批次 12 才落地)"; return; }
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
if subset_of "$deps" "sspf-sdk sspf-contract serde serde_json"; then
ok "AR8 sspf-plugin 依赖干净([$deps])"
else
bad "AR8 sspf-plugin 依赖越界:[$deps] —— 只允许 sspf-sdk/sspf-contract/serde/serde_json(不许 axum/tokio/pglite)"
fi
}
# ---------------------------------------------------------------- AR9
# **平台层不许认识任何业务包**(业务知识隔离,红线 12)。
#
# 🔴 方向是「内核 ⇒ 包」,**不是**「包 ⇒ 内核」:`src/backend/Cargo.toml` 依赖
# `sspf-pack-<app>` 是**允许**的(装配根要装载它们);
# 但**平台层**里出现 `use sspf_pack_*` ⇒ 平台层知道了
# 具体业务 ⇒ 加/删业务包就要改平台层 ⇒ 「链接就好」这个承诺是假的。
# 🔴 **M2 起平台层的真源在 `crates/sspf-core/src/`**,`src/backend/src/platform/`
# 只剩转发壳(`pub use sspf_core::*`)+ 尚未搬走的 `compat/`(M3/M4)。
# ⇒ 闸门必须**两处都扫**:扫真源(管实现)+ 扫转发壳(防有人往壳里塞实现)。
# 只扫壳 = 尺子量空壳 = 虚假安全感。
check_ar9() {
local dirs=()
[ "${#PLAT_SRC_DIRS[@]}" -gt 0 ] || { skip "AR9 平台层目录不存在"; return; }
dirs=("${PLAT_SRC_DIRS[@]}")
local hits
hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "${dirs[@]}" 2>/dev/null || true)"
if [ -z "$hits" ]; then
ok "AR9 平台层没有 use sspf_pack_*(业务知识没漏进 sspf-core/ / compat 各包 / platform/)"
else
bad "AR9 平台层出现了业务包引用(业务知识漏进平台层 ⇒ 加包要改平台层):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR10
# **平台层不许反向依赖契约面**(M1 解开的环 A,防回退)。
#
# 🔴 **背景**:M1 之前 `platform/auth.rs` 里写着
# `crate::platform::compat::helper::current_user(...)` —— 平台层反过来调契约面。
# 同 crate 内这只是「层间倒挂」(能编译),但**拆 crate 时就是循环依赖**,
# 编译器直接报错 ⇒ 整个迁移(M2–M6)全部卡死。
# M1 已把分流点上移到装配根(`routes.rs`),平台层不再认识契约面。
#
# 🔴 **为什么必须钉住**:拆 crate 是**渐进**的 —— 在拆完之前,加回这一行
# **照样编译通过、测试照样全绿**,只有到 M2 那天才炸 ⇒ 那时候已经改了一堆东西,
# 回滚成本高得多。⇒ 现在就把它拦住。
#
# 判据:平台层真源(`crates/sspf-core/src/**`)与转发壳(`src/backend/src/platform/**`,
# **不含 compat/**)里都不许出现 `crate::platform::compat` / `super::compat` / `crate::compat`。
check_ar10() {
local dirs=()
[ "${#PLAT_SRC_DIRS[@]}" -gt 0 ] || { skip "AR10 平台层目录不存在"; return; }
dirs=("${PLAT_SRC_DIRS[@]}")
local hits
# 🔴 **必须排除注释行**(`//` / `//!` / `///`)—— 文档注释里的路径引用是
# **给人看的**(如 `//! (见 crate::platform::compat::helper::load_menus])`),
# 不是依赖 ⇒ 不该判红。
# 🔴 纯 grep 过滤不了:`//!` 前面**没有空格** ⇒ `^\s*//` 漏掉它。
# 这里用 python3 逐行判(与 MEM1/MEM2 同一套路)。
hits="$(python3 - "${dirs[@]}" <<'PY'
import os, re, sys
pat = re.compile(r'(crate::platform::compat|crate::compat|super::compat)')
bad = []
for root in sys.argv[1:]:
for dirpath, dirnames, files in os.walk(root):
dirnames[:] = [d for d in dirnames if d != 'compat'] # 契约面自己互引合法
for fn in files:
if not fn.endswith('.rs'):
continue
p = os.path.join(dirpath, fn)
try:
lines = open(p, encoding='utf-8').read().splitlines()
except OSError:
continue
for i, line in enumerate(lines, 1):
s = line.strip()
# 整行注释(含 `//!` / `///`)⇒ 跳过
if s.startswith('//'):
continue
# 行尾注释:把 `//` 之后截掉再判(`use x::y; // 说明` 里的说明不算)
code = line.split('//', 1)[0]
if pat.search(code):
bad.append(f'{p}:{i}: {s}')
for b in bad:
print(b)
PY
)"
if [ -z "$hits" ]; then
ok "AR10 平台层没有反向依赖契约面(拆 crate 的前置条件仍成立)"
else
bad "AR10 平台层反向依赖契约面(拆 crate 时就是循环依赖 ⇒ 必须把调用点上移到装配根):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR11
# **契约面底座(helper)不许依赖契约面业务模块**(M1 解开的环 B/C,防回退)。
#
# 🔴 **背景**:`compat/helper.rs` 被 **14 个**契约面模块依赖(实测)⇒ 它是底座。
# 若它反过来 `use super::system` / `use super::permission` ⇒
# 拆 crate 时 helper ↔ system / helper ↔ permission 都是**循环依赖**。
# M1 已把 `menu_node` / `official_view_path` / `USER_DETAIL_COLUMNS` /
# `organize_name_of` 搬进 helper,切断了这两条边。
#
# 🔴 **M3 起底座真源在 `crates/sspf-compat-core/src/helper.rs`**(壳只剩 `pub use`)
# ⇒ 两处都扫(扫真源管实现 + 扫壳防塞私货)。跨 crate 形态的同一纪律 =
# `sspf-compat-core` 的 Cargo.toml 不许依赖 `sspf-compat-*`(M4 的 6 个包)。
#
# 判据(两处):
# ① `helper.rs`(真源或壳)里不许 `use super::` 指向**非 helper 的模块**,
# 也不许 `use crate::res`(同 crate 内的反向依赖);
# ② `crates/sspf-compat-core/Cargo.toml` 不许依赖 `sspf-compat-*`。
check_ar11() {
local files=()
[ -f "$CRATES/sspf-compat-core/src/helper.rs" ] && files+=("$CRATES/sspf-compat-core/src/helper.rs")
local hits=""
if [ "${#files[@]}" -gt 0 ]; then
# 🔴🔴 **必须用 `-H`(强制输出文件名前缀)** —— M7 起文件只有一个,
# `grep -n` 只输出「行号:内容」⇒ **不含路径** ⇒ 反自证里
# `grep -q "sspf-compat-core/src/helper.rs"` **永远匹配不到**
# ⇒ 尺子明明抓到了违规,自证却报「尺子是假的」(实测踩过)。
# ⇒ `-H` 保证路径在场,反自证才能**按路径**精确验证。
hits="$(grep -HnE '^[[:space:]]*(pub )?use[[:space:]]+(super::[a-z_]+|crate::res)' "${files[@]}" 2>/dev/null \
| grep -vE 'super::helper|crate::helper' || true)"
fi
# 跨 crate 形态:底座的 Cargo.toml 不许依赖 6 个契约面包
local toml="$CRATES/sspf-compat-core/Cargo.toml"
if [ -f "$toml" ]; then
local dep_hits
dep_hits="$(grep -nE '^[[:space:]]*sspf-compat-[a-z_-]+[[:space:]]*=' "$toml" 2>/dev/null || true)"
if [ -n "$dep_hits" ]; then
hits="${hits:+$hits$'\n'}${dep_hits}"
fi
fi
if [ -z "$hits" ]; then
ok "AR11 契约面底座(helper/sspf-compat-core)不依赖其它契约面模块(14 个模块依赖它 ⇒ 反向依赖即成环)"
else
bad "AR11 契约面底座反向依赖契约面业务模块(拆 crate 时即成环):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR12
# **契约面各包之间不许互相依赖**(M4 拆 6 个包时的防环回流闸门)。
#
# 🔴 **为什么需要**:M4 把 49,000 行契约面拆成 7 个 crate。各包本应**彼此独立**
# (都只依赖 `sspf-compat-core` 底座 + `sspf-core` 平台核心)。
# 一旦 A 包 `use sspf_compat_b::…` 而 B 包又 `use sspf_compat_a::…`
# ⇒ **循环依赖** ⇒ 编译器直接报错(但那时已经改了一堆东西,回滚成本高)。
#
# 🔴 **唯一允许的两条单向依赖**(方向单一 ⇒ 不成环,已核实被依赖方不反向依赖):
# · `sspf-compat-permission` → `sspf-compat-system`
# (权限域用系统域的 `SYSTEM_LIST_PROJECTION` / `load_system_tops` /
# `log_page` / `shape_system_list_item`)
# · `sspf-compat-ext` → `sspf-compat-system` + `sspf-compat-msg`
# (移动端复用系统域 `home_data` 控制台卡片 + 消息域 `send_config_select_list`)
#
# 判据:每个 `crates/sspf-compat-*/Cargo.toml` 里出现的 `sspf-compat-*` 依赖,
# 必须在白名单内,且**白名单方向要反过来核实**(被依赖方不许依赖依赖方)。
check_ar12() {
local hits=""
local dir
for dir in "$CRATES"/sspf-compat-*; do
[ -d "$dir" ] || continue
local toml="$dir/Cargo.toml"
[ -f "$toml" ] || continue
local self_name
self_name="$(basename "$dir")"
local dep
for dep in $(grep -oE '^[[:space:]]*sspf-compat-[a-z_-]+[[:space:]]*=' "$toml" 2>/dev/null | grep -oE 'sspf-compat-[a-z_-]+' | sort -u); do
# 底座(sspf-compat-core)永远允许
[ "$dep" = "sspf-compat-core" ] && continue
# 白名单:按「依赖方 → 被依赖方」判定
local allowed=0
case "${self_name}:${dep}" in
sspf-compat-permission:sspf-compat-system) allowed=1 ;;
sspf-compat-ext:sspf-compat-system) allowed=1 ;;
sspf-compat-ext:sspf-compat-msg) allowed=1 ;;
esac
if [ "$allowed" -eq 0 ]; then
hits="${hits:+$hits$'\n'}${toml}: ${self_name} → ${dep}(不在白名单)"
fi
done
done
if [ -z "$hits" ]; then
ok "AR12 契约面各包彼此独立(只依赖底座 + 两条单向白名单 ⇒ 不会成环)"
else
bad "AR12 契约面包之间出现了未授权依赖(跨包依赖易成环):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR13
# **低代码执行层的依赖白名单**(M5 把 `lowcode_*.rs` 下沉到 `sspf-lowcode-exec`)。
#
# 🔴 **为什么需要**:`sspf-lowcode`(AR7)是**纯计算**层 —— 只认 serde,不许碰 DB/HTTP。
# M5 新增的 `sspf-lowcode-exec` 是它的**执行层**,允许连库;但依赖面必须**锁死**:
# 一旦它拖进 `axum`(web 框架)⇒ 这层就再也用不了 CLI / MCP / 离线工具;
# 一旦它拖进 `sspf_pack_*`(业务包)⇒ 平台层开始认识业务 ⇒ 破 AR9。
#
# 判据(两层):
# ① `crates/sspf-lowcode-exec/Cargo.toml` 的依赖 ⊆ 白名单;
# ② 该 crate 的源码里**不许**出现 `sspf_pack_`(与 AR9 同款语义,但独立钉住
# —— AR9 只扫平台层目录,执行层是新的目录,得单独管)。
check_ar13() {
local f="$CRATES/sspf-lowcode-exec/Cargo.toml"
if [ ! -f "$f" ]; then
skip "AR13 sspf-lowcode-exec 不存在"
return
fi
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
# 🔴 白名单:`sspf-lowcode`(纯计算)+ `sspf-core`(平台核心)+ `sspf-store`(Db 真源)
# + `sspf-mcp`(ToolError)+ `pglite-rs`(真实库)+ `chrono` + `serde_json`。
# **不许** axum(web 框架)/ tokio(异步运行时,本层是同步函数 + 调用方 await)。
if subset_of "$deps" "sspf-lowcode sspf-core sspf-store sspf-mcp pglite-rs chrono serde_json"; then
ok "AR13 sspf-lowcode-exec 依赖干净([$deps])"
else
bad "AR13 sspf-lowcode-exec 依赖越界:[$deps] —— 只许 {lowcode, core, store, mcp, pglite-rs, chrono, serde_json},不许 web 框架 / 业务包"
fi
# 第二层:源码不许出现业务包引用
local src="$CRATES/sspf-lowcode-exec/src"
if [ -d "$src" ]; then
local hits
hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "$src" 2>/dev/null || true)"
if [ -z "$hits" ]; then
ok "AR13 执行层源码没有 use sspf_pack_*(业务知识没漏进执行层)"
else
bad "AR13 执行层源码出现了业务包引用(业务知识漏进平台层):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
fi
}
# ---------------------------------------------------------------- AR14
# **MCP 适配层的依赖白名单**(M6 把 `mcp_{adapter,compat}.rs` 下沉到 `sspf-mcp-adapter`)。
#
# 🔴 **为什么需要**:`sspf-mcp-adapter` 是**全仓唯一「知道全部包」的 crate** ——
# `mcp_compat.rs` 直调 workflow / system / permission / onlinedev 四个契约面域包
# 的 handler ⇒ 依赖图上它是**顶层汇聚点**。
# 这本身**不是环**(被依赖方谁都不认识它 ⇒ 方向单一),但它有两个真实风险:
# ① 依赖面失控 —— 一旦拖进业务包(`sspf_pack_*`),适配层就开始认识业务
# ⇒ 破 AR9 的「平台层零业务知识」承诺;
# ② 退化成「万能壳」 —— 拖进 `sspf-contract` / `sspf-plugin` 等非必需依赖,
# 会让它变成第二个什么都认识的模块 ⇒ 迁移的收益(壳瘦下来)被抵消。
#
# 🔴 **为什么不复用 AR9**:AR9 扫的是**平台层目录**(`sspf-core` + `sspf-compat-*` +
# `platform/` 壳)。适配层是**新的目录**,AR9 扫不到 ⇒ 必须单列一条钉住
# (与 AR13 对 `sspf-lowcode-exec` 的处理同款)。
#
# 判据(两层):
# ① `crates/sspf-mcp-adapter/Cargo.toml` 的依赖 ⊆ 白名单;
# ② 该 crate 的源码里**不许**出现 `use sspf_pack_`(业务包引用)。
check_ar14() {
local f="$CRATES/sspf-mcp-adapter/Cargo.toml"
if [ ! -f "$f" ]; then
skip "AR14 sspf-mcp-adapter 不存在"
return
fi
local deps; deps="$(deps_of "$f" | tr '\n' ' ')"
# 🔴 白名单:MCP 工具层(工具契约)+ 平台核心(AppState/Db/ids/cipher/信封)
# + 契约面四个域包(handler 直调对象)+ 低代码两层(动态 CRUD 工具)
# + axum(handler 的 extractor / 信封)+ pglite-rs(ToSql 参数绑定)+ 序列化。
# **不许** sspf_pack_*(业务包)/ sspf-contract(间接依赖即可)/ sspf-plugin。
if subset_of "$deps" "sspf-mcp sspf-core sspf-compat-system sspf-compat-permission sspf-compat-workflow sspf-compat-onlinedev sspf-lowcode sspf-lowcode-exec axum pglite-rs serde_json serde_urlencoded"; then
ok "AR14 sspf-mcp-adapter 依赖干净([$deps])"
else
bad "AR14 sspf-mcp-adapter 依赖越界:[$deps] —— 只许 {mcp, core, compat-*, lowcode*, axum, pglite-rs, serde*}"
fi
# 第二层:源码不许出现业务包引用
local src="$CRATES/sspf-mcp-adapter/src"
if [ -d "$src" ]; then
local hits
hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "$src" 2>/dev/null || true)"
if [ -z "$hits" ]; then
ok "AR14 适配层源码没有 use sspf_pack_*(业务知识没漏进适配层)"
else
bad "AR14 适配层源码出现了业务包引用(业务知识漏进适配层):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
fi
}
# ---------------------------------------------------------------- AR15
# **M7 删壳后:旧平台路径不许复活**(`crate::platform::…` / `ssw_platform::platform::…`)。
#
# 🔴 **为什么需要**:M7 把 `src/backend/src/platform/` 的 38 个转发壳**全删了**,
# 平台能力的路径变成 `sspf_core::…` / `sspf_compat_<包>::…`。
# 删除本身是**可逆的**(git 一 revert 就回来了)⇒ 必须有闸门钉住「不许回来」。
#
# 🔴 **为什么这条不能靠「编译不过」兜底**:如果有人为了图省事
# ① 重建 `src/backend/src/platform/mod.rs` + 几个 `pub use` 壳,
# ② 把 import 改回 `crate::platform::…`,
# ⇒ **一切照常编译、测试照常全绿**,但架构**已经退回 M2 之前** ——
# 而 M2–M7 这 7 个批次(几万行搬迁、6 个契约面包)的收益**全部蒸发**,
# 而且**没有任何闸门会报红**。⇒ 这正是本仓最怕的那类静默退化。
#
# 🔴 **判据**(源码级,全仓 Rust 文件):
# ① 不许出现 `crate::platform::`(壳内引用旧路径);
# ② 不许出现 `ssw_platform::platform::`(集成测试引用旧路径);
# ③ 不许存在 `src/backend/src/platform/` 目录(M7 的删除不被回退)。
#
# 🔴 **注释不算违规** —— 文档里提到旧路径是**正常**的(迁移记录 / 历史说明)。
# ⇒ 只判**非注释行**(与 AR10 同一套路)。
check_ar15() {
local hits=""
local roots=()
[ -d "$KERNEL/src" ] && roots+=("$KERNEL/src")
[ -d "$KERNEL/tests" ] && roots+=("$KERNEL/tests")
[ -d "$CRATES" ] && roots+=("$CRATES")
[ -d "$ROOT/packs" ] && roots+=("$ROOT/packs")
if [ "${#roots[@]}" -gt 0 ]; then
hits="$(python3 - "${roots[@]}" <<'PY'
import os, re, sys
pat = re.compile(r'(crate::platform::|ssw_platform::platform::)')
bad = []
for root in sys.argv[1:]:
for dirpath, dirnames, files in os.walk(root):
for fn in files:
if not fn.endswith('.rs'):
continue
p = os.path.join(dirpath, fn)
try:
lines = open(p, encoding='utf-8').read().splitlines()
except OSError:
continue
for i, line in enumerate(lines, 1):
s = line.strip()
if s.startswith('//'):
continue # 整行注释(含 //! / ///)
code = line.split('//', 1)[0]
if pat.search(code):
bad.append(f'{p}:{i}: {s}')
for b in bad:
print(b)
PY
)"
fi
# 🔴 第三层:旧目录本身不许复活。
# ⚠️ **只看「含 .rs 文件」** —— git **不跟踪空目录** ⇒ 自证里
# `mkdir -p` 出来的空目录在清理后可能残留(rmdir 失败)⇒
# 若按「目录存在」判 ⇒ 假红(报了一个不存在的违规)。
# ⇒ 判据 = 「目录里**有** .rs 文件」= 真的有壳被重建了。
if [ -d "$KERNEL/src/platform" ]; then
local plat_rs
plat_rs="$(find "$KERNEL/src/platform" -name '*.rs' -type f 2>/dev/null | head -1)"
if [ -n "$plat_rs" ]; then
hits="${hits:+$hits$'\n'}$KERNEL/src/platform: 目录复活(M7 已删除该转发壳层,发现 ${plat_rs})"
fi
fi
if [ -z "$hits" ]; then
ok "AR15 旧平台路径未复活(无 crate::platform:: / ssw_platform::platform:: / platform/ 目录)"
else
bad "AR15 旧平台路径复活(M7 已删转发壳层 ⇒ 平台能力只能走 sspf_core:: / sspf_compat_*/::):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- PACK1
# **spec 单一真源**:`modules/<app>.rs` 只许做转发,不许自己写 spec。
#
# 🔴 背景:批次 12 之前 `modules/asset.rs` 与 `packs/asset/src/lib.rs` 是
# **两份逐字拷贝** ⇒ 改一处忘另一处 ⇒ **静默**不一致,且当时没有任何闸门比对。
# 现在 spec 的真源在包里,模块文件只 `pub use` 转发。
# ⇒ 本闸门要防的是「有人又在模块文件里写了一份」——
# 那等于回到两份拷贝,而且**看起来一切正常**(编译过、测试过)。
#
# 判据(对每个「模块文件里有 `pub use sspf_pack_`」的模块):
# · 模块文件里**不许**出现 `: EntitySpec =` / `: MenuSpec =` 的定义
# (`pub use` 转发不算定义 —— 它没有 `=` 字面量);
# · 与它同 app_code 的包**必须存在**且**确实声明了** EntitySpec(否则转发了个空)。
check_pack1() {
local n=0
for mf in "$MODULES_DIR"/*.rs; do
[ -f "$mf" ] || continue
case "$(basename "$mf")" in mod.rs) continue ;; esac
grep -q "pub use sspf_pack_" "$mf" 2>/dev/null || continue
n=$((n + 1))
local name; name="$(basename "$mf" .rs)"
# ① 模块文件里不许有 spec / menu 的**定义**(`= EntitySpec {` / `= MenuSpec {`)
local defs
defs="$(grep -nE '=[[:space:]]*(EntitySpec|MenuSpec)[[:space:]]*\{' "$mf" 2>/dev/null || true)"
if [ -n "$defs" ]; then
bad "PACK1 ${name}.rs 既 re-export 又**自己定义**了 spec(两份拷贝回来了):"
printf '%s\n' "$defs" | sed 's/^/ /'
continue
fi
# ② 包必须存在,且真的声明了 EntitySpec
local lib="$ROOT/packs/$name/src/lib.rs"
if [ ! -f "$lib" ]; then
bad "PACK1 ${name}.rs 从 sspf_pack_${name} 转发,但 packs/${name}/src/lib.rs 不存在"
continue
fi
if ! grep -qE ':[[:space:]]*EntitySpec[[:space:]]*=' "$lib" 2>/dev/null; then
bad "PACK1 packs/${name}/src/lib.rs 没有 EntitySpec 声明(模块转发了个空)"
continue
fi
ok "PACK1 ${name}.rs 只做 re-export,spec 真源在 packs/${name}/src/lib.rs"
done
[ "$n" -eq 0 ] && skip "PACK1 尚无「模块转发业务包」的模块"
return 0
}
# ---------------------------------------------------------------- MEM1
# 只看**代码行**:去掉 `//` 之后的注释、`//!` / `///` 文档注释、以及字符串里的反引号示例。
check_mem1() {
local hits
hits="$(python3 - "$ROOT" <<'PY'
import os, re, sys
root = sys.argv[1]
pat = re.compile(r'SELECT\s+\*', re.I)
bad = []
for base in ('src/backend/src', 'crates'):
for dirpath, dirnames, files in os.walk(os.path.join(root, base)):
dirnames[:] = [d for d in dirnames if d not in ('target', 'tests', 'data')]
for fn in files:
if not fn.endswith('.rs'):
continue
p = os.path.join(dirpath, fn)
# 文件名以 _it.rs 结尾的是集成测试,不查
if fn.endswith('_it.rs'):
continue
try:
lines = open(p, encoding='utf-8').read().splitlines()
except OSError:
continue
in_test = False
for i, line in enumerate(lines, 1):
s = line.strip()
if s.startswith('#[cfg(test)]'):
in_test = True
if in_test:
continue
code = line.split('//', 1)[0]
if pat.search(code):
bad.append(f'{p}:{i}: {s}')
for b in bad:
print(b)
PY
)"
if [ -z "$hits" ]; then
ok "MEM1 无非注释的 SELECT *(全表读进 Vec 会直接超内存预算)"
else
bad "MEM1 发现 SELECT *(终端产品内存预算 ≤120MB,禁止整表载入):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- MEM2
# 近似检查:出现 `Mutex<HashMap` 的静态缓存,同文件必须有 MAX_ / CAPACITY 常量。
check_mem2() {
local hits
hits="$(python3 - "$ROOT" <<'PY'
import os, re, sys
root = sys.argv[1]
cache = re.compile(r'Mutex\s*<\s*(std::collections::)?HashMap')
cap = re.compile(r'\b(MAX|CAPACITY|LIMIT)_[A-Z0-9_]+\b')
bad = []
for base in ('src/backend/src', 'crates'):
for dirpath, dirnames, files in os.walk(os.path.join(root, base)):
dirnames[:] = [d for d in dirnames if d not in ('target', 'tests', 'data')]
for fn in files:
if not fn.endswith('.rs') or fn.endswith('_it.rs'):
continue
p = os.path.join(dirpath, fn)
try:
text = open(p, encoding='utf-8').read()
except OSError:
continue
if cache.search(text) and not cap.search(text):
for i, line in enumerate(text.splitlines(), 1):
if cache.search(line):
bad.append(f'{p}:{i}: {line.strip()}')
break
for b in bad:
print(b)
PY
)"
if [ -z "$hits" ]; then
ok "MEM2 缓存均有上限常量(无界缓存 = 慢性内存泄漏)"
else
bad "MEM2 发现疑似无界缓存(同文件没有 MAX_/CAPACITY_ 常量):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR16
# **内核只是库,可执行的装配只有一个,集成测试不挂在内核包里**(2026-11-04 定)。
#
# 🔴 **为什么需要**:这三件事在 2026-11-04 之前是**反的**,而且没有任何闸门会红:
# ① `src/backend` 自带 `[[bin]]` ⇒ 内核既是库又是服务器。谁想复用内核
# (CLI / MCP 适配器 / 另一个应用 / 测试)都得连带享受一份「启动即开库、
# 即绑端口」的语义;`cargo add` 一个库顺带下载一个服务器。
# ② 37 个集成测试(`*_it.rs`)摆在 `src/backend/tests/` ⇒ 它们测的是
# 「装配好的平台」(内核 + 契约面 + 业务包 + 路由),却被登记成**内核的实现细节**:
# 内核改一次名/拆一次包,37 个文件跟着搬(历史上真搬过 3 次)。
# ③ 于是「默认装配」散落在各处:进程级的事(读环境变量 / 开库 / 种子 / 绑端口 /
# 优雅停机)写在 `main.rs` 里,而 `main.rs` 在内核包里 ⇒ 没有一个地方叫「应用」。
# ⇒ 现在:内核 = lib;`crates/sspf-admin` = 默认装配(bin);`crates/tests` = 测试宿主。
#
# 判据:
# ① `src/backend/Cargo.toml` 里**不许**有 `[[bin]]`;
# ② `src/backend/tests/` 里**不许**有 `.rs`(测试宿主在 `crates/tests/tests/`);
# ③ `crates/sspf-admin/Cargo.toml` **必须存在**且声明 `[[bin]]`(默认装配不许被删)。
check_ar16() {
local hits=""
local kernel_toml="$KERNEL/Cargo.toml"
if [ -f "$kernel_toml" ]; then
local binln
binln="$(grep -nE '^\[\[bin\]\]' "$kernel_toml" 2>/dev/null | head -1)"
if [ -n "$binln" ]; then
hits="src/backend/Cargo.toml:${binln%%:*}: 内核声明了 [[bin]](内核只能是 lib ⇒ 装配归 crates/sspf-admin)"
fi
fi
# ⚠️ 只看「有 .rs 文件」:git 不跟踪空目录 ⇒ 空目录残留不算违规(与 AR15 同款)。
if [ -d "$KERNEL/tests" ]; then
local trs
trs="$(find "$KERNEL/tests" -name '*.rs' -type f 2>/dev/null | head -3)"
if [ -n "$trs" ]; then
hits="${hits:+$hits$'\n'}src/backend/tests: 集成测试回到了内核包(宿主是 crates/tests/tests/):$(printf '%s' "$trs" | tr '\n' ' ')"
fi
fi
local admin="$CRATES/sspf-admin/Cargo.toml"
if [ ! -f "$admin" ]; then
hits="${hits:+$hits$'\n'}crates/sspf-admin/Cargo.toml: 不存在(默认装配缺失 ⇒ 全仓没有可执行入口)"
elif ! grep -qE '^\[\[bin\]\]' "$admin" 2>/dev/null; then
hits="${hits:+$hits$'\n'}crates/sspf-admin/Cargo.toml: 没有 [[bin]](默认装配必须产出可执行文件)"
fi
if [ -z "$hits" ]; then
ok "AR16 内核只有 lib + 默认装配在 crates/sspf-admin + 集成测试在 crates/tests"
else
bad "AR16 内核/装配/测试的边界被打破:"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR17
# **内核默认 feature 下不得编译期依赖 `packs/*`**(2026-11-04 标准平台包)。
#
# 🔴 **为什么需要**:`crates/sspf` 是给业务仓的**标准平台包**(业务仓唯一依赖)。
# 内核若在默认 feature 下硬依赖 4 个示例包(asset / books / demo / shop),
# 业务仓依赖门面就等于把这四个包拖进自己的二进制 ⇒ 「平台包里零业务」是假话,
# 且 `cargo tree -p sspf | grep sspf-pack` 会冒出 4 行(P0 的出口判据 ①)。
# ⇒ 示例包降为 `example-packs` feature,只有本仓 `sspf-admin` 与 `sspf-tests` 开。
#
# 判据(三条,全部静态 —— 不跑 `cargo tree`,闸门必须秒级):
# ① `src/backend/Cargo.toml` 里每条 `sspf-pack-*` 依赖必须带 `optional = true`;
# ② 内核 `[features] default` 不得含 `example-packs` / `sspf-pack-*`;
# ③ 门面 `crates/sspf/Cargo.toml` 的 `default` 同样不得开 `example-packs`
# (门面自己开了 = 业务仓一依赖就被拖进示例包,绕过了 ①②)。
#
# 🔴 **为什么不靠 `cargo tree` 兜底**:`cargo tree` 要解析依赖图(~1-3s),
# 而且它看的是**本次构建的实际 feature 组合**(workspace 里 sspf-tests 开着
# feature ⇒ 永远有 sspf-pack-*)⇒ 判据必须是**清单层面**的。
check_ar17() {
local toml="$KERNEL/Cargo.toml"
[ -f "$toml" ] || { skip "AR17 内核 Cargo.toml 不存在"; return; }
local hits=""
# ① 每条 pack 依赖都必须 optional
local not_optional
not_optional="$(grep -nE '^[[:space:]]*sspf-pack-[A-Za-z0-9_-]+[[:space:]]*=' "$toml" 2>/dev/null \
| grep -vE 'optional[[:space:]]*=[[:space:]]*true' || true)"
if [ -n "$not_optional" ]; then
hits="src/backend/Cargo.toml: 示例包依赖必须 optional = true(否则业务仓被拖进示例包):"$'\n'"$(printf '%s\n' "$not_optional" | sed 's/^/ /')"
fi
# ② 内核 default 必须零包
local kdef
kdef="$(awk '/^\[features\]/{f=1;next} /^\[/{f=0} f && /^[[:space:]]*default[[:space:]]*=/' "$toml" 2>/dev/null)"
case "$kdef" in
*example-packs*|*sspf-pack-*)
hits="${hits:+$hits$'\n'}src/backend/Cargo.toml: [features] default 不许含 example-packs / sspf-pack-*(默认 feature 必须是平台包):$kdef" ;;
esac
# ③ 门面 default 不许开示例包
local facade="$CRATES/sspf/Cargo.toml"
if [ -f "$facade" ]; then
local fdef
fdef="$(awk '/^\[features\]/{f=1;next} /^\[/{f=0} f && /^[[:space:]]*default[[:space:]]*=/' "$facade" 2>/dev/null)"
case "$fdef" in
*example-packs*)
hits="${hits:+$hits$'\n'}crates/sspf/Cargo.toml: 门面 default 不许开 example-packs(业务仓会跟着被拖进示例包):$fdef" ;;
esac
fi
if [ -z "$hits" ]; then
ok "AR17 内核默认 feature 零业务包(示例包 optional + default 不含 example-packs)"
else
bad "AR17 平台包里混进了业务包(业务仓会被拖进示例包):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR18
# **门面 crate 不得出现任何业务字面量**(2026-11-04 标准平台包)。
#
# 🔴 **为什么需要**:门面是「平台 ↔ 业务」的**唯一汇聚点** —— 它既认识平台的 19 个
# crate,又会被业务仓依赖。正因为它两边都碰得到,「顺手写一句业务」的成本极低:
# `${业务表}_list` 的默认路由、`/api/ssw/...` 的示例端点、某个租户的写死分支……
# 这类代码**不会让任何测试变红**,但平台包就从「可复用」退化成「那一个业务的」。
#
# 判据:`crates/sspf/src/**` 里**任何一行**(含注释)不得出现:
# - 业务仓名 `tdc`
# - 本仓 4 个示例包的表名(`asset_data_resource` / `demo_item` /
# `shop_product` / `book_shop_book`)
# - 面 A 的端点前缀 `/api/ssw/`
#
# 🔴 **注释也扫**(故意的):门面里出现业务名,读者就会以为平台认识它。
# 要写业务示例 ⇒ 写在 `docs/` 或业务仓自己那边。
check_ar18() {
local dir="$CRATES/sspf/src"
[ -d "$dir" ] || { skip "AR18 门面 crate 不存在(crates/sspf)"; return; }
local hits
hits="$(python3 - "$dir" <<'PY'
import os, re, sys
pat = re.compile(r'(?i)(tdc|asset_data_resource|demo_item|shop_product|book_shop_book|/api/ssw/)')
bad = []
for root in sys.argv[1:]:
for dirpath, _, files in os.walk(root):
for fn in files:
if not fn.endswith('.rs'):
continue
p = os.path.join(dirpath, fn)
try:
lines = open(p, encoding='utf-8').read().splitlines()
except OSError:
continue
for i, line in enumerate(lines, 1):
if pat.search(line):
bad.append(f'{p}:{i}: {line.strip()}')
for b in bad:
print(b)
PY
)"
if [ -z "$hits" ]; then
ok "AR18 门面里没有业务字面量(无业务仓名 / 业务表名 / 面 A 端点)"
else
bad "AR18 门面里出现业务字面量(平台包退化成「那一个业务的」):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- AR19
# **唯一装配链**(2026-11-04 v0.3.0 两阶段装配)。
#
# 🔴 **为什么需要**:业务自带状态的 `Router<()>` 现在能在 merge 点注入,
# 「自己再抄一遍 fallback + layer + with_state」的诱惑变大了 —— 抄错顺序时
# axum 不报编译错,404 兜底只是悄悄失去 catch-all 保护,且**测试全绿**。
#
# 判据(只看 `src/backend/src/routes.rs` 的**非注释**代码行):
# - `pub fn build_app_with` 恰好 1 处;
# - `.layer(catch_all())` 恰好 1 处;
# - `.fallback(` / `.fallback_service(` 恰好 2 处(`if/else` 互斥分支 ⇒ 恒只有一个生效);
# - `Extras.router_owned` 的文档注释必须含「不许自带 fallback」。
check_ar19() {
local file="$KERNEL/src/routes.rs"
[ -f "$file" ] || { skip "AR19 routes.rs 不存在"; return; }
local hits
hits="$(python3 - "$file" <<'PY'
import re, sys
lines = open(sys.argv[1], encoding='utf-8').read().splitlines()
code = [(i, l) for i, l in enumerate(lines, 1) if not l.lstrip().startswith('//')]
def hits(pat):
return [(i, l) for i, l in code if re.search(pat, l)]
bad = []
n = hits(r'pub fn build_app_with\b')
if len(n) != 1:
bad.append(f'unique-chain: pub fn build_app_with 应恰好 1 处,实际 {len(n)} 处')
n = hits(r'\.layer\(catch_all\(\)\)')
if len(n) != 1:
bad.append(f'unique-catch-all: .layer(catch_all()) 应恰好 1 处,实际 {len(n)} 处')
n = hits(r'\.fallback(_service)?\(')
if len(n) != 2:
bad.append(f'single-fallback: fallback 调用点应恰好 2 处(互斥分支),实际 {len(n)} 处')
doc = '\n'.join(lines)
m = re.search(r'((?:^\s*///.*\n)+)\s*pub router_owned:', doc, re.M)
if not m or '不许自带 fallback' not in m.group(1):
bad.append('router_owned-doc: Extras.router_owned 注释缺「不许自带 fallback」约定')
for b in bad:
print(b)
PY
)"
if [ -z "$hits" ]; then
ok "AR19 唯一装配链(build_app_with / catch_all / 单兜底 / 自带状态路由注释)"
else
bad "AR19 装配链被抄了第二遍(或兜底挂法退化):"
printf '%s\n' "$hits" | sed 's/^/ /'
fi
}
# ---------------------------------------------------------------- 反自证
# 🔴 永远返回「干净」的尺子 = 没有尺子。造明知违规的输入,必须被抓到。
self_test() {
local rc=0
echo "── 反自证 1/14:造一个依赖越界的假 pack,AR2 必须报 ❌ ──"
local tmp="$ROOT/packs/__arch_selftest__"
mkdir -p "$tmp"
cat > "$tmp/Cargo.toml" <<'TOML'
[package]
name = "arch-selftest"
version = "0.0.0"
edition = "2021"
[dependencies]
sspf-sdk = { path = "../../crates/sspf-sdk" }
axum = "0.8"
TOML
local before=$FAIL
check_ar2 >/dev/null 2>&1
local caught=0
[ "$FAIL" -gt "$before" ] && caught=1
rm -rf "$tmp"
FAIL=$before
if [ "$caught" -eq 1 ]; then
echo "✅ 反自证通过:AR2 抓到了 axum 依赖"
else
echo "❌ 反自证失败:AR2 没抓到明显违规 ⇒ 这把尺子是假的"
rc=1
fi
echo "── 反自证 2/14:往平台层塞一个 use sspf_pack_*,AR9 必须报 ❌ ──"
#
# 🔴 **为什么必须自证 AR9**:它的判据是 `grep 目录`。
# 目录名写错 / 路径拼错 ⇒ `grep` 永远返回空 ⇒ **永远"通过"**。
# 这类尺子比没有更危险(它给出虚假的安全感)。
# 🔴🔴 **M7 起:平台层**只有真源**(`src/backend/src/platform/` 的 38 个转发壳已删)
# ⇒ 注入点只剩真源一处。但**契约面各包也要注入**(AR9 扫的是整个
# `PLAT_SRC_DIRS`,含 `sspf-compat-*/src`)—— 只注入 core 不注入 compat
# ⇒ 单点注入会漏判「闸门只扫 core 不扫 compat」⇒ **两处都注入**、
# 且**两处都被抓到**才算尺子有效。
local a9core="$CRATES/sspf-core/src/__ar9_selftest.rs"
local a9compat="$CRATES/sspf-compat-system/src/__ar9_selftest.rs"
local a9ok=0
if [ -d "$CRATES/sspf-core/src" ] || [ -d "$CRATES/sspf-compat-system/src" ]; then
[ -d "$CRATES/sspf-core/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9core"
[ -d "$CRATES/sspf-compat-system/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9compat"
local a9out
a9out="$(check_ar9 2>&1 || true)"
rm -f "$a9core" "$a9compat"
# 🔴 **按路径分别验**:必须证明闸门**两处都看得到** ——
# 只验「输出里有 __ar9_selftest」不够(单处抓到会误判成两处都抓到)。
local a9need=0 a9c=0
if [ -d "$CRATES/sspf-core/src" ]; then
a9need=$((a9need+1))
echo "$a9out" | grep -q "sspf-core/src/__ar9_selftest" && a9c=$((a9c+1))
fi
if [ -d "$CRATES/sspf-compat-system/src" ]; then
a9need=$((a9need+1))
echo "$a9out" | grep -q "sspf-compat-system/src/__ar9_selftest" && a9c=$((a9c+1))
fi
[ "$a9need" -gt 0 ] && [ "$a9c" -ge "$a9need" ] && a9ok=1
fi
if [ "$a9ok" -eq 1 ]; then
echo "✅ 反自证通过:AR9 抓到了真源与契约面包里的 use sspf_pack_*"
else
echo "❌ 反自证失败:AR9 没抓到平台层里的业务包引用(或漏扫了真源/契约面)⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 3/14:往 re-export 的模块里塞一份 spec,PACK1 必须报 ❌ ──"
#
# 🔴 造在**临时模块文件**上(不动真文件):只要它同时有 `pub use sspf_pack_`
# 和 `= EntitySpec {`,PACK1 就必须红。
local mprobe="$MODULES_DIR/__pack1_selftest.rs"
if [ -d "$MODULES_DIR" ]; then
cat > "$mprobe" <<'RS'
pub use sspf_pack_asset::DATA_RESOURCE_SPEC;
pub const DUP_SPEC: EntitySpec = EntitySpec { entity: "Dup", table: "dup", .. };
RS
before=$FAIL
check_pack1 >/dev/null 2>&1
caught=0
[ "$FAIL" -gt "$before" ] && caught=1
rm -f "$mprobe"
FAIL=$before
if [ "$caught" -eq 1 ]; then
echo "✅ 反自证通过:PACK1 抓到了「既 re-export 又自己定义 spec」"
else
echo "❌ 反自证失败:PACK1 没抓到两份拷贝 ⇒ 尺子是假的"
rc=1
fi
else
echo "⏭ 跳过 PACK1 反自证(业务模块目录不存在)"
fi
echo "── 反自证 4/14:往 sspf-plugin 塞 axum 依赖,AR8 必须报 ❌ ──"
local pfile="$CRATES/sspf-plugin/Cargo.toml"
if [ -f "$pfile" ]; then
cp "$pfile" "$pfile.bak"
printf 'axum = "0.8"\n' >> "$pfile"
before=$FAIL
check_ar8 >/dev/null 2>&1
caught=0
[ "$FAIL" -gt "$before" ] && caught=1
mv "$pfile.bak" "$pfile"
FAIL=$before
if [ "$caught" -eq 1 ]; then
echo "✅ 反自证通过:AR8 抓到了装载器里的 axum 依赖"
else
echo "❌ 反自证失败:AR8 没抓到装载器里的 axum ⇒ 尺子是假的"
rc=1
fi
else
echo "⏭ 跳过 AR8 反自证(sspf-plugin 不存在)"
fi
echo "── 反自证 5/14:往平台层塞 crate::platform::compat,AR10 必须报 ❌ ──"
#
# 🔴 **必须自证 AR10**:它的判据是「扫平台层目录找契约面引用」。
# 目录名写错 / 路径拼错 ⇒ 扫描永远返回空 ⇒ **永远"通过"** ⇒ 虚假安全感。
# 而且这条判据守护的是**拆 crate 的前置条件** —— 它一旦失效,后续批次才炸。
# 🔴🔴 **M7 起注入两处**(平台核心真源 + 契约面真源),与 2/6 同理:单点注入会漏判。
# ⚠️ 契约面**自己**引用 `compat::` 是合法的(面 B 内部互引)⇒ AR10 的
# Python 扫描会跳过名为 `compat` 的子目录 —— 但现在契约面在**独立 crate**里
# ⇒ 目录里**没有** `compat` 子目录 ⇒ 注入到 `sspf-compat-system/src/` 会被抓到。
local a10core="$CRATES/sspf-core/src/__ar10_selftest.rs"
local a10compat="$CRATES/sspf-compat-system/src/__ar10_selftest.rs"
local a10ok=0
if [ -d "$CRATES/sspf-core/src" ] || [ -d "$CRATES/sspf-compat-system/src" ]; then
[ -d "$CRATES/sspf-core/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10core"
[ -d "$CRATES/sspf-compat-system/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10compat"
local a10out
a10out="$(check_ar10 2>&1 || true)"
rm -f "$a10core" "$a10compat"
local a10need=0 a10c=0
if [ -d "$CRATES/sspf-core/src" ]; then
a10need=$((a10need+1))
echo "$a10out" | grep -q "sspf-core/src/__ar10_selftest" && a10c=$((a10c+1))
fi
if [ -d "$CRATES/sspf-compat-system/src" ]; then
a10need=$((a10need+1))
echo "$a10out" | grep -q "sspf-compat-system/src/__ar10_selftest" && a10c=$((a10c+1))
fi
[ "$a10need" -gt 0 ] && [ "$a10c" -ge "$a10need" ] && a10ok=1
fi
if [ "$a10ok" -eq 1 ]; then
echo "✅ 反自证通过:AR10 抓到了真源里的 crate::platform::compat"
else
echo "❌ 反自证失败:AR10 没抓到平台层的契约面反向依赖(或漏扫了真源)⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 6/14:往契约面底座塞 use super::system,AR11 必须报 ❌ ──"
#
# 🔴🔴 **M7 起底座只有一处**:真源 `crates/sspf-compat-core/src/helper.rs`
# (转发壳 `src/backend/src/platform/compat/helper.rs` 已随 M7 删除)。
# ⇒ 注入点只剩真源一处。
# 做法:备份真文件 → 追加违规行 → 跑判据 → 还原(helper.rs 是活文件)。
local a11ok=0
local a11core="$CRATES/sspf-compat-core/src/helper.rs"
local a11need=0 a11c=0 a11out
if [ -f "$a11core" ]; then
cp "$a11core" "$a11core.bak" && printf '\nuse super::system::menu_node;\n' >> "$a11core" && a11need=$((a11need+1))
a11out="$(check_ar11 2>&1 || true)"
[ -f "$a11core.bak" ] && mv "$a11core.bak" "$a11core"
[ -f "$a11core" ] && { echo "$a11out" | grep -q "sspf-compat-core/src/helper.rs" && a11c=$((a11c+1)); }
[ "$a11need" -gt 0 ] && [ "$a11c" -ge "$a11need" ] && a11ok=1
fi
if [ "$a11ok" -eq 1 ]; then
echo "✅ 反自证通过:AR11 抓到了底座真源里的 use super::system"
else
echo "❌ 反自证失败:AR11 没抓到底座的反向依赖(或漏扫了真源)⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 7/14:往壳里写 crate::platform::,AR15 必须报 ❌ ──"
#
# 🔴 **必须自证 AR15**:删掉 `platform/` 转发壳之后,旧路径就**没有编译器**兜底了
# —— 只要有人重建壳目录并把 import 改回去,**一切照常编译、测试照常全绿**,
# 而 M2–M7 的架构收益全部蒸发。⇒ 必须有一条闸门钉住「不许回来」。
# 🔴 **注入三处**(证明三层判据都有效):
# ① 壳内引用旧路径(`crate::platform::`)⇒ 源码级判据要抓到;
# ② 集成测试引用旧路径(`ssw_platform::platform::`)⇒ 同上;
# ③ 重建 `src/backend/src/platform/` 目录 ⇒ 目录级判据要抓到。
local a15ok=0
local a15probe="$KERNEL/src/__ar15_selftest.rs"
# 🔴 **2026-11-04 起集成测试宿主在 `crates/tests/tests/`**(AR16)——
# 探针必须打在**真在扫描面里**的目录上:AR15 的 roots 含 `$CRATES`,
# 所以打到 `crates/tests/tests/` 才证明「测试里的旧路径也被抓」。
local a15testdir="$ROOT/crates/tests/tests"
local a15test="$a15testdir/__ar15_selftest.rs"
local a15dir="$KERNEL/src/platform"
local a15had_dir=0
[ -d "$a15dir" ] && a15had_dir=1
printf 'use crate::platform::sys::user_list;\n' > "$a15probe"
[ -d "$a15testdir" ] && printf 'use ssw_platform::platform::db::Db;\n' > "$a15test"
mkdir -p "$a15dir"
printf '//! 探针\n' > "$a15dir/__ar15_selftest.rs"
local a15out
a15out="$(check_ar15 2>&1 || true)"
rm -f "$a15probe" "$a15test" "$a15dir/__ar15_selftest.rs"
# 🔴 **清理要彻底**:删探针文件 + 删目录(git 不跟踪空目录 ⇒ 残留会让下次
# 主检查**假红** —— 实测踩过:`rmdir` 失败后留下空目录)。
rm -rf "$a15dir"
[ "$a15had_dir" -eq 1 ] && mkdir -p "$a15dir"
# 🔴 **按判据分别验**:三处都必须被提到(只看「输出非空」不够)。
local a15c=0
echo "$a15out" | grep -q "__ar15_selftest.rs" && a15c=$((a15c+1))
echo "$a15out" | grep -q "platform: 目录复活" && a15c=$((a15c+1))
[ "$a15c" -ge 2 ] && a15ok=1
if [ "$a15ok" -eq 1 ]; then
echo "✅ 反自证通过:AR15 抓到了旧路径引用与 platform/ 目录复活"
else
echo "❌ 反自证失败:AR15 没抓到旧平台路径复活(源码级 / 目录级判据可能失效)⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 8/14:给域包塞一条未授权的跨包依赖,AR12 必须报 ❌ ──"
#
# 🔴 **为什么必须自证 AR12**:它的判据是「读 Cargo.toml 找 sspf-compat-* 依赖」。
# 若 grep 模式写错(包名含连字符/下划线混用)⇒ 永远扫不到依赖 ⇒
# **永远"通过"** ⇒ 虚假安全感。而 AR12 守的正是「契约面各包不会成环」。
# 🔴 **注入必须避开白名单**:挑 `sspf-compat-msg`(它不在任何白名单里,
# 反向依赖 `sspf-compat-workflow` ⇒ 立刻成环)⇒ 必须被抓到。
local a12ok=0
local a12toml="$CRATES/sspf-compat-msg/Cargo.toml"
if [ -f "$a12toml" ]; then
cp "$a12toml" "$a12toml.bak"
printf '\nsspf-compat-workflow = { path = "../sspf-compat-workflow" }\n' >> "$a12toml"
local a12out
a12out="$(check_ar12 2>&1 || true)"
mv "$a12toml.bak" "$a12toml"
# 🔴 必须**按路径验**:输出里要明确出现被注入的那个包 + 那个依赖
if echo "$a12out" | grep -q "sspf-compat-msg → sspf-compat-workflow"; then
a12ok=1
fi
fi
if [ "$a12ok" -eq 1 ]; then
echo "✅ 反自证通过:AR12 抓到了 msg → workflow 的未授权跨包依赖"
else
echo "❌ 反自证失败:AR12 没抓到未授权的跨包依赖 ⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 9/14:给执行层塞一个越界依赖 + 一条业务包引用,AR13 必须报 ❌ ──"
#
# 🔴 **必须自证 AR13**:它的判据是「读 Cargo.toml + grep 源码」。
# 两种失效模式都得堵:
# ① 依赖白名单写错/漏项 ⇒ 越界依赖进得来(执行层拖进 web 框架 ⇒ CLI/MCP 报废);
# ② 源码 grep 路径写错 ⇒ 业务包引用扫不到(平台层开始认识业务 ⇒ 破 AR9)。
# 🔴 **两处都注入、两处都被抓到**才算尺子有效(单点注入会漏判)。
local a13ok=0
local a13toml="$CRATES/sspf-lowcode-exec/Cargo.toml"
local a13src="$CRATES/sspf-lowcode-exec/src/__ar13_selftest.rs"
local a13need=0 a13c=0 a13out
if [ -f "$a13toml" ]; then
cp "$a13toml" "$a13toml.bak"
printf '\naxum = { workspace = true }\n' >> "$a13toml"
a13need=$((a13need+1))
printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a13src"
a13need=$((a13need+1))
a13out="$(check_ar13 2>&1 || true)"
[ -f "$a13toml.bak" ] && mv "$a13toml.bak" "$a13toml"
rm -f "$a13src"
# ① 越界依赖(axum)必须被依赖白名单抓到
echo "$a13out" | grep -q "依赖越界" && a13c=$((a13c+1))
# ② 业务包引用必须被源码层抓到,且**路径明确**(不能只看到"有输出")
echo "$a13out" | grep -q "sspf-lowcode-exec/src/__ar13_selftest" && a13c=$((a13c+1))
[ "$a13need" -gt 0 ] && [ "$a13c" -ge "$a13need" ] && a13ok=1
fi
if [ "$a13ok" -eq 1 ]; then
echo "✅ 反自证通过:AR13 抓到了越界依赖(axum)与执行层里的业务包引用"
else
echo "❌ 反自证失败:AR13 没抓到越界依赖 / 业务包引用(或漏扫了其中一处)⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 10/14:给适配层塞一个越界依赖 + 一条业务包引用,AR14 必须报 ❌ ──"
#
# 🔴 **必须自证 AR14**:它是 M6 新增的判据,守护的是「全仓唯一知道全部包的
# 汇聚点」的依赖面。两种失效模式都得堵:
# ① 依赖白名单写错/漏项 ⇒ 越界依赖进得来(适配层拖进业务包 ⇒ 破 AR9 的隔离);
# ② 源码 grep 路径写错 ⇒ 业务包引用扫不到(业务知识漏进适配层)。
# 🔴 **两处都注入、两处都被抓到**才算尺子有效(单点注入会漏判)。
local a14ok=0
local a14toml="$CRATES/sspf-mcp-adapter/Cargo.toml"
local a14src="$CRATES/sspf-mcp-adapter/src/__ar14_selftest.rs"
local a14need=0 a14c=0 a14out
if [ -f "$a14toml" ]; then
cp "$a14toml" "$a14toml.bak"
printf '\nsspf-contract = { path = "../sspf-contract" }\n' >> "$a14toml"
a14need=$((a14need+1))
printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a14src"
a14need=$((a14need+1))
a14out="$(check_ar14 2>&1 || true)"
[ -f "$a14toml.bak" ] && mv "$a14toml.bak" "$a14toml"
rm -f "$a14src"
# ① 越界依赖(sspf-contract)必须被依赖白名单抓到
echo "$a14out" | grep -q "依赖越界" && a14c=$((a14c+1))
# ② 业务包引用必须被源码层抓到,且**路径明确**(不能只看到"有输出")
echo "$a14out" | grep -q "sspf-mcp-adapter/src/__ar14_selftest" && a14c=$((a14c+1))
[ "$a14need" -gt 0 ] && [ "$a14c" -ge "$a14need" ] && a14ok=1
fi
if [ "$a14ok" -eq 1 ]; then
echo "✅ 反自证通过:AR14 抓到了越界依赖(sspf-contract)与适配层里的业务包引用"
else
echo "❌ 反自证失败:AR14 没抓到越界依赖 / 业务包引用(或漏扫了其中一处)⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 11/14:内核加回 [[bin]] + 塞回 tests/*.rs,AR16 必须两处都报 ❌ ──"
#
# 🔴 **必须自证 AR16**:它的三条判据全是「文件/目录在不在」——
# 路径写错(比如把 $KERNEL 拼成别的名字)⇒ 永远判「没问题」⇒
# 结构会静默退回到 2026-11-04 之前的样子(内核自带 bin、测试挂内核包)。
# ⇒ 两处都注入、两处都被抓到才算尺子有效。
local a16ok=0
local a16toml="$KERNEL/Cargo.toml"
local a16dir="$KERNEL/tests"
local a16need=0 a16c=0 a16before a16out=""
if [ -f "$a16toml" ]; then
a16before=$FAIL
cp "$a16toml" "$a16toml.bak"
printf '\n[[bin]]\nname = "__ar16_selftest"\npath = "src/lib.rs"\n' >> "$a16toml"
a16need=$((a16need + 1))
mkdir -p "$a16dir"
printf '// AR16 自证用,跑完即删\n' > "$a16dir/__ar16_selftest.rs"
a16need=$((a16need + 1))
a16out="$(check_ar16 2>&1 || true)"
[ -f "$a16toml.bak" ] && mv "$a16toml.bak" "$a16toml"
rm -f "$a16dir/__ar16_selftest.rs"
rmdir "$a16dir" 2>/dev/null || true
FAIL=$a16before
echo "$a16out" | grep -qF '内核声明了 [[bin]]' && a16c=$((a16c + 1))
echo "$a16out" | grep -qF '集成测试回到了内核包' && a16c=$((a16c + 1))
[ "$a16need" -gt 0 ] && [ "$a16c" -ge "$a16need" ] && a16ok=1
fi
if [ "$a16ok" -eq 1 ]; then
echo "✅ 反自证通过:AR16 抓到了内核里的 [[bin]] 与回流的 tests/*.rs"
else
echo "❌ 反自证失败:AR16 没抓到内核 [[bin]] / 回流的 tests(或漏判了其中一处)⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 12/14:把内核一条示例包依赖改成非 optional,AR17 必须报 ❌ ──"
#
# 🔴 **为什么自证 AR17**:它的判据是「grep 依赖行里有没有 optional」。
# grep 的模式写错 ⇒ 永远匹配不到 ⇒ **永远"通过"**(与 AR9 同一类风险)。
local a17toml="$KERNEL/Cargo.toml"
local a17ok=0
if [ -f "$a17toml" ]; then
cp "$a17toml" "$a17toml.ar17bak"
python3 - "$a17toml" <<'PY'
import re, sys
p = sys.argv[1]
s = open(p, encoding='utf-8').read()
# 只摘掉**第一行** pack 依赖的 optional(模拟「有人手改回硬依赖」)
s2, n = re.subn(
r'(?m)^(sspf-pack-[A-Za-z0-9_-]+\s*=\s*\{[^}\n]*?),\s*optional\s*=\s*true',
r'\1',
s,
count=1,
)
if n != 1:
sys.stderr.write('AR17 自证:没找到可改的 pack 依赖行\n')
open(p, 'w', encoding='utf-8').write(s2)
PY
local a17before=$FAIL
check_ar17 >/dev/null 2>&1
local a17caught=0
[ "$FAIL" -gt "$a17before" ] && a17caught=1
mv "$a17toml.ar17bak" "$a17toml"
FAIL=$a17before
[ "$a17caught" -eq 1 ] && a17ok=1
fi
if [ "$a17ok" -eq 1 ]; then
echo "✅ 反自证通过:AR17 抓到了非 optional 的示例包依赖"
else
echo "❌ 反自证失败:AR17 没抓到非 optional 的示例包依赖 ⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 13/14:往门面里塞一句业务字面量,AR18 必须报 ❌ ──"
#
# 🔴 **为什么自证 AR18**:它扫的是「门面源码里的业务名」。目录写错 / 正则写错
# ⇒ 永远空 ⇒ 永远"通过"。这条自证保证「平台包里零业务」不是一句口号。
local a18dir="$CRATES/sspf/src"
local a18ok=0
if [ -d "$a18dir" ]; then
printf 'pub const AR18_SELFTEST: &str = "tdc_order";\n' > "$a18dir/__ar18_selftest.rs"
local a18before=$FAIL
check_ar18 >/dev/null 2>&1
local a18caught=0
[ "$FAIL" -gt "$a18before" ] && a18caught=1
rm -f "$a18dir/__ar18_selftest.rs"
FAIL=$a18before
[ "$a18caught" -eq 1 ] && a18ok=1
fi
if [ "$a18ok" -eq 1 ]; then
echo "✅ 反自证通过:AR18 抓到了门面里的业务表名"
else
echo "❌ 反自证失败:AR18 没抓到门面里的业务字面量 ⇒ 尺子是假的"
rc=1
fi
echo "── 反自证 14/14:往 routes.rs 塞第二处 .layer(catch_all()),AR19 必须报 ❌ ──"
#
# 🔴 **为什么自证 AR19**:它数的是「非注释代码里 catch_all 层的条数」。
# 正则写错 / 扫描面写错 ⇒ 永远数到 1 ⇒ 永远"通过"。
local a19file="$KERNEL/src/routes.rs"
local a19ok=0
if [ -f "$a19file" ]; then
cp "$a19file" "$a19file.ar19bak"
printf '\nfn __ar19_selftest() { let _ = axum::Router::new().layer(catch_all()); }\n' >> "$a19file"
local a19before=$FAIL
check_ar19 >/dev/null 2>&1
local a19caught=0
[ "$FAIL" -gt "$a19before" ] && a19caught=1
mv "$a19file.ar19bak" "$a19file"
FAIL=$a19before
[ "$a19caught" -eq 1 ] && a19ok=1
fi
if [ "$a19ok" -eq 1 ]; then
echo "✅ 反自证通过:AR19 抓到了第二处 catch_all 层"
else
echo "❌ 反自证失败:AR19 没抓到重复的装配链层 ⇒ 尺子是假的"
rc=1
fi
return $rc
}
# ---------------------------------------------------------------- main
[ "${1:-}" = "--help" ] && { usage; exit 0; }
echo "── 架构边界闸门(crate 依赖纪律 + 内存红线)──"
check_ar1
check_ar2
check_ar3
check_ar4
check_ar5
check_ar6
check_ar7
check_ar8
check_ar9
check_ar10
check_ar11
check_ar12
check_ar13
check_ar14
check_ar15
check_ar16
check_ar17
check_ar18
check_ar19
check_pack1
check_mem1
check_mem2
echo
printf '结果: %d 通过 / %d 失败 / %d 跳过\n' "$PASS" "$FAIL" "$SKIP"
if [ "${1:-}" = "--self-test" ]; then
echo
self_test || exit 1
fi
[ "$FAIL" -eq 0 ] || exit 1
exit 0