@xenonbyte/xsk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xenon Byte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# xsk
+
+Agent skill aggregator. `xsk` curates a small set of agent skills and installs them across Claude Code, Codex, opencode, and Gemini with manifest-backed safety.
+
+Package: `@xenonbyte/xsk` · Binary: `xsk` · Runtime: Node >= 20, CommonJS, zero third-party runtime dependencies.
+
+## Overview
+
+Two recurring frictions when working across AI coding agents: third-party skill packs are all-or-nothing, and self-authored skills are scattered with no shared install/manifest/safety story. `xsk` solves both. It ships six curated skills (two distilled from third parties, four original) and a CLI that installs each skill into every supported platform's skill directory, then tracks exactly what it created so uninstall removes only those files.
+
+`xsk` is itself an agent-skill project and conforms to the same standard its scaffold skill enforces.
+
+## Installation
+
+```sh
+npm install -g @xenonbyte/xsk
+```
+
+Requires Node >= 20 on macOS or Linux.
+
+## Usage
+
+```sh
+xsk install                 # install every skill into every platform
+xsk install --platform claude,codex
+xsk status                  # read-only: what is installed per platform
+xsk status --json
+xsk uninstall               # remove only what xsk created
+xsk doctor                  # probe environment + manifest health
+xsk version
+xsk help
+```
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `version` (also `--version` / `-v`) | Print the package version. |
+| `help` (also `--help` / `-h`, and on no args) | Print the user command list. |
+| `install [--platform <list>]` | Generate and install skills, uninstall-first: a reinstall resets prior owned files (pruning skills no longer installed) before regenerating, so no manual `uninstall` is needed; user-edited owned files are still refused and rolled back. `--platform` is comma-separated, defaults to all four platforms. Unknown or duplicate values are rejected. |
+| `uninstall [--platform <list>]` | Remove only the manifest-recorded generated files. |
+| `status [--json]` | Read-only per-platform report: `ok`, `drift`, or `invalid`. Validates manifest shape, not just parse success. |
+| `doctor [--json]` | Read-only probe of Node version, target-dir writability, and manifest validity. Pass/fail per check. No capability claims. |
+
+Unknown options fail loud with a non-zero exit.
+
+## Skills
+
+Six skills, prefixed `xsk-`:
+
+| Skill | Purpose |
+|---|---|
+| `xsk-think` | Turn a rough idea into a decision-complete plan before any code is written. Distilled from Waza `/think`. |
+| `xsk-bypass-claude` | Set the current project to Claude Code bypass-permissions mode by writing `.claude/settings.local.json`. Claude only. |
+| `xsk-skill-scaffold` | Bring an agent-skill project up to the `xsk` standard, or refuse if it is not one. |
+| `xsk-write-req` | Convert plain-language needs into a compliant requirement doc in `requirements/`, grounded in the current project. |
+| `xsk-archive-req` | Archive the active requirement doc into `requirements/archive/`. |
+| `xsk-check` | Review a code change before it ships: scope drift, hard stops, evidence-gated findings, then verify and sign off. Distilled from Waza `/check`. |
+
+`xsk-bypass-claude` targets Claude Code only; `xsk install` skips it on the other three platforms.
+
+## Platforms
+
+All four platforms are full and use the same `<name>/SKILL.md` skill-directory shape.
+
+| Platform | Install location |
+|---|---|
+| Claude Code | `~/.claude/skills/<name>/SKILL.md` |
+| Codex | `~/.agents/skills/<name>/SKILL.md` |
+| opencode | `~/.config/opencode/skills/<name>/SKILL.md` |
+| Gemini | `~/.gemini/skills/<name>/SKILL.md` |
+
+Platform behavior is verified as of 2026-06-25 against the official docs linked from the source repository's `docs/REQUIREMENTS.md`.
+
+## Discovery aliases and duplicate skills
+
+opencode also reads `~/.claude/skills/<name>/SKILL.md` and `~/.agents/skills/<name>/SKILL.md` in addition to its native `~/.config/opencode/skills/<name>/SKILL.md`. Gemini also reads `~/.agents/skills/<name>/SKILL.md` as an alias for `~/.gemini/skills/<name>/SKILL.md`.
+
+Because those aliases are cross-platform visible, a skill copied into one readable alias directory can also be discovered by another agent. `xsk` still writes one manifest-owned copy per selected platform, so each platform copy stays independently uninstallable even when another platform can also see an alias copy.
+
+`xsk-bypass-claude` remains Claude Code-only. If another agent discovers it through an alias, the skill body refuses or stops inertly outside Claude Code instead of applying Claude-specific behavior.
+
+## Safety
+
+Installing into user home config dirs is destructive if careless. `xsk` is manifest-backed:
+
+- Owned-only removal. Uninstall removes only paths the manifest recorded.
+- Ownership markers. A `.xsk-owned` marker inside each installed skill dir gates directory removal.
+- No symlink traversal or removal. `xsk` refuses on encounter.
+- Atomic writes. Each file is written to a temp sibling then renamed into place; a failed write restores the original.
+- User edits preserved. If a generated file was user-modified, uninstall keeps it, reports a partial result, and narrows the retained manifest so a later run can finish.
+
+`xsk` writes only under `~/.xsk/` and the four platform skill dirs.
+
+## Development
+
+```sh
+npm test            # full node:test suite
+npm run syntaxcheck # node --check every bin/, lib/, test/ file
+npm pack --dry-run  # verify package contents
+```
+
+The full requirement specification lives in the source repository at `docs/REQUIREMENTS.md`.
+
+## License
+
+MIT

package/README.zh-CN.md

@@ -0,0 +1,107 @@
+# xsk
+
+Agent skill aggregator（智能体技能聚合器）。`xsk` 精选了一小组 agent skill，并以 manifest 记录作为安全保障，将它们安装到 Claude Code、Codex、opencode 与 Gemini 四个平台。
+
+Package: `@xenonbyte/xsk` · Binary: `xsk` · Runtime: Node >= 20, CommonJS, 零第三方运行时依赖。
+
+## Overview
+
+跨多个 AI coding agent 工作时有两类反复出现的摩擦：第三方 skill 包要么全装要么不装（all-or-nothing），自写的 skill 又散落各处、缺少统一的安装 / manifest / 安全方案。`xsk` 同时解决这两点。它内置六个精选 skill（两个从第三方蒸馏而来，四个原创），并提供一个 CLI，把每个 skill 安装到所有受支持平台的 skill 目录，再精确记录它创建了哪些文件，使 uninstall 只移除这些文件。
+
+`xsk` 本身就是一个 agent-skill 项目，并符合它自己的 scaffold skill 所执行的同一套标准。
+
+## Installation
+
+```sh
+npm install -g @xenonbyte/xsk
+```
+
+要求 macOS 或 Linux 上的 Node >= 20。
+
+## Usage
+
+```sh
+xsk install                 # 把所有 skill 安装到所有平台
+xsk install --platform claude,codex
+xsk status                  # 只读：查看每个平台已安装的内容
+xsk status --json
+xsk uninstall               # 只移除 xsk 创建的内容
+xsk doctor                  # 探测环境与 manifest 健康状况
+xsk version
+xsk help
+```
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `version`（亦作 `--version` / `-v`） | 打印 package version。 |
+| `help`（亦作 `--help` / `-h`，无参数时同样触发） | 打印用户命令清单。 |
+| `install [--platform <list>]` | 生成并安装 skill，默认 uninstall-first：重装会先重置此前 owned 的文件（清理已不再安装的 skill）再生成，无需手动 `uninstall`；用户改过的 owned 文件仍会被拒绝并回滚。`--platform` 以逗号分隔，缺省为全部四个平台；未知或重复的值会被拒绝。 |
+| `uninstall [--platform <list>]` | 仅移除 manifest 记录的生成文件。 |
+| `status [--json]` | 每个平台的只读报告：`ok`、`drift` 或 `invalid`。校验 manifest 形状，而非仅判断能否解析。 |
+| `doctor [--json]` | 对 Node 版本、目标目录可写性、manifest 有效性做只读探测；逐项给出 pass/fail，不声明任何能力。 |
+
+未知选项会 fail loud 并以非零码退出。
+
+## Skills
+
+共六个 skill，统一前缀 `xsk-`：
+
+| Skill | Purpose |
+|---|---|
+| `xsk-think` | 把一个粗略想法在写任何代码之前变成 decision-complete 的 plan。蒸馏自 Waza `/think`。 |
+| `xsk-bypass-claude` | 通过写 `.claude/settings.local.json` 把当前项目设为 Claude Code bypass-permissions 模式。仅 Claude。 |
+| `xsk-skill-scaffold` | 把一个 agent-skill 项目带到 `xsk` 标准；若不是这类项目则拒绝。 |
+| `xsk-write-req` | 把白话需求转成 `requirements/` 下合规的需求文档，并扎根于当前项目。 |
+| `xsk-archive-req` | 把当前 active 需求文档归档到 `requirements/archive/`。 |
+| `xsk-check` | 在改动合入前评审：范围漂移、hard stops、证据门控的发现项，再验证后签收。蒸馏自 Waza `/check`。 |
+
+`xsk-bypass-claude` 仅面向 Claude Code；`xsk install` 会在其余三个平台跳过它。
+
+## Platforms
+
+四个平台均为 full，并使用同一种 `<name>/SKILL.md` skill-directory 形态。
+
+| Platform | Install location |
+|---|---|
+| Claude Code | `~/.claude/skills/<name>/SKILL.md` |
+| Codex | `~/.agents/skills/<name>/SKILL.md` |
+| opencode | `~/.config/opencode/skills/<name>/SKILL.md` |
+| Gemini | `~/.gemini/skills/<name>/SKILL.md` |
+
+平台行为依据源仓库 `docs/REQUIREMENTS.md` 中链接的官方文档，校验日期为 2026-06-25。
+
+## Discovery aliases and duplicate skills
+
+opencode 除了自己的 `~/.config/opencode/skills/<name>/SKILL.md`，也会读取 `~/.claude/skills/<name>/SKILL.md` 与 `~/.agents/skills/<name>/SKILL.md`。Gemini 也会把 `~/.agents/skills/<name>/SKILL.md` 当作 `~/.gemini/skills/<name>/SKILL.md` 的 alias 一并发现。
+
+因为这些 alias 具有 cross-platform visibility，一个放进可读 alias 目录的 skill 也可能被另一个 agent 发现。`xsk` 仍然会按所选平台各写入一份由 manifest 跟踪的 owned 副本，因此即使别的平台也能看见 alias 副本，每个平台自己的副本依然可以 independently uninstallable。
+
+`xsk-bypass-claude` 仍然是 Claude Code-only。若别的 agent 通过 alias 发现它，skill body 会在 Claude Code 之外直接 refuse，或 inertly stop，而不会执行 Claude 专属行为。
+
+## Safety
+
+向用户 home 配置目录写入若不小心具有破坏性。`xsk` 以 manifest 为后盾：
+
+- Owned-only removal。uninstall 只移除 manifest 记录的路径。
+- Ownership markers。每个已安装 skill 目录内有 `.xsk-owned` 标记，目录移除需先校验该标记。
+- No symlink traversal or removal。`xsk` 遇到 symlink 会拒绝。
+- Atomic writes。每个文件先写入临时同目录文件，再 rename 就位；写入失败时恢复原文件。
+- User edits preserved。若生成的文件被用户修改，uninstall 会保留它、报告 partial，并收窄保留的 manifest，使后续可继续完成。
+
+`xsk` 只在 `~/.xsk/` 与四个平台 skill 目录下写入。
+
+## Development
+
+```sh
+npm test            # 完整 node:test 套件
+npm run syntaxcheck # 对 bin/、lib/、test/ 下每个文件执行 node --check
+npm pack --dry-run  # 校验 package 内容
+```
+
+完整需求规格见源仓库中的 `docs/REQUIREMENTS.md`。
+
+## License
+
+MIT

package/bin/xsk.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+'use strict';
+
+const { parse } = require('../lib/input');
+const { install } = require('../lib/install');
+const { uninstall } = require('../lib/uninstall');
+const { computeStatus, render: renderStatus } = require('../lib/status');
+const { doctor, render: renderDoctor } = require('../lib/capability');
+
+const VERSION = require('../package.json').version;
+
+const HELP = `xsk ${VERSION} - agent skill aggregator
+
+Usage:
+  xsk <command> [options]
+
+Commands:
+  install [--platform <list>]   Generate and install skills (uninstall-first: a
+                               reinstall resets prior owned files, no manual
+                               uninstall needed). --platform is comma-separated,
+                               defaults to all four platforms.
+  uninstall [--platform <list>] Remove only the manifest-recorded generated files.
+  status [--json]               Read-only per-platform report: ok, drift, invalid,
+                               or not-installed.
+  doctor [--json]               Probe Node version, target-dir writability, and
+                               manifest validity. Pass/fail per check.
+  version                       Print the xsk version (also --version / -v).
+  help                          Print this help (also --help / -h, and on no args).
+
+Platforms: claude, codex, opencode, gemini.
+
+Unknown options fail loud with a non-zero exit.
+`;
+
+function formatInstall(summary) {
+  const lines = [];
+  for (const platform of Object.keys(summary.platforms)) {
+    const r = summary.platforms[platform];
+    if (r.skipped) {
+      lines.push(`${platform}: no applicable skills (skipped)`);
+      continue;
+    }
+    const skillCount = (r.installed || []).filter((p) => p.endsWith('SKILL.md')).length;
+    const backCount = (r.backups || []).length;
+    let line = `${platform}: installed ${skillCount} skill${skillCount === 1 ? '' : 's'}`;
+    if (backCount > 0) {
+      line += `; backed up ${backCount} displaced file${backCount === 1 ? '' : 's'}`;
+    }
+    lines.push(line);
+  }
+  return lines.join('\n') + '\n';
+}
+
+function formatUninstall(summary) {
+  const lines = [];
+  for (const platform of Object.keys(summary.platforms)) {
+    const r = summary.platforms[platform];
+    if (r.nothingInstalled) {
+      lines.push(`${platform}: nothing installed`);
+      continue;
+    }
+    if (r.invalid) {
+      lines.push(`${platform}: manifest invalid - ${r.error}`);
+      continue;
+    }
+    const removedCount = (r.removed || []).filter((p) => p.endsWith('SKILL.md')).length;
+    const restoredCount = (r.restored || []).length;
+    const retainedCount = (r.retained || []).length;
+    let line = `${platform}: removed ${removedCount} skill${removedCount === 1 ? '' : 's'}`;
+    if (restoredCount > 0) {
+      line += `, restored ${restoredCount} displaced file${restoredCount === 1 ? '' : 's'}`;
+    }
+    if (r.partial) {
+      line += `; retained ${retainedCount} user-edited file${retainedCount === 1 ? '' : 's'} (partial)`;
+    }
+    if ((r.skipped || []).length) {
+      line += `; skipped ${(r.skipped || []).length} unowned dir(s)`;
+    }
+    if ((r.refused || []).length) {
+      line += `; refused ${(r.refused || []).length} symlink(s)`;
+    }
+    if (r.partial && r.error) {
+      line += ` - ${r.error}`;
+    }
+    lines.push(line);
+  }
+  return lines.join('\n') + '\n';
+}
+
+function main(argv, options) {
+  const opts = options || {};
+  const out = opts.stdout || process.stdout;
+  const err = opts.stderr || process.stderr;
+
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (e) {
+    err.write(`xsk: ${e.message}\n`);
+    return 1;
+  }
+
+  const dispatchOptions = {
+    platformRoots: opts.platformRoots,
+    xskRoot: opts.xskRoot,
+  };
+
+  switch (parsed.command) {
+    case 'version':
+      out.write(`${VERSION}\n`);
+      return 0;
+    case 'help':
+      out.write(HELP);
+      return 0;
+    case 'install': {
+      try {
+        const summary = install(
+          Object.assign({ platforms: parsed.platforms }, dispatchOptions),
+        );
+        out.write(formatInstall(summary));
+        return 0;
+      } catch (e) {
+        err.write(`xsk install failed: ${e.message}\n`);
+        return 1;
+      }
+    }
+    case 'uninstall': {
+      let summary;
+      try {
+        summary = uninstall(
+          Object.assign({ platforms: parsed.platforms }, dispatchOptions),
+        );
+      } catch (e) {
+        err.write(`xsk uninstall failed: ${e.message}\n`);
+        return 1;
+      }
+      out.write(formatUninstall(summary));
+      return summary.exitCode;
+    }
+    case 'status': {
+      const result = computeStatus(
+        Object.assign({ platforms: parsed.platforms }, dispatchOptions),
+      );
+      out.write(renderStatus(result, { json: parsed.json, platforms: parsed.platforms }) + '\n');
+      return 0;
+    }
+    case 'doctor': {
+      const result = doctor(
+        Object.assign({ platforms: parsed.platforms }, dispatchOptions),
+      );
+      out.write(renderDoctor(result, { json: parsed.json }) + '\n');
+      return result.allPass ? 0 : 1;
+    }
+    default:
+      err.write(`xsk: unknown command\n`);
+      return 1;
+  }
+}
+
+module.exports = { main, HELP, VERSION, formatInstall, formatUninstall };
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}

package/lib/adapters/claude.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const path = require('node:path');
+const os = require('node:os');
+
+const PLATFORM = 'claude';
+
+function skillsRoot(options) {
+  const opts = options || {};
+  const home = opts.home || os.homedir();
+  return path.join(home, '.claude', 'skills');
+}
+
+module.exports = { PLATFORM, skillsRoot };

package/lib/adapters/codex.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const path = require('node:path');
+const os = require('node:os');
+
+const PLATFORM = 'codex';
+
+function skillsRoot(options) {
+  const opts = options || {};
+  const home = opts.home || os.homedir();
+  return path.join(home, '.agents', 'skills');
+}
+
+module.exports = { PLATFORM, skillsRoot };

package/lib/adapters/gemini.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const path = require('node:path');
+const os = require('node:os');
+
+const PLATFORM = 'gemini';
+
+function skillsRoot(options) {
+  const opts = options || {};
+  const home = opts.home || os.homedir();
+  return path.join(home, '.gemini', 'skills');
+}
+
+module.exports = { PLATFORM, skillsRoot };

package/lib/adapters/opencode.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const path = require('node:path');
+const os = require('node:os');
+
+const PLATFORM = 'opencode';
+
+function skillsRoot(options) {
+  const opts = options || {};
+  const home = opts.home || os.homedir();
+  return path.join(home, '.config', 'opencode', 'skills');
+}
+
+module.exports = { PLATFORM, skillsRoot };

package/lib/capability.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { defaultXskRoot, isSafePath } = require('./manifest');
+const { rootFor, ALL_PLATFORMS } = require('./install');
+const { computeStatus } = require('./status');
+
+const REQUIRED_NODE_MAJOR = 20;
+
+function nodeMajor() {
+  return Number.parseInt(String(process.versions.node).split('.')[0], 10) || 0;
+}
+
+function isWritableDir(dir) {
+  try {
+    if (!isSafePath(dir, 'skill dir')) return false;
+    if (fs.existsSync(dir)) {
+      const stat = fs.lstatSync(dir);
+      if (stat.isSymbolicLink() || !stat.isDirectory()) return false;
+      fs.accessSync(dir, fs.constants.W_OK);
+      return true;
+    }
+    let p = dir;
+    while (p && p !== path.dirname(p) && !fs.existsSync(p)) {
+      p = path.dirname(p);
+    }
+    if (!p) return false;
+    const stat = fs.lstatSync(p);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) return false;
+    fs.accessSync(p, fs.constants.W_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function doctor(options) {
+  const opts = options || {};
+  const platforms = opts.platforms || ALL_PLATFORMS;
+  const xskRoot = opts.xskRoot || defaultXskRoot();
+
+  const checks = [];
+
+  checks.push({
+    name: 'node-version',
+    label: `Node >= ${REQUIRED_NODE_MAJOR}`,
+    pass: nodeMajor() >= REQUIRED_NODE_MAJOR,
+    detail: `running Node ${process.versions.node}`,
+  });
+
+  const writableXskRoot = isWritableDir(xskRoot);
+  checks.push({
+    name: 'writable-xsk-root',
+    label: `~/.xsk writable (${xskRoot})`,
+    pass: writableXskRoot,
+    detail: writableXskRoot ? 'writable or creatable' : 'not writable',
+  });
+
+  for (const platform of platforms) {
+    let root;
+    try {
+      root = rootFor(platform, opts.platformRoots);
+    } catch (e) {
+      checks.push({
+        name: `writable-${platform}`,
+        label: `${platform} skill dir writable`,
+        pass: false,
+        detail: `could not resolve skill dir: ${e.message}`,
+      });
+      continue;
+    }
+    checks.push({
+      name: `writable-${platform}`,
+      label: `${platform} skill dir writable (${root})`,
+      pass: isWritableDir(root),
+      detail: isWritableDir(root) ? 'writable or creatable' : 'not writable',
+    });
+  }
+
+  const status = computeStatus({ platforms, xskRoot, platformRoots: opts.platformRoots });
+  let checkedManifests = 0;
+  let invalidManifests = 0;
+  let driftedManifests = 0;
+  for (const platform of platforms) {
+    const entry = status.platforms[platform];
+    if (!entry || entry.state === 'not-installed') continue;
+    checkedManifests += 1;
+    if (entry.state === 'invalid') {
+      invalidManifests += 1;
+    } else if (entry.state === 'drift') {
+      driftedManifests += 1;
+    }
+  }
+  const manifestPass = invalidManifests === 0 && driftedManifests === 0;
+  checks.push({
+    name: 'manifest-valid',
+    label: 'manifests valid',
+    pass: manifestPass,
+    detail:
+      checkedManifests === 0
+        ? 'no manifests present'
+        : manifestPass
+          ? `${checkedManifests} manifest(s) valid`
+          : `${invalidManifests} invalid, ${driftedManifests} drifted of ${checkedManifests} manifest(s)`,
+  });
+
+  const allPass = checks.every((c) => c.pass);
+  return { checks, allPass };
+}
+
+function render(result, options) {
+  const opts = options || {};
+  if (opts.json) {
+    return JSON.stringify(result, null, 2);
+  }
+  const lines = [];
+  for (const c of result.checks) {
+    lines.push(`[${c.pass ? 'PASS' : 'FAIL'}] ${c.label} - ${c.detail}`);
+  }
+  lines.push(result.allPass ? 'doctor: all checks passed' : 'doctor: one or more checks failed');
+  return lines.join('\n');
+}
+
+module.exports = { doctor, render, nodeMajor, isWritableDir, REQUIRED_NODE_MAJOR };

package/lib/content-hash.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+function contentSha256(content) {
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+function isSha256(value) {
+  return typeof value === 'string' && /^[0-9a-f]{64}$/.test(value);
+}
+
+module.exports = { contentSha256, isSha256 };

package/lib/generator.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const PKG_ROOT = path.join(__dirname, '..');
+const SECTIONS = ['purpose', 'triggers', 'behavior', 'output'];
+
+function render(template, values) {
+  return template.replace(/\{\{(\w+)\}\}/g, (m, k) =>
+    Object.prototype.hasOwnProperty.call(values, k) ? String(values[k]) : m,
+  );
+}
+
+function readTrim(p) {
+  return fs.readFileSync(p, 'utf8').replace(/\s+$/, '');
+}
+
+function buildSkill(skill, options) {
+  const opts = options || {};
+  const templatesDir = opts.templatesDir || path.join(PKG_ROOT, 'templates');
+  const sharedDir = opts.sharedDir || path.join(PKG_ROOT, 'shared');
+
+  const values = {
+    NAME: skill.name,
+    DESCRIPTION: skill.description,
+    SHARED: readTrim(path.join(sharedDir, 'skill-common.md')),
+  };
+  for (const sec of SECTIONS) {
+    const fragPath = path.join(templatesDir, 'fragments', `${skill.fragmentBase}.${sec}.md`);
+    values[sec.toUpperCase()] = readTrim(fragPath);
+  }
+
+  const tmpl = fs.readFileSync(path.join(templatesDir, 'skill.md.tmpl'), 'utf8');
+  const content = render(tmpl, values);
+  return { name: skill.name, description: skill.description, content };
+}
+
+function buildAll(options) {
+  const { skills } = require('./skills');
+  return skills.map((s) => buildSkill(s, options));
+}
+
+module.exports = { render, buildSkill, buildAll, PKG_ROOT, SECTIONS };