hive-intelligence 1.1.2 → 1.1.4

package/build/{chunk-CP3FXEQA.js → chunk-NP6NSOG2.js}

@@ -187,7 +187,7 @@ async function writeOutput(envelope) {
   }
   if (globalOpts.csv && envelope.ok && Array.isArray(envelope.data)) {
     process.stdout.write(
-      await formatCsv(envelope.data) + "\n"
+      formatCsv(envelope.data) + "\n"
     );
     return;
   }
@@ -206,7 +206,7 @@ async function writeOutput(envelope) {
   }
   if (envelope.ok && envelope.data != null) {
     if (Array.isArray(envelope.data) && envelope.data.length > 0 && typeof envelope.data[0] === "object" && envelope.data[0] !== null) {
-      const { formatTable } = await import("./format-CVLLK6GD.js");
+      const { formatTable } = await import("./format-5X2HIVDT.js");
       process.stdout.write(
         formatTable(envelope.data) + "\n"
       );
@@ -246,12 +246,11 @@ function debug(msg) {
 function isCI() {
   return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.JENKINS_URL || process.env.HIVE_CI);
 }
-async function formatCsv(data) {
+function formatCsv(data) {
   if (data.length === 0) return "";
-  const { formatCell } = await import("./format-CVLLK6GD.js");
   const keys = [...new Set(data.flatMap((row) => Object.keys(row)))];
   const escape = (val) => {
-    const str = formatCell(val);
+    const str = val == null ? "" : String(val);
     return str.includes(",") || str.includes('"') || str.includes("\n") ? `"${str.replace(/"/g, '""')}"` : str;
   };
   const header = keys.join(",");
@@ -278,4 +277,3 @@ export {
   isCI,
   formatCsv
 };
-//# sourceMappingURL=chunk-CP3FXEQA.js.map

package/build/{chunk-XQJ6PB2L.js → chunk-POT2MBEK.js}

@@ -92,4 +92,3 @@ export {
   resolveApiKey,
   resolveApiUrl
 };
-//# sourceMappingURL=chunk-XQJ6PB2L.js.map

package/build/chunk-VBOKVQ74.js

@@ -0,0 +1,280 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// src/agentSkills.ts
+var HIVE_AGENT_SKILLS = [
+  {
+    name: "hive-mcp",
+    label: "Install Hive MCP",
+    description: "Connect Hive's hosted remote MCP endpoint to Claude, Cursor, VS Code, OpenAI Responses API, Codex, Gemini, and supported MCP clients.",
+    path: "agent-skills/packs/hive-mcp/SKILL.md",
+    toolsetIds: ["search_discovery"],
+    useWhen: ["install hive", "connect mcp", "configure client"]
+  },
+  {
+    name: "hive-build-onboarding",
+    label: "Get a Hive API Key",
+    description: "Guide agents through browser auth, dashboard key creation, and headless environment setup.",
+    path: "agent-skills/packs/hive-build-onboarding/SKILL.md",
+    toolsetIds: ["search_discovery"],
+    useWhen: ["no api key", "sign up", "lost key"]
+  },
+  {
+    name: "hive-build",
+    label: "Build With Hive",
+    description: "Use Hive from application code through REST, MCP clients, or the source-only TypeScript adapter.",
+    path: "agent-skills/packs/hive-build/SKILL.md",
+    toolsetIds: ["search_discovery"],
+    useWhen: ["integrate api", "backend", "sdk", "production app"]
+  },
+  {
+    name: "hive-cli",
+    label: "Use Hive CLI",
+    description: "Run Hive from shell scripts, cron jobs, and terminal research workflows.",
+    path: "agent-skills/packs/hive-cli/SKILL.md",
+    toolsetIds: ["search_discovery"],
+    useWhen: ["terminal", "cli", "jq", "cron"]
+  },
+  {
+    name: "hive-query",
+    label: "Route A Crypto Query",
+    description: "Start from the user's intent, choose the canonical task toolset, inspect schemas, and call exact Hive tools.",
+    path: "agent-skills/packs/hive-query/SKILL.md",
+    toolsetIds: [
+      "market_research",
+      "token_diligence",
+      "wallet_investigation",
+      "security_risk",
+      "onchain_dex_pool_analysis",
+      "defi_protocol_analysis",
+      "nft_research",
+      "network_infrastructure",
+      "solana_analysis",
+      "prediction_markets",
+      "stateful_monitoring",
+      "search_discovery"
+    ],
+    useWhen: [
+      "crypto question",
+      "pick a tool",
+      "tool routing",
+      "unknown crypto data",
+      "which hive endpoint"
+    ]
+  },
+  {
+    name: "hive-stateful-monitoring",
+    label: "Stateful Monitoring",
+    description: "Create, list, update, and archive durable crypto intelligence monitors that agents can schedule, remember, and report from.",
+    path: "agent-skills/packs/hive-stateful-monitoring/SKILL.md",
+    toolsetIds: ["stateful_monitoring"],
+    useWhen: [
+      "remember this",
+      "monitor wallet",
+      "watch token",
+      "schedule crypto report",
+      "alert me",
+      "persistent crypto memory"
+    ]
+  },
+  {
+    name: "hive-tool-discovery",
+    label: "Tool Discovery",
+    description: "Use search_tools, hive://toolsets, schema lookup, and invoke_api_endpoint correctly.",
+    path: "agent-skills/packs/hive-tool-discovery/SKILL.md",
+    toolsetIds: ["search_discovery"],
+    useWhen: [
+      "unknown tool",
+      "schema",
+      "discovery",
+      "search tools",
+      "invoke endpoint",
+      "category tool"
+    ]
+  },
+  {
+    name: "hive-market-research",
+    label: "Market Research",
+    description: "Research prices, liquidity, exchanges, OHLC, order books, and derivatives context.",
+    path: "agent-skills/packs/hive-market-research/SKILL.md",
+    toolsetIds: ["market_research"],
+    useWhen: [
+      "price",
+      "market",
+      "spot",
+      "exchange",
+      "order book",
+      "ohlc",
+      "volume",
+      "funding",
+      "open interest",
+      "liquidations",
+      "derivatives",
+      "options"
+    ]
+  },
+  {
+    name: "hive-token-diligence",
+    label: "Token Diligence",
+    description: "Investigate token metadata, market context, liquidity, holders, enrichment, and risk.",
+    path: "agent-skills/packs/hive-token-diligence/SKILL.md",
+    toolsetIds: ["token_diligence"],
+    useWhen: [
+      "token",
+      "contract",
+      "holders",
+      "top traders",
+      "metadata",
+      "socials",
+      "liquidity",
+      "safe to buy",
+      "token diligence"
+    ]
+  },
+  {
+    name: "hive-wallet-investigation",
+    label: "Wallet Investigation",
+    description: "Inspect wallet balances, transfers, NFTs, PnL, DeFi positions, and notable activity.",
+    path: "agent-skills/packs/hive-wallet-investigation/SKILL.md",
+    toolsetIds: ["wallet_investigation"],
+    useWhen: [
+      "wallet",
+      "portfolio",
+      "balances",
+      "holdings",
+      "pnl",
+      "profitability",
+      "transfers",
+      "swaps",
+      "defi positions",
+      "chain activity"
+    ]
+  },
+  {
+    name: "hive-security-risk",
+    label: "Security Risk",
+    description: "Check token, approval, address, phishing, contract, and simulation risk signals.",
+    path: "agent-skills/packs/hive-security-risk/SKILL.md",
+    toolsetIds: ["security_risk"],
+    useWhen: [
+      "security",
+      "risk",
+      "safe",
+      "scam",
+      "rugpull",
+      "honeypot",
+      "malicious",
+      "phishing",
+      "dapp",
+      "approval",
+      "calldata",
+      "simulate"
+    ]
+  },
+  {
+    name: "hive-dex-pool-analysis",
+    label: "DEX And Pool Analysis",
+    description: "Analyze on-chain pools, pairs, liquidity, trades, OHLCV, and DEX flow.",
+    path: "agent-skills/packs/hive-dex-pool-analysis/SKILL.md",
+    toolsetIds: ["onchain_dex_pool_analysis"],
+    useWhen: [
+      "dex",
+      "pool",
+      "pair",
+      "liquidity",
+      "trades",
+      "ohlcv",
+      "trending pools",
+      "uniswap"
+    ]
+  },
+  {
+    name: "hive-defi-research",
+    label: "DeFi Research",
+    description: "Analyze protocols, TVL, fees, revenue, stablecoins, bridges, and yield pools.",
+    path: "agent-skills/packs/hive-defi-research/SKILL.md",
+    toolsetIds: ["defi_protocol_analysis"],
+    useWhen: [
+      "defi",
+      "protocol",
+      "tvl",
+      "fees",
+      "revenue",
+      "stablecoin",
+      "bridge",
+      "yield",
+      "apy"
+    ]
+  },
+  {
+    name: "hive-nft-research",
+    label: "NFT Research",
+    description: "Research NFT collections, ownership, metadata, floor price, sales, rarity, and spam checks.",
+    path: "agent-skills/packs/hive-nft-research/SKILL.md",
+    toolsetIds: ["nft_research"],
+    useWhen: [
+      "nft",
+      "collection",
+      "floor",
+      "sales",
+      "owner",
+      "metadata",
+      "rarity",
+      "spam"
+    ]
+  },
+  {
+    name: "hive-solana-analysis",
+    label: "Solana Analysis",
+    description: "Analyze Solana wallets, SPL token accounts, DAS assets, parsed transactions, and priority fees.",
+    path: "agent-skills/packs/hive-solana-analysis/SKILL.md",
+    toolsetIds: ["solana_analysis"],
+    useWhen: [
+      "solana",
+      "spl",
+      "das",
+      "priority fee",
+      "pumpfun",
+      "token accounts",
+      "parsed transaction"
+    ]
+  },
+  {
+    name: "hive-network-infrastructure",
+    label: "Network Infrastructure",
+    description: "Read chain state, gas, blocks, receipts, logs, transaction status, and RPC diagnostics.",
+    path: "agent-skills/packs/hive-network-infrastructure/SKILL.md",
+    toolsetIds: ["network_infrastructure"],
+    useWhen: [
+      "gas",
+      "block",
+      "receipt",
+      "logs",
+      "rpc",
+      "transaction status",
+      "chain state",
+      "tenderly networks"
+    ]
+  },
+  {
+    name: "hive-prediction-markets",
+    label: "Prediction Markets",
+    description: "Research prediction markets, events, outcomes, market stats, traders, holders, and trades.",
+    path: "agent-skills/packs/hive-prediction-markets/SKILL.md",
+    toolsetIds: ["prediction_markets"],
+    useWhen: [
+      "prediction market",
+      "polymarket",
+      "kalshi",
+      "odds",
+      "election odds",
+      "sports odds",
+      "event",
+      "outcome",
+      "prediction traders"
+    ]
+  }
+];
+
+export {
+  HIVE_AGENT_SKILLS
+};

package/build/{chunk-WKVZVQTG.js → chunk-YZ2PXBJK.js}

@@ -1,13 +1,16 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  SERVER_VERSION
+} from "./chunk-ZCU7XQKF.js";
 import {
   ensureConfigDir,
   getConfig,
   saveConfig
-} from "./chunk-XQJ6PB2L.js";
+} from "./chunk-POT2MBEK.js";
 
 // src/cli/telemetry.ts
 import { platform, release } from "os";
-var TELEMETRY_URL = "https://dev.hiveintelligence.xyz/api/v1/telemetry";
+var TELEMETRY_URL = process.env.HIVE_CLI_TELEMETRY_URL ?? "https://mcp.hiveintelligence.xyz/api/v1/telemetry";
 function isTelemetryEnabled() {
   return getConfig().telemetry === true;
 }
@@ -43,7 +46,7 @@ function trackCommand(command, durationMs, errorCode) {
     command,
     durationMs,
     errorCode,
-    cliVersion: process.env.npm_package_version ?? "0.1.2",
+    cliVersion: process.env.npm_package_version ?? SERVER_VERSION,
     os: `${platform()} ${release()}`,
     nodeVersion: process.version
   };
@@ -63,4 +66,3 @@ export {
   telemetryStatus,
   trackCommand
 };
-//# sourceMappingURL=chunk-WKVZVQTG.js.map

package/build/chunk-ZCU7XQKF.js

@@ -0,0 +1,14 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// src/version.ts
+var SERVER_NAME = "hive-mcp-server";
+var SERVER_VERSION = "1.1.4";
+var REGISTRY_PACKAGE = "hive-intelligence";
+var CLI_BINARY = "hive";
+
+export {
+  SERVER_NAME,
+  SERVER_VERSION,
+  REGISTRY_PACKAGE,
+  CLI_BINARY
+};

package/build/chunk-ZTJVOWDQ.js

@@ -0,0 +1,85 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+
+// src/cli/errors.ts
+import { distance } from "fastest-levenshtein";
+var ExitCode = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  INVALID_ARGS: 2,
+  TOOL_NOT_FOUND: 3,
+  API_ERROR: 4,
+  AUTH_FAILURE: 5,
+  RATE_LIMITED: 6,
+  TIMEOUT: 124
+};
+var ERROR_CODE_TO_EXIT = {
+  GENERAL_ERROR: ExitCode.GENERAL_ERROR,
+  INVALID_ARGS: ExitCode.INVALID_ARGS,
+  TOOL_NOT_FOUND: ExitCode.TOOL_NOT_FOUND,
+  API_ERROR: ExitCode.API_ERROR,
+  PROVIDER_UNAVAILABLE: ExitCode.AUTH_FAILURE,
+  RATE_LIMITED: ExitCode.RATE_LIMITED,
+  TIMEOUT: ExitCode.TIMEOUT,
+  VALIDATION_ERROR: ExitCode.INVALID_ARGS
+};
+var ERROR_DOC_URLS = {
+  RATE_LIMITED: "https://www.hiveintelligence.xyz/errors#rate-limited",
+  TIMEOUT: "https://www.hiveintelligence.xyz/errors#timeout",
+  PROVIDER_UNAVAILABLE: "https://www.hiveintelligence.xyz/errors#provider-unavailable",
+  TOOL_NOT_FOUND: "https://www.hiveintelligence.xyz/errors#tool-not-found"
+};
+var CliError = class extends Error {
+  code;
+  exitCode;
+  suggestion;
+  docUrl;
+  constructor(code, message, suggestion, docUrl) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = ERROR_CODE_TO_EXIT[code] ?? ExitCode.GENERAL_ERROR;
+    this.suggestion = suggestion;
+    this.docUrl = docUrl ?? ERROR_DOC_URLS[code];
+  }
+};
+function classifyError(error, toolName) {
+  if (error instanceof CliError) return error;
+  const msg = error instanceof Error ? error.message : String(error);
+  const lower = msg.toLowerCase();
+  if (lower.includes("timed out") || lower.includes("timeout")) {
+    return new CliError("TIMEOUT", msg, "Increase timeout with --timeout <ms>");
+  }
+  if (lower.includes("rate limit") || lower.includes("429")) {
+    return new CliError(
+      "RATE_LIMITED",
+      msg,
+      "Wait and retry, or reduce request frequency"
+    );
+  }
+  if (lower.includes("api key") || lower.includes("unauthorized") || lower.includes("not configured") || lower.includes("unavailable")) {
+    return new CliError(
+      "PROVIDER_UNAVAILABLE",
+      msg,
+      "Run: hive auth login"
+    );
+  }
+  if (lower.includes("not found") && toolName) {
+    return new CliError(
+      "TOOL_NOT_FOUND",
+      msg,
+      `Run: hive tools search "${toolName}"`
+    );
+  }
+  return new CliError("API_ERROR", msg);
+}
+function suggestSimilarTools(input, toolNames, maxDistance = 3) {
+  return toolNames.map((name) => ({ name, dist: distance(input, name) })).filter((entry) => entry.dist <= maxDistance).sort((a, b) => a.dist - b.dist).slice(0, 3).map((entry) => entry.name);
+}
+
+export {
+  ExitCode,
+  ERROR_DOC_URLS,
+  CliError,
+  classifyError,
+  suggestSimilarTools
+};

package/build/chunk-ZXB53E7H.js

@@ -0,0 +1,246 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  getClaudeDesktopConfigPath,
+  getCursorConfigPath,
+  getVscodeConfigPath
+} from "./chunk-4F5CI6LX.js";
+import {
+  HIVE_AGENT_SKILLS
+} from "./chunk-VBOKVQ74.js";
+
+// src/cli/detect-clients.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+function getClaudeCodeConfigPath() {
+  return join(homedir(), ".claude.json");
+}
+function getWindsurfConfigPath() {
+  return join(homedir(), ".codeium", "windsurf", "mcp_config.json");
+}
+function getGeminiCliConfigPath() {
+  return join(homedir(), ".gemini", "settings.json");
+}
+function detectClaudeCode() {
+  return existsSync(getClaudeCodeConfigPath()) || existsSync(join(homedir(), ".claude"));
+}
+function detectClaudeDesktop() {
+  const configPath = getClaudeDesktopConfigPath();
+  if (existsSync(configPath)) return true;
+  if (platform() === "darwin") {
+    return existsSync(
+      join(homedir(), "Library", "Application Support", "Claude")
+    );
+  }
+  if (platform() === "win32") {
+    return existsSync(join(homedir(), "AppData", "Roaming", "Claude"));
+  }
+  return existsSync(join(homedir(), ".config", "Claude"));
+}
+function detectCursor() {
+  return existsSync(join(homedir(), ".cursor"));
+}
+function detectVscode() {
+  if (existsSync(join(homedir(), ".vscode"))) return true;
+  if (platform() === "darwin") {
+    return existsSync(
+      join(homedir(), "Library", "Application Support", "Code")
+    );
+  }
+  if (platform() === "win32") {
+    return existsSync(join(homedir(), "AppData", "Roaming", "Code"));
+  }
+  return existsSync(join(homedir(), ".config", "Code"));
+}
+function detectWindsurf() {
+  return existsSync(join(homedir(), ".codeium", "windsurf"));
+}
+function detectGeminiCli() {
+  return existsSync(join(homedir(), ".gemini"));
+}
+function detectClients() {
+  const claudeCode = detectClaudeCode();
+  const claudeDesktop = detectClaudeDesktop();
+  const cursor = detectCursor();
+  const vscode = detectVscode();
+  const windsurf = detectWindsurf();
+  const geminiCli = detectGeminiCli();
+  return [
+    {
+      id: "claude-code",
+      name: "Claude Code",
+      configPath: getClaudeCodeConfigPath(),
+      detected: claudeCode,
+      programmable: true,
+      hint: claudeCode ? void 0 : "~/.claude or ~/.claude.json not found"
+    },
+    {
+      id: "claude-desktop",
+      name: "Claude Desktop",
+      configPath: getClaudeDesktopConfigPath(),
+      detected: claudeDesktop,
+      programmable: true,
+      hint: claudeDesktop ? void 0 : "Claude Desktop application directory not found"
+    },
+    {
+      id: "cursor",
+      name: "Cursor",
+      configPath: getCursorConfigPath(),
+      detected: cursor,
+      programmable: true,
+      hint: cursor ? void 0 : "~/.cursor not found"
+    },
+    {
+      id: "vscode",
+      name: "VS Code",
+      configPath: getVscodeConfigPath(),
+      detected: vscode,
+      programmable: true,
+      hint: vscode ? void 0 : "VS Code user data dir not found"
+    },
+    {
+      id: "windsurf",
+      name: "Windsurf",
+      configPath: getWindsurfConfigPath(),
+      detected: windsurf,
+      programmable: true,
+      hint: windsurf ? void 0 : "~/.codeium/windsurf not found"
+    },
+    {
+      id: "gemini-cli",
+      name: "Gemini CLI",
+      configPath: getGeminiCliConfigPath(),
+      detected: geminiCli,
+      programmable: true,
+      hint: geminiCli ? void 0 : "~/.gemini not found"
+    },
+    {
+      id: "chatgpt-desktop",
+      name: "OpenAI / ChatGPT apps",
+      configPath: "(app or API setup)",
+      detected: false,
+      // No reliable filesystem signal — always print instructions
+      programmable: false,
+      hint: "Direct ChatGPT app connectors are auth-dependent; use OpenAI Responses API or an OAuth-compatible proxy."
+    }
+  ];
+}
+
+// src/cli/skills.ts
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+var SKILL_PACK_NAMES = HIVE_AGENT_SKILLS.map((skill) => skill.name);
+function getClientSkillsDir(client) {
+  switch (client) {
+    case "claude-code":
+      return join2(homedir2(), ".claude", "skills");
+    case "cursor":
+      return join2(homedir2(), ".cursor", "skills");
+    case "vscode":
+      return null;
+    case "windsurf":
+      return null;
+    case "gemini-cli":
+      return null;
+    case "claude-desktop":
+      return join2(homedir2(), ".claude", "skills");
+    case "chatgpt-desktop":
+      return null;
+  }
+}
+function findBundledPacksDir() {
+  const override = process.env.HIVE_SKILLS_PACKS_DIR;
+  if (override && existsSync2(override) && statSync(override).isDirectory()) {
+    return override;
+  }
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    // Compiled (bin/hive-mcp.js -> build/cli/skills.js)
+    resolve(here, "..", "..", "agent-skills", "packs"),
+    // Source tree (tests / dev mode)
+    resolve(here, "..", "..", "agent-skills", "packs"),
+    // Single-level dev (when CLI is run from source)
+    resolve(here, "..", "agent-skills", "packs"),
+    // Process-relative as a last resort
+    resolve(process.cwd(), "agent-skills", "packs")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate) && statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function installSkillsForClient(client) {
+  const dest = getClientSkillsDir(client);
+  if (!dest) {
+    return {
+      client,
+      installed: [],
+      skipped: [...SKILL_PACK_NAMES],
+      destination: null,
+      reason: "Client has no native skills directory \u2014 tools come over MCP"
+    };
+  }
+  const packsRoot = findBundledPacksDir();
+  if (!packsRoot) {
+    return {
+      client,
+      installed: [],
+      skipped: [...SKILL_PACK_NAMES],
+      destination: dest,
+      reason: "Bundled skill packs not found \u2014 package install may be incomplete"
+    };
+  }
+  if (!existsSync2(dest)) mkdirSync(dest, { recursive: true });
+  const installed = [];
+  const skipped = [];
+  for (const pack of SKILL_PACK_NAMES) {
+    const src = join2(packsRoot, pack);
+    if (!existsSync2(src)) {
+      skipped.push(pack);
+      continue;
+    }
+    const target = join2(dest, pack);
+    if (existsSync2(target)) rmSync(target, { recursive: true, force: true });
+    cpSync(src, target, { recursive: true });
+    installed.push(pack);
+  }
+  return { client, installed, skipped, destination: dest };
+}
+function installSkillsForClients(clients) {
+  return clients.map(installSkillsForClient);
+}
+function removeSkillsForClient(client) {
+  const dest = getClientSkillsDir(client);
+  if (!dest || !existsSync2(dest)) {
+    return { client, removed: [], destination: dest };
+  }
+  const removed = [];
+  for (const pack of SKILL_PACK_NAMES) {
+    const target = join2(dest, pack);
+    if (existsSync2(target)) {
+      rmSync(target, { recursive: true, force: true });
+      removed.push(pack);
+    }
+  }
+  return { client, removed, destination: dest };
+}
+function removeSkillsForClients(clients) {
+  return clients.map(removeSkillsForClient);
+}
+
+export {
+  detectClients,
+  installSkillsForClients,
+  removeSkillsForClients
+};