clearai-dsh 0.3.0 → 0.4.0

package/presets/clearai/template/skills/web-artifact/references/when-drawing-a-topology.md

@@ -1,150 +0,0 @@
-# 画一张拓扑图
-
-流程与空间拓扑图这一门类的具体工艺。目标是让关系可读到足以评审与建模讨论，不是复刻一张
-完整的 PFD——每条 DCS 管线、每个阀门、每种公用介质都画上去，反而没人能看出接错了哪一根。
-
-## 布局契约是 ELK JSON
-
-```text
-工艺理解 → ELK 输入 JSON → ELK 输出 JSON → 单文件 HTML
-```
-
-不要先去设计一套完美的通用图 schema。先把这张拓扑画得能看懂；等几张图之后稳定的结构自己
-浮现出来，再谈抽象。中间的输入与输出 JSON 都留盘，这样布局质量的问题和渲染的问题能分开
-定位——图不好看时，先看是 ELK 排得不好，还是渲染器画错了。
-
-```bash
-node scripts/render_topology.js \
-  --elk-input  topo.json \
-  --elk-output topo.laid.json \
-  --out        topo.html \
-  --title "蒸发工段拓扑检查" \
-  --source topo.json \
-  --proves "设备间的物料与公用工程连接关系" \
-  --not-proves "阀门、控制回路与管径"
-```
-
-## 参数基线
-
-工业流程链走 `layered`，从左到右，正交走线：
-
-```json
-{
-  "id": "root",
-  "layoutOptions": {
-    "elk.algorithm": "layered",
-    "elk.direction": "RIGHT",
-    "elk.edgeRouting": "ORTHOGONAL",
-    "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
-    "elk.layered.cycleBreaking.strategy": "MODEL_ORDER",
-    "elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
-    "elk.layered.crossingMinimization.strategy": "LAYER_SWEEP",
-    "elk.layered.unnecessaryBendpoints": "true",
-    "elk.spacing.nodeNode": "34",
-    "elk.spacing.edgeNode": "22",
-    "elk.spacing.edgeEdge": "14",
-    "elk.spacing.labelNode": "8",
-    "elk.layered.spacing.nodeNodeBetweenLayers": "62"
-  },
-  "children": [
-    {"id": "feed", "width": 150, "height": 46,
-     "labels": [{"text": "过滤来精液"}, {"text": "Inlet"}],
-     "properties": {"位号": "V-101"}},
-    {"id": "plate", "width": 150, "height": 46,
-     "labels": [{"text": "板换组"}, {"text": "HeatExchanger"}]}
-  ],
-  "edges": [
-    {"id": "m01", "sources": ["feed"], "targets": ["plate"],
-     "labels": [{"text": "精液"}],
-     "properties": {"role": "main", "medium": "精液", "relation": "主物料"}}
-  ]
-}
-```
-
-`labels[0]` 是节点主名，`labels[1]` 渲染成副标题。`properties` 里除 `role` 与 `elk.*`
-之外的键会原样透传到侧栏——位号、设计参数、出处、备注都可以放，渲染器不挑。
-
-## 关系分类
-
-每条可见的边都该声明 `properties.role`，它是边的颜色与线型的唯一来源：
-
-| role | 含义 |
-|---|---|
-| `main` | 主物料/主工艺链 |
-| `branch` | 次要物料支线或旁路去向 |
-| `seed` | 晶种、料浆一类的返回关系 |
-| `recycle` | 母液、滤液、溢流、循环回用 |
-| `utility` | 水、汽、风、清洗、冷却、控制等公用介质 |
-| `unknown` | 有意义但尚未确认的关系 |
-
-**工业拓扑图里缺 role 是缺陷**：一张图上分不出主链与公用管线，评审的人得逐条问你。生成器
-遇到缺 role 的边会给出提示，并按中性样式渲染——它不会替你伪造成 `unknown`，因为「作者说这
-条不确定」和「这张图不用关系分类」是两回事，混在一起会让极简图整张报成存疑。
-
-拿不准某条关系时，显式写 `role: "unknown"`，把不确定留在 `properties.note` 里。这些边会被
-自动汇总进页面顶部的入口区，专家一打开就先看它们。
-
-## 排序规则
-
-主链清楚时：
-
-1. `children` 里主链节点排在最前，按工艺顺序。
-2. `edges` 里主链边排在最前，按工艺顺序。
-3. 旁系、返回、支线节点排在主链之后。
-4. 保留 `considerModelOrder.strategy: NODES_AND_EDGES`。
-5. 有回路把主链顺序搅乱时，用 `cycleBreaking.strategy: MODEL_ORDER`。
-
-这不只是好看的问题。工业图里回路很常见，而 ELK 默认会优先考虑断环，断出来的顺序未必符合
-工艺上的心智顺序。model order 是把「你认为的主链是哪条」这件事告诉 ELK 的唯一途径。
-
-若某条返回边在视觉上压过了主链，可以只为布局把它反向，同时在渲染出的元数据里保留真实
-流向——用了就在 `properties.note` 里写明，别让后来者以为工艺反了。
-
-## 密度只调 ELK
-
-标签贴到节点、走线挤在一起时，调 spacing，不要去改坐标：
-
-- `elk.layered.spacing.nodeNodeBetweenLayers` — 横向段落的长短
-- `elk.spacing.edgeNode` — 线离节点太近时
-- `elk.spacing.edgeEdge` — 并行边挤在一起时
-- `elk.spacing.labelNode` — 标签离线或节点太近时
-
-先从紧凑值起步，撞上了再放。
-
-## 节点里放什么
-
-克制。概览图的节点只放两行：
-
-```text
-设备名
-简短类型
-```
-
-变量表、DCS 点位、长假设、会撑大节点的徽标，都不要塞进节点——它们让每个盒子尺寸不可预测，
-布局随之抖动。这些内容放侧栏，通过 `properties` 透传过去，点选时再看。
-
-## 边标签
-
-短，面向介质：`精液`、`冷却精液`、`精液+细晶种`、`附聚料浆`、`粗种子`、`母液/滤液`。
-
-解释性的长句放侧栏，不放线上。一条线上挂一句话，图就没法看了。
-
-## 验证
-
-生成后在浏览器里确认（用 http origin，`file://` 下某些宿主不跑 requestAnimationFrame）：
-
-```js
-window.__RENDERED__          // {nodes, edges, labels} —— 与源数据计数比对
-document.querySelectorAll('.node').length
-document.querySelectorAll('.edge').length
-document.querySelectorAll('.legend label').length   // 关系类别数
-```
-
-要看的是：页面不空白、控制台无错误、节点与边的数量对得上、多种关系并存时图例里能分辨、
-缩放平移只影响画布而不动页面其他部分。
-
-## 以后再抽象
-
-几张图跑顺之后，再考虑把工艺事实抽成 `graph.yaml`、把视觉意图抽成 `view.yaml`、把点位绑定
-抽成 `data_bindings.yaml`，以及一个从它们生成 ELK JSON 的转换器。在那之前，ELK JSON 保持
-显式且可检查——它现在就是布局契约。

package/presets/clearai/template/skills/web-artifact/references/when-the-page-must-work-offline.md

@@ -1,62 +0,0 @@
-# 页面必须能离线打开
-
-制品的读者常常不在 Workbench 里，也未必有网。会议室、客户现场、飞机上、内网隔离的工位——
-一份打开是白屏的评审件等于没交付。
-
-## 约束的本意
-
-**运行时零网络请求。** 构建期随便联网（本技能自己就在构建期跑 ELK 布局、算摘要）。
-
-把本意记住比记住禁令有用。「不许引 CDN」只覆盖了一种情况，而实际会漏网的有好几处：
-
-- Google Fonts 也是外部请求。所以字体只用系统栈，`system-ui` 打头，中文补
-  `PingFang SC` 与 `Microsoft YaHei`。想要更强的字体个性，代价是把字体文件内联成
-  data URI——通常不值得，除非是对外交付档。
-- 图片走 data URI，或者干脆用 SVG 画出来。
-- `<link rel="preconnect">`、`<link rel="dns-prefetch">` 这类提示也删掉，它们没用且误导。
-- 动态 `import()` 一个裸模块名同样会失败，因为没有 import map，也不该有。
-
-`scripts/check_artifact.py` 会把这几类都扫一遍。
-
-## 体积预算
-
-原生渲染器的产物大致这样构成：
-
-| 部分 | 量级 |
-|---|---|
-| 渲染器 JS | ~13 KB |
-| 样式 | ~6 KB |
-| 页面骨架 | ~2 KB |
-| 数据 | 随规模，7 节点约 5 KB |
-| **合计** | **20–40 KB** |
-
-作为对照，内联 React + ReactDOM + 一个图库轻松到 450 KB 以上，换来的能力在检查类制品上
-基本用不到。详见 [SKILL.md](../SKILL.md) 的「为什么不用框架」。
-
-真需要一个重型库时（比如某种专门的图表），先问它是否只在构建期需要——布局、统计、聚合都
-可以在生成时算完，把结果写进数据，浏览器端只负责画。本技能的 ELK 就是这么用的：1.6 MB 的
-布局引擎跑在 node 端，一个字节都没进产物。
-
-## 与 App 侧 freeze 的区别
-
-两者都产出一个能双击打开的自包含文件，来路完全不同：
-
-| | 本技能的制品 | App 侧的 freeze |
-|---|---|---|
-| 来源 | 数据文件 | 运行中的 App 实例 |
-| 重新生成 | 改数据再跑一次生成器 | 需要实例还活着 |
-| 版本标识 | 源数据摘要 | source revision |
-| 场景 | 还没建 App，或根本不需要 | 已有 App，要给圈外人看当前状态 |
-
-判断见「你可能还不需要 App」
-一节。
-
-## 自查
-
-```bash
-grep -oE 'https?://[^"'"'"' )]+' out/artifact.html | grep -v w3.org
-python3 scripts/check_artifact.py out/artifact.html --source data.json
-```
-
-真要确认，断网后双击打开一次。这一步只花十秒，而它挡住的是「专家打开是白屏」这种当场
-丢脸的事故。

package/presets/clearai/template/skills/web-artifact/scripts/check_artifact.py

@@ -1,167 +0,0 @@
-#!/usr/bin/env python3
-"""单文件网页制品的确定性检查。
-
-能规则化的判断不交给 LLM。全部 PASS 才算可交付。
-
-    python3 check_artifact.py out/topology.html [--source data.json]
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-
-FAILED: list[str] = []
-PASSED = 0
-RESULTS: list[dict] = []
-
-# SVG/XML 命名空间是标识符，浏览器不会去取它
-ALLOWED_URLS = {
-    "http://www.w3.org/2000/svg",
-    "http://www.w3.org/1999/xlink",
-    "http://www.w3.org/XML/1998/namespace",
-}
-
-
-def check(name: str, ok: bool, detail: str = "") -> None:
-    global PASSED
-    RESULTS.append({"check": name, "ok": bool(ok), "detail": detail})
-    if ok:
-        PASSED += 1
-    else:
-        FAILED.append(name)
-
-
-def check_offline(html: str) -> None:
-    """运行时零网络请求：产物在没网的环境里也要完整打开。"""
-    urls = {u.rstrip('\'").,;') for u in re.findall(r"https?://[^\s\"'<>)]+", html)}
-    leaked = sorted(u for u in urls if u not in ALLOWED_URLS)
-    check("offline.no_external_url", not leaked,
-          f"{len(leaked)} 处外部引用：{leaked[:3]}")
-
-    tags = re.findall(r"<(script|link|img|iframe|source|video|audio)\b[^>]*>", html, re.I)
-    external = [t for t in tags if re.search(r"\b(src|href)\s*=\s*[\"'](?!#|data:)", t)]
-    check("offline.no_external_asset_tag", not external, f"{external[:2]}")
-
-    check("offline.no_import_map", "importmap" not in html)
-    check("offline.no_bare_import",
-          not re.search(r"\bimport\s+.*\bfrom\s+[\"'](?!\.|/|data:)", html))
-
-
-def check_provenance(html: str) -> dict:
-    """制品要自陈来历：从什么生成、什么时候、生成器是谁。"""
-    m = re.search(r'<script id="artifact-data"[^>]*>(.*?)</script>', html, re.S)
-    check("data.embedded", bool(m), "找不到内嵌数据块")
-    if not m:
-        return {}
-    try:
-        data = json.loads(m.group(1).replace("\\u003c", "<"))
-    except json.JSONDecodeError as exc:
-        check("data.valid_json", False, str(exc))
-        return {}
-    check("data.valid_json", True)
-
-    prov = data.get("provenance") or {}
-    check("provenance.generated_at", bool(prov.get("generatedAt")))
-    check("provenance.generator", bool(prov.get("generator")))
-
-    footer = re.search(r"<footer>(.*?)</footer>", html, re.S)
-    check("provenance.visible_in_page",
-          bool(footer and prov.get("generator", "?") in footer.group(1)),
-          "页脚没有把来历写出来，读者看不到")
-    return data
-
-
-def check_graph(data: dict, source: Path | None) -> None:
-    graph = data.get("graph") or {}
-    nodes, edges = graph.get("nodes") or [], graph.get("edges") or []
-    check("graph.non_empty", bool(nodes), "没有任何节点")
-
-    ids = [n.get("id") for n in nodes] + [e.get("id") for e in edges]
-    check("graph.ids_present", all(ids), "存在缺 id 的元素")
-    check("graph.ids_unique", len(ids) == len(set(ids)),
-          "id 重复会让标注对不回来")
-
-    node_ids = {n.get("id") for n in nodes}
-    dangling = [e.get("id") for e in edges
-                if e.get("source") not in node_ids or e.get("target") not in node_ids]
-    check("graph.no_dangling_edge", not dangling, f"悬挂边 {dangling[:3]}")
-
-    no_points = [e.get("id") for e in edges if len(e.get("points") or []) < 2]
-    check("graph.edges_have_geometry", not no_points,
-          f"{len(no_points)} 条边没有布局器给的路径点")
-
-    if source and source.exists():
-        try:
-            src = json.loads(source.read_text())
-        except json.JSONDecodeError:
-            return
-        sn, se = len(src.get("children") or []), len(src.get("edges") or [])
-        check("graph.node_count_matches_source", sn == len(nodes), f"源 {sn} / 产物 {len(nodes)}")
-        check("graph.edge_count_matches_source", se == len(edges), f"源 {se} / 产物 {len(edges)}")
-
-
-def check_theme(html: str) -> None:
-    """三态都要有：显式 light、显式 dark、以及什么都没标的系统态。"""
-    check("theme.root_tokens", ":root {" in html or ":root{" in html)
-    check("theme.system_dark",
-          bool(re.search(r"prefers-color-scheme:\s*dark", html)),
-          "缺了未标记的系统态，最常见的漏配")
-    check("theme.explicit_dark", '[data-theme="dark"]' in html)
-    check("theme.body_background",
-          bool(re.search(r"body\s*\{[^}]*background", html, re.S)),
-          "body 不上底色会借用宿主的底，深浅主题下会串")
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("artifact", type=Path)
-    ap.add_argument("--source", type=Path, default=None,
-                    help="源数据，给了就比对计数")
-    ap.add_argument("--json", type=Path, default=None,
-                    help="把结果写成 JSON，供 done_criteria 引用")
-    args = ap.parse_args()
-
-    if not args.artifact.exists():
-        print(f"找不到 {args.artifact}")
-        return 2
-
-    html = args.artifact.read_text(encoding="utf-8")
-    size_kb = args.artifact.stat().st_size / 1024
-
-    check_offline(html)
-    data = check_provenance(html)
-    if data:
-        check_graph(data, args.source)
-    check_theme(html)
-
-    print(f"检查 {args.artifact}（{size_kb:.0f} KB）\n")
-    for r in RESULTS:
-        mark = "PASS" if r["ok"] else "FAIL"
-        line = f"  {mark}  {r['check']}"
-        if not r["ok"] and r["detail"]:
-            line += f" — {r['detail']}"
-        print(line)
-
-    total = PASSED + len(FAILED)
-    print(f"\n{PASSED}/{total} 通过" + (f"，失败：{', '.join(FAILED)}" if FAILED else ""))
-
-    if args.json:
-        args.json.write_text(json.dumps({
-            "artifact": str(args.artifact),
-            "size_kb": round(size_kb, 1),
-            "passed": PASSED,
-            "total": total,
-            "ok": not FAILED,
-            "failed": FAILED,
-            "checks": RESULTS,
-        }, ensure_ascii=False, indent=2), encoding="utf-8")
-        print(f"结果已写入 {args.json}")
-
-    return 1 if FAILED else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/presets/clearai/template/skills/web-artifact/scripts/render_topology.js

@@ -1,272 +0,0 @@
-#!/usr/bin/env node
-/* 拓扑检查件生成器 —— ELK 算几何，原生 SVG 渲染，产出零外部请求的单文件 HTML。
- *
- *   node render_topology.js --elk-input in.json --out topology.html --title "流程拓扑检查"
- *   node render_topology.js --elk-output laid-out.json --out topology.html
- *
- * 数据无关：节点与边上除 ELK 必需字段之外的属性原样透传给渲染器，有就在侧栏展示。
- * 本脚本不要求输入数据带任何自定义字段。
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-const VERSION = '1.0.0';
-const HERE = __dirname;
-const ASSETS = path.join(HERE, '..', 'assets');
-
-function parseArgs(argv) {
-  const out = {};
-  for (let i = 2; i < argv.length; i++) {
-    const a = argv[i];
-    if (!a.startsWith('--')) continue;
-    const key = a.slice(2);
-    const next = argv[i + 1];
-    if (next && !next.startsWith('--')) { out[key] = next; i++; } else { out[key] = true; }
-  }
-  return out;
-}
-
-function usage() {
-  console.log([
-    '用法：',
-    '  --elk-input <file>    ELK 输入 JSON；给了就先在本地跑 elkjs',
-    '  --elk-output <file>   ELK 输出 JSON；作为输入时直接渲染，作为输出时留盘备查',
-    '  --out <file>          产出的 HTML（必填）',
-    '  --title <text>        页面标题',
-    '  --source <path>       源数据路径，用于页脚自陈来历并算摘要',
-    '  --proves <text>       这份东西证明了什么',
-    '  --not-proves <text>   它不证明什么',
-    '  --annotations <file>  预置已有标注，形状同导出的 annotations.json',
-    '',
-    'ELK 输入与输出都留盘，是为了让布局问题与渲染问题能分开定位。'
-  ].join('\n'));
-}
-
-/* ── ELK：只在本地 vendor 里找，不下载 ── */
-async function runElk(input) {
-  const bundle = path.join(ASSETS, 'vendor', 'elkjs', 'elk.bundled.js');
-  if (!fs.existsSync(bundle)) {
-    throw new Error('缺少 ' + bundle + '（见同目录 UPSTREAM.md 的获取步骤）');
-  }
-  const ELK = require(bundle);
-  return new ELK().layout(input);
-}
-
-/* ── ELK 输出 → 渲染器数据 ── */
-const NODE_RESERVED = new Set(['id', 'x', 'y', 'width', 'height', 'labels', 'properties', 'layoutOptions', 'children', 'ports', 'edges']);
-const EDGE_RESERVED = new Set(['id', 'sources', 'targets', 'sections', 'labels', 'properties', 'source', 'target', 'container', 'junctionPoints']);
-const ROLES = new Set(['main', 'branch', 'seed', 'recycle', 'utility', 'unknown']);
-
-function labelOf(o, i) {
-  if (!o) return undefined;
-  if (i === 0 && typeof o.label === 'string') return o.label;
-  if (i === 1 && typeof o.sub === 'string') return o.sub;
-  const L = o.labels || [];
-  return L[i] && typeof L[i].text === 'string' ? L[i].text : undefined;
-}
-
-function passthrough(obj, reserved) {
-  const extra = {};
-  Object.keys(obj || {}).forEach(k => {
-    if (reserved.has(k) || k === 'label' || k === 'sub') return;
-    if (k.charAt(0) === '$') return;              // elkjs 转译产物的内部字段
-    const v = obj[k];
-    if (v == null || typeof v === 'function') return;
-    extra[k] = v;
-  });
-  Object.keys((obj && obj.properties) || {}).forEach(k => {
-    const v = obj.properties[k];
-    if (v == null) return;
-    if (typeof k === 'string' && k.indexOf('elk.') === 0) return;   // ELK 自己的布局属性不外泄
-    extra[k] = v;
-  });
-  return extra;
-}
-
-function edgePoints(edge) {
-  const s = (edge.sections || [])[0];
-  if (!s) return [];
-  const pts = [];
-  if (s.startPoint) pts.push([s.startPoint.x, s.startPoint.y]);
-  (s.bendPoints || []).forEach(p => pts.push([p.x, p.y]));
-  if (s.endPoint) pts.push([s.endPoint.x, s.endPoint.y]);
-  return pts;
-}
-
-function toGraph(layout) {
-  const nodes = (layout.children || []).map(c => {
-    const n = {
-      id: c.id,
-      x: c.x || 0, y: c.y || 0,
-      width: c.width || 120, height: c.height || 40,
-      label: labelOf(c, 0) || c.id
-    };
-    const sub = labelOf(c, 1);
-    if (sub) n.sub = sub;
-    Object.assign(n, passthrough(c, NODE_RESERVED));
-    return n;
-  });
-
-  const edges = (layout.edges || []).map(e => {
-    const props = e.properties || {};
-    // 显式声明的 role 才采用。缺失时不伪造 unknown——「作者说不确定」与
-    // 「这张图不用 role 语义」是两回事，混为一谈会把极简图全报成存疑。
-    const role = ROLES.has(props.role) ? props.role : (ROLES.has(e.role) ? e.role : null);
-    const o = {
-      id: e.id,
-      source: (e.sources || [e.source])[0],
-      target: (e.targets || [e.target])[0],
-      points: edgePoints(e)
-    };
-    if (role) o.role = role;
-    const lab = (e.labels || [])[0];
-    const text = labelOf(e, 0);
-    if (text) {
-      o.label = text;
-      if (lab && lab.x != null) {
-        o.labelX = lab.x + (lab.width || 0) / 2;
-        o.labelY = lab.y + (lab.height || 0) / 2 + 3;
-      }
-    }
-    Object.assign(o, passthrough(e, EDGE_RESERVED));
-    if (role) o.role = role; else delete o.role;
-    return o;
-  });
-
-  return { nodes, edges };
-}
-
-/* 入口区：只用契约内已有的语义（role=unknown），不引入新字段。
-   数据里自带 entry 时以数据为准。 */
-function buildEntry(src, graph) {
-  if (Array.isArray(src.entry)) return src.entry;
-  const unknown = graph.edges.filter(e => e.role === 'unknown').map(e => e.id);   // 只算显式声明的
-  const items = [];
-  if (unknown.length) items.push({ label: '关系存疑', count: unknown.length, ids: unknown });
-  const isolated = graph.nodes
-    .filter(n => !graph.edges.some(e => e.source === n.id || e.target === n.id))
-    .map(n => n.id);
-  if (isolated.length) items.push({ label: '孤立节点', count: isolated.length, ids: isolated });
-  return items;
-}
-
-function esc(s) {
-  return String(s == null ? '' : s)
-    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
-}
-
-function html(payload, title) {
-  const css = fs.readFileSync(path.join(ASSETS, 'renderer', 'renderer.css'), 'utf8');
-  const js = fs.readFileSync(path.join(ASSETS, 'renderer', 'renderer.js'), 'utf8');
-  const p = payload.provenance || {};
-  const data = JSON.stringify(payload).replace(/</g, '\\u003c');
-
-  const foot = [
-    p.source ? '<b>源数据</b> ' + esc(p.source) + (p.digest ? ' · ' + esc(p.digest) : '') : '',
-    p.generatedAt ? '<b>生成于</b> ' + esc(p.generatedAt) : '',
-    '<b>生成器</b> render_topology ' + esc(p.generator || VERSION)
-  ].filter(Boolean).join(' &nbsp;·&nbsp; ');
-
-  const claims = [
-    p.proves ? '<b>证明</b>：' + esc(p.proves) : '',
-    p.doesNotProve ? '<b>不证明</b>：' + esc(p.doesNotProve) : ''
-  ].filter(Boolean).join('　');
-
-  return `<!doctype html>
-<html lang="zh-CN">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<title>${esc(title)}</title>
-<style>
-${css}
-</style>
-</head>
-<body>
-<header>
-  <h1>${esc(title)}</h1>
-  <span class="counts" id="counts"></span>
-  <span class="spacer"></span>
-  <button class="chip" id="fit">适应窗口</button>
-  <button class="chip" id="export" disabled>导出反馈</button>
-  <button class="chip" id="theme" aria-pressed="false">深色</button>
-</header>
-<div id="entry"></div>
-<main>
-  <div id="stage">
-    <svg id="canvas" aria-label="${esc(title)}"></svg>
-    <div id="minimap" aria-hidden="true"></div>
-  </div>
-  <aside id="side" class="empty"></aside>
-</main>
-<div class="legend" id="legend"></div>
-<footer>
-  ${foot}
-  ${claims ? '<div class="claims">' + claims + '</div>' : ''}
-</footer>
-<script id="artifact-data" type="application/json">${data}</script>
-<script>
-window.__ARTIFACT__ = JSON.parse(document.getElementById('artifact-data').textContent);
-${js}
-</script>
-</body>
-</html>
-`;
-}
-
-async function main() {
-  const args = parseArgs(process.argv);
-  if (args.help || (!args['elk-input'] && !args['elk-output']) || !args.out) { usage(); return 1; }
-
-  let layout;
-  if (args['elk-input']) {
-    const input = JSON.parse(fs.readFileSync(args['elk-input'], 'utf8'));
-    layout = await runElk(input);
-    if (args['elk-output'] && typeof args['elk-output'] === 'string') {
-      fs.writeFileSync(args['elk-output'], JSON.stringify(layout, null, 2));
-    }
-  } else {
-    layout = JSON.parse(fs.readFileSync(args['elk-output'], 'utf8'));
-  }
-
-  const srcRaw = args['elk-input'] ? JSON.parse(fs.readFileSync(args['elk-input'], 'utf8')) : layout;
-  const graph = toGraph(layout);
-
-  const provenance = { generatedAt: new Date().toISOString(), generator: VERSION };
-  if (typeof args.source === 'string') {
-    provenance.source = args.source;
-    if (fs.existsSync(args.source)) {
-      provenance.digest = 'sha256:' + crypto.createHash('sha256')
-        .update(fs.readFileSync(args.source)).digest('hex').slice(0, 12);
-    }
-  }
-  if (typeof args.proves === 'string') provenance.proves = args.proves;
-  if (typeof args['not-proves'] === 'string') provenance.doesNotProve = args['not-proves'];
-
-  let annotations = [];
-  if (typeof args.annotations === 'string' && fs.existsSync(args.annotations)) {
-    const a = JSON.parse(fs.readFileSync(args.annotations, 'utf8'));
-    annotations = Array.isArray(a) ? a : (a.annotations || []);
-  }
-
-  const title = typeof args.title === 'string' ? args.title : '拓扑检查';
-  const payload = { title, provenance, graph, entry: buildEntry(srcRaw, graph), annotations };
-
-  fs.writeFileSync(args.out, html(payload, title));
-  const noRole = graph.edges.filter(e => !e.role).length;
-  if (noRole) {
-    console.log('提示：' + noRole + '/' + graph.edges.length +
-      ' 条边没有声明 properties.role，已按中性样式渲染。' +
-      '工业流程拓扑里这通常是缺陷，见 references/when-drawing-a-topology.md。');
-  }
-  console.log('已生成 ' + args.out +
-    '（' + graph.nodes.length + ' 节点 / ' + graph.edges.length + ' 连线 / ' +
-    (fs.statSync(args.out).size / 1024).toFixed(0) + ' KB）');
-  return 0;
-}
-
-main().then(c => process.exit(c || 0)).catch(e => { console.error(String(e && e.message || e)); process.exit(1); });

package/presets/clearai/template/skills/what-if-oracle/LICENSE.txt

@@ -1,5 +0,0 @@
-What-If Oracle skill adapted from:
-https://github.com/ashrafkahoush-ux/claude-consciousness-skills
-
-Licensed under CC BY-NC-SA 4.0
-https://creativecommons.org/licenses/by-nc-sa/4.0/