hive-intelligence 1.6.7 → 1.7.2

package/build/chunk-AZFOTKS2.js

@@ -0,0 +1,394 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-ZSPPJW4G.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-GYVF75XB.js → chunk-FQNW6SZ6.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-QDZ7MAVN.js";
 import {
   HIVE_AGENT_SKILLS
-} from "./chunk-GADPH72D.js";
+} from "./chunk-4QDGA6GP.js";
 
 // src/cli/detect-clients.ts
 import { existsSync } from "fs";

package/build/{chunk-32NRUWXA.js → chunk-KQVPKTEO.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-POBN6Y5S.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-YQAVCXXO.js");
     const code = result.error?.code;
     const err = code === "AUTH_REQUIRED" || code === "INVALID_TOKEN" ? new CliError(
       "AUTH_REQUIRED",

package/build/{chunk-LW2DHE32.js → chunk-L4KVJDA7.js}

@@ -12,7 +12,7 @@ import {
   shouldOutputJson,
   successEnvelope,
   writeOutput
-} from "./chunk-LP5ECG7A.js";
+} from "./chunk-ZDXMZPC6.js";
 
 // src/cli/upgrade.ts
 import { spawnSync } from "child_process";