hive-intelligence 1.1.2 → 1.1.4

package/agent-skills/packs/hive-wallet-investigation/evals/evals.json

@@ -0,0 +1,27 @@
+{
+  "skill_name": "hive-wallet-investigation",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Investigate this Ethereum wallet's balances and recent transfers: 0x0000000000000000000000000000000000000000",
+      "expected_output": "Uses wallet_investigation, validates chain/address, starts with balances, adds bounded recent transfers, and reports source/freshness/runtime status.",
+      "files": [],
+      "assertions": [
+        "Chooses wallet_investigation.",
+        "Starts with balances/native balance.",
+        "Bounds transfer history."
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "This EVM wallet might be active on several chains. Can you inspect it?",
+      "expected_output": "Asks whether the user wants a specific chain or multi-chain scope, avoids silently mixing chains, and labels each provider/source.",
+      "files": [],
+      "assertions": [
+        "Asks for chain scope or states multi-chain plan.",
+        "Does not silently mix chain data.",
+        "Reports provider/runtime caveats."
+      ]
+    }
+  ]
+}

package/agent-skills/packs/hive-wallet-investigation/references/workflow.md

@@ -0,0 +1,45 @@
+# Wallet Investigation Workflow
+
+Use this reference for wallet balances, transfers, PnL, NFTs, DeFi positions,
+and notable activity.
+
+## Required identifiers
+
+- Wallet address.
+- Chain/network, unless the user explicitly asks for multi-chain.
+- Optional: time window, asset filter, counterparty, protocol, or NFT
+  collection.
+
+Ask for chain when an EVM address appears without context. For Solana wallets,
+use the Solana skill when the request is Solana-specific.
+
+## Tool selection order
+
+1. Validate the identifier shape for the requested chain.
+2. Use `search_tools` for wallet balance, native balance, transfer, NFT, DeFi,
+   and PnL tools.
+3. Inspect schemas before endpoint invocation.
+4. Start with balances/native balance.
+5. Add transfers for activity questions.
+6. Add NFTs, DeFi positions, or PnL only when relevant.
+
+## Bounded calls
+
+- Use explicit `limit`, `page`, `per_page`, or time filters for transfers.
+- Do not fetch full history for a quick portfolio read.
+- Avoid mixing chains unless the user requested multi-chain analysis.
+
+## Report template
+
+- Summary: wallet posture and notable finding.
+- Calls made: endpoints, chain, wallet, filters.
+- Evidence: balances, transfers, exposure, provider/freshness/runtime status.
+- Caveats: missing chains, truncated history, unavailable enrichment, degraded
+  providers.
+- Next action: chain expansion, transfer drilldown, risk check, or PnL detail.
+
+## Gotchas
+
+- Wallet labels and owner identity are not guaranteed.
+- Token balances can include spam or illiquid assets.
+- Absence of DeFi/NFT data may reflect provider coverage, not true absence.

package/agent-skills/references/agents-routing.md

@@ -0,0 +1,51 @@
+# Hive AGENTS.md Routing Snippet
+
+Use this compact routing block in `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, or a
+client-specific always-loaded instruction file. It solves the common failure
+mode where the skill exists but the agent answers from memory before loading it.
+
+```markdown
+## Hive MCP Routing
+
+For live crypto intelligence, prefer Hive retrieval over model memory.
+
+- User asks about live crypto data, prices, wallets, tokens, DeFi, NFTs,
+  Solana, security, DEX pools, network state, or prediction markets:
+  use `hive-query`.
+- Exact Hive endpoint, provider, schema, or argument shape is unknown:
+  use `hive-tool-discovery`.
+- Clear domain request:
+  - prices, liquidity, exchanges, OHLC, order books: `hive-market-research`
+  - token metadata, holders, liquidity, enrichment, risk:
+    `hive-token-diligence`
+  - wallet balances, transfers, PnL, NFTs, DeFi positions:
+    `hive-wallet-investigation`
+  - token, approval, contract, dApp, phishing, simulation risk:
+    `hive-security-risk`
+  - DEX pools, pairs, trades, liquidity, OHLCV: `hive-dex-pool-analysis`
+  - protocol TVL, fees, yields, stablecoins, bridges:
+    `hive-defi-research`
+  - NFT ownership, metadata, floors, sales, rarity: `hive-nft-research`
+  - Solana wallets, SPL accounts, DAS assets, priority fees:
+    `hive-solana-analysis`
+  - blocks, gas, receipts, logs, RPC diagnostics:
+    `hive-network-infrastructure`
+  - prediction markets, events, outcomes, traders:
+    `hive-prediction-markets`
+- User asks Hive to remember, monitor, schedule, alert, or report crypto
+  intelligence across sessions: use `hive-stateful-monitoring`.
+- Setup, API key, CLI, or app integration:
+  use `hive-mcp`, `hive-build-onboarding`, `hive-cli`, or `hive-build`.
+
+Default execution loop:
+1. Read `hive://toolsets` or call `search_tools`.
+2. Select one task toolset or exact endpoint.
+3. Call `get_api_endpoint_schema`.
+4. Execute through `invoke_api_endpoint` with bounded args.
+5. Report provider, source/freshness, fallback/cache/degraded state, and
+   runtime status (`ok`, `missing_key`, `plan_required`, `rate_limited`,
+   `degraded`, or `failing`).
+```
+
+Keep this snippet short. The skill files carry the detailed workflow and should
+be loaded only after the routing layer selects the right Hive skill.

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

@@ -0,0 +1,216 @@
+#!/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",
+]);
+
+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.`);
+  }
+}
+
+// Cross-manifest consistency: every pack on disk must also be installable via
+// the Claude plugin manifest and routed in the top-level SKILL.md. This guards
+// the drift mode where a pack ships with evals but is invisible to install and
+// routing (e.g. a skill missing from plugin.json never loads via plugin install).
+const pluginManifestPath = join(root, ".claude-plugin", "plugin.json");
+if (!existsSync(pluginManifestPath)) {
+  fail("agent-skills/.claude-plugin/plugin.json is missing.");
+} else {
+  const pluginManifest = readJson(pluginManifestPath);
+  if (pluginManifest) {
+    const pluginSkills = new Set((pluginManifest.skills ?? []).map((skill) => skill.name));
+    for (const skillName of skillDirs) {
+      if (!pluginSkills.has(skillName)) {
+        fail(`${skillName} is missing from .claude-plugin/plugin.json skills.`);
+      }
+    }
+    for (const entry of pluginManifest.skills ?? []) {
+      const referenced = entry.path ? join(root, ".claude-plugin", entry.path) : "";
+      if (!referenced || !existsSync(referenced)) {
+        fail(`plugin.json skill ${entry.name ?? "unknown"} path does not resolve: ${entry.path}`);
+      }
+    }
+    if (!pluginManifest.mcpServers) {
+      fail("plugin.json must declare mcpServers so installing the plugin also connects Hive MCP.");
+    } else if (typeof pluginManifest.mcpServers === "string") {
+      const mcpPath = join(root, pluginManifest.mcpServers);
+      if (!existsSync(mcpPath)) {
+        fail(`plugin.json mcpServers points to missing file ${pluginManifest.mcpServers}.`);
+      } else {
+        const mcp = readJson(mcpPath);
+        const hive = mcp?.mcpServers?.hive;
+        if (!hive?.url || !hive.url.includes("mcp.hiveintelligence.xyz")) {
+          fail(`${pluginManifest.mcpServers} must define mcpServers.hive.url for the hosted Hive endpoint.`);
+        }
+      }
+    }
+  }
+}
+
+const rootSkillBody = existsSync(join(root, "SKILL.md"))
+  ? readFileSync(join(root, "SKILL.md"), "utf8")
+  : "";
+for (const skillName of skillDirs) {
+  if (rootSkillBody && !rootSkillBody.includes(skillName)) {
+    fail(`${skillName} is not routed in the top-level SKILL.md.`);
+  }
+}
+
+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 skillDirs) {
+    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,41 @@
+{
+  "$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, prediction-market, and stateful monitoring 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",
+        "hive-stateful-monitoring"
+      ]
+    }
+  ]
+}

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-3OPMQF4X.js}

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

package/build/api-client-EPF6FD7A.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-7JWXBKEJ.js";
+import "./chunk-ZCU7XQKF.js";
+import "./chunk-POT2MBEK.js";
+import "./chunk-3WYWXTNN.js";
+export {
+  authLogin,
+  authMe,
+  authSignup,
+  createKey,
+  executeRemoteTool,
+  fetchToolCatalog,
+  fetchWithRetry,
+  getUsage,
+  listKeysApi,
+  revokeKeyApi
+};

package/build/auth-Q5Q24IRI.js

@@ -0,0 +1,39 @@
+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-5XXI25JE.js";
+import "./chunk-POT2MBEK.js";
+import "./chunk-3WYWXTNN.js";
+export {
+  getActiveProfile,
+  listProfiles,
+  maskKey,
+  removeProfile,
+  runKeysCreate,
+  runKeysList,
+  runKeysRevoke,
+  runLogin,
+  runLogout,
+  runProfiles,
+  runSignup,
+  runSwitch,
+  runUsage,
+  runWhoami,
+  saveProfile,
+  switchProfile
+};

package/build/browser-auth-VPF5LZMZ.js

@@ -0,0 +1,8 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  browserLogin
+} from "./chunk-GZPDEXO4.js";
+import "./chunk-3WYWXTNN.js";
+export {
+  browserLogin
+};

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

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

package/build/{chunk-QMRVH5ZP.js → chunk-3WYWXTNN.js}

@@ -11,6 +11,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -26,6 +29,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -34,11 +38,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 export {
   __require,
+  __esm,
   __commonJS,
   __export,
-  __toESM
+  __reExport,
+  __toESM,
+  __toCommonJS
 };
-//# sourceMappingURL=chunk-QMRVH5ZP.js.map