evolcore 0.0.28 → 0.0.29

package/kits/skills/ec-skill/scripts/deps.mjs

@@ -0,0 +1,107 @@
+/**
+ * 依赖自举：按需把第三方包装进 $EVOLCORE_HOME/skills/.deps/
+ *
+ * 为什么装在 .deps 而不是技能目录里：
+ *   - 本机级技能目录是用户自己的，塞 node_modules 会污染
+ *   - 内置级在 kits/skills/，随包发布，全局安装时可能是只读的
+ *
+ * 装一次之后离线可用：每次都先查 .deps，命中就直接用，不碰网络。
+ * 版本锁死（不用 ^），避免上游升级带来兼容性问题。
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+
+/** 锁定的依赖版本。新增依赖时在此登记。 */
+export const LOCKED_DEPS = {
+  'adm-zip': '0.6.1',
+};
+
+/** $EVOLCORE_HOME 的解析规则与主程序 paths.ts 保持一致 */
+export function evolcoreHome() {
+  if (process.env.EVOLCORE_HOME) return process.env.EVOLCORE_HOME;
+  return path.join(os.homedir(), '.evolcore');
+}
+
+/** 依赖目录 */
+export function depsDir() {
+  return path.join(evolcoreHome(), 'skills', '.deps');
+}
+
+/**
+ * 确保某个依赖可用，返回其模块入口的绝对路径。
+ * 已存在直接返回；缺失则 npm install（锁版本）。
+ */
+export function ensureDep(name) {
+  const version = LOCKED_DEPS[name];
+  if (!version) throw new Error(`未登记的依赖: ${name}（请在 LOCKED_DEPS 中登记并锁定版本）`);
+
+  const pkgDir = path.join(depsDir(), 'node_modules', name);
+  if (!fs.existsSync(pkgDir)) {
+    installDep(name, version);
+  }
+  return pkgDir;
+}
+
+/** 用 CommonJS require 加载依赖（兼容 CJS 包） */
+export function loadDep(name) {
+  const pkgDir = ensureDep(name);
+  const require = createRequire(path.join(pkgDir, 'noop.js'));
+  return require(pkgDir);
+}
+
+function installDep(name, version) {
+  const dir = depsDir();
+  fs.mkdirSync(dir, { recursive: true });
+
+  // 极简并发保护：mkdir 是原子的，抢到锁目录的进程执行安装，其余等待
+  const lockDir = path.join(dir, '.install-lock');
+  const deadline = Date.now() + 120_000;
+  let acquired = false;
+
+  while (Date.now() < deadline) {
+    try {
+      fs.mkdirSync(lockDir);
+      acquired = true;
+      break;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      // 别人正在装：等它装完
+      const target = path.join(dir, 'node_modules', name);
+      if (fs.existsSync(target)) return;
+      sleepSync(300);
+    }
+  }
+
+  if (!acquired) {
+    throw new Error(`等待依赖安装超时（${name}）。若另一进程正在安装，请稍后重试。`);
+  }
+
+  try {
+    // 抢到锁后再查一次（可能别人已装好）
+    if (fs.existsSync(path.join(dir, 'node_modules', name))) return;
+
+    process.stderr.write(`[ec-skill] 首次使用，正在安装依赖 ${name}@${version} ...\n`);
+    execFileSync('npm', ['install', '--prefix', dir, '--no-save', '--no-audit', '--no-fund', `${name}@${version}`], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+      shell: process.platform === 'win32', // Windows 上 npm 是 .cmd，需要 shell
+    });
+  } catch (e) {
+    const detail = e.stderr ? e.stderr.toString() : (e.message || String(e));
+    throw new Error(
+      `安装依赖 ${name}@${version} 失败：${detail}\n` +
+      `提示：首次安装需要联网。若处于离线环境，改用「给目录」的方式安装技能（不需要解压依赖）。`
+    );
+  } finally {
+    try { fs.rmdirSync(lockDir); } catch {}
+  }
+}
+
+/** 同步 sleep（脚本场景下避免引入异步复杂度） */
+function sleepSync(ms) {
+  const sab = new SharedArrayBuffer(4);
+  Atomics.wait(new Int32Array(sab), 0, 0, ms);
+}

package/kits/skills/ec-skill/scripts/frontmatter.mjs

@@ -0,0 +1,104 @@
+/**
+ * SKILL.md frontmatter 的最小解析器。
+ *
+ * 为什么不用 yaml 包：本机级技能在 $EVOLCORE_HOME/skills/（包外面），
+ * 按相对路径解析不到包的 node_modules，脚本必须零外部依赖。
+ *
+ * 只解析规范里定义、且技能作者实际会用的形态：
+ *   简单键值      name: foo
+ *   引号标量      name: "foo"  /  name: 'foo'
+ *   折叠块        description: >-    （后续缩进行拼成一行）
+ *   字面块        description: |     （保留换行）
+ *   行内数组      allowed-tools: [Read, Grep]
+ *   逗号串        allowed-tools: Read, Grep
+ * 不追求完整 YAML 语义——复杂结构（嵌套对象/锚点）超出技能规范范围。
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** 取出 frontmatter 文本块；没有则返回 null */
+export function extractFrontmatter(text) {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  return m ? m[1] : null;
+}
+
+/** 解析 frontmatter 文本为普通对象 */
+export function parseFrontmatter(fmText) {
+  const out = {};
+  const lines = fmText.split(/\r?\n/);
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    // 跳过空行与注释
+    if (!line.trim() || line.trimStart().startsWith('#')) { i++; continue; }
+    // 缩进行属于上一个键，已在块处理里消费
+    if (/^\s/.test(line)) { i++; continue; }
+
+    const m = line.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+    if (!m) { i++; continue; }
+
+    const key = m[1];
+    let value = m[2];
+    i++;
+
+    // 块标量：>- | > | 等
+    if (/^[|>][-+]?\d*$/.test(value.trim())) {
+      const folded = value.trim().startsWith('>');
+      const blockLines = [];
+      while (i < lines.length && (/^\s/.test(lines[i]) || lines[i].trim() === '')) {
+        blockLines.push(lines[i]);
+        i++;
+      }
+      // 去掉公共缩进
+      const indents = blockLines.filter(l => l.trim()).map(l => l.match(/^\s*/)[0].length);
+      const indent = indents.length ? Math.min(...indents) : 0;
+      const stripped = blockLines.map(l => l.slice(indent));
+      // 去掉首尾空行
+      while (stripped.length && !stripped[0].trim()) stripped.shift();
+      while (stripped.length && !stripped[stripped.length - 1].trim()) stripped.pop();
+
+      out[key] = folded
+        ? stripped.map(l => l.trim()).filter(Boolean).join(' ')
+        : stripped.join('\n');
+      continue;
+    }
+
+    out[key] = parseScalar(value);
+  }
+
+  return out;
+}
+
+function parseScalar(raw) {
+  const v = raw.trim();
+  if (v === '') return '';
+  if (v === 'true') return true;
+  if (v === 'false') return false;
+  if (v === 'null' || v === '~') return null;
+  // 引号
+  if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+    return v.slice(1, -1);
+  }
+  // 行内数组
+  if (v.startsWith('[') && v.endsWith(']')) {
+    return v.slice(1, -1).split(',').map(s => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+  }
+  // 逗号串（allowed-tools 允许这种写法）
+  return v;
+}
+
+/** 读取一个技能目录的 frontmatter；失败返回 {__error} */
+export function readSkillFrontmatter(skillDir) {
+  const file = path.join(skillDir, 'SKILL.md');
+  if (!fs.existsSync(file)) return null;
+  const text = fs.readFileSync(file, 'utf-8');
+  const fm = extractFrontmatter(text);
+  if (fm === null) return null;
+  try {
+    return parseFrontmatter(fm);
+  } catch (e) {
+    return { __error: e instanceof Error ? e.message : String(e) };
+  }
+}