hive-intelligence 1.6.7 → 1.7.2

package/build/{chunk-2SPCKQBJ.js → chunk-5QAXJON7.js}

@@ -1,6 +1,30 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
 // src/cli/namespace.ts
+var ARCHIVE_HISTORY_ARGS = {
+  base_coin: {
+    flag: "--base-coin <ticker>",
+    description: "Base asset ticker (BTC, ETH, SOL)",
+    required: true
+  },
+  exchange: {
+    flag: "--exchange <name>",
+    description: "Venue filter (Binance, Hyperliquid); omit for all venues"
+  },
+  from: {
+    flag: "--from <iso>",
+    description: "Inclusive ISO 8601 lower time bound"
+  },
+  to: {
+    flag: "--to <iso>",
+    description: "Inclusive ISO 8601 upper time bound"
+  },
+  limit: {
+    flag: "--limit <n>",
+    description: "Max rows, newest first",
+    type: "number"
+  }
+};
 var NAMESPACE = [
   {
     name: "market",
@@ -610,6 +634,53 @@ var NAMESPACE = [
         }
       }
     ]
+  },
+  {
+    name: "archive",
+    description: "Hive Archive: cross-venue derivatives history (funding, OI, basis, positioning, liquidations)",
+    commands: [
+      {
+        name: "coverage",
+        description: "Archive venues and per-dataset time coverage",
+        tool: "archive_get_coverage",
+        args: {
+          base_coin: {
+            flag: "--base-coin <ticker>",
+            description: "Probe coin for futures datasets (default BTC)"
+          }
+        }
+      },
+      {
+        name: "funding",
+        description: "Historical funding-rate settlements",
+        tool: "archive_get_funding_history",
+        args: { ...ARCHIVE_HISTORY_ARGS }
+      },
+      {
+        name: "oi",
+        description: "Historical open-interest snapshots",
+        tool: "archive_get_open_interest_history",
+        args: { ...ARCHIVE_HISTORY_ARGS }
+      },
+      {
+        name: "basis",
+        description: "Historical spot-vs-futures basis snapshots",
+        tool: "archive_get_basis_history",
+        args: { ...ARCHIVE_HISTORY_ARGS }
+      },
+      {
+        name: "long-short",
+        description: "Historical long/short-ratio snapshots",
+        tool: "archive_get_long_short_history",
+        args: { ...ARCHIVE_HISTORY_ARGS }
+      },
+      {
+        name: "liquidations",
+        description: "Historical liquidation events",
+        tool: "archive_get_liquidations_history",
+        args: { ...ARCHIVE_HISTORY_ARGS }
+      }
+    ]
   }
 ];
 function resolveCommand(domain, subcommand) {

package/build/chunk-APBLB62S.js

@@ -0,0 +1,474 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  CliError,
+  ExitCode
+} from "./chunk-ZSPPJW4G.js";
+import {
+  errorEnvelope,
+  info,
+  shouldOutputJson,
+  successEnvelope,
+  writeOutput,
+  yellow
+} from "./chunk-ZDXMZPC6.js";
+import {
+  ensureConfigDir,
+  getConfigDir,
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-6PC3HUAK.js";
+
+// src/cli/routing.ts
+import { createHash } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+
+// src/cli/routing-block.ts
+var ROUTING_BLOCK = [
+  "## 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` (it loads `hive-query` for the full toolset walk).",
+  "- 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`",
+  "  - Polymarket odds, events, order books, odds history, wallet positions:",
+  "    `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 the compact `hive://toolsets` index or call `search_tools`.",
+  "2. Select one task toolset and its best matching compact `routes[]` entry.",
+  "   Preserve `route_id`; follow the ordered calls, conditional per-call",
+  "   fallbacks, four-call cap, and stop condition. Use `coverageCatalog` only",
+  "   for long-tail discovery.",
+  "3. Call `get_api_endpoint_schema` and inspect `operation`/`callPattern`.",
+  "4. Execute reads through `invoke_api_endpoint` with bounded args. Explain any",
+  "   Hive state change, obtain explicit approval, then use",
+  "   `invoke_stateful_endpoint`; never auto-approve it.",
+  "5. Copy exact server-returned `_hive` blocks into the task receipt, cite exact",
+  "   receipt IDs from `claims[]`, account for every canonical `coverage[]`",
+  "   phase, include `route_id`, and call `validate_task_result` before presenting a structured",
+  "   result.",
+  "6. Report provider, source recency, fallback/cache/degraded state, and runtime",
+  "   status (`ok`, `invalid_input`, `missing_key`, `plan_required`,",
+  "   `rate_limited`, `degraded`, or `failing`). `observed_at` is Hive",
+  "   first-observation/original cache time, not necessarily upstream event time."
+].join("\n");
+
+// src/cli/routing.ts
+var ROUTING_START = "<!-- hive-routing:start -->";
+var ROUTING_END = "<!-- hive-routing:end -->";
+var ROUTING_FILES = ["AGENTS.md", "CLAUDE.md"];
+function detectEol(content) {
+  return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function renderRoutingBlock(eol = "\n") {
+  return [ROUTING_START, ...ROUTING_BLOCK.split("\n"), ROUTING_END].join(eol) + eol;
+}
+function findRoutingBlock(content) {
+  const start = content.indexOf(ROUTING_START);
+  if (start < 0) return null;
+  if (start > 0 && content[start - 1] !== "\n") return null;
+  const endMarker = content.indexOf(ROUTING_END, start + ROUTING_START.length);
+  if (endMarker < 0) return null;
+  let end = endMarker + ROUTING_END.length;
+  if (content.startsWith("\r\n", end)) end += 2;
+  else if (content.startsWith("\n", end)) end += 1;
+  const inner = content.slice(start + ROUTING_START.length, endMarker).replace(/\r\n/g, "\n");
+  const body = inner.replace(/^\n/, "").replace(/\n$/, "");
+  return { start, end, body };
+}
+function appendRoutingBlock(content) {
+  const eol = detectEol(content);
+  const block = renderRoutingBlock(eol);
+  if (content === "") return block;
+  return content + (content.endsWith("\n") ? eol : eol + eol) + block;
+}
+function stripRoutingBlock(content) {
+  const span = findRoutingBlock(content);
+  if (!span) return null;
+  let before = content.slice(0, span.start);
+  if (before.endsWith("\r\n\r\n")) before = before.slice(0, -2);
+  else if (before.endsWith("\n\n")) before = before.slice(0, -1);
+  return before + content.slice(span.end);
+}
+function diffLines(expected, actual) {
+  const a = expected.split("\n");
+  const b = actual.split("\n");
+  const out = [];
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    if (a[i] === b[i]) continue;
+    if (a[i] !== void 0) out.push(`- ${a[i]}`);
+    if (b[i] !== void 0) out.push(`+ ${b[i]}`);
+  }
+  return out;
+}
+function recordsPath() {
+  return join(getConfigDir(), "routing.json");
+}
+function readRoutingRecords() {
+  return readJsonFile(recordsPath()) ?? {};
+}
+function writeRoutingRecords(records) {
+  ensureConfigDir();
+  writeJsonFile(recordsPath(), records);
+}
+function projectHash(projectPath) {
+  return createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
+}
+function backupPath(projectPath) {
+  return join(getConfigDir(), "routing", `${projectHash(projectPath)}.orig`);
+}
+function resolveProject(opts) {
+  return resolve(opts.cwd ?? process.cwd());
+}
+function outcome(action, project, file, status, message, exitCode, extra = {}) {
+  return { action, project, file, status, message, exitCode, ...extra };
+}
+function refuseHome(action, project) {
+  if (project !== resolve(homedir())) return null;
+  return outcome(
+    action,
+    project,
+    null,
+    "refused",
+    "Refusing to touch your home directory; run `hive routing` inside a project.",
+    ExitCode.INVALID_ARGS
+  );
+}
+function skippedByEnv(action, project) {
+  return outcome(
+    action,
+    project,
+    null,
+    "skipped",
+    `Routing ${action} skipped: HIVE_ROUTING=never is set, so the CLI never writes routing blocks on this machine.`,
+    ExitCode.SUCCESS
+  );
+}
+function isRoutingFile(name) {
+  return ROUTING_FILES.includes(name);
+}
+function pickFile(project, requested) {
+  if (requested !== void 0) {
+    if (!isRoutingFile(requested)) {
+      return {
+        error: `--file must be one of ${ROUTING_FILES.join(", ")} (got '${requested}')`
+      };
+    }
+    return { file: requested };
+  }
+  for (const candidate of ROUTING_FILES) {
+    if (existsSync(join(project, candidate))) return { file: candidate };
+  }
+  return { file: ROUTING_FILES[0] };
+}
+function installRouting(opts = {}) {
+  const project = resolveProject(opts);
+  if (process.env.HIVE_ROUTING === "never")
+    return skippedByEnv("install", project);
+  const home = refuseHome("install", project);
+  if (home) return home;
+  const pick = pickFile(project, opts.file);
+  if ("error" in pick) {
+    return outcome(
+      "install",
+      project,
+      null,
+      "refused",
+      pick.error,
+      ExitCode.INVALID_ARGS
+    );
+  }
+  const filePath = join(project, pick.file);
+  const exists = existsSync(filePath);
+  if (!exists && !opts.create) {
+    return outcome(
+      "install",
+      project,
+      pick.file,
+      "refused",
+      `${pick.file} not found in ${project}; pass --create to create it${opts.file ? "" : ", or --file CLAUDE.md to target that file"}.`,
+      ExitCode.INVALID_ARGS
+    );
+  }
+  const originalBytes = exists ? readFileSync(filePath) : Buffer.alloc(0);
+  const original = originalBytes.toString("utf-8");
+  const span = findRoutingBlock(original);
+  const records = readRoutingRecords();
+  if (span) {
+    if (span.body !== ROUTING_BLOCK) {
+      return outcome(
+        "install",
+        project,
+        pick.file,
+        "refused",
+        `${pick.file} already has a Hive routing block that was edited by hand; leaving it alone. Remove it manually to reinstall the stock block.`,
+        ExitCode.GENERAL_ERROR,
+        { diff: diffLines(ROUTING_BLOCK, span.body) }
+      );
+    }
+    if (!opts.dryRun && records[project]?.status !== "installed") {
+      records[project] = {
+        status: "installed",
+        file: pick.file,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      writeRoutingRecords(records);
+    }
+    return outcome(
+      "install",
+      project,
+      pick.file,
+      "already-installed",
+      `${pick.file} already contains the Hive routing block; nothing to do.`,
+      ExitCode.SUCCESS
+    );
+  }
+  const next = appendRoutingBlock(original);
+  if (opts.dryRun) {
+    return outcome(
+      "install",
+      project,
+      pick.file,
+      "dry-run",
+      `Would ${exists ? "append the Hive routing block to" : "create"} ${pick.file} (dry-run: nothing written).`,
+      ExitCode.SUCCESS,
+      { content: next }
+    );
+  }
+  const backup = backupPath(project);
+  mkdirSync(dirname(backup), { recursive: true, mode: 448 });
+  writeFileSync(backup, originalBytes);
+  writeFileSync(filePath, next, "utf-8");
+  records[project] = {
+    status: "installed",
+    file: pick.file,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...exists ? {} : { created: true }
+  };
+  writeRoutingRecords(records);
+  return outcome(
+    "install",
+    project,
+    pick.file,
+    "installed",
+    `${exists ? "Appended" : "Created"} ${pick.file} with the Hive routing block. Undo with: hive routing remove`,
+    ExitCode.SUCCESS
+  );
+}
+function declineRouting(opts = {}) {
+  const project = resolveProject(opts);
+  if (process.env.HIVE_ROUTING === "never")
+    return skippedByEnv("decline", project);
+  const home = refuseHome("decline", project);
+  if (home) return home;
+  if (opts.dryRun) {
+    return outcome(
+      "decline",
+      project,
+      null,
+      "dry-run",
+      `Would record ${project} as declined (dry-run: nothing written).`,
+      ExitCode.SUCCESS
+    );
+  }
+  const records = readRoutingRecords();
+  records[project] = {
+    status: "declined",
+    file: null,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeRoutingRecords(records);
+  return outcome(
+    "decline",
+    project,
+    null,
+    "declined",
+    `Recorded: no Hive routing block for ${project}. Change your mind with: hive routing install`,
+    ExitCode.SUCCESS
+  );
+}
+function forgetProject(project, records) {
+  const backup = backupPath(project);
+  if (existsSync(backup)) unlinkSync(backup);
+  if (project in records) {
+    delete records[project];
+    writeRoutingRecords(records);
+  }
+}
+function removeRouting(opts = {}) {
+  const project = resolveProject(opts);
+  const home = refuseHome("remove", project);
+  if (home) return home;
+  const records = readRoutingRecords();
+  const record = records[project];
+  let file = opts.file ?? record?.file ?? void 0;
+  if (file !== void 0 && !isRoutingFile(file)) {
+    return outcome(
+      "remove",
+      project,
+      null,
+      "refused",
+      `--file must be one of ${ROUTING_FILES.join(", ")} (got '${file}')`,
+      ExitCode.INVALID_ARGS
+    );
+  }
+  if (file === void 0) {
+    file = ROUTING_FILES.find((candidate) => {
+      const path = join(project, candidate);
+      return existsSync(path) && findRoutingBlock(readFileSync(path, "utf-8")) !== null;
+    });
+  }
+  const filePath = file ? join(project, file) : null;
+  const current = filePath && existsSync(filePath) ? readFileSync(filePath, "utf-8") : null;
+  const span = current === null ? null : findRoutingBlock(current);
+  if (current === null || !span) {
+    if (!opts.dryRun) forgetProject(project, records);
+    return outcome(
+      "remove",
+      project,
+      file ?? null,
+      "not-installed",
+      `No Hive routing block found in ${project}; nothing to remove.`,
+      ExitCode.SUCCESS
+    );
+  }
+  if (span.body !== ROUTING_BLOCK) {
+    return outcome(
+      "remove",
+      project,
+      file,
+      "refused",
+      `The Hive routing block in ${file} was edited by hand; refusing to remove it. Delete it manually if you want it gone.`,
+      ExitCode.GENERAL_ERROR,
+      { diff: diffLines(ROUTING_BLOCK, span.body) }
+    );
+  }
+  const stripped = stripRoutingBlock(current);
+  const backup = backupPath(project);
+  let final = stripped;
+  let note = "";
+  if (existsSync(backup)) {
+    const originalBytes = readFileSync(backup);
+    const original = originalBytes.toString("utf-8");
+    if (stripped === original || stripped === original + detectEol(current)) {
+      final = originalBytes;
+    } else {
+      note = " The file changed since install, so only the block was removed and your other edits were kept.";
+    }
+  }
+  if (opts.dryRun) {
+    return outcome(
+      "remove",
+      project,
+      file,
+      "dry-run",
+      `Would remove the Hive routing block from ${file} (dry-run: nothing written).${note}`,
+      ExitCode.SUCCESS,
+      { content: final.toString() }
+    );
+  }
+  if (record?.created && final.length === 0) {
+    unlinkSync(filePath);
+  } else {
+    writeFileSync(filePath, final);
+  }
+  forgetProject(project, records);
+  return outcome(
+    "remove",
+    project,
+    file,
+    "removed",
+    `${record?.created && final.length === 0 ? `Deleted ${file}, which install had created` : `Removed the Hive routing block from ${file}`}.${note}`,
+    ExitCode.SUCCESS
+  );
+}
+function removeRecordedRoutingBlocks(opts = {}) {
+  const records = readRoutingRecords();
+  const outcomes = [];
+  for (const [project, record] of Object.entries(records)) {
+    if (record.status !== "installed") continue;
+    outcomes.push(
+      removeRouting({
+        cwd: project,
+        file: record.file ?? void 0,
+        dryRun: opts.dryRun
+      })
+    );
+  }
+  return outcomes;
+}
+async function runRouting(action, opts = {}) {
+  const result = action === "install" ? installRouting(opts) : action === "decline" ? declineRouting(opts) : removeRouting(opts);
+  const { exitCode, ...data } = result;
+  if (opts.json || shouldOutputJson()) {
+    if (exitCode === ExitCode.SUCCESS) {
+      await writeOutput(successEnvelope(data, {}));
+    } else {
+      const err = new CliError(
+        exitCode === ExitCode.INVALID_ARGS ? "INVALID_ARGS" : "GENERAL_ERROR",
+        result.message
+      );
+      await writeOutput({ ...errorEnvelope(err, {}), data });
+    }
+    return exitCode;
+  }
+  if (result.status === "dry-run" && result.content !== void 0) {
+    process.stdout.write(result.content);
+  }
+  info(result.message);
+  for (const line of result.diff ?? []) {
+    process.stderr.write(yellow(`  ${line}`) + "\n");
+  }
+  return exitCode;
+}
+
+export {
+  ROUTING_START,
+  ROUTING_END,
+  ROUTING_FILES,
+  detectEol,
+  renderRoutingBlock,
+  findRoutingBlock,
+  appendRoutingBlock,
+  stripRoutingBlock,
+  diffLines,
+  readRoutingRecords,
+  projectHash,
+  backupPath,
+  installRouting,
+  declineRouting,
+  removeRouting,
+  removeRecordedRoutingBlocks,
+  runRouting
+};