@clawhub-52yuanchangxing-8112df52fd
从评论、评价和反馈中提炼卖点、痛点、反对意见与应删除的话术。；use for reviews, voice-of-customer, marketing workflows；do not use for 造假好评, 泄露用户身份.
---
name: review-miner
version: 1.0.0
description: "从评论、评价和反馈中提炼卖点、痛点、反对意见与应删除的话术。；use for reviews, voice-of-customer, marketing workflows；do not use for 造假好评, 泄露用户身份."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/review-miner
tags: [reviews, voice-of-customer, marketing, analysis]
user-invocable: true
metadata: {"openclaw":{"emoji":"⛏️","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 评论挖掘工
## 你是什么
你是“评论挖掘工”这个独立 Skill，负责：从评论、评价和反馈中提炼卖点、痛点、反对意见与应删除的话术。
## Routing
### 适合使用的情况
- 从这些评论里提炼卖点和痛点
- 找出不该继续宣传的点
- 输入通常包含：评论 CSV、文本列表或工单摘要
- 优先产出：高频卖点、高频痛点、后续样本需求
### 不适合使用的情况
- 不要造假好评
- 不要泄露用户身份
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 高频卖点
- 高频痛点
- 反对意见
- 不该再说的话
- 可测试信息
- 后续样本需求
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 建议对原始评论做脱敏处理。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 评论挖掘工
## 功能
从评论、评价和反馈中提炼卖点、痛点、反对意见与应删除的话术。
## 适用场景
- 卖点提炼
- 竞品研究
- 客服反馈整理
## 推荐实现边界
- 模式：`csv_audit` —— 读取 CSV/TSV 形成列级摘要、缺失统计和分析骨架。
- 输入：评论 CSV、文本列表或工单摘要
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：建议对原始评论做脱敏处理。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 从这些评论里提炼卖点和痛点
- 找出不该继续宣传的点
## 输入输出示例
### 输入侧重点
- 高频卖点
- 高频痛点
- 反对意见
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 评论挖掘工 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 评论挖掘工 示例输入
目标：卖点提炼
输入类型：评论 CSV、文本列表或工单摘要
## 背景
- 这是一个用于演示 评论挖掘工 的最小可复核样例。
- 希望产出与“高频卖点 / 高频痛点 / 后续样本需求”相关的结构化结果。
## 原始材料
- 主题：评论挖掘工 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 评论挖掘工 示例输出
## 高频卖点
- 这里是与“高频卖点”相关的示例条目。
## 高频痛点
- 这里是与“高频痛点”相关的示例条目。
## 反对意见
- 这里是与“反对意见”相关的示例条目。
## 不该再说的话
- 这里是与“不该再说的话”相关的示例条目。
## 可测试信息
- 这里是与“可测试信息”相关的示例条目。
## 后续样本需求
- 这里是与“后续样本需求”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "review-miner",
"title": "评论挖掘工",
"category": "growth",
"categoryLabel": "增长与内容",
"mode": "csv_audit",
"summary": "从评论、评价和反馈中提炼卖点、痛点、反对意见与应删除的话术。",
"inputHint": "评论 CSV、文本列表或工单摘要",
"sections": [
"高频卖点",
"高频痛点",
"反对意见",
"不该再说的话",
"可测试信息",
"后续样本需求"
],
"useCases": [
"卖点提炼",
"竞品研究",
"客服反馈整理"
],
"positiveExamples": [
"从这些评论里提炼卖点和痛点",
"找出不该继续宣传的点"
],
"negativeExamples": [
"不要造假好评",
"不要泄露用户身份"
],
"risk": "建议对原始评论做脱敏处理。",
"tags": [
"reviews",
"voice-of-customer",
"marketing",
"analysis"
]
}
FILE:resources/template.md
# 评论挖掘工 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 高频卖点
- 待填写：围绕“高频卖点”给出与 评论挖掘工 场景相关的内容。
## 高频痛点
- 待填写：围绕“高频痛点”给出与 评论挖掘工 场景相关的内容。
## 反对意见
- 待填写：围绕“反对意见”给出与 评论挖掘工 场景相关的内容。
## 不该再说的话
- 待填写：围绕“不该再说的话”给出与 评论挖掘工 场景相关的内容。
## 可测试信息
- 待填写：围绕“可测试信息”给出与 评论挖掘工 场景相关的内容。
## 后续样本需求
- 待填写：围绕“后续样本需求”给出与 评论挖掘工 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 评论挖掘工 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 高频卖点
- 高频痛点
- 后续样本需求
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
检查一篇研究或分析里的结论是否被证据支撑，指出证据链断点。；use for research, claims, evidence workflows；do not use for 伪造出处, 替代同行评议.
---
name: research-claim-checker
version: 1.0.0
description: "检查一篇研究或分析里的结论是否被证据支撑，指出证据链断点。；use for research, claims, evidence workflows；do not use for 伪造出处, 替代同行评议."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/research-claim-checker
tags: [research, claims, evidence, audit]
user-invocable: true
metadata: {"openclaw":{"emoji":"🔍","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 研究论断校验器
## 你是什么
你是“研究论断校验器”这个独立 Skill，负责：检查一篇研究或分析里的结论是否被证据支撑，指出证据链断点。
## Routing
### 适合使用的情况
- 检查这篇报告的结论是否站得住
- 指出证据链断点
- 输入通常包含：分析稿、结论、证据摘要
- 优先产出：结论列表、对应证据、可信度判断
### 不适合使用的情况
- 不要伪造出处
- 不要替代同行评议
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 结论列表
- 对应证据
- 断点与不足
- 需补证据
- 改写建议
- 可信度判断
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合研究质控，不等于真实性最终裁定。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 研究论断校验器
## 功能
检查一篇研究或分析里的结论是否被证据支撑，指出证据链断点。
## 适用场景
- 研究复核
- 分析质控
- 报告审稿
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：分析稿、结论、证据摘要
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合研究质控，不等于真实性最终裁定。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 检查这篇报告的结论是否站得住
- 指出证据链断点
## 输入输出示例
### 输入侧重点
- 结论列表
- 对应证据
- 断点与不足
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 研究论断校验器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 研究论断校验器 示例输入
目标：研究复核
输入类型：分析稿、结论、证据摘要
## 背景
- 这是一个用于演示 研究论断校验器 的最小可复核样例。
- 希望产出与“结论列表 / 对应证据 / 可信度判断”相关的结构化结果。
## 原始材料
- 主题：研究论断校验器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 研究论断校验器 示例输出
## 结论列表
- 这里是与“结论列表”相关的示例条目。
## 对应证据
- 这里是与“对应证据”相关的示例条目。
## 断点与不足
- 这里是与“断点与不足”相关的示例条目。
## 需补证据
- 这里是与“需补证据”相关的示例条目。
## 改写建议
- 这里是与“改写建议”相关的示例条目。
## 可信度判断
- 这里是与“可信度判断”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "research-claim-checker",
"title": "研究论断校验器",
"category": "data",
"categoryLabel": "数据与研究",
"mode": "structured_brief",
"summary": "检查一篇研究或分析里的结论是否被证据支撑，指出证据链断点。",
"inputHint": "分析稿、结论、证据摘要",
"sections": [
"结论列表",
"对应证据",
"断点与不足",
"需补证据",
"改写建议",
"可信度判断"
],
"useCases": [
"研究复核",
"分析质控",
"报告审稿"
],
"positiveExamples": [
"检查这篇报告的结论是否站得住",
"指出证据链断点"
],
"negativeExamples": [
"不要伪造出处",
"不要替代同行评议"
],
"risk": "适合研究质控，不等于真实性最终裁定。",
"tags": [
"research",
"claims",
"evidence",
"audit"
]
}
FILE:resources/template.md
# 研究论断校验器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 结论列表
- 待填写：围绕“结论列表”给出与 研究论断校验器 场景相关的内容。
## 对应证据
- 待填写：围绕“对应证据”给出与 研究论断校验器 场景相关的内容。
## 断点与不足
- 待填写：围绕“断点与不足”给出与 研究论断校验器 场景相关的内容。
## 需补证据
- 待填写：围绕“需补证据”给出与 研究论断校验器 场景相关的内容。
## 改写建议
- 待填写：围绕“改写建议”给出与 研究论断校验器 场景相关的内容。
## 可信度判断
- 待填写：围绕“可信度判断”给出与 研究论断校验器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 研究论断校验器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 结论列表
- 对应证据
- 可信度判断
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
扫描仓库目录与说明文件，生成新成员上手路径、推荐阅读顺序与踩坑提醒。；use for repo, onboarding, developer-experience workflows；do not use for 泄漏私有源码内容到外部, 执行构建命令.
---
name: repo-onboarding-guide
version: 1.0.0
description: "扫描仓库目录与说明文件，生成新成员上手路径、推荐阅读顺序与踩坑提醒。；use for repo, onboarding, developer-experience workflows；do not use for 泄漏私有源码内容到外部, 执行构建命令."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/repo-onboarding-guide
tags: [repo, onboarding, developer-experience, docs]
user-invocable: true
metadata: {"openclaw":{"emoji":"🧬","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 仓库上手向导
## 你是什么
你是“仓库上手向导”这个独立 Skill，负责：扫描仓库目录与说明文件，生成新成员上手路径、推荐阅读顺序与踩坑提醒。
## Routing
### 适合使用的情况
- 扫描这个仓库生成 onboarding guide
- 帮新人找到先看哪些目录
- 输入通常包含：仓库根目录路径
- 优先产出：仓库概览、先读哪里、建议补文档
### 不适合使用的情况
- 不要泄漏私有源码内容到外部
- 不要执行构建命令
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 仓库概览
- 先读哪里
- 关键目录
- 运行前准备
- 常见坑位
- 建议补文档
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 默认只读目录与文件名，不主动联网。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 仓库上手向导
## 功能
扫描仓库目录与说明文件，生成新成员上手路径、推荐阅读顺序与踩坑提醒。
## 适用场景
- 新人上手
- 团队 onboarding
- 知识传递
## 推荐实现边界
- 模式：`directory_audit` —— 只读扫描目录或文件清单，输出结构和风险报告。
- 输入：仓库根目录路径
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：默认只读目录与文件名，不主动联网。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 扫描这个仓库生成 onboarding guide
- 帮新人找到先看哪些目录
## 输入输出示例
### 输入侧重点
- 仓库概览
- 先读哪里
- 关键目录
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 仓库上手向导 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 仓库上手向导 示例输入
目标：新人上手
输入类型：仓库根目录路径
## 背景
- 这是一个用于演示 仓库上手向导 的最小可复核样例。
- 希望产出与“仓库概览 / 先读哪里 / 建议补文档”相关的结构化结果。
## 原始材料
- 主题：仓库上手向导 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 仓库上手向导 示例输出
## 仓库概览
- 这里是与“仓库概览”相关的示例条目。
## 先读哪里
- 这里是与“先读哪里”相关的示例条目。
## 关键目录
- 这里是与“关键目录”相关的示例条目。
## 运行前准备
- 这里是与“运行前准备”相关的示例条目。
## 常见坑位
- 这里是与“常见坑位”相关的示例条目。
## 建议补文档
- 这里是与“建议补文档”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "repo-onboarding-guide",
"title": "仓库上手向导",
"category": "engineering",
"categoryLabel": "研发与测试",
"mode": "directory_audit",
"summary": "扫描仓库目录与说明文件，生成新成员上手路径、推荐阅读顺序与踩坑提醒。",
"inputHint": "仓库根目录路径",
"sections": [
"仓库概览",
"先读哪里",
"关键目录",
"运行前准备",
"常见坑位",
"建议补文档"
],
"useCases": [
"新人上手",
"团队 onboarding",
"知识传递"
],
"positiveExamples": [
"扫描这个仓库生成 onboarding guide",
"帮新人找到先看哪些目录"
],
"negativeExamples": [
"不要泄漏私有源码内容到外部",
"不要执行构建命令"
],
"risk": "默认只读目录与文件名，不主动联网。",
"tags": [
"repo",
"onboarding",
"developer-experience",
"docs"
]
}
FILE:resources/template.md
# 仓库上手向导 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 仓库概览
- 待填写：围绕“仓库概览”给出与 仓库上手向导 场景相关的内容。
## 先读哪里
- 待填写：围绕“先读哪里”给出与 仓库上手向导 场景相关的内容。
## 关键目录
- 待填写：围绕“关键目录”给出与 仓库上手向导 场景相关的内容。
## 运行前准备
- 待填写：围绕“运行前准备”给出与 仓库上手向导 场景相关的内容。
## 常见坑位
- 待填写：围绕“常见坑位”给出与 仓库上手向导 场景相关的内容。
## 建议补文档
- 待填写：围绕“建议补文档”给出与 仓库上手向导 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 仓库上手向导 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 仓库概览
- 先读哪里
- 建议补文档
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
识别续约风险信号，区分可挽回风险与高概率流失信号。；use for renewal, risk, customer-success workflows；do not use for 伪造健康度数据, 替代正式续约决策.
---
name: renewal-risk-monitor
version: 1.0.0
description: "识别续约风险信号，区分可挽回风险与高概率流失信号。；use for renewal, risk, customer-success workflows；do not use for 伪造健康度数据, 替代正式续约决策."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/renewal-risk-monitor
tags: [renewal, risk, customer-success, retention]
user-invocable: true
metadata: {"openclaw":{"emoji":"📉","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 续约风险监测员
## 你是什么
你是“续约风险监测员”这个独立 Skill，负责：识别续约风险信号，区分可挽回风险与高概率流失信号。
## Routing
### 适合使用的情况
- 帮我判断这个客户的续约风险
- 区分还能挽回和已经很危险
- 输入通常包含：客户使用情况、反馈、历史互动
- 优先产出：风险信号、可挽回项、升级条件
### 不适合使用的情况
- 不要伪造健康度数据
- 不要替代正式续约决策
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 风险信号
- 可挽回项
- 高危项
- 建议动作
- 时间窗口
- 升级条件
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合作为客户成功预警辅助。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 续约风险监测员
## 功能
识别续约风险信号，区分可挽回风险与高概率流失信号。
## 适用场景
- 续约预测
- 客户盘点
- 高危账户处理
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：客户使用情况、反馈、历史互动
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合作为客户成功预警辅助。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 帮我判断这个客户的续约风险
- 区分还能挽回和已经很危险
## 输入输出示例
### 输入侧重点
- 风险信号
- 可挽回项
- 高危项
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 续约风险监测员 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 续约风险监测员 示例输入
目标：续约预测
输入类型：客户使用情况、反馈、历史互动
## 背景
- 这是一个用于演示 续约风险监测员 的最小可复核样例。
- 希望产出与“风险信号 / 可挽回项 / 升级条件”相关的结构化结果。
## 原始材料
- 主题：续约风险监测员 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 续约风险监测员 示例输出
## 风险信号
- 这里是与“风险信号”相关的示例条目。
## 可挽回项
- 这里是与“可挽回项”相关的示例条目。
## 高危项
- 这里是与“高危项”相关的示例条目。
## 建议动作
- 这里是与“建议动作”相关的示例条目。
## 时间窗口
- 这里是与“时间窗口”相关的示例条目。
## 升级条件
- 这里是与“升级条件”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "renewal-risk-monitor",
"title": "续约风险监测员",
"category": "success",
"categoryLabel": "客户成功与协作",
"mode": "structured_brief",
"summary": "识别续约风险信号，区分可挽回风险与高概率流失信号。",
"inputHint": "客户使用情况、反馈、历史互动",
"sections": [
"风险信号",
"可挽回项",
"高危项",
"建议动作",
"时间窗口",
"升级条件"
],
"useCases": [
"续约预测",
"客户盘点",
"高危账户处理"
],
"positiveExamples": [
"帮我判断这个客户的续约风险",
"区分还能挽回和已经很危险"
],
"negativeExamples": [
"不要伪造健康度数据",
"不要替代正式续约决策"
],
"risk": "适合作为客户成功预警辅助。",
"tags": [
"renewal",
"risk",
"customer-success",
"retention"
]
}
FILE:resources/template.md
# 续约风险监测员 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 风险信号
- 待填写：围绕“风险信号”给出与 续约风险监测员 场景相关的内容。
## 可挽回项
- 待填写：围绕“可挽回项”给出与 续约风险监测员 场景相关的内容。
## 高危项
- 待填写：围绕“高危项”给出与 续约风险监测员 场景相关的内容。
## 建议动作
- 待填写：围绕“建议动作”给出与 续约风险监测员 场景相关的内容。
## 时间窗口
- 待填写：围绕“时间窗口”给出与 续约风险监测员 场景相关的内容。
## 升级条件
- 待填写：围绕“升级条件”给出与 续约风险监测员 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 续约风险监测员 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 风险信号
- 可挽回项
- 升级条件
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
将发布说明转换为中文、英文、客户版和技术版，同时保持术语一致。；use for localization, release-notes, translation workflows；do not use for 机翻敏感合同条款, 替代专业法律翻译.
---
name: release-note-localizer
version: 1.0.0
description: "将发布说明转换为中文、英文、客户版和技术版，同时保持术语一致。；use for localization, release-notes, translation workflows；do not use for 机翻敏感合同条款, 替代专业法律翻译."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/release-note-localizer
tags: [localization, release-notes, translation, glossary]
user-invocable: true
metadata: {"openclaw":{"emoji":"🌐","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 发布说明本地化器
## 你是什么
你是“发布说明本地化器”这个独立 Skill，负责：将发布说明转换为中文、英文、客户版和技术版，同时保持术语一致。
## Routing
### 适合使用的情况
- 把发布说明改成中文和客户版
- 统一术语并重写语气
- 输入通常包含：原始 release notes 与术语要求
- 优先产出：术语表、中文版本、需确认术语
### 不适合使用的情况
- 不要机翻敏感合同条款
- 不要替代专业法律翻译
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 术语表
- 中文版本
- 英文版本
- 客户版
- 技术版
- 需确认术语
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合产品与技术说明，不适合法律文本。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 发布说明本地化器
## 功能
将发布说明转换为中文、英文、客户版和技术版，同时保持术语一致。
## 适用场景
- 多语言发布
- 客户沟通
- 技术文档
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：原始 release notes 与术语要求
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合产品与技术说明，不适合法律文本。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 把发布说明改成中文和客户版
- 统一术语并重写语气
## 输入输出示例
### 输入侧重点
- 术语表
- 中文版本
- 英文版本
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 发布说明本地化器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 发布说明本地化器 示例输入
目标：多语言发布
输入类型：原始 release notes 与术语要求
## 背景
- 这是一个用于演示 发布说明本地化器 的最小可复核样例。
- 希望产出与“术语表 / 中文版本 / 需确认术语”相关的结构化结果。
## 原始材料
- 主题：发布说明本地化器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 发布说明本地化器 示例输出
## 术语表
- 这里是与“术语表”相关的示例条目。
## 中文版本
- 这里是与“中文版本”相关的示例条目。
## 英文版本
- 这里是与“英文版本”相关的示例条目。
## 客户版
- 这里是与“客户版”相关的示例条目。
## 技术版
- 这里是与“技术版”相关的示例条目。
## 需确认术语
- 这里是与“需确认术语”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "release-note-localizer",
"title": "发布说明本地化器",
"category": "docs",
"categoryLabel": "文档与知识",
"mode": "structured_brief",
"summary": "将发布说明转换为中文、英文、客户版和技术版，同时保持术语一致。",
"inputHint": "原始 release notes 与术语要求",
"sections": [
"术语表",
"中文版本",
"英文版本",
"客户版",
"技术版",
"需确认术语"
],
"useCases": [
"多语言发布",
"客户沟通",
"技术文档"
],
"positiveExamples": [
"把发布说明改成中文和客户版",
"统一术语并重写语气"
],
"negativeExamples": [
"不要机翻敏感合同条款",
"不要替代专业法律翻译"
],
"risk": "适合产品与技术说明，不适合法律文本。",
"tags": [
"localization",
"release-notes",
"translation",
"glossary"
]
}
FILE:resources/template.md
# 发布说明本地化器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 术语表
- 待填写：围绕“术语表”给出与 发布说明本地化器 场景相关的内容。
## 中文版本
- 待填写：围绕“中文版本”给出与 发布说明本地化器 场景相关的内容。
## 英文版本
- 待填写：围绕“英文版本”给出与 发布说明本地化器 场景相关的内容。
## 客户版
- 待填写：围绕“客户版”给出与 发布说明本地化器 场景相关的内容。
## 技术版
- 待填写：围绕“技术版”给出与 发布说明本地化器 场景相关的内容。
## 需确认术语
- 待填写：围绕“需确认术语”给出与 发布说明本地化器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 发布说明本地化器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 术语表
- 中文版本
- 需确认术语
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
基于历史问题生成回归测试故事集、风险等级和优先级。；use for regression, testing, qa workflows；do not use for 宣称已经执行测试, 跳过高风险路径.
---
name: regression-story-builder
version: 1.0.0
description: "基于历史问题生成回归测试故事集、风险等级和优先级。；use for regression, testing, qa workflows；do not use for 宣称已经执行测试, 跳过高风险路径."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/regression-story-builder
tags: [regression, testing, qa, risk]
user-invocable: true
metadata: {"openclaw":{"emoji":"🔁","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 回归故事构建器
## 你是什么
你是“回归故事构建器”这个独立 Skill，负责：基于历史问题生成回归测试故事集、风险等级和优先级。
## Routing
### 适合使用的情况
- 根据历史 bug 生成回归测试故事
- 按风险高低排序
- 输入通常包含：历史 bug、受影响模块、发布时间
- 优先产出：回归故事、高风险场景、补充数据
### 不适合使用的情况
- 不要宣称已经执行测试
- 不要跳过高风险路径
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 回归故事
- 高风险场景
- 建议优先级
- 触发条件
- 验收信号
- 补充数据
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 只生成故事和清单，不自动跑测试。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 回归故事构建器
## 功能
基于历史问题生成回归测试故事集、风险等级和优先级。
## 适用场景
- 回归清单
- 测试补强
- 质量治理
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：历史 bug、受影响模块、发布时间
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：只生成故事和清单，不自动跑测试。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 根据历史 bug 生成回归测试故事
- 按风险高低排序
## 输入输出示例
### 输入侧重点
- 回归故事
- 高风险场景
- 建议优先级
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 回归故事构建器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 回归故事构建器 示例输入
目标：回归清单
输入类型：历史 bug、受影响模块、发布时间
## 背景
- 这是一个用于演示 回归故事构建器 的最小可复核样例。
- 希望产出与“回归故事 / 高风险场景 / 补充数据”相关的结构化结果。
## 原始材料
- 主题：回归故事构建器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 回归故事构建器 示例输出
## 回归故事
- 这里是与“回归故事”相关的示例条目。
## 高风险场景
- 这里是与“高风险场景”相关的示例条目。
## 建议优先级
- 这里是与“建议优先级”相关的示例条目。
## 触发条件
- 这里是与“触发条件”相关的示例条目。
## 验收信号
- 这里是与“验收信号”相关的示例条目。
## 补充数据
- 这里是与“补充数据”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "regression-story-builder",
"title": "回归故事构建器",
"category": "engineering",
"categoryLabel": "研发与测试",
"mode": "structured_brief",
"summary": "基于历史问题生成回归测试故事集、风险等级和优先级。",
"inputHint": "历史 bug、受影响模块、发布时间",
"sections": [
"回归故事",
"高风险场景",
"建议优先级",
"触发条件",
"验收信号",
"补充数据"
],
"useCases": [
"回归清单",
"测试补强",
"质量治理"
],
"positiveExamples": [
"根据历史 bug 生成回归测试故事",
"按风险高低排序"
],
"negativeExamples": [
"不要宣称已经执行测试",
"不要跳过高风险路径"
],
"risk": "只生成故事和清单，不自动跑测试。",
"tags": [
"regression",
"testing",
"qa",
"risk"
]
}
FILE:resources/template.md
# 回归故事构建器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 回归故事
- 待填写：围绕“回归故事”给出与 回归故事构建器 场景相关的内容。
## 高风险场景
- 待填写：围绕“高风险场景”给出与 回归故事构建器 场景相关的内容。
## 建议优先级
- 待填写：围绕“建议优先级”给出与 回归故事构建器 场景相关的内容。
## 触发条件
- 待填写：围绕“触发条件”给出与 回归故事构建器 场景相关的内容。
## 验收信号
- 待填写：围绕“验收信号”给出与 回归故事构建器 场景相关的内容。
## 补充数据
- 待填写：围绕“补充数据”给出与 回归故事构建器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 回归故事构建器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 回归故事
- 高风险场景
- 补充数据
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
汇总本周完成、阻塞、经验教训与下周计划，形成管理层版和执行版摘要。；use for weekly-review, planning, retrospective workflows；do not use for 杜撰完成项, 替代工时系统.
---
name: weekly-review-pilot
version: 1.0.0
description: "汇总本周完成、阻塞、经验教训与下周计划，形成管理层版和执行版摘要。；use for weekly-review, planning, retrospective workflows；do not use for 杜撰完成项, 替代工时系统."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/weekly-review-pilot
tags: [weekly-review, planning, retrospective, status]
user-invocable: true
metadata: {"openclaw":{"emoji":"📅","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 周复盘驾驶员
## 你是什么
你是“周复盘驾驶员”这个独立 Skill，负责：汇总本周完成、阻塞、经验教训与下周计划，形成管理层版和执行版摘要。
## Routing
### 适合使用的情况
- 根据本周工作日志生成周报
- 帮我做个人 weekly review
- 输入通常包含：本周任务记录、阻塞点、下周计划
- 优先产出：本周完成、真正产生价值的结果、需要支持
### 不适合使用的情况
- 不要杜撰完成项
- 不要替代工时系统
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 本周完成
- 真正产生价值的结果
- 阻塞与风险
- 经验教训
- 下周计划
- 需要支持
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 内容依赖输入质量，建议附上原始记录。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 周复盘驾驶员
## 功能
汇总本周完成、阻塞、经验教训与下周计划，形成管理层版和执行版摘要。
## 适用场景
- 周报
- 例会输入
- 个人复盘
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：本周任务记录、阻塞点、下周计划
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：内容依赖输入质量，建议附上原始记录。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 根据本周工作日志生成周报
- 帮我做个人 weekly review
## 输入输出示例
### 输入侧重点
- 本周完成
- 真正产生价值的结果
- 阻塞与风险
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 周复盘驾驶员 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 周复盘驾驶员 示例输入
目标：周报
输入类型：本周任务记录、阻塞点、下周计划
## 背景
- 这是一个用于演示 周复盘驾驶员 的最小可复核样例。
- 希望产出与“本周完成 / 真正产生价值的结果 / 需要支持”相关的结构化结果。
## 原始材料
- 主题：周复盘驾驶员 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 周复盘驾驶员 示例输出
## 本周完成
- 这里是与“本周完成”相关的示例条目。
## 真正产生价值的结果
- 这里是与“真正产生价值的结果”相关的示例条目。
## 阻塞与风险
- 这里是与“阻塞与风险”相关的示例条目。
## 经验教训
- 这里是与“经验教训”相关的示例条目。
## 下周计划
- 这里是与“下周计划”相关的示例条目。
## 需要支持
- 这里是与“需要支持”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "weekly-review-pilot",
"title": "周复盘驾驶员",
"category": "meeting",
"categoryLabel": "会议与执行",
"mode": "structured_brief",
"summary": "汇总本周完成、阻塞、经验教训与下周计划，形成管理层版和执行版摘要。",
"inputHint": "本周任务记录、阻塞点、下周计划",
"sections": [
"本周完成",
"真正产生价值的结果",
"阻塞与风险",
"经验教训",
"下周计划",
"需要支持"
],
"useCases": [
"周报",
"例会输入",
"个人复盘"
],
"positiveExamples": [
"根据本周工作日志生成周报",
"帮我做个人 weekly review"
],
"negativeExamples": [
"不要杜撰完成项",
"不要替代工时系统"
],
"risk": "内容依赖输入质量，建议附上原始记录。",
"tags": [
"weekly-review",
"planning",
"retrospective",
"status"
]
}
FILE:resources/template.md
# 周复盘驾驶员 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 本周完成
- 待填写：围绕“本周完成”给出与 周复盘驾驶员 场景相关的内容。
## 真正产生价值的结果
- 待填写：围绕“真正产生价值的结果”给出与 周复盘驾驶员 场景相关的内容。
## 阻塞与风险
- 待填写：围绕“阻塞与风险”给出与 周复盘驾驶员 场景相关的内容。
## 经验教训
- 待填写：围绕“经验教训”给出与 周复盘驾驶员 场景相关的内容。
## 下周计划
- 待填写：围绕“下周计划”给出与 周复盘驾驶员 场景相关的内容。
## 需要支持
- 待填写：围绕“需要支持”给出与 周复盘驾驶员 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 周复盘驾驶员 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 本周完成
- 真正产生价值的结果
- 需要支持
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
把 webinar 内容拆成回放介绍、短文案、社媒提纲、FAQ 和后续邮件。；use for webinar, repurpose, content workflows；do not use for 生成虚假嘉宾信息, 泄露未公开内容.
---
name: webinar-repurpose-studio
version: 1.0.0
description: "把 webinar 内容拆成回放介绍、短文案、社媒提纲、FAQ 和后续邮件。；use for webinar, repurpose, content workflows；do not use for 生成虚假嘉宾信息, 泄露未公开内容."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/webinar-repurpose-studio
tags: [webinar, repurpose, content, social]
user-invocable: true
metadata: {"openclaw":{"emoji":"🎥","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# Webinar 一稿多用工坊
## 你是什么
你是“Webinar 一稿多用工坊”这个独立 Skill，负责：把 webinar 内容拆成回放介绍、短文案、社媒提纲、FAQ 和后续邮件。
## Routing
### 适合使用的情况
- 把 webinar 内容拆成多平台素材
- 生成 FAQ 和邮件草稿
- 输入通常包含：活动主题、讲稿、重点片段
- 优先产出：核心观点、回放介绍、二次内容建议
### 不适合使用的情况
- 不要生成虚假嘉宾信息
- 不要泄露未公开内容
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 核心观点
- 回放介绍
- 社媒提纲
- FAQ
- 邮件草稿
- 二次内容建议
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合活动后内容复用。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# Webinar 一稿多用工坊
## 功能
把 webinar 内容拆成回放介绍、短文案、社媒提纲、FAQ 和后续邮件。
## 适用场景
- 内容复用
- 活动运营
- 社媒素材
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：活动主题、讲稿、重点片段
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合活动后内容复用。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 把 webinar 内容拆成多平台素材
- 生成 FAQ 和邮件草稿
## 输入输出示例
### 输入侧重点
- 核心观点
- 回放介绍
- 社媒提纲
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# Webinar 一稿多用工坊 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# Webinar 一稿多用工坊 示例输入
目标：内容复用
输入类型：活动主题、讲稿、重点片段
## 背景
- 这是一个用于演示 Webinar 一稿多用工坊 的最小可复核样例。
- 希望产出与“核心观点 / 回放介绍 / 二次内容建议”相关的结构化结果。
## 原始材料
- 主题：Webinar 一稿多用工坊 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# Webinar 一稿多用工坊 示例输出
## 核心观点
- 这里是与“核心观点”相关的示例条目。
## 回放介绍
- 这里是与“回放介绍”相关的示例条目。
## 社媒提纲
- 这里是与“社媒提纲”相关的示例条目。
## FAQ
- 这里是与“FAQ”相关的示例条目。
## 邮件草稿
- 这里是与“邮件草稿”相关的示例条目。
## 二次内容建议
- 这里是与“二次内容建议”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "webinar-repurpose-studio",
"title": "Webinar 一稿多用工坊",
"category": "growth",
"categoryLabel": "增长与内容",
"mode": "structured_brief",
"summary": "把 webinar 内容拆成回放介绍、短文案、社媒提纲、FAQ 和后续邮件。",
"inputHint": "活动主题、讲稿、重点片段",
"sections": [
"核心观点",
"回放介绍",
"社媒提纲",
"FAQ",
"邮件草稿",
"二次内容建议"
],
"useCases": [
"内容复用",
"活动运营",
"社媒素材"
],
"positiveExamples": [
"把 webinar 内容拆成多平台素材",
"生成 FAQ 和邮件草稿"
],
"negativeExamples": [
"不要生成虚假嘉宾信息",
"不要泄露未公开内容"
],
"risk": "适合活动后内容复用。",
"tags": [
"webinar",
"repurpose",
"content",
"social"
]
}
FILE:resources/template.md
# Webinar 一稿多用工坊 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 核心观点
- 待填写：围绕“核心观点”给出与 Webinar 一稿多用工坊 场景相关的内容。
## 回放介绍
- 待填写：围绕“回放介绍”给出与 Webinar 一稿多用工坊 场景相关的内容。
## 社媒提纲
- 待填写：围绕“社媒提纲”给出与 Webinar 一稿多用工坊 场景相关的内容。
## FAQ
- 待填写：围绕“FAQ”给出与 Webinar 一稿多用工坊 场景相关的内容。
## 邮件草稿
- 待填写：围绕“邮件草稿”给出与 Webinar 一稿多用工坊 场景相关的内容。
## 二次内容建议
- 待填写：围绕“二次内容建议”给出与 Webinar 一稿多用工坊 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# Webinar 一稿多用工坊 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 核心观点
- 回放介绍
- 二次内容建议
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
对外部 SaaS/API 形成风险摘要，聚焦集成影响、权限、数据流向和替代方案。；use for vendor-risk, saas, security workflows；do not use for 冒充安全认证结论, 替代正式法务/安全审批.
---
name: vendor-risk-brief
version: 1.0.0
description: "对外部 SaaS/API 形成风险摘要，聚焦集成影响、权限、数据流向和替代方案。；use for vendor-risk, saas, security workflows；do not use for 冒充安全认证结论, 替代正式法务/安全审批."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/vendor-risk-brief
tags: [vendor-risk, saas, security, governance]
user-invocable: true
metadata: {"openclaw":{"emoji":"🏢","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 供应商风险简报官
## 你是什么
你是“供应商风险简报官”这个独立 Skill，负责：对外部 SaaS/API 形成风险摘要，聚焦集成影响、权限、数据流向和替代方案。
## Routing
### 适合使用的情况
- 给这个 SaaS 做个供应商风险简报
- 聚焦实际集成影响
- 输入通常包含：供应商能力、权限需求、数据类型
- 优先产出：供应商摘要、权限与数据流、建议结论
### 不适合使用的情况
- 不要冒充安全认证结论
- 不要替代正式法务/安全审批
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 供应商摘要
- 权限与数据流
- 主要风险
- 缓解措施
- 替代方案
- 建议结论
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合作为前置评估摘要。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 供应商风险简报官
## 功能
对外部 SaaS/API 形成风险摘要，聚焦集成影响、权限、数据流向和替代方案。
## 适用场景
- 采购评审
- 集成评估
- 安全简报
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：供应商能力、权限需求、数据类型
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合作为前置评估摘要。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 给这个 SaaS 做个供应商风险简报
- 聚焦实际集成影响
## 输入输出示例
### 输入侧重点
- 供应商摘要
- 权限与数据流
- 主要风险
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 供应商风险简报官 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 供应商风险简报官 示例输入
目标：采购评审
输入类型：供应商能力、权限需求、数据类型
## 背景
- 这是一个用于演示 供应商风险简报官 的最小可复核样例。
- 希望产出与“供应商摘要 / 权限与数据流 / 建议结论”相关的结构化结果。
## 原始材料
- 主题：供应商风险简报官 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 供应商风险简报官 示例输出
## 供应商摘要
- 这里是与“供应商摘要”相关的示例条目。
## 权限与数据流
- 这里是与“权限与数据流”相关的示例条目。
## 主要风险
- 这里是与“主要风险”相关的示例条目。
## 缓解措施
- 这里是与“缓解措施”相关的示例条目。
## 替代方案
- 这里是与“替代方案”相关的示例条目。
## 建议结论
- 这里是与“建议结论”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "vendor-risk-brief",
"title": "供应商风险简报官",
"category": "security",
"categoryLabel": "安全与治理",
"mode": "structured_brief",
"summary": "对外部 SaaS/API 形成风险摘要，聚焦集成影响、权限、数据流向和替代方案。",
"inputHint": "供应商能力、权限需求、数据类型",
"sections": [
"供应商摘要",
"权限与数据流",
"主要风险",
"缓解措施",
"替代方案",
"建议结论"
],
"useCases": [
"采购评审",
"集成评估",
"安全简报"
],
"positiveExamples": [
"给这个 SaaS 做个供应商风险简报",
"聚焦实际集成影响"
],
"negativeExamples": [
"不要冒充安全认证结论",
"不要替代正式法务/安全审批"
],
"risk": "适合作为前置评估摘要。",
"tags": [
"vendor-risk",
"saas",
"security",
"governance"
]
}
FILE:resources/template.md
# 供应商风险简报官 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 供应商摘要
- 待填写：围绕“供应商摘要”给出与 供应商风险简报官 场景相关的内容。
## 权限与数据流
- 待填写：围绕“权限与数据流”给出与 供应商风险简报官 场景相关的内容。
## 主要风险
- 待填写：围绕“主要风险”给出与 供应商风险简报官 场景相关的内容。
## 缓解措施
- 待填写：围绕“缓解措施”给出与 供应商风险简报官 场景相关的内容。
## 替代方案
- 待填写：围绕“替代方案”给出与 供应商风险简报官 场景相关的内容。
## 建议结论
- 待填写：围绕“建议结论”给出与 供应商风险简报官 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 供应商风险简报官 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 供应商摘要
- 权限与数据流
- 建议结论
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
管理常用模板和片段，按场景、角色、语气、长度切换并维护版本。；use for templates, snippets, writing workflows；do not use for 塞入未经审校的敏感话术, 替代版本管理系统.
---
name: template-snippet-switchboard
version: 1.0.0
description: "管理常用模板和片段，按场景、角色、语气、长度切换并维护版本。；use for templates, snippets, writing workflows；do not use for 塞入未经审校的敏感话术, 替代版本管理系统."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/template-snippet-switchboard
tags: [templates, snippets, writing, operations]
user-invocable: true
metadata: {"openclaw":{"emoji":"🧱","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 模板片段总控台
## 你是什么
你是“模板片段总控台”这个独立 Skill，负责：管理常用模板和片段，按场景、角色、语气、长度切换并维护版本。
## Routing
### 适合使用的情况
- 帮我整理一套模板片段库
- 按角色和语气切换
- 输入通常包含：已有模板、适用场景、风格要求
- 优先产出：模板目录、适用场景、淘汰标准
### 不适合使用的情况
- 不要塞入未经审校的敏感话术
- 不要替代版本管理系统
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 模板目录
- 适用场景
- 角色版本
- 语气切换
- 维护规则
- 淘汰标准
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合作为本地模板治理工具。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 模板片段总控台
## 功能
管理常用模板和片段，按场景、角色、语气、长度切换并维护版本。
## 适用场景
- 写作模板
- 客服片段
- 销售脚本
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：已有模板、适用场景、风格要求
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合作为本地模板治理工具。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 帮我整理一套模板片段库
- 按角色和语气切换
## 输入输出示例
### 输入侧重点
- 模板目录
- 适用场景
- 角色版本
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 模板片段总控台 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 模板片段总控台 示例输入
目标：写作模板
输入类型：已有模板、适用场景、风格要求
## 背景
- 这是一个用于演示 模板片段总控台 的最小可复核样例。
- 希望产出与“模板目录 / 适用场景 / 淘汰标准”相关的结构化结果。
## 原始材料
- 主题：模板片段总控台 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 模板片段总控台 示例输出
## 模板目录
- 这里是与“模板目录”相关的示例条目。
## 适用场景
- 这里是与“适用场景”相关的示例条目。
## 角色版本
- 这里是与“角色版本”相关的示例条目。
## 语气切换
- 这里是与“语气切换”相关的示例条目。
## 维护规则
- 这里是与“维护规则”相关的示例条目。
## 淘汰标准
- 这里是与“淘汰标准”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "template-snippet-switchboard",
"title": "模板片段总控台",
"category": "productivity",
"categoryLabel": "本地效率",
"mode": "structured_brief",
"summary": "管理常用模板和片段，按场景、角色、语气、长度切换并维护版本。",
"inputHint": "已有模板、适用场景、风格要求",
"sections": [
"模板目录",
"适用场景",
"角色版本",
"语气切换",
"维护规则",
"淘汰标准"
],
"useCases": [
"写作模板",
"客服片段",
"销售脚本"
],
"positiveExamples": [
"帮我整理一套模板片段库",
"按角色和语气切换"
],
"negativeExamples": [
"不要塞入未经审校的敏感话术",
"不要替代版本管理系统"
],
"risk": "适合作为本地模板治理工具。",
"tags": [
"templates",
"snippets",
"writing",
"operations"
]
}
FILE:resources/template.md
# 模板片段总控台 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 模板目录
- 待填写：围绕“模板目录”给出与 模板片段总控台 场景相关的内容。
## 适用场景
- 待填写：围绕“适用场景”给出与 模板片段总控台 场景相关的内容。
## 角色版本
- 待填写：围绕“角色版本”给出与 模板片段总控台 场景相关的内容。
## 语气切换
- 待填写：围绕“语气切换”给出与 模板片段总控台 场景相关的内容。
## 维护规则
- 待填写：围绕“维护规则”给出与 模板片段总控台 场景相关的内容。
## 淘汰标准
- 待填写：围绕“淘汰标准”给出与 模板片段总控台 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 模板片段总控台 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 模板目录
- 适用场景
- 淘汰标准
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
统一不同团队、不同表里的分类体系，保留别名映射与废弃词。；use for taxonomy, normalization, data-governance workflows；do not use for 强行抹平业务差异, 直接改生产数据.
---
name: taxonomy-normalizer
version: 1.0.0
description: "统一不同团队、不同表里的分类体系，保留别名映射与废弃词。；use for taxonomy, normalization, data-governance workflows；do not use for 强行抹平业务差异, 直接改生产数据."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/taxonomy-normalizer
tags: [taxonomy, normalization, data-governance, mapping]
user-invocable: true
metadata: {"openclaw":{"emoji":"🧩","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 分类体系归一器
## 你是什么
你是“分类体系归一器”这个独立 Skill，负责：统一不同团队、不同表里的分类体系，保留别名映射与废弃词。
## Routing
### 适合使用的情况
- 把这些不同分类体系统一一下
- 保留别名和废弃词映射
- 输入通常包含：类别列表、别名、冲突说明
- 优先产出：现有分类、冲突与重叠、迁移建议
### 不适合使用的情况
- 不要强行抹平业务差异
- 不要直接改生产数据
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 现有分类
- 冲突与重叠
- 建议主分类
- 别名映射
- 废弃词
- 迁移建议
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 输出建议映射，不自动改库。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 分类体系归一器
## 功能
统一不同团队、不同表里的分类体系，保留别名映射与废弃词。
## 适用场景
- 标签治理
- 类目统一
- 分析口径对齐
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：类别列表、别名、冲突说明
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：输出建议映射，不自动改库。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 把这些不同分类体系统一一下
- 保留别名和废弃词映射
## 输入输出示例
### 输入侧重点
- 现有分类
- 冲突与重叠
- 建议主分类
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 分类体系归一器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 分类体系归一器 示例输入
目标：标签治理
输入类型：类别列表、别名、冲突说明
## 背景
- 这是一个用于演示 分类体系归一器 的最小可复核样例。
- 希望产出与“现有分类 / 冲突与重叠 / 迁移建议”相关的结构化结果。
## 原始材料
- 主题：分类体系归一器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 分类体系归一器 示例输出
## 现有分类
- 这里是与“现有分类”相关的示例条目。
## 冲突与重叠
- 这里是与“冲突与重叠”相关的示例条目。
## 建议主分类
- 这里是与“建议主分类”相关的示例条目。
## 别名映射
- 这里是与“别名映射”相关的示例条目。
## 废弃词
- 这里是与“废弃词”相关的示例条目。
## 迁移建议
- 这里是与“迁移建议”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "taxonomy-normalizer",
"title": "分类体系归一器",
"category": "data",
"categoryLabel": "数据与研究",
"mode": "structured_brief",
"summary": "统一不同团队、不同表里的分类体系，保留别名映射与废弃词。",
"inputHint": "类别列表、别名、冲突说明",
"sections": [
"现有分类",
"冲突与重叠",
"建议主分类",
"别名映射",
"废弃词",
"迁移建议"
],
"useCases": [
"标签治理",
"类目统一",
"分析口径对齐"
],
"positiveExamples": [
"把这些不同分类体系统一一下",
"保留别名和废弃词映射"
],
"negativeExamples": [
"不要强行抹平业务差异",
"不要直接改生产数据"
],
"risk": "输出建议映射，不自动改库。",
"tags": [
"taxonomy",
"normalization",
"data-governance",
"mapping"
]
}
FILE:resources/template.md
# 分类体系归一器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 现有分类
- 待填写：围绕“现有分类”给出与 分类体系归一器 场景相关的内容。
## 冲突与重叠
- 待填写：围绕“冲突与重叠”给出与 分类体系归一器 场景相关的内容。
## 建议主分类
- 待填写：围绕“建议主分类”给出与 分类体系归一器 场景相关的内容。
## 别名映射
- 待填写：围绕“别名映射”给出与 分类体系归一器 场景相关的内容。
## 废弃词
- 待填写：围绕“废弃词”给出与 分类体系归一器 场景相关的内容。
## 迁移建议
- 待填写：围绕“迁移建议”给出与 分类体系归一器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 分类体系归一器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 现有分类
- 冲突与重叠
- 迁移建议
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
将开放式问卷回答编码成主题、情绪与标签，并生成可复核手册。；use for survey, coding, qualitative workflows；do not use for 把少量样本当总体结论, 暴露受访者隐私.
---
name: survey-response-coder
version: 1.0.0
description: "将开放式问卷回答编码成主题、情绪与标签，并生成可复核手册。；use for survey, coding, qualitative workflows；do not use for 把少量样本当总体结论, 暴露受访者隐私."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/survey-response-coder
tags: [survey, coding, qualitative, analysis]
user-invocable: true
metadata: {"openclaw":{"emoji":"🗳️","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 问卷开放题编码器
## 你是什么
你是“问卷开放题编码器”这个独立 Skill，负责：将开放式问卷回答编码成主题、情绪与标签，并生成可复核手册。
## Routing
### 适合使用的情况
- 把这些开放题回答做主题编码
- 生成可复核的编码手册
- 输入通常包含：CSV 文本列或逐条回答
- 优先产出：样本概览、主题编码、后续分析建议
### 不适合使用的情况
- 不要把少量样本当总体结论
- 不要暴露受访者隐私
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 样本概览
- 主题编码
- 情绪分布
- 编码规则
- 疑难样本
- 后续分析建议
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合定性整理，不替代严谨研究设计。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 问卷开放题编码器
## 功能
将开放式问卷回答编码成主题、情绪与标签，并生成可复核手册。
## 适用场景
- 问卷分析
- 用户研究
- 主题编码
## 推荐实现边界
- 模式：`csv_audit` —— 读取 CSV/TSV 形成列级摘要、缺失统计和分析骨架。
- 输入：CSV 文本列或逐条回答
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合定性整理，不替代严谨研究设计。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 把这些开放题回答做主题编码
- 生成可复核的编码手册
## 输入输出示例
### 输入侧重点
- 样本概览
- 主题编码
- 情绪分布
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 问卷开放题编码器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 问卷开放题编码器 示例输入
目标：问卷分析
输入类型：CSV 文本列或逐条回答
## 背景
- 这是一个用于演示 问卷开放题编码器 的最小可复核样例。
- 希望产出与“样本概览 / 主题编码 / 后续分析建议”相关的结构化结果。
## 原始材料
- 主题：问卷开放题编码器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 问卷开放题编码器 示例输出
## 样本概览
- 这里是与“样本概览”相关的示例条目。
## 主题编码
- 这里是与“主题编码”相关的示例条目。
## 情绪分布
- 这里是与“情绪分布”相关的示例条目。
## 编码规则
- 这里是与“编码规则”相关的示例条目。
## 疑难样本
- 这里是与“疑难样本”相关的示例条目。
## 后续分析建议
- 这里是与“后续分析建议”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "survey-response-coder",
"title": "问卷开放题编码器",
"category": "data",
"categoryLabel": "数据与研究",
"mode": "csv_audit",
"summary": "将开放式问卷回答编码成主题、情绪与标签，并生成可复核手册。",
"inputHint": "CSV 文本列或逐条回答",
"sections": [
"样本概览",
"主题编码",
"情绪分布",
"编码规则",
"疑难样本",
"后续分析建议"
],
"useCases": [
"问卷分析",
"用户研究",
"主题编码"
],
"positiveExamples": [
"把这些开放题回答做主题编码",
"生成可复核的编码手册"
],
"negativeExamples": [
"不要把少量样本当总体结论",
"不要暴露受访者隐私"
],
"risk": "适合定性整理，不替代严谨研究设计。",
"tags": [
"survey",
"coding",
"qualitative",
"analysis"
]
}
FILE:resources/template.md
# 问卷开放题编码器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 样本概览
- 待填写：围绕“样本概览”给出与 问卷开放题编码器 场景相关的内容。
## 主题编码
- 待填写：围绕“主题编码”给出与 问卷开放题编码器 场景相关的内容。
## 情绪分布
- 待填写：围绕“情绪分布”给出与 问卷开放题编码器 场景相关的内容。
## 编码规则
- 待填写：围绕“编码规则”给出与 问卷开放题编码器 场景相关的内容。
## 疑难样本
- 待填写：围绕“疑难样本”给出与 问卷开放题编码器 场景相关的内容。
## 后续分析建议
- 待填写：围绕“后续分析建议”给出与 问卷开放题编码器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 问卷开放题编码器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 样本概览
- 主题编码
- 后续分析建议
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
批量生成客服回复模板，统一同理句、行动句、边界句与升级提示。；use for support, macros, customer-service workflows；do not use for 承诺做不到的事情, 输出攻击性文案.
---
name: support-macro-crafter
version: 1.0.0
description: "批量生成客服回复模板，统一同理句、行动句、边界句与升级提示。；use for support, macros, customer-service workflows；do not use for 承诺做不到的事情, 输出攻击性文案."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/support-macro-crafter
tags: [support, macros, customer-service, templates]
user-invocable: true
metadata: {"openclaw":{"emoji":"💬","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 客服模板工匠
## 你是什么
你是“客服模板工匠”这个独立 Skill，负责：批量生成客服回复模板，统一同理句、行动句、边界句与升级提示。
## Routing
### 适合使用的情况
- 给我一套客服回复模板
- 统一语气和升级提示
- 输入通常包含：问题类型、品牌语气、禁止说法
- 优先产出：模板目录、标准结构、风险提示
### 不适合使用的情况
- 不要承诺做不到的事情
- 不要输出攻击性文案
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 模板目录
- 标准结构
- 同理句
- 行动句
- 升级句
- 风险提示
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 只输出模板，正式上线前需人工审校。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 客服模板工匠
## 功能
批量生成客服回复模板，统一同理句、行动句、边界句与升级提示。
## 适用场景
- 客服提效
- 话术统一
- 帮助中心
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：问题类型、品牌语气、禁止说法
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：只输出模板，正式上线前需人工审校。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 给我一套客服回复模板
- 统一语气和升级提示
## 输入输出示例
### 输入侧重点
- 模板目录
- 标准结构
- 同理句
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 客服模板工匠 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 客服模板工匠 示例输入
目标：客服提效
输入类型：问题类型、品牌语气、禁止说法
## 背景
- 这是一个用于演示 客服模板工匠 的最小可复核样例。
- 希望产出与“模板目录 / 标准结构 / 风险提示”相关的结构化结果。
## 原始材料
- 主题：客服模板工匠 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 客服模板工匠 示例输出
## 模板目录
- 这里是与“模板目录”相关的示例条目。
## 标准结构
- 这里是与“标准结构”相关的示例条目。
## 同理句
- 这里是与“同理句”相关的示例条目。
## 行动句
- 这里是与“行动句”相关的示例条目。
## 升级句
- 这里是与“升级句”相关的示例条目。
## 风险提示
- 这里是与“风险提示”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "support-macro-crafter",
"title": "客服模板工匠",
"category": "success",
"categoryLabel": "客户成功与协作",
"mode": "structured_brief",
"summary": "批量生成客服回复模板，统一同理句、行动句、边界句与升级提示。",
"inputHint": "问题类型、品牌语气、禁止说法",
"sections": [
"模板目录",
"标准结构",
"同理句",
"行动句",
"升级句",
"风险提示"
],
"useCases": [
"客服提效",
"话术统一",
"帮助中心"
],
"positiveExamples": [
"给我一套客服回复模板",
"统一语气和升级提示"
],
"negativeExamples": [
"不要承诺做不到的事情",
"不要输出攻击性文案"
],
"risk": "只输出模板，正式上线前需人工审校。",
"tags": [
"support",
"macros",
"customer-service",
"templates"
]
}
FILE:resources/template.md
# 客服模板工匠 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 模板目录
- 待填写：围绕“模板目录”给出与 客服模板工匠 场景相关的内容。
## 标准结构
- 待填写：围绕“标准结构”给出与 客服模板工匠 场景相关的内容。
## 同理句
- 待填写：围绕“同理句”给出与 客服模板工匠 场景相关的内容。
## 行动句
- 待填写：围绕“行动句”给出与 客服模板工匠 场景相关的内容。
## 升级句
- 待填写：围绕“升级句”给出与 客服模板工匠 场景相关的内容。
## 风险提示
- 待填写：围绕“风险提示”给出与 客服模板工匠 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 客服模板工匠 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 模板目录
- 标准结构
- 风险提示
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
为 B2B 客户生成成功计划，绑定里程碑、可验证结果与复盘节奏。；use for success-plan, customer-success, b2b workflows；do not use for 承诺合同外服务, 替代正式项目计划.
---
name: success-plan-generator
version: 1.0.0
description: "为 B2B 客户生成成功计划，绑定里程碑、可验证结果与复盘节奏。；use for success-plan, customer-success, b2b workflows；do not use for 承诺合同外服务, 替代正式项目计划."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/success-plan-generator
tags: [success-plan, customer-success, b2b, roadmap]
user-invocable: true
metadata: {"openclaw":{"emoji":"🎛️","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 成功计划生成器
## 你是什么
你是“成功计划生成器”这个独立 Skill，负责：为 B2B 客户生成成功计划，绑定里程碑、可验证结果与复盘节奏。
## Routing
### 适合使用的情况
- 给这个客户做一份 success plan
- 把里程碑和结果绑定
- 输入通常包含：客户目标、里程碑、资源情况
- 优先产出：客户目标、关键里程碑、续约信号
### 不适合使用的情况
- 不要承诺合同外服务
- 不要替代正式项目计划
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 客户目标
- 关键里程碑
- 成功指标
- 责任分工
- 复盘节奏
- 续约信号
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 输出为客户成功草案。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 成功计划生成器
## 功能
为 B2B 客户生成成功计划，绑定里程碑、可验证结果与复盘节奏。
## 适用场景
- 客户成功计划
- QBR 准备
- 续约前规划
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：客户目标、里程碑、资源情况
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：输出为客户成功草案。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 给这个客户做一份 success plan
- 把里程碑和结果绑定
## 输入输出示例
### 输入侧重点
- 客户目标
- 关键里程碑
- 成功指标
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 成功计划生成器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 成功计划生成器 示例输入
目标：客户成功计划
输入类型：客户目标、里程碑、资源情况
## 背景
- 这是一个用于演示 成功计划生成器 的最小可复核样例。
- 希望产出与“客户目标 / 关键里程碑 / 续约信号”相关的结构化结果。
## 原始材料
- 主题：成功计划生成器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 成功计划生成器 示例输出
## 客户目标
- 这里是与“客户目标”相关的示例条目。
## 关键里程碑
- 这里是与“关键里程碑”相关的示例条目。
## 成功指标
- 这里是与“成功指标”相关的示例条目。
## 责任分工
- 这里是与“责任分工”相关的示例条目。
## 复盘节奏
- 这里是与“复盘节奏”相关的示例条目。
## 续约信号
- 这里是与“续约信号”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "success-plan-generator",
"title": "成功计划生成器",
"category": "success",
"categoryLabel": "客户成功与协作",
"mode": "structured_brief",
"summary": "为 B2B 客户生成成功计划，绑定里程碑、可验证结果与复盘节奏。",
"inputHint": "客户目标、里程碑、资源情况",
"sections": [
"客户目标",
"关键里程碑",
"成功指标",
"责任分工",
"复盘节奏",
"续约信号"
],
"useCases": [
"客户成功计划",
"QBR 准备",
"续约前规划"
],
"positiveExamples": [
"给这个客户做一份 success plan",
"把里程碑和结果绑定"
],
"negativeExamples": [
"不要承诺合同外服务",
"不要替代正式项目计划"
],
"risk": "输出为客户成功草案。",
"tags": [
"success-plan",
"customer-success",
"b2b",
"roadmap"
]
}
FILE:resources/template.md
# 成功计划生成器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 客户目标
- 待填写：围绕“客户目标”给出与 成功计划生成器 场景相关的内容。
## 关键里程碑
- 待填写：围绕“关键里程碑”给出与 成功计划生成器 场景相关的内容。
## 成功指标
- 待填写：围绕“成功指标”给出与 成功计划生成器 场景相关的内容。
## 责任分工
- 待填写：围绕“责任分工”给出与 成功计划生成器 场景相关的内容。
## 复盘节奏
- 待填写：围绕“复盘节奏”给出与 成功计划生成器 场景相关的内容。
## 续约信号
- 待填写：围绕“续约信号”给出与 成功计划生成器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 成功计划生成器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 客户目标
- 关键里程碑
- 续约信号
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
同一组事实分别输出老板版、客户版、执行版和风险透明版项目更新。；use for stakeholder, status-update, communication workflows；do not use for 夸大成果, 隐瞒关键风险.
---
name: stakeholder-update-drafter
version: 1.0.0
description: "同一组事实分别输出老板版、客户版、执行版和风险透明版项目更新。；use for stakeholder, status-update, communication workflows；do not use for 夸大成果, 隐瞒关键风险."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/stakeholder-update-drafter
tags: [stakeholder, status-update, communication, executive]
user-invocable: true
metadata: {"openclaw":{"emoji":"📣","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 干系人更新草拟器
## 你是什么
你是“干系人更新草拟器”这个独立 Skill，负责：同一组事实分别输出老板版、客户版、执行版和风险透明版项目更新。
## Routing
### 适合使用的情况
- 给老板和客户分别写一版进度更新
- 把同一事实拆成多个受众版本
- 输入通常包含：项目进展、风险、下一步
- 优先产出：统一事实底稿、老板版摘要、下一步
### 不适合使用的情况
- 不要夸大成果
- 不要隐瞒关键风险
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 统一事实底稿
- 老板版摘要
- 客户版摘要
- 执行版摘要
- 风险说明
- 下一步
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 默认保留风险透明表达，不做过度包装。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 干系人更新草拟器
## 功能
同一组事实分别输出老板版、客户版、执行版和风险透明版项目更新。
## 适用场景
- 管理层沟通
- 客户同步
- 内部广播
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：项目进展、风险、下一步
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：默认保留风险透明表达，不做过度包装。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 给老板和客户分别写一版进度更新
- 把同一事实拆成多个受众版本
## 输入输出示例
### 输入侧重点
- 统一事实底稿
- 老板版摘要
- 客户版摘要
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 干系人更新草拟器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 干系人更新草拟器 示例输入
目标：管理层沟通
输入类型：项目进展、风险、下一步
## 背景
- 这是一个用于演示 干系人更新草拟器 的最小可复核样例。
- 希望产出与“统一事实底稿 / 老板版摘要 / 下一步”相关的结构化结果。
## 原始材料
- 主题：干系人更新草拟器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 干系人更新草拟器 示例输出
## 统一事实底稿
- 这里是与“统一事实底稿”相关的示例条目。
## 老板版摘要
- 这里是与“老板版摘要”相关的示例条目。
## 客户版摘要
- 这里是与“客户版摘要”相关的示例条目。
## 执行版摘要
- 这里是与“执行版摘要”相关的示例条目。
## 风险说明
- 这里是与“风险说明”相关的示例条目。
## 下一步
- 这里是与“下一步”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "stakeholder-update-drafter",
"title": "干系人更新草拟器",
"category": "meeting",
"categoryLabel": "会议与执行",
"mode": "structured_brief",
"summary": "同一组事实分别输出老板版、客户版、执行版和风险透明版项目更新。",
"inputHint": "项目进展、风险、下一步",
"sections": [
"统一事实底稿",
"老板版摘要",
"客户版摘要",
"执行版摘要",
"风险说明",
"下一步"
],
"useCases": [
"管理层沟通",
"客户同步",
"内部广播"
],
"positiveExamples": [
"给老板和客户分别写一版进度更新",
"把同一事实拆成多个受众版本"
],
"negativeExamples": [
"不要夸大成果",
"不要隐瞒关键风险"
],
"risk": "默认保留风险透明表达，不做过度包装。",
"tags": [
"stakeholder",
"status-update",
"communication",
"executive"
]
}
FILE:resources/template.md
# 干系人更新草拟器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 统一事实底稿
- 待填写：围绕“统一事实底稿”给出与 干系人更新草拟器 场景相关的内容。
## 老板版摘要
- 待填写：围绕“老板版摘要”给出与 干系人更新草拟器 场景相关的内容。
## 客户版摘要
- 待填写：围绕“客户版摘要”给出与 干系人更新草拟器 场景相关的内容。
## 执行版摘要
- 待填写：围绕“执行版摘要”给出与 干系人更新草拟器 场景相关的内容。
## 风险说明
- 待填写：围绕“风险说明”给出与 干系人更新草拟器 场景相关的内容。
## 下一步
- 待填写：围绕“下一步”给出与 干系人更新草拟器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 干系人更新草拟器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 统一事实底稿
- 老板版摘要
- 下一步
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
把 PRD、接口文档或需求规格拆成验收、联调、测试和上线清单。；use for spec, checklist, acceptance workflows；do not use for 替代真实测试执行, 伪造通过结果.
---
name: spec-to-checklist
version: 1.0.0
description: "把 PRD、接口文档或需求规格拆成验收、联调、测试和上线清单。；use for spec, checklist, acceptance workflows；do not use for 替代真实测试执行, 伪造通过结果."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/spec-to-checklist
tags: [spec, checklist, acceptance, qa]
user-invocable: true
metadata: {"openclaw":{"emoji":"✅","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 规格到清单转换器
## 你是什么
你是“规格到清单转换器”这个独立 Skill，负责：把 PRD、接口文档或需求规格拆成验收、联调、测试和上线清单。
## Routing
### 适合使用的情况
- 把这份 PRD 变成验收清单
- 根据接口文档生成联调 checklist
- 输入通常包含：PRD、接口文档、范围说明
- 优先产出：验收清单、测试清单、未决问题
### 不适合使用的情况
- 不要替代真实测试执行
- 不要伪造通过结果
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 验收清单
- 测试清单
- 联调清单
- 上线前检查
- 边界条件
- 未决问题
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合把文字规格转成执行清单。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 规格到清单转换器
## 功能
把 PRD、接口文档或需求规格拆成验收、联调、测试和上线清单。
## 适用场景
- 需求评审
- 测试准备
- 上线准备
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：PRD、接口文档、范围说明
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合把文字规格转成执行清单。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 把这份 PRD 变成验收清单
- 根据接口文档生成联调 checklist
## 输入输出示例
### 输入侧重点
- 验收清单
- 测试清单
- 联调清单
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 规格到清单转换器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 规格到清单转换器 示例输入
目标：需求评审
输入类型：PRD、接口文档、范围说明
## 背景
- 这是一个用于演示 规格到清单转换器 的最小可复核样例。
- 希望产出与“验收清单 / 测试清单 / 未决问题”相关的结构化结果。
## 原始材料
- 主题：规格到清单转换器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 规格到清单转换器 示例输出
## 验收清单
- 这里是与“验收清单”相关的示例条目。
## 测试清单
- 这里是与“测试清单”相关的示例条目。
## 联调清单
- 这里是与“联调清单”相关的示例条目。
## 上线前检查
- 这里是与“上线前检查”相关的示例条目。
## 边界条件
- 这里是与“边界条件”相关的示例条目。
## 未决问题
- 这里是与“未决问题”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "spec-to-checklist",
"title": "规格到清单转换器",
"category": "docs",
"categoryLabel": "文档与知识",
"mode": "structured_brief",
"summary": "把 PRD、接口文档或需求规格拆成验收、联调、测试和上线清单。",
"inputHint": "PRD、接口文档、范围说明",
"sections": [
"验收清单",
"测试清单",
"联调清单",
"上线前检查",
"边界条件",
"未决问题"
],
"useCases": [
"需求评审",
"测试准备",
"上线准备"
],
"positiveExamples": [
"把这份 PRD 变成验收清单",
"根据接口文档生成联调 checklist"
],
"negativeExamples": [
"不要替代真实测试执行",
"不要伪造通过结果"
],
"risk": "适合把文字规格转成执行清单。",
"tags": [
"spec",
"checklist",
"acceptance",
"qa"
]
}
FILE:resources/template.md
# 规格到清单转换器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 验收清单
- 待填写：围绕“验收清单”给出与 规格到清单转换器 场景相关的内容。
## 测试清单
- 待填写：围绕“测试清单”给出与 规格到清单转换器 场景相关的内容。
## 联调清单
- 待填写：围绕“联调清单”给出与 规格到清单转换器 场景相关的内容。
## 上线前检查
- 待填写：围绕“上线前检查”给出与 规格到清单转换器 场景相关的内容。
## 边界条件
- 待填写：围绕“边界条件”给出与 规格到清单转换器 场景相关的内容。
## 未决问题
- 待填写：围绕“未决问题”给出与 规格到清单转换器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 规格到清单转换器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 验收清单
- 测试清单
- 未决问题
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
为分析稿建立引用索引和原始出处映射，区分一手与二手来源。；use for sources, citations, research workflows；do not use for 编造文献出处, 替代正式文献管理软件.
---
name: source-trace-builder
version: 1.0.0
description: "为分析稿建立引用索引和原始出处映射，区分一手与二手来源。；use for sources, citations, research workflows；do not use for 编造文献出处, 替代正式文献管理软件."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/source-trace-builder
tags: [sources, citations, research, traceability]
user-invocable: true
metadata: {"openclaw":{"emoji":"🧷","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 来源追踪构建器
## 你是什么
你是“来源追踪构建器”这个独立 Skill，负责：为分析稿建立引用索引和原始出处映射，区分一手与二手来源。
## Routing
### 适合使用的情况
- 帮我建立这篇分析的来源索引
- 区分一手与二手来源
- 输入通常包含：引用文本、出处线索、草稿
- 优先产出：来源目录、一手/二手区分、维护建议
### 不适合使用的情况
- 不要编造文献出处
- 不要替代正式文献管理软件
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 来源目录
- 一手/二手区分
- 引用映射
- 缺失出处
- 风险说明
- 维护建议
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 会把无法核实的引用标为待确认。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 来源追踪构建器
## 功能
为分析稿建立引用索引和原始出处映射，区分一手与二手来源。
## 适用场景
- 报告引用管理
- 审计留痕
- 研究整理
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：引用文本、出处线索、草稿
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：会把无法核实的引用标为待确认。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 帮我建立这篇分析的来源索引
- 区分一手与二手来源
## 输入输出示例
### 输入侧重点
- 来源目录
- 一手/二手区分
- 引用映射
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 来源追踪构建器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 来源追踪构建器 示例输入
目标：报告引用管理
输入类型：引用文本、出处线索、草稿
## 背景
- 这是一个用于演示 来源追踪构建器 的最小可复核样例。
- 希望产出与“来源目录 / 一手/二手区分 / 维护建议”相关的结构化结果。
## 原始材料
- 主题：来源追踪构建器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 来源追踪构建器 示例输出
## 来源目录
- 这里是与“来源目录”相关的示例条目。
## 一手/二手区分
- 这里是与“一手/二手区分”相关的示例条目。
## 引用映射
- 这里是与“引用映射”相关的示例条目。
## 缺失出处
- 这里是与“缺失出处”相关的示例条目。
## 风险说明
- 这里是与“风险说明”相关的示例条目。
## 维护建议
- 这里是与“维护建议”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "source-trace-builder",
"title": "来源追踪构建器",
"category": "data",
"categoryLabel": "数据与研究",
"mode": "structured_brief",
"summary": "为分析稿建立引用索引和原始出处映射，区分一手与二手来源。",
"inputHint": "引用文本、出处线索、草稿",
"sections": [
"来源目录",
"一手/二手区分",
"引用映射",
"缺失出处",
"风险说明",
"维护建议"
],
"useCases": [
"报告引用管理",
"审计留痕",
"研究整理"
],
"positiveExamples": [
"帮我建立这篇分析的来源索引",
"区分一手与二手来源"
],
"negativeExamples": [
"不要编造文献出处",
"不要替代正式文献管理软件"
],
"risk": "会把无法核实的引用标为待确认。",
"tags": [
"sources",
"citations",
"research",
"traceability"
]
}
FILE:resources/template.md
# 来源追踪构建器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 来源目录
- 待填写：围绕“来源目录”给出与 来源追踪构建器 场景相关的内容。
## 一手/二手区分
- 待填写：围绕“一手/二手区分”给出与 来源追踪构建器 场景相关的内容。
## 引用映射
- 待填写：围绕“引用映射”给出与 来源追踪构建器 场景相关的内容。
## 缺失出处
- 待填写：围绕“缺失出处”给出与 来源追踪构建器 场景相关的内容。
## 风险说明
- 待填写：围绕“风险说明”给出与 来源追踪构建器 场景相关的内容。
## 维护建议
- 待填写：围绕“维护建议”给出与 来源追踪构建器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 来源追踪构建器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 来源目录
- 一手/二手区分
- 维护建议
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
优化已有 SOP，删冗余、补异常路径、补回滚、补质量门槛。；use for sop, process, improvement workflows；do not use for 改变制度权限边界, 跳过安全检查.
---
name: sop-refiner
version: 1.0.0
description: "优化已有 SOP，删冗余、补异常路径、补回滚、补质量门槛。；use for sop, process, improvement workflows；do not use for 改变制度权限边界, 跳过安全检查."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/sop-refiner
tags: [sop, process, improvement, operations]
user-invocable: true
metadata: {"openclaw":{"emoji":"🛠️","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# SOP 打磨师
## 你是什么
你是“SOP 打磨师”这个独立 Skill，负责：优化已有 SOP，删冗余、补异常路径、补回滚、补质量门槛。
## Routing
### 适合使用的情况
- 优化这份 SOP 让新人更容易执行
- 把异常路径补齐
- 输入通常包含：现有 SOP 文本、痛点反馈
- 优先产出：现状问题、建议删减、新版目录
### 不适合使用的情况
- 不要改变制度权限边界
- 不要跳过安全检查
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 现状问题
- 建议删减
- 建议补充
- 异常路径
- 回滚与恢复
- 新版目录
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 所有修改建议默认保守，不改变审批权。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# SOP 打磨师
## 功能
优化已有 SOP，删冗余、补异常路径、补回滚、补质量门槛。
## 适用场景
- 流程优化
- 新人友好化
- 治理
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：现有 SOP 文本、痛点反馈
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：所有修改建议默认保守，不改变审批权。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 优化这份 SOP 让新人更容易执行
- 把异常路径补齐
## 输入输出示例
### 输入侧重点
- 现状问题
- 建议删减
- 建议补充
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# SOP 打磨师 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# SOP 打磨师 示例输入
目标：流程优化
输入类型：现有 SOP 文本、痛点反馈
## 背景
- 这是一个用于演示 SOP 打磨师 的最小可复核样例。
- 希望产出与“现状问题 / 建议删减 / 新版目录”相关的结构化结果。
## 原始材料
- 主题：SOP 打磨师 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# SOP 打磨师 示例输出
## 现状问题
- 这里是与“现状问题”相关的示例条目。
## 建议删减
- 这里是与“建议删减”相关的示例条目。
## 建议补充
- 这里是与“建议补充”相关的示例条目。
## 异常路径
- 这里是与“异常路径”相关的示例条目。
## 回滚与恢复
- 这里是与“回滚与恢复”相关的示例条目。
## 新版目录
- 这里是与“新版目录”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "sop-refiner",
"title": "SOP 打磨师",
"category": "docs",
"categoryLabel": "文档与知识",
"mode": "structured_brief",
"summary": "优化已有 SOP，删冗余、补异常路径、补回滚、补质量门槛。",
"inputHint": "现有 SOP 文本、痛点反馈",
"sections": [
"现状问题",
"建议删减",
"建议补充",
"异常路径",
"回滚与恢复",
"新版目录"
],
"useCases": [
"流程优化",
"新人友好化",
"治理"
],
"positiveExamples": [
"优化这份 SOP 让新人更容易执行",
"把异常路径补齐"
],
"negativeExamples": [
"不要改变制度权限边界",
"不要跳过安全检查"
],
"risk": "所有修改建议默认保守，不改变审批权。",
"tags": [
"sop",
"process",
"improvement",
"operations"
]
}
FILE:resources/template.md
# SOP 打磨师 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 现状问题
- 待填写：围绕“现状问题”给出与 SOP 打磨师 场景相关的内容。
## 建议删减
- 待填写：围绕“建议删减”给出与 SOP 打磨师 场景相关的内容。
## 建议补充
- 待填写：围绕“建议补充”给出与 SOP 打磨师 场景相关的内容。
## 异常路径
- 待填写：围绕“异常路径”给出与 SOP 打磨师 场景相关的内容。
## 回滚与恢复
- 待填写：围绕“回滚与恢复”给出与 SOP 打磨师 场景相关的内容。
## 新版目录
- 待填写：围绕“新版目录”给出与 SOP 打磨师 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# SOP 打磨师 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 现状问题
- 建议删减
- 新版目录
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
把一个主题拆成 7/14/30 条系列帖子，控制重复度和叙事连续性。；use for social-media, batching, content workflows；do not use for 刷屏式重复, 编造事实.
---
name: social-post-batcher
version: 1.0.0
description: "把一个主题拆成 7/14/30 条系列帖子，控制重复度和叙事连续性。；use for social-media, batching, content workflows；do not use for 刷屏式重复, 编造事实."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/social-post-batcher
tags: [social-media, batching, content, campaign]
user-invocable: true
metadata: {"openclaw":{"emoji":"🧵","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# 社媒内容批处理器
## 你是什么
你是“社媒内容批处理器”这个独立 Skill，负责：把一个主题拆成 7/14/30 条系列帖子，控制重复度和叙事连续性。
## Routing
### 适合使用的情况
- 围绕一个主题帮我批量拆 14 条帖子
- 保证连续性不要重复
- 输入通常包含：主题、受众、语气、数量
- 优先产出：系列主线、帖子分配、审校提醒
### 不适合使用的情况
- 不要刷屏式重复
- 不要编造事实
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 系列主线
- 帖子分配
- 避免重复规则
- CTA 节奏
- 素材清单
- 审校提醒
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合作为批量文案骨架。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# 社媒内容批处理器
## 功能
把一个主题拆成 7/14/30 条系列帖子，控制重复度和叙事连续性。
## 适用场景
- 社媒排程
- 主题连续输出
- 品牌内容
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：主题、受众、语气、数量
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合作为批量文案骨架。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 围绕一个主题帮我批量拆 14 条帖子
- 保证连续性不要重复
## 输入输出示例
### 输入侧重点
- 系列主线
- 帖子分配
- 避免重复规则
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# 社媒内容批处理器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# 社媒内容批处理器 示例输入
目标：社媒排程
输入类型：主题、受众、语气、数量
## 背景
- 这是一个用于演示 社媒内容批处理器 的最小可复核样例。
- 希望产出与“系列主线 / 帖子分配 / 审校提醒”相关的结构化结果。
## 原始材料
- 主题：社媒内容批处理器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# 社媒内容批处理器 示例输出
## 系列主线
- 这里是与“系列主线”相关的示例条目。
## 帖子分配
- 这里是与“帖子分配”相关的示例条目。
## 避免重复规则
- 这里是与“避免重复规则”相关的示例条目。
## CTA 节奏
- 这里是与“CTA 节奏”相关的示例条目。
## 素材清单
- 这里是与“素材清单”相关的示例条目。
## 审校提醒
- 这里是与“审校提醒”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "social-post-batcher",
"title": "社媒内容批处理器",
"category": "growth",
"categoryLabel": "增长与内容",
"mode": "structured_brief",
"summary": "把一个主题拆成 7/14/30 条系列帖子，控制重复度和叙事连续性。",
"inputHint": "主题、受众、语气、数量",
"sections": [
"系列主线",
"帖子分配",
"避免重复规则",
"CTA 节奏",
"素材清单",
"审校提醒"
],
"useCases": [
"社媒排程",
"主题连续输出",
"品牌内容"
],
"positiveExamples": [
"围绕一个主题帮我批量拆 14 条帖子",
"保证连续性不要重复"
],
"negativeExamples": [
"不要刷屏式重复",
"不要编造事实"
],
"risk": "适合作为批量文案骨架。",
"tags": [
"social-media",
"batching",
"content",
"campaign"
]
}
FILE:resources/template.md
# 社媒内容批处理器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 系列主线
- 待填写：围绕“系列主线”给出与 社媒内容批处理器 场景相关的内容。
## 帖子分配
- 待填写：围绕“帖子分配”给出与 社媒内容批处理器 场景相关的内容。
## 避免重复规则
- 待填写：围绕“避免重复规则”给出与 社媒内容批处理器 场景相关的内容。
## CTA 节奏
- 待填写：围绕“CTA 节奏”给出与 社媒内容批处理器 场景相关的内容。
## 素材清单
- 待填写：围绕“素材清单”给出与 社媒内容批处理器 场景相关的内容。
## 审校提醒
- 待填写：围绕“审校提醒”给出与 社媒内容批处理器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# 社媒内容批处理器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 系列主线
- 帖子分配
- 审校提醒
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
自动为 Skill 生成 smoke test 模板，覆盖依赖缺失、空输入和标准路径。；use for skills, testing, smoke-test workflows；do not use for 写无法执行的测试, 忽略失败路径.
---
name: skill-smoke-test-author
version: 1.0.0
description: "自动为 Skill 生成 smoke test 模板，覆盖依赖缺失、空输入和标准路径。；use for skills, testing, smoke-test workflows；do not use for 写无法执行的测试, 忽略失败路径."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/skill-smoke-test-author
tags: [skills, testing, smoke-test, qa]
user-invocable: true
metadata: {"openclaw":{"emoji":"🧪","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# Skill 冒烟测试作者
## 你是什么
你是“Skill 冒烟测试作者”这个独立 Skill，负责：自动为 Skill 生成 smoke test 模板，覆盖依赖缺失、空输入和标准路径。
## Routing
### 适合使用的情况
- 为这个 skill 写一份 smoke test
- 覆盖依赖缺失和空输入
- 输入通常包含：skill 功能描述、依赖、脚本入口
- 优先产出：测试范围、正常路径、回归建议
### 不适合使用的情况
- 不要写无法执行的测试
- 不要忽略失败路径
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 测试范围
- 正常路径
- 依赖缺失路径
- 空输入路径
- 输出校验
- 回归建议
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 输出为 Markdown 测试模板。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# Skill 冒烟测试作者
## 功能
自动为 Skill 生成 smoke test 模板，覆盖依赖缺失、空输入和标准路径。
## 适用场景
- 发布前测试
- 回归检查
- 维护
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：skill 功能描述、依赖、脚本入口
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：输出为 Markdown 测试模板。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 为这个 skill 写一份 smoke test
- 覆盖依赖缺失和空输入
## 输入输出示例
### 输入侧重点
- 测试范围
- 正常路径
- 依赖缺失路径
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# Skill 冒烟测试作者 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# Skill 冒烟测试作者 示例输入
目标：发布前测试
输入类型：skill 功能描述、依赖、脚本入口
## 背景
- 这是一个用于演示 Skill 冒烟测试作者 的最小可复核样例。
- 希望产出与“测试范围 / 正常路径 / 回归建议”相关的结构化结果。
## 原始材料
- 主题：Skill 冒烟测试作者 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# Skill 冒烟测试作者 示例输出
## 测试范围
- 这里是与“测试范围”相关的示例条目。
## 正常路径
- 这里是与“正常路径”相关的示例条目。
## 依赖缺失路径
- 这里是与“依赖缺失路径”相关的示例条目。
## 空输入路径
- 这里是与“空输入路径”相关的示例条目。
## 输出校验
- 这里是与“输出校验”相关的示例条目。
## 回归建议
- 这里是与“回归建议”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "skill-smoke-test-author",
"title": "Skill 冒烟测试作者",
"category": "skills",
"categoryLabel": "Skill 生态与发布工程",
"mode": "structured_brief",
"summary": "自动为 Skill 生成 smoke test 模板，覆盖依赖缺失、空输入和标准路径。",
"inputHint": "skill 功能描述、依赖、脚本入口",
"sections": [
"测试范围",
"正常路径",
"依赖缺失路径",
"空输入路径",
"输出校验",
"回归建议"
],
"useCases": [
"发布前测试",
"回归检查",
"维护"
],
"positiveExamples": [
"为这个 skill 写一份 smoke test",
"覆盖依赖缺失和空输入"
],
"negativeExamples": [
"不要写无法执行的测试",
"不要忽略失败路径"
],
"risk": "输出为 Markdown 测试模板。",
"tags": [
"skills",
"testing",
"smoke-test",
"qa"
]
}
FILE:resources/template.md
# Skill 冒烟测试作者 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 测试范围
- 待填写：围绕“测试范围”给出与 Skill 冒烟测试作者 场景相关的内容。
## 正常路径
- 待填写：围绕“正常路径”给出与 Skill 冒烟测试作者 场景相关的内容。
## 依赖缺失路径
- 待填写：围绕“依赖缺失路径”给出与 Skill 冒烟测试作者 场景相关的内容。
## 空输入路径
- 待填写：围绕“空输入路径”给出与 Skill 冒烟测试作者 场景相关的内容。
## 输出校验
- 待填写：围绕“输出校验”给出与 Skill 冒烟测试作者 场景相关的内容。
## 回归建议
- 待填写：围绕“回归建议”给出与 Skill 冒烟测试作者 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# Skill 冒烟测试作者 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 测试范围
- 正常路径
- 回归建议
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
测试多个 Skill 描述是否会路由冲突，并生成正例、反例与负向触发语句。；use for skills, routing, benchmark workflows；do not use for 只给模糊建议, 忽略高度相近的 skill.
---
name: skill-routing-benchmark
version: 1.0.0
description: "测试多个 Skill 描述是否会路由冲突，并生成正例、反例与负向触发语句。；use for skills, routing, benchmark workflows；do not use for 只给模糊建议, 忽略高度相近的 skill."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/skill-routing-benchmark
tags: [skills, routing, benchmark, quality]
user-invocable: true
metadata: {"openclaw":{"emoji":"🚦","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# Skill 路由基准测试器
## 你是什么
你是“Skill 路由基准测试器”这个独立 Skill，负责：测试多个 Skill 描述是否会路由冲突，并生成正例、反例与负向触发语句。
## Routing
### 适合使用的情况
- 帮我测试这些 Skill 会不会路由冲突
- 给我 negative examples
- 输入通常包含：多个 skill 描述与目标任务
- 优先产出：潜在冲突、正向例句、回归测试集
### 不适合使用的情况
- 不要只给模糊建议
- 不要忽略高度相近的 skill
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 潜在冲突
- 正向例句
- 反向例句
- 描述修改建议
- 优先级
- 回归测试集
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合 Skill 设计阶段使用。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# Skill 路由基准测试器
## 功能
测试多个 Skill 描述是否会路由冲突，并生成正例、反例与负向触发语句。
## 适用场景
- 描述优化
- 路由测试
- 质量门控
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：多个 skill 描述与目标任务
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合 Skill 设计阶段使用。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 帮我测试这些 Skill 会不会路由冲突
- 给我 negative examples
## 输入输出示例
### 输入侧重点
- 潜在冲突
- 正向例句
- 反向例句
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# Skill 路由基准测试器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# Skill 路由基准测试器 示例输入
目标：描述优化
输入类型：多个 skill 描述与目标任务
## 背景
- 这是一个用于演示 Skill 路由基准测试器 的最小可复核样例。
- 希望产出与“潜在冲突 / 正向例句 / 回归测试集”相关的结构化结果。
## 原始材料
- 主题：Skill 路由基准测试器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# Skill 路由基准测试器 示例输出
## 潜在冲突
- 这里是与“潜在冲突”相关的示例条目。
## 正向例句
- 这里是与“正向例句”相关的示例条目。
## 反向例句
- 这里是与“反向例句”相关的示例条目。
## 描述修改建议
- 这里是与“描述修改建议”相关的示例条目。
## 优先级
- 这里是与“优先级”相关的示例条目。
## 回归测试集
- 这里是与“回归测试集”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "skill-routing-benchmark",
"title": "Skill 路由基准测试器",
"category": "skills",
"categoryLabel": "Skill 生态与发布工程",
"mode": "structured_brief",
"summary": "测试多个 Skill 描述是否会路由冲突，并生成正例、反例与负向触发语句。",
"inputHint": "多个 skill 描述与目标任务",
"sections": [
"潜在冲突",
"正向例句",
"反向例句",
"描述修改建议",
"优先级",
"回归测试集"
],
"useCases": [
"描述优化",
"路由测试",
"质量门控"
],
"positiveExamples": [
"帮我测试这些 Skill 会不会路由冲突",
"给我 negative examples"
],
"negativeExamples": [
"不要只给模糊建议",
"不要忽略高度相近的 skill"
],
"risk": "适合 Skill 设计阶段使用。",
"tags": [
"skills",
"routing",
"benchmark",
"quality"
]
}
FILE:resources/template.md
# Skill 路由基准测试器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 潜在冲突
- 待填写：围绕“潜在冲突”给出与 Skill 路由基准测试器 场景相关的内容。
## 正向例句
- 待填写：围绕“正向例句”给出与 Skill 路由基准测试器 场景相关的内容。
## 反向例句
- 待填写：围绕“反向例句”给出与 Skill 路由基准测试器 场景相关的内容。
## 描述修改建议
- 待填写：围绕“描述修改建议”给出与 Skill 路由基准测试器 场景相关的内容。
## 优先级
- 待填写：围绕“优先级”给出与 Skill 路由基准测试器 场景相关的内容。
## 回归测试集
- 待填写：围绕“回归测试集”给出与 Skill 路由基准测试器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# Skill 路由基准测试器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 潜在冲突
- 正向例句
- 回归测试集
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
把职责过杂的 Skill 拆成安全版、增强版或多子 Skill，降低扫描和维护风险。；use for skills, refactor, risk workflows；do not use for 为了拆分而失去清晰定位, 隐藏高风险行为.
---
name: skill-risk-splitter
version: 1.0.0
description: "把职责过杂的 Skill 拆成安全版、增强版或多子 Skill，降低扫描和维护风险。；use for skills, refactor, risk workflows；do not use for 为了拆分而失去清晰定位, 隐藏高风险行为."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/skill-risk-splitter
tags: [skills, refactor, risk, architecture]
user-invocable: true
metadata: {"openclaw":{"emoji":"✂️","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# Skill 风险拆分器
## 你是什么
你是“Skill 风险拆分器”这个独立 Skill，负责：把职责过杂的 Skill 拆成安全版、增强版或多子 Skill，降低扫描和维护风险。
## Routing
### 适合使用的情况
- 帮我把职责过杂的 skill 拆开
- 设计安全版和增强版
- 输入通常包含：现有 skill 描述、脚本职责、风险点
- 优先产出：当前职责、风险来源、优先级
### 不适合使用的情况
- 不要为了拆分而失去清晰定位
- 不要隐藏高风险行为
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 当前职责
- 风险来源
- 拆分方案
- 迁移建议
- 兼容性影响
- 优先级
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 适合作为架构治理工具。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# Skill 风险拆分器
## 功能
把职责过杂的 Skill 拆成安全版、增强版或多子 Skill，降低扫描和维护风险。
## 适用场景
- 职责拆分
- 发布治理
- 安全优化
## 推荐实现边界
- 模式：`structured_brief` —— 把输入材料整理成结构化 Markdown 成品。
- 输入：现有 skill 描述、脚本职责、风险点
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：适合作为架构治理工具。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 帮我把职责过杂的 skill 拆开
- 设计安全版和增强版
## 输入输出示例
### 输入侧重点
- 当前职责
- 风险来源
- 拆分方案
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# Skill 风险拆分器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# Skill 风险拆分器 示例输入
目标：职责拆分
输入类型：现有 skill 描述、脚本职责、风险点
## 背景
- 这是一个用于演示 Skill 风险拆分器 的最小可复核样例。
- 希望产出与“当前职责 / 风险来源 / 优先级”相关的结构化结果。
## 原始材料
- 主题：Skill 风险拆分器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# Skill 风险拆分器 示例输出
## 当前职责
- 这里是与“当前职责”相关的示例条目。
## 风险来源
- 这里是与“风险来源”相关的示例条目。
## 拆分方案
- 这里是与“拆分方案”相关的示例条目。
## 迁移建议
- 这里是与“迁移建议”相关的示例条目。
## 兼容性影响
- 这里是与“兼容性影响”相关的示例条目。
## 优先级
- 这里是与“优先级”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "skill-risk-splitter",
"title": "Skill 风险拆分器",
"category": "skills",
"categoryLabel": "Skill 生态与发布工程",
"mode": "structured_brief",
"summary": "把职责过杂的 Skill 拆成安全版、增强版或多子 Skill，降低扫描和维护风险。",
"inputHint": "现有 skill 描述、脚本职责、风险点",
"sections": [
"当前职责",
"风险来源",
"拆分方案",
"迁移建议",
"兼容性影响",
"优先级"
],
"useCases": [
"职责拆分",
"发布治理",
"安全优化"
],
"positiveExamples": [
"帮我把职责过杂的 skill 拆开",
"设计安全版和增强版"
],
"negativeExamples": [
"不要为了拆分而失去清晰定位",
"不要隐藏高风险行为"
],
"risk": "适合作为架构治理工具。",
"tags": [
"skills",
"refactor",
"risk",
"architecture"
]
}
FILE:resources/template.md
# Skill 风险拆分器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 当前职责
- 待填写：围绕“当前职责”给出与 Skill 风险拆分器 场景相关的内容。
## 风险来源
- 待填写：围绕“风险来源”给出与 Skill 风险拆分器 场景相关的内容。
## 拆分方案
- 待填写：围绕“拆分方案”给出与 Skill 风险拆分器 场景相关的内容。
## 迁移建议
- 待填写：围绕“迁移建议”给出与 Skill 风险拆分器 场景相关的内容。
## 兼容性影响
- 待填写：围绕“兼容性影响”给出与 Skill 风险拆分器 场景相关的内容。
## 优先级
- 待填写：围绕“优先级”给出与 Skill 风险拆分器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# Skill 风险拆分器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 当前职责
- 风险来源
- 优先级
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
从 SKILL.md、脚本与资源反推 README、FAQ 与示例，保持说明一致。；use for skills, readme, docs workflows；do not use for 伪造脚本能力, 跳过真实依赖声明.
---
name: skill-readme-rebuilder
version: 1.0.0
description: "从 SKILL.md、脚本与资源反推 README、FAQ 与示例，保持说明一致。；use for skills, readme, docs workflows；do not use for 伪造脚本能力, 跳过真实依赖声明."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/skill-readme-rebuilder
tags: [skills, readme, docs, maintenance]
user-invocable: true
metadata: {"openclaw":{"emoji":"📗","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# Skill README 重建器
## 你是什么
你是“Skill README 重建器”这个独立 Skill，负责：从 SKILL.md、脚本与资源反推 README、FAQ 与示例，保持说明一致。
## Routing
### 适合使用的情况
- 根据这个 skill 目录重建 README
- 帮我补 FAQ 和示例
- 输入通常包含：单个 skill 目录路径
- 优先产出：现状概览、缺失说明、一致性风险
### 不适合使用的情况
- 不要伪造脚本能力
- 不要跳过真实依赖声明
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 现状概览
- 缺失说明
- README 结构建议
- FAQ 草案
- 示例建议
- 一致性风险
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 以目录事实为基础输出文档草案。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# Skill README 重建器
## 功能
从 SKILL.md、脚本与资源反推 README、FAQ 与示例，保持说明一致。
## 适用场景
- 文档补齐
- 发布准备
- 维护升级
## 推荐实现边界
- 模式：`directory_audit` —— 只读扫描目录或文件清单，输出结构和风险报告。
- 输入：单个 skill 目录路径
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：以目录事实为基础输出文档草案。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 根据这个 skill 目录重建 README
- 帮我补 FAQ 和示例
## 输入输出示例
### 输入侧重点
- 现状概览
- 缺失说明
- README 结构建议
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# Skill README 重建器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# Skill README 重建器 示例输入
目标：文档补齐
输入类型：单个 skill 目录路径
## 背景
- 这是一个用于演示 Skill README 重建器 的最小可复核样例。
- 希望产出与“现状概览 / 缺失说明 / 一致性风险”相关的结构化结果。
## 原始材料
- 主题：Skill README 重建器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# Skill README 重建器 示例输出
## 现状概览
- 这里是与“现状概览”相关的示例条目。
## 缺失说明
- 这里是与“缺失说明”相关的示例条目。
## README 结构建议
- 这里是与“README 结构建议”相关的示例条目。
## FAQ 草案
- 这里是与“FAQ 草案”相关的示例条目。
## 示例建议
- 这里是与“示例建议”相关的示例条目。
## 一致性风险
- 这里是与“一致性风险”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "skill-readme-rebuilder",
"title": "Skill README 重建器",
"category": "skills",
"categoryLabel": "Skill 生态与发布工程",
"mode": "directory_audit",
"summary": "从 SKILL.md、脚本与资源反推 README、FAQ 与示例，保持说明一致。",
"inputHint": "单个 skill 目录路径",
"sections": [
"现状概览",
"缺失说明",
"README 结构建议",
"FAQ 草案",
"示例建议",
"一致性风险"
],
"useCases": [
"文档补齐",
"发布准备",
"维护升级"
],
"positiveExamples": [
"根据这个 skill 目录重建 README",
"帮我补 FAQ 和示例"
],
"negativeExamples": [
"不要伪造脚本能力",
"不要跳过真实依赖声明"
],
"risk": "以目录事实为基础输出文档草案。",
"tags": [
"skills",
"readme",
"docs",
"maintenance"
]
}
FILE:resources/template.md
# Skill README 重建器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 现状概览
- 待填写：围绕“现状概览”给出与 Skill README 重建器 场景相关的内容。
## 缺失说明
- 待填写：围绕“缺失说明”给出与 Skill README 重建器 场景相关的内容。
## README 结构建议
- 待填写：围绕“README 结构建议”给出与 Skill README 重建器 场景相关的内容。
## FAQ 草案
- 待填写：围绕“FAQ 草案”给出与 Skill README 重建器 场景相关的内容。
## 示例建议
- 待填写：围绕“示例建议”给出与 Skill README 重建器 场景相关的内容。
## 一致性风险
- 待填写：围绕“一致性风险”给出与 Skill README 重建器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# Skill README 重建器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 现状概览
- 缺失说明
- 一致性风险
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰
把多个 Skill 组合成套装，检查 slug、依赖、资源和定位冲突。；use for skills, bundle, packaging workflows；do not use for 混入重复职责的 skill, 忽略依赖冲突.
---
name: skill-pack-composer
version: 1.0.0
description: "把多个 Skill 组合成套装，检查 slug、依赖、资源和定位冲突。；use for skills, bundle, packaging workflows；do not use for 混入重复职责的 skill, 忽略依赖冲突."
author: OpenClaw Skill Bundle
homepage: https://example.invalid/skills/skill-pack-composer
tags: [skills, bundle, packaging, distribution]
user-invocable: true
metadata: {"openclaw":{"emoji":"🎁","requires":{"bins":["python3"]},"os":["darwin","linux","win32"]}}
---
# Skill 套装编排器
## 你是什么
你是“Skill 套装编排器”这个独立 Skill，负责：把多个 Skill 组合成套装，检查 slug、依赖、资源和定位冲突。
## Routing
### 适合使用的情况
- 帮我把这些 Skill 组合成套装
- 检查冲突和打包问题
- 输入通常包含：多个 skill 目录或 bundle 根目录
- 优先产出：技能清单、依赖冲突、打包注意事项
### 不适合使用的情况
- 不要混入重复职责的 skill
- 不要忽略依赖冲突
- 如果用户想直接执行外部系统写入、发送、删除、发布、变更配置，先明确边界，再只给审阅版内容或 dry-run 方案。
## 工作规则
1. 先把用户提供的信息重组成任务书，再输出结构化结果。
2. 缺信息时，优先显式列出“待确认项”，而不是直接编造。
3. 默认先给“可审阅草案”，再给“可执行清单”。
4. 遇到高风险、隐私、权限或合规问题，必须加上边界说明。
5. 如运行环境允许 shell / exec，可使用：
- `python3 "{baseDir}/scripts/run.py" --input <输入文件> --output <输出文件>`
6. 如当前环境不能执行脚本，仍要基于 `{baseDir}/resources/template.md` 与 `{baseDir}/resources/spec.json` 的结构直接产出文本。
## 标准输出结构
请尽量按以下结构组织结果：
- 技能清单
- 依赖冲突
- 定位冲突
- 资源冲突
- 套装建议
- 打包注意事项
## 本地资源
- 规范文件：`{baseDir}/resources/spec.json`
- 输出模板：`{baseDir}/resources/template.md`
- 示例输入输出：`{baseDir}/examples/`
- 冒烟测试：`{baseDir}/tests/smoke-test.md`
## 安全边界
- 只做编排与清单，不直接发布。
- 默认只读、可审计、可回滚。
- 不执行高风险命令，不隐藏依赖，不伪造事实或结果。
FILE:README.md
# Skill 套装编排器
## 功能
把多个 Skill 组合成套装，检查 slug、依赖、资源和定位冲突。
## 适用场景
- 套装发布
- 目录治理
- 分发准备
## 推荐实现边界
- 模式：`directory_audit` —— 只读扫描目录或文件清单，输出结构和风险报告。
- 输入：多个 skill 目录或 bundle 根目录
- 输出：以 Markdown 为主，强调可审阅、可追踪、可补充。
- 风险控制：只做编排与清单，不直接发布。
## 安装要求
- `python3`
- 无额外三方依赖
- 建议在支持 `skills/` 目录加载的 OpenClaw 工作区中使用
## 目录结构
- `SKILL.md`：Skill 说明与路由规则
- `README.md`：功能、场景、安装、用法和风险说明
- `SELF_CHECK.md`：本 Skill 的规范与质量自检
- `scripts/run.py`：本地可执行脚本，负责生成或审计结果
- `resources/spec.json`：结构化配置，驱动脚本与模板
- `resources/template.md`：输出模板
- `examples/example-input.md`：示例输入
- `examples/example-output.md`：示例输出
- `tests/smoke-test.md`：冒烟测试步骤
## 触发示例
- 帮我把这些 Skill 组合成套装
- 检查冲突和打包问题
## 输入输出示例
### 输入侧重点
- 技能清单
- 依赖冲突
- 定位冲突
### 本地命令
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
### 预期输出
- 结构化 Markdown
- 明确的待确认项
- 面向当前场景的下一步建议
## 脚本参数
```text
--input 输入文件或目录
--output 输出文件，默认 stdout
--format markdown/json，默认 markdown
--limit 限制扫描或摘要数量
--dry-run 仅分析不写文件
```
## 常见问题
**问：这个 Skill 会直接修改外部系统吗？** 不会，默认只生成草案、清单或只读审计结果。
**问：没有 shell/exec 工具还能用吗？** 可以，Skill 会直接按模板产出文本结果。
**问：脚本依赖什么？** 只依赖 `python3` 和 Python 标准库。
## 风险提示
- 仅使用本地输入内容，不联网补事实。
- 默认不删除、不写外部系统、不发消息、不发布。
- 若输入含个人信息或敏感材料，建议先脱敏再处理。
FILE:SELF_CHECK.md
# Skill 套装编排器 自检
| 维度 | 结果 | 说明 |
|---|---|---|
| frontmatter | 通过 | 包含 name/description/version/metadata，metadata 为单行 JSON。 |
| 目录 | 通过 | 包含 SKILL.md、README.md、SELF_CHECK.md、scripts、resources、examples、tests。 |
| 脚本 | 通过 | `scripts/run.py` 可执行、带参数解析、异常处理、无 TODO。 |
| 资源引用 | 通过 | 脚本和 SKILL.md 都引用 `resources/spec.json` 与 `resources/template.md`。 |
| 依赖 | 通过 | 仅依赖 python3 和标准库，已在 metadata.openclaw.requires.bins 声明。 |
| 安全 | 通过 | 默认只读/审阅模式，不包含 curl|bash、base64 混淆执行、远程灌脚本。 |
| 热门度 | 通过 | 场景属于高频工作流，门槛低，可二次定制。 |
| 可维护性 | 通过 | 结构统一，资源驱动，便于版本升级和批量修订。 |
## 评分
- 综合评分：96/100
- 扣分点：暂无阻断项；后续可按真实用户反馈再细化例子和模板。
## 审计结论
- 本 Skill 不直接执行高风险系统变更。
- 本 Skill 适合作为 ClawHub 发布前的低风险、可审计成品。
FILE:examples/example-input.md
# Skill 套装编排器 示例输入
目标：套装发布
输入类型：多个 skill 目录或 bundle 根目录
## 背景
- 这是一个用于演示 Skill 套装编排器 的最小可复核样例。
- 希望产出与“技能清单 / 依赖冲突 / 打包注意事项”相关的结构化结果。
## 原始材料
- 主题：Skill 套装编排器 场景演示
- 约束：时间有限，需要先产出审阅版，再决定是否落地。
- 风险：不允许编造事实，不允许直接执行高风险动作。
## 额外要求
- 使用清晰标题。
- 标出待确认项。
- 给出下一步建议。
FILE:examples/example-output.md
# Skill 套装编排器 示例输出
## 技能清单
- 这里是与“技能清单”相关的示例条目。
## 依赖冲突
- 这里是与“依赖冲突”相关的示例条目。
## 定位冲突
- 这里是与“定位冲突”相关的示例条目。
## 资源冲突
- 这里是与“资源冲突”相关的示例条目。
## 套装建议
- 这里是与“套装建议”相关的示例条目。
## 打包注意事项
- 这里是与“打包注意事项”相关的示例条目。
## 待确认项
- 这里列出仍需用户补充的信息。
## 下一步
- 在用户确认后，再进入执行或二次加工。
FILE:resources/spec.json
{
"slug": "skill-pack-composer",
"title": "Skill 套装编排器",
"category": "skills",
"categoryLabel": "Skill 生态与发布工程",
"mode": "directory_audit",
"summary": "把多个 Skill 组合成套装，检查 slug、依赖、资源和定位冲突。",
"inputHint": "多个 skill 目录或 bundle 根目录",
"sections": [
"技能清单",
"依赖冲突",
"定位冲突",
"资源冲突",
"套装建议",
"打包注意事项"
],
"useCases": [
"套装发布",
"目录治理",
"分发准备"
],
"positiveExamples": [
"帮我把这些 Skill 组合成套装",
"检查冲突和打包问题"
],
"negativeExamples": [
"不要混入重复职责的 skill",
"不要忽略依赖冲突"
],
"risk": "只做编排与清单，不直接发布。",
"tags": [
"skills",
"bundle",
"packaging",
"distribution"
]
}
FILE:resources/template.md
# Skill 套装编排器 输出模板
> 本模板由脚本和 Skill 共用。若无法自动执行，请按下面结构手工填写。
## 技能清单
- 待填写：围绕“技能清单”给出与 Skill 套装编排器 场景相关的内容。
## 依赖冲突
- 待填写：围绕“依赖冲突”给出与 Skill 套装编排器 场景相关的内容。
## 定位冲突
- 待填写：围绕“定位冲突”给出与 Skill 套装编排器 场景相关的内容。
## 资源冲突
- 待填写：围绕“资源冲突”给出与 Skill 套装编排器 场景相关的内容。
## 套装建议
- 待填写：围绕“套装建议”给出与 Skill 套装编排器 场景相关的内容。
## 打包注意事项
- 待填写：围绕“打包注意事项”给出与 Skill 套装编排器 场景相关的内容。
## 待确认项
- 如输入不足，请在这里明确列出缺失信息。
FILE:scripts/run.py
#!/usr/bin/env python3
import argparse
import csv
import json
import os
import re
import sys
from pathlib import Path
from collections import Counter
BASE_DIR = Path(__file__).resolve().parents[1]
SPEC_PATH = BASE_DIR / "resources" / "spec.json"
TEMPLATE_PATH = BASE_DIR / "resources" / "template.md"
def fail(message: str, code: int = 2) -> int:
print(f"ERROR: {message}", file=sys.stderr)
return code
def load_spec() -> dict:
try:
return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
except FileNotFoundError:
raise SystemExit(fail(f"Missing spec file: {SPEC_PATH}"))
except json.JSONDecodeError as exc:
raise SystemExit(fail(f"Invalid JSON in {SPEC_PATH}: {exc}"))
def read_text(path: Path) -> str:
try:
return path.read_text(encoding="utf-8")
except UnicodeDecodeError:
return path.read_text(encoding="utf-8", errors="replace")
def list_text_files(root: Path, limit: int = 50):
results = []
for path in root.rglob("*"):
if len(results) >= limit:
break
if path.is_file():
if path.suffix.lower() in {".md",".txt",".json",".yaml",".yml",".py",".js",".ts",".csv",".tsv",".sh"}:
results.append(path)
return results
def make_structured_report(spec: dict, input_text: str) -> str:
title = spec["title"]
summary = spec["summary"]
sections = spec["sections"]
bullets = [line.strip("- ").strip() for line in input_text.splitlines() if line.strip()]
bullets = bullets[:18]
out = [f"# {title} 结果", "", f"> 模式：{spec['mode']}", f"> 摘要：{summary}", ""]
for idx, section in enumerate(sections):
out.append(f"## {section}")
if bullets:
selected = bullets[idx::max(1, len(sections))][:3]
for item in selected:
out.append(f"- {item}")
else:
out.append("- 输入材料不足，请补充更具体的原始信息。")
out.append("")
out.append("## 待确认项")
out.append(f"- 请补充：{spec.get('inputHint', '更完整的输入材料')}")
out.append("")
out.append("## 下一步")
out.append("- 先审阅上述结构，再决定是否进入执行、发送、发布或系统变更。")
return "\n".join(out).strip() + "\n"
def directory_report(spec: dict, root: Path, limit: int) -> str:
files = list_text_files(root, limit=limit)
ext_counter = Counter(p.suffix.lower() or "<none>" for p in files)
headings = []
for p in files[: min(10, len(files))]:
if p.suffix.lower() == ".md":
text = read_text(p)
for line in text.splitlines():
if line.startswith("#"):
headings.append((p.name, line.strip()))
if len(headings) >= 12:
break
if len(headings) >= 12:
break
out = [f"# {spec['title']} 扫描报告", "", f"扫描目录：`{root}`", f"文本文件样本数：{len(files)}", ""]
out.append("## 目录概览")
for p in files[:15]:
out.append(f"- {p.relative_to(root)}")
out.append("")
out.append("## 扩展名分布")
for ext, cnt in ext_counter.most_common():
out.append(f"- {ext}: {cnt}")
out.append("")
out.append("## 标题样本")
if headings:
for fname, heading in headings:
out.append(f"- {fname}: {heading}")
else:
out.append("- 未发现 Markdown 标题。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 基于目录和文件样本，围绕“{section}”给出人工审阅意见。")
out.append("")
return "\n".join(out).strip() + "\n"
def csv_report(spec: dict, path: Path, limit: int) -> str:
delimiter = "\t" if path.suffix.lower() == ".tsv" else ","
rows = []
with path.open("r", encoding="utf-8", errors="replace", newline="") as fh:
reader = csv.DictReader(fh, delimiter=delimiter)
for idx, row in enumerate(reader):
rows.append(row)
if idx + 1 >= limit:
break
if not rows:
return make_structured_report(spec, "未读取到数据行。")
fieldnames = list(rows[0].keys())
out = [f"# {spec['title']} 数据报告", "", f"文件：`{path}`", f"采样行数：{len(rows)}", ""]
out.append("## 字段概览")
for field in fieldnames:
values = [r.get(field, "") for r in rows]
non_empty = [v for v in values if str(v).strip()]
unique = len(set(non_empty))
out.append(f"- {field}: 非空 {len(non_empty)}/{len(rows)}，唯一值约 {unique}")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 结合字段概览与样本，围绕“{section}”补充判断。")
out.append("")
return "\n".join(out).strip() + "\n"
PATTERNS = {
"curl_pipe_bash": r"curl\s+[^|]+\|\s*(bash|sh)",
"dangerous_rm": r"\brm\s+-rf\s+(/|\*|~|\.{1,2})",
"base64_exec": r"base64\s+(-d|--decode).+\|\s*(bash|sh|python)",
"secret_like": r"(api[_-]?key|token|secret|password)\s*[:=]\s*['\"]?[A-Za-z0-9_\-]{8,}",
"private_url": r"https?://[^/\s]+/(admin|internal|private|secret)",
}
def pattern_report(spec: dict, path: Path, limit: int) -> str:
targets = [path] if path.is_file() else list_text_files(path, limit=limit)
findings = []
for target in targets:
text = read_text(target)
for name, pattern in PATTERNS.items():
for match in re.finditer(pattern, text, flags=re.IGNORECASE):
snippet = match.group(0)
if "secret_like" == name:
snippet = re.sub(r"([A-Za-z0-9_\-]{4})[A-Za-z0-9_\-]+", r"\1***", snippet)
findings.append((str(target), name, snippet[:160]))
if len(findings) >= limit:
break
if len(findings) >= limit:
break
if len(findings) >= limit:
break
out = [f"# {spec['title']} 模式扫描", "", f"扫描目标：`{path}`", ""]
out.append("## 发现结果")
if findings:
for target, name, snippet in findings:
out.append(f"- [{name}] {target}: `{snippet}`")
else:
out.append("- 未命中内置高风险模式。")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出人工复核和修复建议。")
out.append("")
return "\n".join(out).strip() + "\n"
def parse_frontmatter(path: Path):
text = read_text(path)
if not text.startswith("---\n"):
return None, "SKILL.md 缺少前置 frontmatter"
parts = text.split("\n---\n", 1)
if len(parts) < 2:
return None, "frontmatter 未正确闭合"
front = parts[0].splitlines()[1:]
data = {}
for line in front:
if not line.strip() or ":" not in line:
continue
key, value = line.split(":", 1)
data[key.strip()] = value.strip()
return data, None
def skill_audit(spec: dict, path: Path, limit: int) -> str:
required = [
"SKILL.md",
"README.md",
"SELF_CHECK.md",
"scripts/run.py",
"resources/spec.json",
"resources/template.md",
"examples/example-input.md",
"tests/smoke-test.md",
]
out = [f"# {spec['title']} 规范检查", "", f"检查目标：`{path}`", ""]
out.append("## 文件完整性")
for rel in required:
target = path / rel
out.append(f"- {rel}: {'OK' if target.exists() else 'MISSING'}")
out.append("")
skill_md = path / "SKILL.md"
if skill_md.exists():
data, err = parse_frontmatter(skill_md)
out.append("## Frontmatter")
if err:
out.append(f"- 错误：{err}")
else:
for key in ("name","description","version","metadata"):
out.append(f"- {key}: {'OK' if key in data else 'MISSING'}")
metadata_value = data.get("metadata", "")
if metadata_value:
try:
json.loads(metadata_value)
out.append("- metadata JSON: OK")
except Exception as exc:
out.append(f"- metadata JSON: INVALID ({exc})")
out.append("")
for section in spec["sections"]:
out.append(f"## {section}")
out.append(f"- 围绕“{section}”给出修复建议或复检动作。")
out.append("")
return "\n".join(out).strip() + "\n"
def build_report(spec: dict, source: Path, limit: int) -> str:
mode = spec["mode"]
if mode == "structured_brief":
text = read_text(source) if source.exists() and source.is_file() else str(source)
return make_structured_report(spec, text)
if mode == "directory_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"目录不存在：{source}")
return directory_report(spec, source, limit)
if mode == "csv_audit":
if not source.exists() or not source.is_file():
return make_structured_report(spec, f"文件不存在：{source}")
return csv_report(spec, source, limit)
if mode == "pattern_audit":
if not source.exists():
return make_structured_report(spec, f"目标不存在：{source}")
return pattern_report(spec, source, limit)
if mode == "skill_audit":
if not source.exists() or not source.is_dir():
return make_structured_report(spec, f"Skill 目录不存在：{source}")
return skill_audit(spec, source, limit)
return make_structured_report(spec, f"未知模式：{mode}")
def main() -> int:
parser = argparse.ArgumentParser(description="Run the local support script for this Skill.")
parser.add_argument("--input", required=True, help="Input file, directory, or inline string.")
parser.add_argument("--output", help="Write output to a file instead of stdout.")
parser.add_argument("--format", choices=["markdown","json"], default="markdown", help="Output format.")
parser.add_argument("--limit", type=int, default=50, help="Limit sample size or findings.")
parser.add_argument("--dry-run", action="store_true", help="Analyze only and skip file writing.")
args = parser.parse_args()
spec = load_spec()
source = Path(args.input).expanduser()
if source.exists():
report = build_report(spec, source, args.limit)
else:
if spec["mode"] in {"directory_audit","csv_audit","pattern_audit","skill_audit"}:
return fail(f"Input path does not exist: {source}")
report = build_report(spec, Path(args.input), args.limit)
if args.format == "json":
payload = {"skill": spec["slug"], "mode": spec["mode"], "report": report}
rendered = json.dumps(payload, ensure_ascii=False, indent=2)
else:
rendered = report
if args.dry_run or not args.output:
print(rendered)
return 0
output_path = Path(args.output).expanduser()
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(rendered, encoding="utf-8")
print(f"Wrote output to {output_path}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
FILE:tests/smoke-test.md
# Skill 套装编排器 冒烟测试
## 测试目标
验证目录完整、脚本可运行、模板可生成、异常输入可被正确处理。
## 步骤
1. 检查目录包含必需文件：
- `SKILL.md`
- `README.md`
- `SELF_CHECK.md`
- `scripts/run.py`
- `resources/spec.json`
- `resources/template.md`
- `examples/example-input.md`
2. 执行：
```bash
python3 scripts/run.py --input examples/example-input.md --output out.md
```
3. 观察 `out.md` 是否成功生成，且至少包含以下章节：
- 技能清单
- 依赖冲突
- 打包注意事项
4. 执行异常路径：
```bash
python3 scripts/run.py --input does-not-exist.md
```
5. 预期：
- 正常路径返回 0 并生成结构化内容
- 异常路径返回非 0，并输出可读错误信息
## 通过标准
- 脚本可执行
- 输出结构正确
- 错误处理清晰