hive-intelligence 1.6.3 → 1.7.1

package/build/chunk-POPAEM4E.js

@@ -0,0 +1,474 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  CliError,
+  ExitCode
+} from "./chunk-3Z5VR53Z.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
+};

package/build/{chunk-P7NLFSZQ.js → chunk-TWYGJEVN.js}

@@ -1,4 +1,7 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  NEVER_RETRY_ERROR_CODES
+} from "./chunk-3Z5VR53Z.js";
 import {
   SERVER_VERSION
 } from "./chunk-ZXKFJQDE.js";
@@ -9,6 +12,56 @@ import {
 } from "./chunk-6PC3HUAK.js";
 
 // src/cli/api-client.ts
+function errorCodeFromBody(body) {
+  if (!body || typeof body !== "object") return null;
+  const error = body.error;
+  if (!error || typeof error !== "object") return null;
+  const direct = error.code;
+  if (typeof direct === "string") return direct;
+  const nested = error.data?.code;
+  return typeof nested === "string" ? nested : null;
+}
+async function peekErrorCode(response) {
+  if (typeof response.clone !== "function") return null;
+  try {
+    return errorCodeFromBody(await response.clone().json());
+  } catch {
+    return null;
+  }
+}
+function parseRetryAfter(header) {
+  if (header == null || header === "") return null;
+  const seconds = Number.parseInt(header, 10);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds : null;
+}
+function attachResponseMeta(data, response, now = Date.now()) {
+  const meta = { ...data.meta ?? {} };
+  const quotaHeader = response.headers?.get?.("x-quota-remaining");
+  if (quotaHeader != null && quotaHeader !== "") {
+    const quotaRemaining = Number.parseInt(quotaHeader, 10);
+    if (Number.isFinite(quotaRemaining)) meta.quota_remaining = quotaRemaining;
+  }
+  if ("credits_remaining" in meta) {
+    const credits = meta.credits_remaining;
+    if (credits === null || typeof credits === "number") {
+      meta.quota_remaining = credits;
+    }
+  }
+  const retryAfter = parseRetryAfter(response.headers?.get?.("retry-after"));
+  const bodyResetAt = [
+    data.reset_at,
+    data.error?.reset_at,
+    data.error?.data?.reset_at,
+    meta.reset_at
+  ].find((value) => typeof value === "string" && value !== "");
+  if (retryAfter !== null) meta.retry_after_seconds = retryAfter;
+  if (bodyResetAt) {
+    meta.reset_at = bodyResetAt;
+  } else if (retryAfter !== null) {
+    meta.reset_at = new Date(now + retryAfter * 1e3).toISOString();
+  }
+  return { ...data, meta };
+}
 var MAX_RETRIES = 3;
 var BASE_DELAY_MS = 500;
 var MAX_DELAY_MS = 5e3;
@@ -44,6 +97,8 @@ async function fetchWithRetry(url, init, fetchFn = fetch) {
       if (response.ok || !isRetryable(response.status) || attempt === maxRetries) {
         return response;
       }
+      const code = await peekErrorCode(response);
+      if (code && NEVER_RETRY_ERROR_CODES.has(code)) return response;
       lastResponse = response;
       const retryAfter = response.headers?.get?.("retry-after") ?? null;
       const waitMs = computeDelay(attempt, retryAfter);
@@ -87,14 +142,7 @@ async function executeRemoteTool(toolName, args, timeoutMs = 3e4) {
       signal: controller.signal
     });
     const data = await response.json();
-    const quotaHeader = response.headers?.get?.("x-quota-remaining");
-    if (quotaHeader != null && quotaHeader !== "") {
-      const quotaRemaining = Number.parseInt(quotaHeader, 10);
-      if (Number.isFinite(quotaRemaining)) {
-        data.meta = { ...data.meta ?? {}, quota_remaining: quotaRemaining };
-      }
-    }
-    return data;
+    return attachResponseMeta(data, response);
   } catch (error) {
     if (error instanceof Error && error.name === "AbortError") {
       return {
@@ -192,10 +240,53 @@ async function getUsage() {
   });
   return response.json();
 }
+var SMALL_REQUEST_TIMEOUT_MS = 1e4;
+async function parseJsonBody(response) {
+  try {
+    const body = await response.json();
+    return body && typeof body === "object" ? body : null;
+  } catch {
+    return null;
+  }
+}
+async function postFeedback(payload) {
+  const url = buildApiUrl("/api/v1/feedback");
+  const response = await fetchWithRetry(url, {
+    method: "POST",
+    headers: getHeaders(resolveApiKey()),
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(SMALL_REQUEST_TIMEOUT_MS)
+  });
+  const body = await parseJsonBody(response);
+  if (!body) {
+    return {
+      ok: false,
+      error: {
+        code: "API_ERROR",
+        message: `Feedback endpoint answered HTTP ${response.status} without a JSON body`,
+        suggestion: `Check HIVE_API_URL (${resolveApiUrl()})`
+      },
+      meta: { http_status: response.status }
+    };
+  }
+  return attachResponseMeta(body, response);
+}
+async function getAnonQuota() {
+  const url = buildApiUrl("/api/v1/quota");
+  const response = await fetchWithRetry(url, {
+    headers: getHeaders(),
+    signal: AbortSignal.timeout(SMALL_REQUEST_TIMEOUT_MS)
+  });
+  return { status: response.status, body: await parseJsonBody(response) };
+}
 
 export {
+  errorCodeFromBody,
+  attachResponseMeta,
   fetchWithRetry,
   executeRemoteTool,
   fetchToolCatalog,
-  getUsage
+  getUsage,
+  postFeedback,
+  getAnonQuota
 };

package/build/{chunk-32NRUWXA.js → chunk-UPWYFTTJ.js}

@@ -294,11 +294,11 @@ async function runSwitch(name) {
   }
 }
 async function runUsage() {
-  const { getUsage } = await import("./api-client-6AM3HVHQ.js");
+  const { getUsage } = await import("./api-client-UGNFUZ2L.js");
   const result = await getUsage();
   if (!result.ok) {
-    const { outputError } = await import("./output-XGTE4EWJ.js");
-    const { CliError, classifyError } = await import("./errors-EL6UMXNJ.js");
+    const { outputError } = await import("./output-BBHBJI32.js");
+    const { CliError, classifyError } = await import("./errors-W3GXQN34.js");
     const code = result.error?.code;
     const err = code === "AUTH_REQUIRED" || code === "INVALID_TOKEN" ? new CliError(
       "AUTH_REQUIRED",