@agentskillshub/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentSkillsHub
+
+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,59 @@
+# `ash` — AgentSkillsHub CLI
+
+Search, audit, and install open-source AI agent skills & MCP servers from your terminal. Every result is **security-graded** and **quality-scored** by [AgentSkillsHub](https://agentskillshub.top).
+
+```bash
+npx @agentskillshub/cli search "scrape a website" --safe
+```
+
+## Why
+
+Discovering a skill is easy. Knowing whether it's safe to run against your credentials is not. `ash` puts the trust signal *before* the install:
+
+```
+$ ash search postgres --category mcp-server --limit 2
+
+call518/MCP-PostgreSQL-Ops  150★  🟢 SAFE
+  Give AI assistants full PostgreSQL DBA superpowers — 30+ tools…
+  mcp-server · claude-code · mcp · python   https://agentskillshub.top/skill/call518/MCP-PostgreSQL-Ops/
+
+sgaunet/postgresql-mcp  5★  ⚪ UNAUDITED  ~23.0k tok
+  A Model Context Protocol (MCP) server… read-only query execution…
+  mcp-server · claude-code · go · mcp   https://agentskillshub.top/skill/sgaunet/postgresql-mcp/
+```
+
+## Commands
+
+| | |
+|---|---|
+| `ash search <query> [filters]` | Find skills. Filters: `--category` `--platform` `--min-stars` `--safe` `--limit` |
+| `ash audit <owner/repo>` | Free basic trust check: security grade + plain-English verdict |
+| `ash install <owner/repo>` | Install commands + "check before you install" safety line |
+| `ash update` | Force-refresh the cached index |
+
+Add `--json` to any of `search` / `audit` / `install` for machine-readable output.
+
+## How it works
+
+The catalog (~20K quality skills, stars ≥ 5) is a single static file (~1.7MB gzipped) served from the CDN. `ash` downloads it once, caches it at `~/.cache/agentskillshub/`, and refreshes every ~8h. **All searching is local** — fast, works offline, and puts zero load on the backend.
+
+## Security grades
+
+🟢 SAFE · 🟡 CAUTION · 🔴 UNSAFE · ⛔ REJECT · ⚪ UNAUDITED
+
+⚪ **UNAUDITED** is not "probably fine" — it means *no one has audited it*. Check the code, the credentials it asks for, and who maintains it before you trust it.
+
+## Free vs. Pro
+
+- **Free**: search · basic audit · install commands, for any catalogued skill.
+- **Pro / Enterprise**: 5-dimension deep audit, any GitHub URL (incl. <5★ / private), CI/batch auditing, compliance evidence → <https://agentskillshub.top/enterprise/>
+
+## Env
+
+| Var | Default |
+|---|---|
+| `AGENTSKILLSHUB_BASE` | `https://agentskillshub.top` |
+| `AGENTSKILLSHUB_CACHE` | `~/.cache/agentskillshub` |
+| `NO_COLOR` | unset (set to disable color) |
+
+MIT © AgentSkillsHub

package/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: agentskillshub
+description: Use when the user wants to find, evaluate, audit, or install an open-source AI agent skill or MCP server — e.g. "find an MCP server for Postgres", "is this skill safe to install", "what should I use to scrape a website". Searches a quality-scored, security-graded catalog of ~20K skills locally (cached index, zero backend load) and returns each result's security grade, quality score, and install commands so you can check trust BEFORE installing.
+---
+
+# AgentSkillsHub
+
+Discover → audit → install open-source AI agent skills and MCP servers without leaving the terminal. Backed by [AgentSkillsHub](https://agentskillshub.top): ~106K indexed skills, of which ~20K (stars ≥ 5) are in the searchable catalog, each carrying a **quality score** and a **security grade**.
+
+The catalog is a static index downloaded once and cached locally (`~/.cache/agentskillshub/`, refreshed every ~8h). Every search after the first is **instant, offline, and puts zero load on the Hub backend**.
+
+## When to use
+
+- The user is looking for a skill / MCP server for a task ("find an MCP server for X", "what can scrape a website").
+- The user wants to know if a skill is safe / trustworthy before installing it.
+- The user wants the install command for a specific skill.
+
+## How to use
+
+The CLI is `bin/ash.mjs` (Node ≥ 18, zero dependencies). Run it with `node`:
+
+```bash
+# Search (local fuzzy ranking over name/desc/tags; quality + popularity tiebreak)
+node bin/ash.mjs search "scrape a website" --safe --limit 5
+node bin/ash.mjs search postgres --category mcp-server
+#   filters: --category <c> --platform <p> --min-stars <n> --safe --limit <n>
+
+# Audit — free basic trust check (security grade + plain-English verdict)
+node bin/ash.mjs audit owner/repo
+
+# Install — install commands + a "check before you install" safety line
+node bin/ash.mjs install owner/repo
+
+# Force-refresh the cached index
+node bin/ash.mjs update
+```
+
+Add `--json` to `search`, `audit`, or `install` for structured output to parse programmatically.
+
+## Reading the output
+
+- **Security grade**: 🟢 SAFE · 🟡 CAUTION · 🔴 UNSAFE · ⛔ REJECT · ⚪ UNAUDITED.
+  ⚪ UNAUDITED means *no one has ever audited it* — treat it as a black box, not as "probably fine". 97%+ of the wider catalog is unaudited; surface this honestly to the user.
+- **Quality score** (0-100): documentation, maintenance, examples, structure — not stars.
+- **`~Nk tok`**: rough context cost when loaded (omitted when the upstream estimate is implausible).
+- **✓ official**: published by a verified official org account.
+
+## What's free vs. paid
+
+- **Free**: search, basic audit (grade + flags + verdict), install commands — for any skill in the catalog.
+- **Pro / Enterprise**: 5-dimension deep audit (code · credentials · vendor · supply-chain · operational), auditing *any* GitHub URL (including < 5★ or private repos), CI/batch auditing, and compliance evidence. Point the user to <https://agentskillshub.top/enterprise/>.
+
+## Guidance for the agent
+
+- Default to `--safe` only when the user explicitly cares about production/brand safety; otherwise show the full ranked list so they see unaudited options too (and warn about them).
+- Before suggesting the user install anything, run `audit` and relay the grade honestly. Never imply an UNAUDITED skill is safe.
+- This skill **never runs install commands itself** — it returns the commands for the user/agent to run.

package/bin/ash.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+/**
+ * ash — AgentSkillsHub CLI
+ *
+ * Discover, audit, and install open-source AI agent skills / MCP servers
+ * without leaving the terminal. Searches a quality-filtered catalog of ~20K
+ * skills (stars >= 5) that is downloaded once and cached locally, so every
+ * search after the first is instant and offline — and puts ZERO load on the
+ * Hub's backend (the index is a static file on the CDN).
+ *
+ * Commands:
+ *   ash search <query> [filters]   find skills (local fuzzy ranking)
+ *   ash audit  <owner/repo>        free basic trust check (security grade + flags)
+ *   ash install <owner/repo>       install commands + "check before you install"
+ *   ash update                     force-refresh the cached index
+ *   ash --help
+ *
+ * Zero dependencies — Node >= 18 built-ins only (fetch, zlib, fs).
+ */
+
+import { gunzipSync } from "node:zlib";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const BASE = process.env.AGENTSKILLSHUB_BASE || "https://agentskillshub.top";
+const META_URL = `${BASE}/search-index-meta.json`;
+const INDEX_URL = `${BASE}/search-index.json.gz`;
+const HUB_SKILL = (full) => `${BASE}/skill/${full}/`;
+
+const CACHE_DIR = join(process.env.AGENTSKILLSHUB_CACHE || join(homedir(), ".cache", "agentskillshub"));
+const CACHE_INDEX = join(CACHE_DIR, "search-index.json");
+const CACHE_META = join(CACHE_DIR, "search-index-meta.json");
+const TTL_MS = 8 * 60 * 60 * 1000; // refresh at most every 8h (matches sync cadence)
+
+// security_grade → display
+const GRADE = {
+  safe: { label: "SAFE", mark: "🟢" },
+  caution: { label: "CAUTION", mark: "🟡" },
+  unsafe: { label: "UNSAFE", mark: "🔴" },
+  reject: { label: "REJECT", mark: "⛔" },
+  unknown: { label: "UNAUDITED", mark: "⚪" },
+};
+
+// ─── tiny ANSI (auto-off when not a TTY / NO_COLOR) ──────────────────────────
+const tty = process.stdout.isTTY && !process.env.NO_COLOR;
+const c = (code, s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : s);
+const bold = (s) => c("1", s);
+const dim = (s) => c("2", s);
+const cyan = (s) => c("36", s);
+const green = (s) => c("32", s);
+const yellow = (s) => c("33", s);
+
+// ─── cache / index loading ───────────────────────────────────────────────────
+async function fetchJson(url) {
+  const res = await fetch(url, { headers: { "user-agent": "ash-cli" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${url}`);
+  return res.json();
+}
+
+function readCachedIndex() {
+  if (!existsSync(CACHE_INDEX)) return null;
+  try {
+    return JSON.parse(readFileSync(CACHE_INDEX, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function cacheFresh() {
+  if (!existsSync(CACHE_INDEX)) return false;
+  return Date.now() - statSync(CACHE_INDEX).mtimeMs < TTL_MS;
+}
+
+async function downloadIndex() {
+  process.stderr.write(dim("⏬ downloading skill index…\n"));
+  const res = await fetch(INDEX_URL, { headers: { "user-agent": "ash-cli" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} fetching index`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  const json = gunzipSync(buf).toString("utf8");
+  mkdirSync(CACHE_DIR, { recursive: true });
+  writeFileSync(CACHE_INDEX, json);
+  const parsed = JSON.parse(json);
+  writeFileSync(CACHE_META, JSON.stringify({ v: parsed.v, generated_at: parsed.generated_at, count: parsed.count, min_stars: parsed.min_stars }));
+  process.stderr.write(dim(`✓ cached ${parsed.count} skills (${(buf.length / 1024 / 1024).toFixed(1)}MB)\n`));
+  return parsed;
+}
+
+/** Load index, refreshing if stale or if the CDN has a newer generation. */
+async function loadIndex({ force = false } = {}) {
+  if (!force && cacheFresh()) {
+    const cached = readCachedIndex();
+    if (cached) return cached;
+  }
+  // Cheap freshness probe (77B) before pulling the full 1.7MB index.
+  if (!force && existsSync(CACHE_META) && existsSync(CACHE_INDEX)) {
+    try {
+      const [remote, local] = [await fetchJson(META_URL), JSON.parse(readFileSync(CACHE_META, "utf8"))];
+      if (remote.generated_at === local.generated_at) {
+        writeFileSync(CACHE_INDEX, readFileSync(CACHE_INDEX)); // bump mtime → reset TTL
+        return readCachedIndex();
+      }
+    } catch {
+      const cached = readCachedIndex();
+      if (cached) return cached; // offline → serve stale rather than fail
+    }
+  }
+  try {
+    return await downloadIndex();
+  } catch (err) {
+    const cached = readCachedIndex();
+    if (cached) {
+      process.stderr.write(yellow(`⚠ refresh failed (${err.message}); using cached index\n`));
+      return cached;
+    }
+    throw err;
+  }
+}
+
+// ─── search ──────────────────────────────────────────────────────────────────
+function parseFilters(args) {
+  const f = { limit: 10, json: false, minStars: 0, safe: false, category: null, platform: null };
+  const terms = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--json") f.json = true;
+    else if (a === "--safe" || a === "--safe-only") f.safe = true;
+    else if (a === "--limit") f.limit = Math.max(1, parseInt(args[++i], 10) || 10);
+    else if (a === "--min-stars") f.minStars = parseInt(args[++i], 10) || 0;
+    else if (a === "--category") f.category = (args[++i] || "").toLowerCase();
+    else if (a === "--platform") f.platform = (args[++i] || "").toLowerCase();
+    else if (a.startsWith("--")) {} // ignore unknown flags
+    else terms.push(a);
+  }
+  f.query = terms.join(" ").trim();
+  return f;
+}
+
+/** Score one skill row against the tokenized query. Higher = better match. */
+function scoreRow(row, tokens) {
+  if (!tokens.length) return row.q || 0; // no query → quality-ranked browse
+  const name = (row.n || "").toLowerCase();
+  const full = (row.f || "").toLowerCase();
+  const desc = (row.d || "").toLowerCase();
+  const tags = (row.t || []).join(" ").toLowerCase();
+  let score = 0;
+  for (const tok of tokens) {
+    if (name === tok) score += 50;
+    else if (name.includes(tok)) score += 20;
+    if (full.includes(tok)) score += 8;
+    if (tags.includes(tok)) score += 10;
+    if (desc.includes(tok)) score += 5;
+  }
+  if (score === 0) return -1; // matched nothing
+  return score + (row.q || 0) / 20 + Math.min(row.s, 50000) / 25000; // quality + popularity tiebreak
+}
+
+function applyFilters(skills, f) {
+  return skills.filter((r) => {
+    if (f.minStars && (r.s || 0) < f.minStars) return false;
+    if (f.safe && !(r.g === "safe")) return false;
+    if (f.category && (r.c || "").toLowerCase() !== f.category) return false;
+    if (f.platform && !(r.p || []).map((p) => p.toLowerCase()).includes(f.platform)) return false;
+    return true;
+  });
+}
+
+function runSearch(index, args) {
+  const f = parseFilters(args);
+  const tokens = f.query.toLowerCase().split(/\s+/).filter(Boolean);
+  const pool = applyFilters(index.skills, f);
+  const ranked = pool
+    .map((r) => ({ r, score: scoreRow(r, tokens) }))
+    .filter((x) => x.score >= 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, f.limit)
+    .map((x) => x.r);
+
+  if (f.json) {
+    console.log(JSON.stringify(ranked.map(expand), null, 2));
+    return;
+  }
+  if (!ranked.length) {
+    console.log(dim(`No skills matched "${f.query}".`) + " Try fewer/broader terms or drop --safe / --category.");
+    return;
+  }
+  console.log(bold(`\n${ranked.length} result${ranked.length > 1 ? "s" : ""}`) + dim(`  ·  catalog ${index.count} skills, generated ${index.generated_at.slice(0, 10)}\n`));
+  ranked.forEach(printResult);
+  console.log(dim(`\nNext:  ash audit <owner/repo>   ·   ash install <owner/repo>\n`));
+}
+
+// ─── display helpers ─────────────────────────────────────────────────────────
+function gradeBadge(g) {
+  const meta = GRADE[g] || GRADE.unknown;
+  return `${meta.mark} ${meta.label}`;
+}
+
+/** estimated_tokens is noisy upstream (some rows hold whole-repo counts).
+ *  Only surface it when plausibly a context cost. */
+function tokenHint(k) {
+  if (!k || k <= 0 || k > 200000) return "";
+  return dim(`  ~${k >= 1000 ? (k / 1000).toFixed(1) + "k" : k} tok`);
+}
+
+function starStr(s) {
+  return s >= 1000 ? `${(s / 1000).toFixed(1)}k★` : `${s}★`;
+}
+
+function printResult(r) {
+  const head = `${bold(cyan(r.f))}  ${yellow(starStr(r.s))}  ${gradeBadge(r.g)}`;
+  console.log(head + tokenHint(r.k) + (r.o ? green("  ✓ official") : ""));
+  if (r.d) console.log(`  ${r.d}`);
+  const meta = [r.c, ...(r.p || [])].filter(Boolean).join(" · ");
+  console.log(dim(`  ${meta}   ${HUB_SKILL(r.f)}`) + "\n");
+}
+
+function expand(r) {
+  return {
+    repo_full_name: r.f, name: r.n, author: r.a, stars: r.s, description: r.d,
+    category: r.c, platforms: r.p, tags: r.t, quality_score: r.q,
+    security_grade: r.g, estimated_tokens: r.k, official: !!r.o, hub_url: HUB_SKILL(r.f),
+  };
+}
+
+// ─── audit (free basic tier) ─────────────────────────────────────────────────
+const VERDICT = {
+  safe: "Reviewed, no blocking issues — reasonable for general use. Still confirm credential handling for production.",
+  caution: "Has caution flags — fine for personal trials; review credentials/maintainer before brand or production use.",
+  unsafe: "Flagged unsafe — do NOT run against real credentials or production data.",
+  reject: "Rejected — known serious problems. Avoid.",
+  unknown: "Never audited by anyone. It's a black box: check the code, what credentials it asks for, and who maintains it before you trust it.",
+};
+
+function runAudit(index, args) {
+  const json = args.includes("--json");
+  const target = args.find((a) => !a.startsWith("--"));
+  if (!target) return fail('audit needs a target, e.g. `ash audit owner/repo`');
+  const row = index.skills.find((r) => r.f.toLowerCase() === target.toLowerCase());
+  if (!row) {
+    const msg = `"${target}" is not in the quality catalog (stars < 5, or not indexed).`;
+    if (json) return console.log(JSON.stringify({ target, in_catalog: false, note: msg + " Deep audit of any GitHub URL is a Pro feature." }, null, 2));
+    console.log(`\n${yellow("Not in the free catalog.")} ${msg}`);
+    console.log(dim(`Deep audit of any GitHub URL (incl. <5★ / private) is a Pro feature → ${BASE}/enterprise/\n`));
+    return;
+  }
+  if (json) {
+    return console.log(JSON.stringify({ ...expand(row), in_catalog: true, verdict: VERDICT[row.g] || VERDICT.unknown, tier_note: "Basic (free). 5-dimension deep audit + any GitHub URL → Pro." }, null, 2));
+  }
+  console.log(`\n${bold(cyan(row.f))}  ${yellow(starStr(row.s))}${row.o ? green("  ✓ official") : ""}`);
+  console.log(`Security: ${gradeBadge(row.g)}     Quality: ${row.q}/100`);
+  if (row.d) console.log(dim(`\n  ${row.d}`));
+  console.log(`\n${bold("Basic verdict")} ${dim("(free tier)")}`);
+  console.log(`  ${VERDICT[row.g] || VERDICT.unknown}`);
+  console.log(dim(`\n  Full 5-dimension audit (code · credentials · vendor · supply-chain · operational)`));
+  console.log(dim(`  + any GitHub URL → ${BASE}/enterprise/`));
+  console.log(dim(`  Report page: ${HUB_SKILL(row.f)}#audit\n`));
+}
+
+// ─── install ─────────────────────────────────────────────────────────────────
+function installCommands(full) {
+  return {
+    "claude-code": `npx skills add ${full}`,
+    cursor: `npx skills add ${full}`,
+    manual: `git clone https://github.com/${full}.git`,
+  };
+}
+
+function runInstall(index, args) {
+  const json = args.includes("--json");
+  const target = args.find((a) => !a.startsWith("--"));
+  if (!target) return fail('install needs a target, e.g. `ash install owner/repo`');
+  const row = index.skills.find((r) => r.f.toLowerCase() === target.toLowerCase());
+  const cmds = installCommands(target);
+  if (json) {
+    return console.log(JSON.stringify({ repo_full_name: target, in_catalog: !!row, install_commands: cmds, pre_install_safety: row ? { security_grade: row.g, must_check: ["What credentials does it ask for, and where are they stored?", "Is the maintainer identifiable / the repo actively maintained?"] } : null, hub_url: HUB_SKILL(target) }, null, 2));
+  }
+  console.log(`\n${bold("Install ")}${cyan(target)}`);
+  console.log(`  ${green(cmds["claude-code"])}   ${dim("# Claude Code / Cursor")}`);
+  console.log(dim(`  ${cmds.manual}   # manual\n`));
+  if (row) {
+    console.log(`${bold("Before you install")}  ${gradeBadge(row.g)}`);
+    if (row.g === "unknown") console.log(`  ${yellow("Unaudited.")} Check the code, the credentials it requests, and who maintains it.`);
+    else console.log(`  ${VERDICT[row.g]}`);
+  } else {
+    console.log(dim("Not in the quality catalog — audit it yourself before trusting it."));
+  }
+  console.log(dim(`\n  Details: ${HUB_SKILL(target)}\n`));
+}
+
+// ─── plumbing ────────────────────────────────────────────────────────────────
+function fail(msg) {
+  console.error(`✗ ${msg}`);
+  process.exitCode = 1;
+}
+
+const HELP = `${bold("ash")} — AgentSkillsHub CLI  ${dim("· search · audit · install · ~20K skills")}
+
+${bold("Usage")}
+  ash search <query> [--category <c>] [--platform <p>] [--min-stars <n>] [--safe] [--limit <n>] [--json]
+  ash audit  <owner/repo> [--json]
+  ash install <owner/repo> [--json]
+  ash update                      force-refresh the cached index
+  ash --help
+
+${bold("Examples")}
+  ash search "scrape a website" --safe
+  ash search postgres --category mcp-server --limit 5
+  ash audit modelcontextprotocol/servers
+  ash install owner/repo
+
+${dim("Index is a static CDN file, downloaded once and cached at")} ${CACHE_DIR}
+${dim("Refreshes every 8h. Zero backend load.  Set NO_COLOR=1 to disable color.")}`;
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") return console.log(HELP);
+
+  if (cmd === "update") {
+    await loadIndex({ force: true });
+    return console.log(green("✓ index refreshed."));
+  }
+  const index = await loadIndex();
+  if (cmd === "search" || cmd === "s") return runSearch(index, rest);
+  if (cmd === "audit" || cmd === "a") return runAudit(index, rest);
+  if (cmd === "install" || cmd === "i") return runInstall(index, rest);
+
+  // bare `ash <query>` → treat as search
+  runSearch(index, [cmd, ...rest]);
+}
+
+main().catch((err) => fail(err.message || String(err)));

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@agentskillshub/cli",
+  "version": "0.1.0",
+  "description": "Search, audit, and install open-source AI agent skills & MCP servers from the terminal — security-graded, quality-scored.",
+  "type": "module",
+  "bin": {
+    "ash": "bin/ash.mjs"
+  },
+  "files": [
+    "bin/ash.mjs",
+    "SKILL.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "Jason Zhu (AgentSkillsHub)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentskillshub/cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/agentskillshub/cli/issues"
+  },
+  "keywords": [
+    "mcp",
+    "ai-agent",
+    "claude",
+    "skills",
+    "security-audit",
+    "cli"
+  ],
+  "homepage": "https://agentskillshub.top",
+  "license": "MIT"
+}