hivenet 0.4.2 → 0.6.0

package/dist/owner-ZWROA7AU.js

@@ -0,0 +1,539 @@
+import {
+  attachmentFlags
+} from "./chunk-AK23JXBN.js";
+import {
+  ATTACHMENT_TARGET_TYPES,
+  EVAL_STATUSES,
+  EVENT_STATUSES,
+  FEEDBACK_CATEGORIES,
+  FeedbackError,
+  ISSUE_STATUSES,
+  __toESM,
+  attachmentTargetSchema,
+  ownerApi,
+  require_arg,
+  resolveApiOrigin
+} from "./chunk-DNR6HNJD.js";
+
+// src/owner.ts
+var import_arg = __toESM(require_arg(), 1);
+var SECRET_ENV_VAR = "HIVENET_SECRET_KEY";
+async function runAttach(argv) {
+  const args = (0, import_arg.default)({ ...OWNER_FLAGS, ...attachmentFlags() }, { argv });
+  if (args["--help"]) {
+    console.log(`
+  Usage
+    $ npx hivenet attach <record type> <id> --attach <path> [--describe "<what it shows>"] \u2026
+
+  Record types: ${ATTACHMENT_TARGET_TYPES.join(" | ")}.
+  Up to 10 files per record, 20 MiB each. Files on a question are shared with every agent
+  that receives it; everything else stays private. Auth: --secret or ${SECRET_ENV_VAR}.
+`);
+    return;
+  }
+  const target = attachmentTargetSchema.safeParse({ type: args._[0], id: args._[1] });
+  if (!target.success || args._.length !== 2 || !args["--attach"]?.length) {
+    throw new FeedbackError(
+      "Usage: hivenet attach <record type> <id> --attach <path>. See hivenet attach --help."
+    );
+  }
+  const api = await buildApi(args);
+  const result = await api.attachFiles(target.data, args["--attach"]);
+  console.log(
+    args["--json"] ? JSON.stringify(result, null, 2) : `\u2713 Attached ${args["--attach"].length} file(s) to ${target.data.type} ${target.data.id}.`
+  );
+}
+var OWNER_FLAGS = {
+  "--to": String,
+  "--dsn": String,
+  "--api": String,
+  "--secret": String,
+  "--json": Boolean,
+  "--help": Boolean,
+  "-h": "--help"
+};
+async function buildApi(args) {
+  const secretKey = args["--secret"] ?? process.env[SECRET_ENV_VAR];
+  if (!secretKey?.startsWith("hv_sec_")) {
+    throw new FeedbackError(
+      `An owner secret key is required (hv_sec_\u2026, from your project's Settings).
+Pass --secret <key> or set ${SECRET_ENV_VAR}.`
+    );
+  }
+  const apiOrigin = args["--api"] ?? await resolveApiOrigin({
+    ...args["--to"] !== void 0 ? { to: args["--to"] } : {},
+    ...args["--dsn"] !== void 0 ? { dsn: args["--dsn"] } : {}
+  });
+  return ownerApi({ secretKey, apiOrigin });
+}
+function statusIcon(status) {
+  return { new: "\u25CF", seen: "\u25D0", in_progress: "\u25D2", resolved: "\u2713", wont_fix: "\u2717", spam: "\u2298" }[status];
+}
+function printEvent(event, verbose = false) {
+  const subject = event.subject ? ` \xB7 ${event.subject}` : "";
+  console.log(
+    `${statusIcon(event.status)} ${event.id}  [${event.status}]  ${event.category}${subject}  (${event.agent ?? event.author ?? "unknown"}, ${event.received_at.slice(0, 16).replace("T", " ")})`
+  );
+  console.log(`    ${event.feedback}`);
+  if (event.triage_note) {
+    console.log(`    \u21B3 note: ${event.triage_note}`);
+  }
+  if (verbose) {
+    console.log(
+      `    thread ${event.thread_id} \xB7 telemetry ${event.consent_telemetry ? "on" : "off"}`
+    );
+  }
+}
+async function runInbox(argv) {
+  const args = (0, import_arg.default)(
+    {
+      ...OWNER_FLAGS,
+      "--status": String,
+      "--category": String,
+      "--thread": String,
+      "--limit": Number
+    },
+    { argv }
+  );
+  if (args["--help"]) {
+    console.log(`
+  Usage
+    $ npx hivenet inbox [--status new] [--category mcp] [--thread <id>] [--limit 50]
+
+  List feedback for your project (owners only). Auth: --secret <hv_sec_\u2026> or
+  ${SECRET_ENV_VAR}. Destination: --to <slug|domain>, --dsn, or --api <origin>
+  (defaults to the hosted API). Statuses: ${EVENT_STATUSES.join(" | ")}. --json for raw output.
+`);
+    return;
+  }
+  const status = args["--status"];
+  if (status && !EVENT_STATUSES.includes(status)) {
+    throw new FeedbackError(
+      `Invalid --status "${status}". Expected: ${EVENT_STATUSES.join(", ")}.`
+    );
+  }
+  const api = await buildApi(args);
+  const result = await api.listFeedback({
+    ...status ? { status } : {},
+    ...args["--category"] ? { category: args["--category"] } : {},
+    ...args["--thread"] ? { thread: args["--thread"] } : {},
+    ...args["--limit"] ? { limit: args["--limit"] } : {}
+  });
+  if (args["--json"]) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.events.length === 0) {
+    console.log(`No matching feedback for ${result.project}.`);
+    return;
+  }
+  console.log(`${result.events.length} event(s) for ${result.project}:
+`);
+  for (const event of result.events) {
+    printEvent(event);
+  }
+  console.log(
+    `
+Triage: npx hivenet triage <eventId> --status <${EVENT_STATUSES.join("|")}> [--note "\u2026"]`
+  );
+}
+async function runTriage(argv) {
+  const args = (0, import_arg.default)(
+    { ...OWNER_FLAGS, "--status": String, "--note": String, "--link": String },
+    { argv }
+  );
+  if (args["--help"] || args._.length === 0) {
+    console.log(`
+  Usage
+    $ npx hivenet triage <eventId> [--status <status>] [--note "why"] [--link <url>]
+
+  Set triage status and/or attach an external link (Slack, Linear, GitHub, PR) to a
+  feedback event (owners only). Statuses: ${EVENT_STATUSES.join(" | ")}.
+  Auth: --secret <hv_sec_\u2026> or ${SECRET_ENV_VAR}. Destination: --to/--dsn/--api.
+`);
+    if (!args["--help"]) {
+      throw new FeedbackError("An event ID is required.");
+    }
+    return;
+  }
+  const status = args["--status"];
+  if (status && !EVENT_STATUSES.includes(status)) {
+    throw new FeedbackError(`Invalid --status. Expected: ${EVENT_STATUSES.join(", ")}.`);
+  }
+  if (!status && !args["--link"]) {
+    throw new FeedbackError("Provide --status and/or --link.");
+  }
+  const api = await buildApi(args);
+  const id = args._[0];
+  if (args["--link"]) {
+    await api.addLink(id, args["--link"]);
+  }
+  const event = status ? (await api.setFeedbackStatus(
+    id,
+    status,
+    args["--note"] !== void 0 ? args["--note"] : void 0
+  )).event : (await api.getFeedback(id)).event;
+  if (args["--json"]) {
+    console.log(JSON.stringify({ event }, null, 2));
+    return;
+  }
+  console.log("Updated:");
+  printEvent(event, true);
+  printLinks(event.links_json);
+}
+function printLinks(linksJson) {
+  try {
+    const links = JSON.parse(linksJson ?? "[]");
+    for (const link of links) {
+      console.log(`    \u21C4 ${link.kind}: ${link.url}`);
+    }
+  } catch {
+  }
+}
+function issueIcon(status) {
+  return {
+    open: "\u25CF",
+    in_progress: "\u25D2",
+    needs_review: "\u25CE",
+    resolved: "\u2713",
+    wont_fix: "\u2717",
+    spam: "\u2298"
+  }[status];
+}
+function printIssue(issue) {
+  const regressed = issue.reopened_count > 0 ? `  \u21BB regressed \xD7${issue.reopened_count}` : "";
+  console.log(
+    `${issueIcon(issue.status)} ${issue.id}  [${issue.status}]  ${issue.title}  (${issue.event_count} event${issue.event_count === 1 ? "" : "s"}, last ${issue.last_seen.slice(0, 16).replace("T", " ")})${regressed}`
+  );
+  printLinks(issue.links_json);
+}
+async function runIssues(argv) {
+  const args = (0, import_arg.default)({ ...OWNER_FLAGS, "--status": String, "--limit": Number }, { argv });
+  if (args["--help"]) {
+    console.log(`
+  Usage
+    $ npx hivenet issues [--status open] [--limit 50]
+
+  List issues \u2014 feedback clustered by thread and (category, subject) fingerprint.
+  Statuses: ${ISSUE_STATUSES.join(" | ")}. Auth: --secret or ${SECRET_ENV_VAR}.
+  Manage one: npx hivenet issue <issueId> --status resolved --note "\u2026" --link <url>
+`);
+    return;
+  }
+  const status = args["--status"];
+  if (status && !ISSUE_STATUSES.includes(status)) {
+    throw new FeedbackError(`Invalid --status. Expected: ${ISSUE_STATUSES.join(", ")}.`);
+  }
+  const api = await buildApi(args);
+  const result = await api.listIssues({
+    ...status ? { status } : {},
+    ...args["--limit"] ? { limit: args["--limit"] } : {}
+  });
+  if (args["--json"]) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.issues.length === 0) {
+    console.log(`No matching issues for ${result.project}.`);
+    return;
+  }
+  console.log(`${result.issues.length} issue(s) for ${result.project}:
+`);
+  for (const issue of result.issues) {
+    printIssue(issue);
+  }
+}
+async function runIssue(argv) {
+  const args = (0, import_arg.default)(
+    { ...OWNER_FLAGS, "--status": String, "--note": String, "--link": String },
+    { argv }
+  );
+  if (args["--help"] || args._.length === 0) {
+    console.log(`
+  Usage
+    $ npx hivenet issue <issueId>                         (show with events)
+    $ npx hivenet issue <issueId> --status resolved --note "\u2026" --link <url>
+
+  Statuses: ${ISSUE_STATUSES.join(" | ")}. Resolving cascades to member events; new
+  feedback on a resolved issue reopens it. Auth: --secret or ${SECRET_ENV_VAR}.
+`);
+    if (!args["--help"]) {
+      throw new FeedbackError("An issue ID is required.");
+    }
+    return;
+  }
+  const status = args["--status"];
+  if (status && !ISSUE_STATUSES.includes(status)) {
+    throw new FeedbackError(`Invalid --status. Expected: ${ISSUE_STATUSES.join(", ")}.`);
+  }
+  if (args["--note"] !== void 0 && !status) {
+    throw new FeedbackError("--note requires --status.");
+  }
+  const api = await buildApi(args);
+  const id = args._[0];
+  if (args["--link"]) {
+    await api.addLink(id, args["--link"]);
+  }
+  if (status) {
+    await api.setIssueStatus(id, status, args["--note"] !== void 0 ? args["--note"] : void 0);
+  }
+  const { issue, events } = await api.getIssue(id);
+  if (args["--json"]) {
+    console.log(JSON.stringify({ issue, events }, null, 2));
+    return;
+  }
+  printIssue(issue);
+  if (issue.summary) {
+    console.log(`    ${issue.summary}`);
+  }
+  console.log("");
+  for (const event of events) {
+    printEvent(event);
+  }
+}
+function printQuestion(question) {
+  const icon = question.status === "active" ? "\u25CF" : "\u2713";
+  const auto = question.source === "system" ? " [auto]" : "";
+  const target = question.target.category ? ` \xB7 ${question.target.category}` : question.target.issue_id ? ` \xB7 verifies ${question.target.issue_id.slice(0, 14)}\u2026` : "";
+  console.log(`${icon} ${question.id}  [${question.status}]${auto}${target}`);
+  console.log(`    ${question.prompt}`);
+  for (const answer of question.answers) {
+    const who = answer.agent ?? answer.client_name ?? "unknown";
+    console.log(
+      `    \u21B3 (${who}, ${answer.received_at.slice(0, 16).replace("T", " ")}) ${answer.feedback}`
+    );
+  }
+}
+async function runQuestions(argv) {
+  const args = (0, import_arg.default)({ ...OWNER_FLAGS, "--status": String }, { argv });
+  if (args["--help"]) {
+    console.log(`
+  Usage
+    $ npx hivenet questions [--status active|closed]      (list with answers)
+    $ npx hivenet ask "<prompt>" [--category cli]         (publish a question)
+    $ npx hivenet question <id> --close                   (stop delivery)
+
+  Questions ride along with submission responses \u2014 one per response, delivered
+  to matching agents; answers group under each question. Auth: --secret or
+  ${SECRET_ENV_VAR}.
+
+  Show agents what you mean: --attach <path> [--describe "<what it shows>"] on ask
+  (repeatable; 10 files, 20 MiB each). Every agent the question reaches can open them.
+`);
+    return;
+  }
+  const status = args["--status"];
+  if (status && status !== "active" && status !== "closed") {
+    throw new FeedbackError("Invalid --status. Expected: active or closed.");
+  }
+  const api = await buildApi(args);
+  const result = await api.listQuestions(status ? { status } : {});
+  if (args["--json"]) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.questions.length === 0) {
+    console.log('No questions yet. Publish one: npx hivenet ask "<prompt>" [--category cli]');
+    return;
+  }
+  console.log(`${result.questions.length} question(s):
+`);
+  for (const question of result.questions) {
+    printQuestion(question);
+    console.log("");
+  }
+}
+async function runAsk(argv) {
+  const args = (0, import_arg.default)(
+    { ...OWNER_FLAGS, "--category": String, "--idempotency-key": String, ...attachmentFlags() },
+    { argv }
+  );
+  const prompt = args._.join(" ").trim();
+  if (args["--help"] || prompt.length === 0) {
+    console.log(`
+  Usage
+    $ npx hivenet ask "If you used <feature>: what broke or was missing?" [--category cli]
+
+  Publishes a question to the agents using your product. Targeted beats
+  open-ended. Categories: ${FEEDBACK_CATEGORIES.join(" | ")}. Auth: --secret or ${SECRET_ENV_VAR}.
+  --attach <path> [--describe "<what it shows>"] shares a file with every agent that receives it.
+  --idempotency-key <key> publishes the question once however often you retry (8\u201364 letters,
+  digits, _ or -).
+`);
+    if (!args["--help"]) {
+      throw new FeedbackError("A question prompt is required.");
+    }
+    return;
+  }
+  const api = await buildApi(args);
+  const { question } = await api.createQuestion(prompt, args["--category"], {
+    ...args["--attach"] ? { files: args["--attach"] } : {},
+    ...args["--idempotency-key"] ? { idempotencyKey: args["--idempotency-key"] } : {}
+  });
+  if (args["--json"]) {
+    console.log(JSON.stringify({ question }, null, 2));
+    return;
+  }
+  console.log(`\u2713 Question published (${question.id})`);
+  console.log(`  It rides along with matching submission responses \u2014 one ask per response.`);
+  console.log(
+    `  Answers: npx hivenet questions \xB7 close: npx hivenet question ${question.id} --close`
+  );
+}
+async function runQuestion(argv) {
+  const args = (0, import_arg.default)({ ...OWNER_FLAGS, "--close": Boolean }, { argv });
+  if (args["--help"] || args._.length === 0) {
+    console.log(`
+  Usage
+    $ npx hivenet question <questionId>            (show with answers)
+    $ npx hivenet question <questionId> --close    (stop delivery)
+`);
+    if (!args["--help"]) {
+      throw new FeedbackError("A question ID is required.");
+    }
+    return;
+  }
+  const api = await buildApi(args);
+  const id = args._[0];
+  if (args["--close"]) {
+    await api.closeQuestion(id);
+  }
+  const { questions } = await api.listQuestions();
+  const question = questions.find((candidate) => candidate.id === id);
+  if (!question) {
+    throw new FeedbackError(`Question "${id}" not found.`);
+  }
+  if (args["--json"]) {
+    console.log(JSON.stringify({ question }, null, 2));
+    return;
+  }
+  printQuestion(question);
+}
+function evalIcon(status) {
+  return { proposed: "\u25C7", accepted: "\u25C6", archived: "\u229F" }[status];
+}
+function printEval(entry) {
+  console.log(`${evalIcon(entry.status)} ${entry.id}  [${entry.status}]  ${entry.title}`);
+  console.log(`    task: ${entry.task}`);
+  if (entry.expected) console.log(`    expected: ${entry.expected}`);
+  if (entry.setup) {
+    console.log(`    setup: ${entry.setup}`);
+  } else {
+    console.log(
+      `    setup: missing${entry.setup_pending ? " \u2014 reporter asked on their thread" : ""}`
+    );
+  }
+  if (entry.source) {
+    const who = entry.source.agent ?? entry.source.client_name ?? "unknown";
+    const attempts = entry.source.attempts ? ` \xB7 ${entry.source.attempts} attempts` : "";
+    console.log(`    from ${entry.source.event_id} (${who}${attempts})`);
+  }
+  if (entry.note) console.log(`    \u21B3 note: ${entry.note}`);
+}
+async function runEvals(argv) {
+  const args = (0, import_arg.default)({ ...OWNER_FLAGS, "--status": String }, { argv });
+  if (args["--help"]) {
+    console.log(`
+  Usage
+    $ npx hivenet evals [--status proposed|accepted|archived]   (list the corpus)
+    $ npx hivenet eval <id> [--status accepted] [--note "\u2026"]    (curate one)
+    $ npx hivenet promote <eventId>                             (report \u2192 eval)
+
+  Evals are real tasks agents failed at, promoted from failed-task reports.
+  Use --json for a machine-readable corpus export. Auth: --secret or ${SECRET_ENV_VAR}.
+`);
+    return;
+  }
+  const status = args["--status"];
+  if (status && !EVAL_STATUSES.includes(status)) {
+    throw new FeedbackError(`Invalid --status. Expected: ${EVAL_STATUSES.join(", ")}.`);
+  }
+  const api = await buildApi(args);
+  const result = await api.listEvals(status ? { status } : {});
+  if (args["--json"]) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.evals.length === 0) {
+    console.log("No evals yet. Promote a failed-task report: npx hivenet promote <eventId>");
+    return;
+  }
+  console.log(`${result.evals.length} eval(s):
+`);
+  for (const entry of result.evals) {
+    printEval(entry);
+    console.log("");
+  }
+}
+async function runEval(argv) {
+  const args = (0, import_arg.default)({ ...OWNER_FLAGS, "--status": String, "--note": String }, { argv });
+  if (args["--help"] || args._.length === 0) {
+    console.log(`
+  Usage
+    $ npx hivenet eval <evalId>                            (show)
+    $ npx hivenet eval <evalId> --status accepted          (curate)
+    $ npx hivenet eval <evalId> --status archived --note "why"
+
+  Statuses: ${EVAL_STATUSES.join(" | ")}. Auth: --secret or ${SECRET_ENV_VAR}.
+`);
+    if (!args["--help"]) {
+      throw new FeedbackError("An eval ID is required.");
+    }
+    return;
+  }
+  const status = args["--status"];
+  if (status && !EVAL_STATUSES.includes(status)) {
+    throw new FeedbackError(`Invalid --status. Expected: ${EVAL_STATUSES.join(", ")}.`);
+  }
+  if (args["--note"] !== void 0 && !status) {
+    throw new FeedbackError("--note requires --status.");
+  }
+  const api = await buildApi(args);
+  const id = args._[0];
+  if (status) {
+    await api.setEvalStatus(id, status, args["--note"] !== void 0 ? args["--note"] : void 0);
+  }
+  const { eval: entry } = await api.getEval(id);
+  if (args["--json"]) {
+    console.log(JSON.stringify({ eval: entry }, null, 2));
+    return;
+  }
+  printEval(entry);
+}
+async function runPromote(argv) {
+  const args = (0, import_arg.default)({ ...OWNER_FLAGS }, { argv });
+  if (args["--help"] || args._.length === 0) {
+    console.log(`
+  Usage
+    $ npx hivenet promote <eventId>    (failed-task report \u2192 eval candidate)
+
+  Idempotent per event. When the report lacks reproduction state, the reporter
+  is asked for it on their thread; the answer fills the eval's setup.
+`);
+    if (!args["--help"]) {
+      throw new FeedbackError("An event ID is required.");
+    }
+    return;
+  }
+  const api = await buildApi(args);
+  const { eval: entry, created } = await api.promoteEval(args._[0]);
+  if (args["--json"]) {
+    console.log(JSON.stringify({ eval: entry, created }, null, 2));
+    return;
+  }
+  console.log(created ? `\u2713 Promoted to eval (${entry.id})` : `Already promoted (${entry.id})`);
+  printEval(entry);
+}
+export {
+  runAsk,
+  runAttach,
+  runEval,
+  runEvals,
+  runInbox,
+  runIssue,
+  runIssues,
+  runPromote,
+  runQuestion,
+  runQuestions,
+  runTriage
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hivenet",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "description": "Submit feedback about any agentic system's tools, docs, CLI, or MCP server \u2014 from any AI agent or human",
   "keywords": [
     "agent",