hive-intelligence 1.1.2 → 1.1.3

package/agent-skills/scripts/validate-agent-skills-package.mjs

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const packsRoot = join(root, "packs");
+const failures = [];
+
+const workflowReferenceSkills = new Set([
+  "hive-market-research",
+  "hive-token-diligence",
+  "hive-wallet-investigation",
+  "hive-security-risk",
+  "hive-dex-pool-analysis",
+  "hive-defi-research",
+  "hive-nft-research",
+  "hive-solana-analysis",
+  "hive-network-infrastructure",
+  "hive-prediction-markets",
+]);
+
+const requiredTriggerCoverage = new Set([
+  "hive-query",
+  "hive-tool-discovery",
+  "hive-mcp",
+  "hive-build",
+  "hive-build-onboarding",
+  "hive-cli",
+  "hive-token-diligence",
+]);
+
+function fail(message) {
+  failures.push(message);
+  console.log(`- [FAIL] ${message}`);
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    fail(`${file} is not valid JSON: ${error.message}`);
+    return null;
+  }
+}
+
+function frontmatter(body, file) {
+  const match = body.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) {
+    fail(`${file} is missing YAML frontmatter.`);
+    return "";
+  }
+  return match[1];
+}
+
+function field(frontmatterBody, name) {
+  return frontmatterBody.match(new RegExp(`^${name}:\\s*(.*)$`, "m"))?.[1] ?? "";
+}
+
+console.log("# Hive Agent Skills Package Validation\n");
+
+if (!existsSync(join(root, "LICENSE"))) fail("agent-skills/LICENSE is missing.");
+if (!existsSync(join(root, "SKILL.md"))) fail("agent-skills/SKILL.md is missing.");
+if (!existsSync(join(root, "skills.sh.json"))) fail("agent-skills/skills.sh.json is missing.");
+if (!existsSync(join(root, "references", "agents-routing.md"))) {
+  fail("agent-skills/references/agents-routing.md is missing.");
+}
+if (!existsSync(join(root, "evals", "trigger-queries.json"))) {
+  fail("agent-skills/evals/trigger-queries.json is missing.");
+}
+
+const skillDirs = readdirSync(packsRoot, { withFileTypes: true })
+  .filter((entry) => entry.isDirectory())
+  .map((entry) => entry.name)
+  .sort();
+
+for (const skillName of skillDirs) {
+  const skillDir = join(packsRoot, skillName);
+  const skillFile = join(skillDir, "SKILL.md");
+  console.log(`### ${skillName}`);
+
+  if (!existsSync(skillFile)) {
+    fail(`${skillName} is missing SKILL.md.`);
+    continue;
+  }
+
+  const body = readFileSync(skillFile, "utf8");
+  const fm = frontmatter(body, skillFile);
+  const name = field(fm, "name");
+  const description = field(fm, "description");
+
+  if (name !== skillName) fail(`${skillName} frontmatter name must match directory.`);
+  if (!description.startsWith("Use this skill")) {
+    fail(`${skillName} description must start with trigger language: "Use this skill".`);
+  }
+  if (description.includes(": ")) {
+    fail(`${skillName} description contains ': ', which breaks some YAML parsers unless quoted.`);
+  }
+  if (description.length > 1024) fail(`${skillName} description exceeds 1024 characters.`);
+  if (!field(fm, "license")) fail(`${skillName} is missing license frontmatter.`);
+  if (!fm.includes("metadata:\n")) fail(`${skillName} is missing metadata frontmatter.`);
+  if (!fm.includes('package: "@hiveintelligence/agent-skills"')) {
+    fail(`${skillName} metadata.package must identify @hiveintelligence/agent-skills.`);
+  }
+  if (!body.includes("## Runtime status handling")) {
+    fail(`${skillName} must document runtime status handling.`);
+  }
+
+  const evalFile = join(skillDir, "evals", "evals.json");
+  if (!existsSync(evalFile)) {
+    fail(`${skillName} is missing evals/evals.json.`);
+  } else {
+    const evals = readJson(evalFile);
+    if (evals?.skill_name !== skillName) fail(`${skillName} eval skill_name mismatch.`);
+    if (!Array.isArray(evals?.evals) || evals.evals.length < 2) {
+      fail(`${skillName} must define at least two eval prompts.`);
+    }
+    for (const entry of evals?.evals ?? []) {
+      if (!entry.prompt || !entry.expected_output) {
+        fail(`${skillName} eval ${entry.id ?? "unknown"} needs prompt and expected_output.`);
+      }
+      if (!Array.isArray(entry.assertions) || entry.assertions.length === 0) {
+        fail(`${skillName} eval ${entry.id ?? "unknown"} needs assertions.`);
+      }
+    }
+  }
+
+  if (workflowReferenceSkills.has(skillName)) {
+    const workflow = join(skillDir, "references", "workflow.md");
+    if (!existsSync(workflow)) fail(`${skillName} is missing references/workflow.md.`);
+  }
+
+  const referenceMatches = [...body.matchAll(/`(references\/[^`]+)`/g)];
+  for (const match of referenceMatches) {
+    const referenced = join(skillDir, match[1]);
+    if (!existsSync(referenced)) fail(`${skillName} references missing file ${match[1]}.`);
+  }
+}
+
+const directoryManifest = readJson(join(root, "skills.sh.json"));
+if (directoryManifest) {
+  const groupedSkills = new Set();
+  for (const grouping of directoryManifest.groupings ?? []) {
+    for (const skill of grouping.skills ?? []) groupedSkills.add(skill);
+  }
+  for (const skillName of skillDirs) {
+    if (!groupedSkills.has(skillName)) fail(`${skillName} is missing from skills.sh.json groupings.`);
+  }
+}
+
+const triggerQueries = readJson(join(root, "evals", "trigger-queries.json"));
+if (triggerQueries) {
+  const triggerSkillNames = new Set();
+  for (const skill of triggerQueries.skills ?? []) {
+    triggerSkillNames.add(skill.skill_name);
+    if (!skillDirs.includes(skill.skill_name)) {
+      fail(`trigger-queries references unknown skill ${skill.skill_name}.`);
+    }
+    for (const split of ["train", "validation"]) {
+      for (const query of skill[split] ?? []) {
+        if (typeof query.query !== "string" || typeof query.should_trigger !== "boolean") {
+          fail(`trigger-queries ${skill.skill_name}.${split} entries need query and should_trigger.`);
+        }
+      }
+    }
+  }
+  for (const skillName of requiredTriggerCoverage) {
+    if (!triggerSkillNames.has(skillName)) {
+      fail(`trigger-queries must include trigger coverage for ${skillName}.`);
+    }
+  }
+}
+
+console.log("\n## Summary");
+console.log(`Skills: ${skillDirs.length}`);
+console.log(`Failures: ${failures.length}`);
+
+if (failures.length > 0) process.exit(1);

package/agent-skills/skills.sh.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://skills.sh/schemas/skills.sh.schema.json",
+  "notGrouped": "bottom",
+  "groupings": [
+    {
+      "title": "Setup and Build",
+      "description": "Skills for installing Hive MCP, getting API keys, using the Hive CLI, and integrating Hive into application code.",
+      "skills": [
+        "hive-mcp",
+        "hive-build-onboarding",
+        "hive-cli",
+        "hive-build"
+      ]
+    },
+    {
+      "title": "Discovery and Routing",
+      "description": "Skills that teach agents how to discover task toolsets, inspect schemas, and execute bounded Hive MCP calls.",
+      "skills": [
+        "hive-query",
+        "hive-tool-discovery"
+      ]
+    },
+    {
+      "title": "Crypto Research Workflows",
+      "description": "Focused workflows for market, token, wallet, security, DEX, DeFi, NFT, Solana, network, and prediction-market analysis.",
+      "skills": [
+        "hive-market-research",
+        "hive-token-diligence",
+        "hive-wallet-investigation",
+        "hive-security-risk",
+        "hive-dex-pool-analysis",
+        "hive-defi-research",
+        "hive-nft-research",
+        "hive-solana-analysis",
+        "hive-network-infrastructure",
+        "hive-prediction-markets"
+      ]
+    }
+  ]
+}

package/bin/hive-mcp.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+// CJS-style version check runs BEFORE ESM parsing.
+// In an ESM file (type:module), static imports are parsed before execution,
+// so a version check using `if (major < 20)` would never execute on old Node.
+// However, since this file IS ESM and uses import statements, the check below
+// is a best-effort guard for Node 20+ (which already supports ESM + TLA).
+// For Node <16, this file fails at parse time with a SyntaxError — engines
+// field in package.json is the primary enforcement mechanism.
+
+const major = parseInt(process.versions.node.split(".")[0], 10);
+if (major < 20) {
+  process.stderr.write(
+    `Error: hive requires Node.js 20 or later (found ${process.versions.node}).\n`,
+  );
+  process.exit(1);
+}
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cliPath = join(__dirname, "..", "build", "cli.js");
+
+if (!existsSync(cliPath)) {
+  process.stderr.write(
+    "Error: build/cli.js not found. Run `npm run build` or `bun run build` first.\n",
+  );
+  process.exit(1);
+}
+
+await import(cliPath);

package/build/{alias-INGXWFCG.js → alias-CZ3DEYHF.js}

@@ -3,8 +3,8 @@ import {
   ensureConfigDir,
   getConfig,
   saveConfig
-} from "./chunk-XQJ6PB2L.js";
-import "./chunk-QMRVH5ZP.js";
+} from "./chunk-V77LO4RO.js";
+import "./chunk-KBVPIZS4.js";
 
 // src/cli/alias.ts
 function getAliases() {
@@ -38,4 +38,4 @@ export {
   removeAlias,
   setAlias
 };
-//# sourceMappingURL=alias-INGXWFCG.js.map
+//# sourceMappingURL=alias-CZ3DEYHF.js.map

package/build/api-client-I23XLSHU.js

@@ -0,0 +1,28 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  authLogin,
+  authMe,
+  authSignup,
+  createKey,
+  executeRemoteTool,
+  fetchToolCatalog,
+  fetchWithRetry,
+  getUsage,
+  listKeysApi,
+  revokeKeyApi
+} from "./chunk-IZTN7WFH.js";
+import "./chunk-V77LO4RO.js";
+import "./chunk-KBVPIZS4.js";
+export {
+  authLogin,
+  authMe,
+  authSignup,
+  createKey,
+  executeRemoteTool,
+  fetchToolCatalog,
+  fetchWithRetry,
+  getUsage,
+  listKeysApi,
+  revokeKeyApi
+};
+//# sourceMappingURL=api-client-I23XLSHU.js.map

package/build/auth-KKINNBXT.js

@@ -0,0 +1,40 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  getActiveProfile,
+  listProfiles,
+  maskKey,
+  removeProfile,
+  runKeysCreate,
+  runKeysList,
+  runKeysRevoke,
+  runLogin,
+  runLogout,
+  runProfiles,
+  runSignup,
+  runSwitch,
+  runUsage,
+  runWhoami,
+  saveProfile,
+  switchProfile
+} from "./chunk-RKICZ6DZ.js";
+import "./chunk-V77LO4RO.js";
+import "./chunk-KBVPIZS4.js";
+export {
+  getActiveProfile,
+  listProfiles,
+  maskKey,
+  removeProfile,
+  runKeysCreate,
+  runKeysList,
+  runKeysRevoke,
+  runLogin,
+  runLogout,
+  runProfiles,
+  runSignup,
+  runSwitch,
+  runUsage,
+  runWhoami,
+  saveProfile,
+  switchProfile
+};
+//# sourceMappingURL=auth-KKINNBXT.js.map

package/build/browser-auth-EEFGRHWY.js

@@ -0,0 +1,9 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  browserLogin
+} from "./chunk-PGBVNMNZ.js";
+import "./chunk-KBVPIZS4.js";
+export {
+  browserLogin
+};
+//# sourceMappingURL=browser-auth-EEFGRHWY.js.map

package/build/{cache-US4LSZPI.js → cache-EGNMENNA.js}

@@ -4,8 +4,8 @@ import {
   getConfigDir,
   readJsonFile,
   writeJsonFile
-} from "./chunk-XQJ6PB2L.js";
-import "./chunk-QMRVH5ZP.js";
+} from "./chunk-V77LO4RO.js";
+import "./chunk-KBVPIZS4.js";
 
 // src/cli/cache.ts
 import { existsSync, unlinkSync } from "fs";
@@ -49,4 +49,4 @@ export {
   getCachedTools,
   setCachedTools
 };
-//# sourceMappingURL=cache-US4LSZPI.js.map
+//# sourceMappingURL=cache-EGNMENNA.js.map