hive-intelligence 1.6.7 → 1.7.1

package/build/{chunk-KUF754NT.js → chunk-WII7MTYZ.js}

@@ -1,16 +1,23 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  saveLastReceipt
+} from "./chunk-XN3T6YOG.js";
 import {
   executeRemoteTool
-} from "./chunk-P7NLFSZQ.js";
+} from "./chunk-TWYGJEVN.js";
 import {
   trackCommand
 } from "./chunk-RU6QOFHH.js";
+import {
+  ExitCode
+} from "./chunk-3Z5VR53Z.js";
 import {
   debug,
   dim,
+  isQuiet,
   shouldOutputJson,
   writeOutput
-} from "./chunk-LP5ECG7A.js";
+} from "./chunk-ZDXMZPC6.js";
 import {
   resolveApiKey
 } from "./chunk-6PC3HUAK.js";
@@ -79,8 +86,38 @@ function remapForKeylessHero(toolName, args) {
 }
 
 // src/cli/execute.ts
+var EXIT_CODE_BY_ERROR = {
+  TOOL_NOT_FOUND: ExitCode.TOOL_NOT_FOUND,
+  TOOL_RETIRED: ExitCode.TOOL_NOT_FOUND,
+  PROVIDER_UNAVAILABLE: ExitCode.AUTH_FAILURE,
+  RATE_LIMITED: ExitCode.RATE_LIMITED,
+  TIMEOUT: ExitCode.TIMEOUT,
+  // Cap lane (exit 6): the call is outside what this credential can do
+  // today; the human message carries the reset time.
+  ANON_QUOTA_EXCEEDED: ExitCode.RATE_LIMITED,
+  ANON_GLOBAL_CAP_EXCEEDED: ExitCode.RATE_LIMITED,
+  ANON_AUTH_REQUIRED: ExitCode.RATE_LIMITED,
+  QUOTA_EXCEEDED: ExitCode.RATE_LIMITED,
+  FEEDBACK_RATE_LIMITED: ExitCode.RATE_LIMITED,
+  // Account state, not a cap: no reset time, retrying cannot help.
+  NO_WALLET: ExitCode.API_ERROR
+};
+function exitCodeForError(code) {
+  return code && EXIT_CODE_BY_ERROR[code] || ExitCode.API_ERROR;
+}
+function creditFooter(meta, keyed) {
+  if (!meta) return null;
+  if (keyed) {
+    if (typeof meta.credits_used !== "number") return null;
+    const remaining = meta.credits_remaining === null ? "unlimited" : typeof meta.credits_remaining === "number" ? String(meta.credits_remaining) : null;
+    return remaining === null ? `credits: used ${meta.credits_used}` : `credits: used ${meta.credits_used}, remaining ${remaining}`;
+  }
+  if (typeof meta.quota_remaining !== "number") return null;
+  return `free calls left today: ${meta.quota_remaining} (run \`hive auth login\` for a full key)`;
+}
 async function executeTool(toolName, args, timeoutMs = 3e4) {
-  if (!resolveApiKey()) {
+  const keyed = Boolean(resolveApiKey());
+  if (!keyed) {
     const remap = remapForKeylessHero(toolName, args);
     if (remap) {
       debug(remap.note);
@@ -106,17 +143,20 @@ async function executeTool(toolName, args, timeoutMs = 3e4) {
     response.ok ? void 0 : response.error?.code
   );
   await writeOutput(response);
-  const quotaRemaining = response.meta?.quota_remaining;
-  if (typeof quotaRemaining === "number" && !resolveApiKey() && !shouldOutputJson()) {
-    process.stderr.write(
-      dim(
-        `${quotaRemaining} free call${quotaRemaining === 1 ? "" : "s"} left today. Run \`hive auth login\` for a full key.`
-      ) + "\n"
-    );
+  const receiptId = response.meta?.receipt_id;
+  if (response.ok && typeof receiptId === "string" && receiptId) {
+    saveLastReceipt({
+      receipt_id: receiptId,
+      tool: toolName,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const footer = creditFooter(response.meta, keyed);
+  if (footer && !shouldOutputJson() && !isQuiet()) {
+    process.stderr.write(dim(footer) + "\n");
   }
   if (!response.ok) {
-    const exitCode = response.error?.code === "TOOL_NOT_FOUND" || response.error?.code === "TOOL_RETIRED" ? 3 : response.error?.code === "PROVIDER_UNAVAILABLE" ? 5 : response.error?.code === "RATE_LIMITED" ? 6 : response.error?.code === "TIMEOUT" ? 124 : 4;
-    process.exit(exitCode);
+    process.exit(exitCodeForError(response.error?.code));
   }
 }
 

package/build/chunk-XN3T6YOG.js

@@ -0,0 +1,32 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  ensureConfigDir,
+  getConfigDir,
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-6PC3HUAK.js";
+
+// src/cli/last-receipt.ts
+import { join } from "path";
+function lastReceiptPath() {
+  return join(getConfigDir(), "last-receipt.json");
+}
+function saveLastReceipt(receipt) {
+  try {
+    ensureConfigDir();
+    writeJsonFile(lastReceiptPath(), receipt);
+  } catch {
+  }
+}
+function readLastReceipt() {
+  const stored = readJsonFile(lastReceiptPath());
+  if (!stored || typeof stored.receipt_id !== "string" || typeof stored.tool !== "string" || typeof stored.at !== "string") {
+    return null;
+  }
+  return { receipt_id: stored.receipt_id, tool: stored.tool, at: stored.at };
+}
+
+export {
+  saveLastReceipt,
+  readLastReceipt
+};

package/build/chunk-XT6RURQV.js

@@ -0,0 +1,394 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-3Z5VR53Z.js";
+
+// src/cli/call-args.ts
+var BOOLEAN_LITERALS = /* @__PURE__ */ new Set(["true", "false", "1", "0", "yes", "no"]);
+function parseBooleanLiteral(value) {
+  const lower = value.toLowerCase();
+  if (!BOOLEAN_LITERALS.has(lower)) return null;
+  return lower === "true" || lower === "1" || lower === "yes";
+}
+function isFlagToken(token) {
+  return token.startsWith("--") && token.length > 2;
+}
+function parseFlagTokens(tokens, isBooleanFlag = () => false) {
+  const positionals = [];
+  const flags = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === "--") {
+      positionals.push(...tokens.slice(i + 1));
+      break;
+    }
+    if (!isFlagToken(token)) {
+      positionals.push(token);
+      continue;
+    }
+    const body = token.slice(2);
+    const eq = body.indexOf("=");
+    if (eq >= 0) {
+      const rawName = body.slice(0, eq);
+      const negated2 = rawName.startsWith("no-") && rawName.length > 3;
+      flags.push({
+        name: negated2 ? rawName.slice(3) : rawName,
+        value: body.slice(eq + 1),
+        negated: negated2,
+        raw: token
+      });
+      continue;
+    }
+    const negated = body.startsWith("no-") && body.length > 3;
+    const name = negated ? body.slice(3) : body;
+    const next = tokens[i + 1];
+    let value;
+    if (next !== void 0 && next !== "--" && !isFlagToken(next)) {
+      if (negated) {
+      } else if (isBooleanFlag(name)) {
+        if (parseBooleanLiteral(next) !== null) {
+          value = next;
+          i++;
+        }
+      } else {
+        value = next;
+        i++;
+      }
+    }
+    flags.push({ name, value, negated, raw: token });
+  }
+  return { positionals, flags };
+}
+function canonicalParamName(name) {
+  return name.toLowerCase().replace(/[-_]/g, "");
+}
+var ALWAYS_RESERVED_OPTIONS = [
+  "--help",
+  "--version",
+  "--profile",
+  "--args"
+];
+function reservedOptionNames(longFlags) {
+  const names = /* @__PURE__ */ new Set();
+  for (const flag of [...longFlags, ...ALWAYS_RESERVED_OPTIONS]) {
+    const name = flag.replace(/^--/, "");
+    names.add(name);
+    if (name.startsWith("no-")) names.add(name.slice(3));
+  }
+  return names;
+}
+function firstType(schema) {
+  if (!schema) return void 0;
+  if (Array.isArray(schema.type)) {
+    return schema.type.find((t) => t !== "null") ?? void 0;
+  }
+  return schema.type;
+}
+function isNestedSchema(schema) {
+  if (!schema) return false;
+  if (schema.$ref || schema.oneOf || schema.anyOf || schema.allOf) return true;
+  const type = firstType(schema);
+  if (type === "object" && schema.properties) return true;
+  if (type === "array" && schema.items) {
+    const itemType = firstType(schema.items);
+    return itemType === "object" || isNestedSchema(schema.items);
+  }
+  return false;
+}
+function buildResolver(schema) {
+  const properties = schema?.properties ?? {};
+  const required = new Set(schema?.required ?? []);
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (const prop of Object.keys(properties)) {
+    const key = canonicalParamName(prop);
+    byCanonical.set(key, [...byCanonical.get(key) ?? [], prop]);
+  }
+  const resolve = (name) => {
+    if (name in properties) return name;
+    const candidates = byCanonical.get(canonicalParamName(name)) ?? [];
+    return candidates.length === 1 ? candidates[0] : null;
+  };
+  return {
+    resolve,
+    isBoolean: (name) => {
+      const prop = resolve(name);
+      return prop !== null && firstType(properties[prop]) === "boolean";
+    },
+    properties,
+    required
+  };
+}
+function coerceScalar(raw, type, flag) {
+  switch (type) {
+    case "integer": {
+      if (!/^-?\d+$/.test(raw.trim())) {
+        throw new CliError(
+          "VALIDATION_ERROR",
+          `${flag} expects an integer, got '${raw}'`
+        );
+      }
+      return Number.parseInt(raw, 10);
+    }
+    case "number": {
+      const numeric = Number(raw);
+      if (raw.trim() === "" || !Number.isFinite(numeric)) {
+        throw new CliError(
+          "VALIDATION_ERROR",
+          `${flag} expects a number, got '${raw}'`
+        );
+      }
+      return numeric;
+    }
+    case "boolean": {
+      const parsed = parseBooleanLiteral(raw);
+      if (parsed === null) {
+        throw new CliError(
+          "VALIDATION_ERROR",
+          `${flag} expects true or false, got '${raw}'`
+        );
+      }
+      return parsed;
+    }
+    case "string":
+      return raw;
+    default: {
+      const trimmed = raw.trim();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          return JSON.parse(trimmed);
+        } catch {
+          return raw;
+        }
+      }
+      return raw;
+    }
+  }
+}
+function coerceArrayValue(raw, itemType, flag) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      throw new CliError(
+        "VALIDATION_ERROR",
+        `${flag} looks like a JSON array but did not parse`
+      );
+    }
+    if (!Array.isArray(parsed)) {
+      throw new CliError("VALIDATION_ERROR", `${flag} expects a JSON array`);
+    }
+    return parsed;
+  }
+  return raw.split(",").map((part) => part.trim()).filter((part) => part !== "").map((part) => coerceScalar(part, itemType ?? "string", flag));
+}
+function coerceObjectValue(raw, flag) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CliError(
+      "VALIDATION_ERROR",
+      `${flag} expects a JSON object, got '${raw}'`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliError("VALIDATION_ERROR", `${flag} expects a JSON object`);
+  }
+  return parsed;
+}
+function acceptedFieldsSuggestion(toolName, properties, reservedNames) {
+  const names = Object.keys(properties);
+  const reservedCanonical = new Set([...reservedNames].map(canonicalParamName));
+  const viaArgs = names.filter(
+    (n) => reservedCanonical.has(canonicalParamName(n))
+  );
+  const accepted = names.length ? `Accepted parameters for ${toolName}: ${names.join(", ")}.` : `${toolName} takes no parameters.`;
+  const argsNote = viaArgs.length ? ` ${viaArgs.join(", ")} share a name with a CLI option and go through --args '<json>'.` : "";
+  return `${accepted}${argsNote} Run: hive tools info ${toolName} (or hive tools refresh if the catalog is stale)`;
+}
+function coerceFlagsToArgs(flags, schema, options) {
+  const resolver = buildResolver(schema);
+  const args = {};
+  const arrays = /* @__PURE__ */ new Map();
+  const reservedCanonical = new Set(
+    [...options.reservedNames].map(canonicalParamName)
+  );
+  const suggestion = () => acceptedFieldsSuggestion(
+    options.toolName,
+    resolver.properties,
+    options.reservedNames
+  );
+  for (const flag of flags) {
+    const typedName = flag.name;
+    if (reservedCanonical.has(canonicalParamName(typedName))) {
+      throw new CliError(
+        "VALIDATION_ERROR",
+        `--${typedName} is reserved for the CLI; pass '${typedName}' through --args '<json>'`,
+        suggestion()
+      );
+    }
+    if (!schema) {
+      args[typedName] = flag.negated ? false : flag.value ?? true;
+      continue;
+    }
+    const prop = resolver.resolve(typedName);
+    if (prop === null) {
+      throw new CliError(
+        "VALIDATION_ERROR",
+        `Unknown parameter '${typedName}' for ${options.toolName}`,
+        suggestion()
+      );
+    }
+    const propSchema = resolver.properties[prop];
+    const type = firstType(propSchema);
+    const flagLabel = `--${typedName}`;
+    if (flag.negated) {
+      if (type !== "boolean") {
+        throw new CliError(
+          "VALIDATION_ERROR",
+          `--no-${typedName} only applies to boolean parameters; '${prop}' is ${type ?? "untyped"}`,
+          suggestion()
+        );
+      }
+      args[prop] = false;
+      continue;
+    }
+    if (type === "boolean") {
+      args[prop] = flag.value === void 0 ? true : coerceScalar(flag.value, "boolean", flagLabel);
+      continue;
+    }
+    if (flag.value === void 0) {
+      throw new CliError(
+        "VALIDATION_ERROR",
+        `${flagLabel} expects a value`,
+        suggestion()
+      );
+    }
+    if (type === "array") {
+      const items = coerceArrayValue(
+        flag.value,
+        firstType(propSchema.items),
+        flagLabel
+      );
+      const collected = [...arrays.get(prop) ?? [], ...items];
+      arrays.set(prop, collected);
+      args[prop] = collected;
+      continue;
+    }
+    if (type === "object") {
+      args[prop] = coerceObjectValue(flag.value, flagLabel);
+      continue;
+    }
+    args[prop] = coerceScalar(flag.value, type, flagLabel);
+  }
+  return args;
+}
+function parseArgsJson(raw, source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new CliError(
+      "VALIDATION_ERROR",
+      `Invalid JSON in ${source}: ${err instanceof Error ? err.message : String(err)}`,
+      `Pass a JSON object, e.g. --args '{"ids":"bitcoin"}'`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliError(
+      "VALIDATION_ERROR",
+      `${source} must be a JSON object`,
+      `Pass a JSON object, e.g. --args '{"ids":"bitcoin"}'`
+    );
+  }
+  return parsed;
+}
+async function planToolCall(input) {
+  const untyped = parseFlagTokens(input.tokens);
+  const toolName = untyped.positionals[0];
+  if (!toolName) {
+    throw new CliError(
+      "INVALID_ARGS",
+      "Missing tool name",
+      "Usage: hive tools call <name> [--<param> <value>...] [--args '<json>']"
+    );
+  }
+  let args = {};
+  if (input.argsJson !== void 0) {
+    args = parseArgsJson(input.argsJson, "--args");
+  } else if (input.stdinJson !== void 0 && input.stdinJson.trim() !== "") {
+    args = parseArgsJson(input.stdinJson, "stdin");
+  }
+  if (untyped.flags.length === 0) {
+    if (untyped.positionals.length > 1) {
+      throw new CliError(
+        "INVALID_ARGS",
+        `Unexpected argument '${untyped.positionals[1]}'`,
+        "Tool parameters are passed as --<param> <value> or --args '<json>'"
+      );
+    }
+    return { toolName, args };
+  }
+  const schema = await input.lookupSchema(toolName);
+  const resolver = buildResolver(schema);
+  const typed = parseFlagTokens(
+    input.tokens,
+    (name) => resolver.isBoolean(name)
+  );
+  if (typed.positionals.length > 1) {
+    throw new CliError(
+      "INVALID_ARGS",
+      `Unexpected argument '${typed.positionals[1]}'`,
+      "Tool parameters are passed as --<param> <value> or --args '<json>'"
+    );
+  }
+  const flagArgs = coerceFlagsToArgs(typed.flags, schema, {
+    reservedNames: input.reservedNames,
+    toolName
+  });
+  return { toolName, args: { ...args, ...flagArgs } };
+}
+function firstSentence(text, max = 60) {
+  if (!text) return "";
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  const match = oneLine.match(/^(.*?[.!?])(?:\s|$)/);
+  const sentence = (match ? match[1] : oneLine).trim();
+  return sentence.length > max ? `${sentence.slice(0, max - 3)}...` : sentence;
+}
+function describeType(schema) {
+  if (isNestedSchema(schema)) return "json";
+  const type = firstType(schema);
+  if (type === "array") {
+    const itemType = firstType(schema.items) ?? "string";
+    return `array<${itemType}>`;
+  }
+  return type ?? "any";
+}
+function describeParameters(schema) {
+  const properties = schema?.properties ?? {};
+  const required = new Set(schema?.required ?? []);
+  return Object.entries(properties).map(([name, prop]) => ({
+    name,
+    type: describeType(prop),
+    required: required.has(name),
+    enumValues: Array.isArray(prop.enum) ? prop.enum.map(String) : [],
+    defaultValue: prop.default === void 0 ? "" : typeof prop.default === "string" ? prop.default : JSON.stringify(prop.default),
+    description: firstSentence(prop.description),
+    ...isNestedSchema(prop) ? { nested: prop } : {}
+  }));
+}
+
+export {
+  parseFlagTokens,
+  canonicalParamName,
+  ALWAYS_RESERVED_OPTIONS,
+  reservedOptionNames,
+  isNestedSchema,
+  coerceFlagsToArgs,
+  parseArgsJson,
+  planToolCall,
+  firstSentence,
+  describeParameters
+};

package/build/{chunk-LP5ECG7A.js → chunk-ZDXMZPC6.js}

@@ -119,6 +119,9 @@ function shouldOutputJson() {
   if (globalOpts.pretty) return false;
   return !process.stdout.isTTY;
 }
+function isQuiet() {
+  return Boolean(globalOpts.quiet);
+}
 function colorEnabled() {
   if (globalOpts.noColor) return false;
   if (process.env.NO_COLOR) return false;
@@ -140,6 +143,20 @@ function dim(s) {
 function bold(s) {
   return colorEnabled() ? `\x1B[1m${s}\x1B[0m` : s;
 }
+function formatDuration(totalSeconds) {
+  const seconds = Math.max(0, Math.round(totalSeconds));
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const rest = seconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  if (minutes > 0) return `${minutes}m ${rest}s`;
+  return `${rest}s`;
+}
+function describeReset(meta) {
+  if (!meta.reset_at) return null;
+  const relative = typeof meta.retry_after_seconds === "number" ? ` (in ${formatDuration(meta.retry_after_seconds)})` : "";
+  return `Resets: ${meta.reset_at}${relative}`;
+}
 function successEnvelope(data, meta) {
   return { ok: true, data, meta };
 }
@@ -219,7 +236,9 @@ async function writeOutput(envelope) {
 `));
     }
     if (envelope.meta.truncated) {
-      process.stderr.write(yellow("Evidence warning: response was truncated.\n"));
+      process.stderr.write(
+        yellow("Evidence warning: response was truncated.\n")
+      );
     }
     for (const warning of envelope.meta.warnings ?? []) {
       process.stderr.write(yellow(`Evidence warning: ${warning}
@@ -247,11 +266,14 @@ async function writeOutput(envelope) {
 `)
       );
     }
-    const nextAction = envelope.meta?.next_action;
+    const nextAction = envelope.meta.next_action;
     if (typeof nextAction === "string" && nextAction.trim()) {
       process.stderr.write(yellow(`  Next: ${nextAction}
 `));
     }
+    const reset = describeReset(envelope.meta);
+    if (reset) process.stderr.write(yellow(`  ${reset}
+`));
   }
 }
 async function outputSuccess(data, meta) {
@@ -289,12 +311,14 @@ function formatCsv(data) {
 export {
   setOutputOptions,
   shouldOutputJson,
+  isQuiet,
   colorEnabled,
   red,
   green,
   yellow,
   dim,
   bold,
+  describeReset,
   successEnvelope,
   errorEnvelope,
   writeOutput,