dsh-plugin-agentflow 0.0.0-stage → 0.2.1

package/runtime/skills.mjs

@@ -0,0 +1,131 @@
+// skills.mjs —— 扫描并加载 skill。
+//
+// skill 就是一个目录，里面有 SKILL.md：
+//   ---
+//   name: code-review
+//   description: 审查 diff 的清单
+//   ---
+//   正文……
+//
+// 这里只做两件事：列出有哪些 skill、把某个 skill 的正文读出来拼进 prompt。
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.dirname(fileURLToPath(import.meta.url));
+
+/** 默认扫描的目录：本机的 + 项目自带的 */
+export function defaultSkillDirs() {
+  return [
+    path.join(ROOT, 'skills'),
+    path.join(os.homedir(), '.dsh', 'skills'),
+  ];
+}
+
+/** 极简 frontmatter 解析：认 --- 包起来的那段 key: value，支持 > / | 块标量 */
+function parseFrontmatter(text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+  if (!m) return { meta: {}, body: text };
+  const lines = m[1].split(/\r?\n/);
+  const meta = {};
+
+  for (let i = 0; i < lines.length; i++) {
+    const kv = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(lines[i]);
+    if (!kv) continue;
+    const key = kv[1];
+    let val = kv[2].trim();
+
+    // 块标量：description: > 后面跟一段缩进的多行文字
+    if (/^[>|][+-]?$/.test(val)) {
+      const folded = val.startsWith('>');
+      const buf = [];
+      let j = i + 1;
+      for (; j < lines.length; j++) {
+        const line = lines[j];
+        if (/^\s+\S/.test(line)) buf.push(line.trim());
+        else if (/^\s*$/.test(line)) buf.push('');
+        else break;
+      }
+      i = j - 1;
+      val = folded ? buf.join(' ').replace(/\s+/g, ' ').trim() : buf.join('\n').trim();
+    }
+
+    // 去掉成对的引号
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    meta[key] = val;
+  }
+  return { meta, body: text.slice(m[0].length) };
+}
+
+/**
+ * 列出所有 skill。
+ * @returns [{ name, description, path, dir }]
+ */
+export async function listSkills(dirs) {
+  const scan = dirs && dirs.length ? dirs : defaultSkillDirs();
+  const out = [];
+  const seen = new Set();
+
+  for (const dir of scan) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      continue; // 目录不存在就跳过，不算错
+    }
+    for (const ent of entries) {
+      if (!ent.isDirectory()) continue;
+      const skillDir = path.join(dir, ent.name);
+      const file = path.join(skillDir, 'SKILL.md');
+      let text;
+      try {
+        text = await fs.readFile(file, 'utf8');
+      } catch {
+        continue;
+      }
+      const { meta } = parseFrontmatter(text);
+      const name = meta.name || ent.name;
+      if (seen.has(name)) continue; // 同名只留第一个（项目目录优先）
+      seen.add(name);
+      out.push({
+        name,
+        description: meta.description || '',
+        path: file,
+        dir: skillDir,
+      });
+    }
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+
+/** 读某个 skill 的正文（去掉 frontmatter），找不到返回 null */
+export async function loadSkillBody(name, dirs) {
+  const all = await listSkills(dirs);
+  const hit = all.find((s) => s.name === name);
+  if (!hit) return null;
+  const text = await fs.readFile(hit.path, 'utf8');
+  return parseFrontmatter(text).body.trim();
+}
+
+/**
+ * 把节点挂载的 skills 拼成一段 system 提示。
+ * 没有任何 skill 时返回空串。
+ */
+export async function composeSkillPrompt(names, dirs) {
+  if (!Array.isArray(names) || !names.length) return '';
+  const parts = [];
+  for (const n of names) {
+    const body = await loadSkillBody(n, dirs);
+    if (!body) {
+      parts.push(`【技能 ${n}】未找到，忽略。`);
+      continue;
+    }
+    parts.push(`【技能：${n}】\n${body}`);
+  }
+  return parts.join('\n\n');
+}

package/runtime/store.mjs

@@ -0,0 +1,103 @@
+// store.mjs —— 落盘底层：读 JSON、原子写、把并发写串起来。
+//
+// 多画布（boards.json + boards/<id>.json）的存取在 boards.mjs；
+// 这里同时留着单画布接口（loadBoard/saveBoard/mutateBoard），给 run.mjs 这类旧代码用。
+// 不包含业务判断（那些在 server.mjs / boards.mjs）。
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.dirname(fileURLToPath(import.meta.url));
+
+/** 数据目录。每次调用都读 env：测试可以在同一进程里切临时目录。 */
+export function dataDir() {
+  return process.env.AGENTFLOW_DATA_DIR || path.join(ROOT, 'data');
+}
+
+// 旧代码直接 import 这个常量；进程启动后地址不变（测试传 env 起子进程，没问题）。
+export const DATA_DIR = dataDir();
+const BOARD_FILE = path.join(DATA_DIR, 'board.json');
+const CONFIG_FILE = path.join(DATA_DIR, 'config.json');
+
+// 所有写操作排成一队，避免两次请求同时写同一个文件导致半截 JSON。
+let writeChain = Promise.resolve();
+
+function enqueue(fn) {
+  const run = writeChain.then(fn, fn);
+  // 吞掉错误避免链断掉；真正的错误由 run 返回给调用方
+  writeChain = run.catch(() => {});
+  return run;
+}
+
+/** 串行执行一段异步逻辑（boards.mjs 的读-改-写用它）。 */
+export function exclusive(fn) {
+  return enqueue(fn);
+}
+
+async function ensureDirFor(file) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+}
+
+/** 原子写：先写 .tmp 再 rename，避免进程被杀留下半截文件。 */
+async function atomicWrite(file, text, mode) {
+  await ensureDirFor(file);
+  const tmp = `${file}.${process.pid}.tmp`;
+  await fs.writeFile(tmp, text, 'utf8');
+  if (mode) await fs.chmod(tmp, mode);
+  await fs.rename(tmp, file);
+}
+
+/** 原子写 JSON（boards.mjs 的画布/索引文件共用这一套）。 */
+export async function writeJsonAtomic(file, value, mode) {
+  await atomicWrite(file, JSON.stringify(value, null, 2), mode);
+  return value;
+}
+
+export async function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+  } catch (err) {
+    if (err.code === 'ENOENT') return fallback;
+    throw err;
+  }
+}
+
+// ---------- 单画布（旧接口，过渡期保留） ----------
+
+export async function loadBoard() {
+  return readJson(BOARD_FILE, null);
+}
+
+export async function saveBoard(board) {
+  return enqueue(async () => {
+    await atomicWrite(BOARD_FILE, JSON.stringify(board, null, 2));
+    return board;
+  });
+}
+
+/** 读-改-写，串行执行，避免并发丢更新。 */
+export async function mutateBoard(fn) {
+  return enqueue(async () => {
+    const board = (await loadBoard()) || { id: 'demo', name: '未命名', nodes: [], edges: [] };
+    const next = await fn(board);
+    await atomicWrite(BOARD_FILE, JSON.stringify(next, null, 2));
+    return next;
+  });
+}
+
+// ---------- 配置 ----------
+
+export async function loadConfig() {
+  return readJson(CONFIG_FILE, null);
+}
+
+export async function saveConfig(cfg) {
+  return enqueue(async () => {
+    // 600：只有本用户可读，key 不外泄
+    await atomicWrite(CONFIG_FILE, JSON.stringify(cfg, null, 2), 0o600);
+    return cfg;
+  });
+}
+
+export const files = { BOARD_FILE, CONFIG_FILE };

package/runtime/verify.mjs

@@ -0,0 +1,219 @@
+// verify.mjs —— 节点的「结果判断」。
+//
+// 三种模式（用户在卡片详情里选）：
+//   human ：跑完停住，标成 review，等人点通过/打回
+//   jev   ：调 TypeSafe System One 判定（只给概率，不出文）
+//   self  ：同一个模型自评是否达到 criteria
+//
+// TypeSafe 在中国区返回 451（2026-10-19 实测），所以这里支持走 HTTP 代理。
+// Node 自带 fetch 不认代理，为了保持零依赖，这里用裸 http/https 手写 CONNECT 隧道。
+
+import http from 'node:http';
+import https from 'node:https';
+import tls from 'node:tls';
+
+const JEV_ENDPOINT = 'https://api.typesafe.ai/v1/systemone';
+const JEV_MODEL = 'jev-latest';
+
+/**
+ * 通过 HTTP 代理发一个 HTTPS POST。
+ * 不依赖 undici / https-proxy-agent：CONNECT 拿到裸 socket，再在它上面做 TLS。
+ */
+function postJsonViaProxy({ proxyUrl, url, headers, body, timeoutMs = 20000 }) {
+  const proxy = new URL(proxyUrl);
+  const target = new URL(url);
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const done = (fn, arg) => {
+      if (settled) return;
+      settled = true;
+      fn(arg);
+    };
+
+    const timer = setTimeout(() => done(reject, new Error(`代理请求超时 ${timeoutMs}ms`)), timeoutMs);
+
+    const connectReq = http.request({
+      host: proxy.hostname,
+      port: proxy.port || 80,
+      method: 'CONNECT',
+      path: `${target.hostname}:443`,
+      headers: { Host: `${target.hostname}:443` },
+    });
+
+    connectReq.on('error', (err) => {
+      clearTimeout(timer);
+      done(reject, new Error(`代理连接失败：${err.message}`));
+    });
+
+    connectReq.on('connect', (res, socket) => {
+      if (res.statusCode !== 200) {
+        clearTimeout(timer);
+        socket.destroy();
+        return done(reject, new Error(`代理拒绝 CONNECT：HTTP ${res.statusCode}`));
+      }
+
+      // 关键：必须用一个自定义 Agent 来接管 socket。
+      // 之前用 `agent: false` + createConnection 是不行的 —— agent:false 会新建一个
+      // 默认 Agent，createConnection 永远不被调用，结果还是直连，照样 451。
+      const agent = new https.Agent({ keepAlive: false });
+      agent.createConnection = (opts, cb) => {
+        const tlsSocket = tls.connect(
+          { socket, servername: target.hostname },
+          () => cb(null, tlsSocket)
+        );
+        tlsSocket.once('error', (err) => cb(err));
+      };
+
+      const req = https.request(
+        {
+          host: target.hostname,
+          path: target.pathname + target.search,
+          method: 'POST',
+          headers,
+          agent,
+        },
+        (pres) => {
+          let text = '';
+          pres.setEncoding('utf8');
+          pres.on('data', (d) => (text += d));
+          pres.on('end', () => {
+            clearTimeout(timer);
+            agent.destroy();
+            done(resolve, { status: pres.statusCode, body: text });
+          });
+        }
+      );
+      req.on('error', (err) => {
+        clearTimeout(timer);
+        agent.destroy();
+        done(reject, err);
+      });
+      req.end(body);
+    });
+
+    connectReq.end();
+  });
+}
+
+/** 直连（没有配代理时用） */
+async function postJsonDirect({ url, headers, body, timeoutMs = 20000 }) {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers,
+    body,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  return { status: res.status, body: await res.text() };
+}
+
+/**
+ * 问一次 Jev：这段内容是否达标。
+ * @returns { pass: boolean, score: number, raw: object }
+ */
+export async function askJev({ apiKey, proxy, content, criteria, timeoutMs }) {
+  if (!apiKey) throw new Error('没有配 jev 的 apiKey');
+
+  const instructions = criteria
+    ? `判断下面这段内容是否达到以下标准：${criteria}`
+    : '判断下面这段内容是否完整、可用地完成了一个明确任务';
+
+  const payload = {
+    state: { content: String(content).slice(0, 12000) },
+    model: JEV_MODEL,
+    questions: {
+      ok: {
+        type: 'noul',
+        instructions,
+      },
+    },
+  };
+
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(JSON.stringify(payload)),
+  };
+  const body = JSON.stringify(payload);
+
+  const run = (opts) =>
+    proxy
+      ? postJsonViaProxy({ ...opts, proxyUrl: proxy, url: JEV_ENDPOINT, headers, body })
+      : postJsonDirect({ ...opts, url: JEV_ENDPOINT, headers, body });
+
+  let res;
+  try {
+    res = await run({ timeoutMs });
+  } catch (err) {
+    throw new Error(`Jev 调用失败：${err.message}`);
+  }
+
+  if (res.status === 451) {
+    throw new Error('TypeSafe 返回 451（地区封锁），需要在配置里填 HTTP 代理');
+  }
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error(`Jev HTTP ${res.status}：${String(res.body).slice(0, 200)}`);
+  }
+
+  let data;
+  try {
+    data = JSON.parse(res.body);
+  } catch {
+    throw new Error(`Jev 返回不是 JSON：${String(res.body).slice(0, 200)}`);
+  }
+
+  // 实测线上形如 { "type": "noul", "noul": 0.95 }；也兼容 answers.ok.noul 包一层
+  const score =
+    Number(data?.noul) ||
+    Number(data?.answers?.ok?.noul) ||
+    Number(data?.questions?.ok?.noul) ||
+    0;
+
+  return { pass: score >= 0.5, score, raw: data };
+}
+
+/**
+ * 模型自评：让同一个模型对照 criteria 检查自己刚写的内容。
+ * 复用传入的 callLLM（所以自动带上同一节点的 provider / mock 设置）。
+ */
+export async function selfVerify(callLLM, node, content) {
+  const judgeNode = { ...node, skills: [], tools: [], verify: '' };
+  const prompt = [
+    '这是一个【质量检查】任务。你只能判定，绝对不能重写、续写或补充内容。',
+    '',
+    '【当初的任务要求】',
+    node.task || '(无)',
+    '',
+    '【完成标准】',
+    node.criteria || '内容完整、可用地完成了任务',
+    '',
+    '【需要判定的内容】',
+    '<<<',
+    String(content).slice(0, 12000),
+    '>>>',
+    '',
+    '只输出一行，不要任何其他文字、不要解释、不要重复内容：',
+    'PASS|不超过30字的理由',
+    '或',
+    'FAIL|不超过30字的理由',
+  ].join('\n');
+
+  const res = await callLLM(judgeNode, prompt);
+  const text = String(res.content || '').trim();
+
+  // 宽松取结果：优先看行首，其次找第一个独立出现的关键词
+  let verdictWord = '';
+  const head = /^(PASS|FAIL)/i.exec(text);
+  if (head) verdictWord = head[1].toUpperCase();
+  else {
+    const anywhere = /\b(PASS|FAIL)\b/i.exec(text.slice(0, 80));
+    if (anywhere) verdictWord = anywhere[1].toUpperCase();
+  }
+
+  const pass = verdictWord === 'PASS';
+  let reason = text.replace(/^(PASS|FAIL)\s*[|｜:：]?\s*/i, '').replace(/\s+/g, ' ').trim();
+  if (!verdictWord) {
+    reason = `模型没按格式回答（${text.slice(0, 40)}…），按未通过处理`;
+  }
+  return { pass, reason: reason.slice(0, 60), raw: text };
+}