agent-standup 0.20.0

package/dist/chunk-VBXNDGOD.js

@@ -0,0 +1,203 @@
+// src/lib/interventions/types.ts
+var INTERVENTION_LEVELS = ["nothing", "nudge", "block-overridable", "hard-block"];
+var INTERVENTION_TIMINGS = ["immediate", "digest"];
+var BLOCKING_LEVELS = /* @__PURE__ */ new Set([
+  "block-overridable",
+  "hard-block"
+]);
+function isBlockingLevel(level) {
+  return BLOCKING_LEVELS.has(level);
+}
+
+// src/lib/interventions/capture.ts
+var INTERVENTION_OUTCOMES = ["silent", "nudged", "blocked", "overridden"];
+var MAX_CAPTURED_COMMAND = 200;
+function truncateCommand(command, limit = MAX_CAPTURED_COMMAND) {
+  if (command.length <= limit) return command;
+  return `${command.slice(0, limit)}\u2026[truncated]`;
+}
+function outcomeFor(finding, context) {
+  if (finding.level === "nothing") return "silent";
+  if (!isBlockingLevel(finding.level)) return "nudged";
+  if (context.overriddenEntryIds?.includes(finding.id) === true) return "overridden";
+  return context.blocked === false ? "nudged" : "blocked";
+}
+function buildCaptures(findings, context) {
+  return findings.map((finding) => {
+    const command = context.command === void 0 ? void 0 : truncateCommand(context.command);
+    const outcome = outcomeFor(finding, context);
+    const overrideReason = outcome === "overridden" ? context.overrideReason : void 0;
+    return {
+      entryId: finding.id,
+      sessionId: context.sessionId,
+      ...context.rootSessionId === void 0 ? {} : { rootSessionId: context.rootSessionId },
+      ...context.itemId === void 0 ? {} : { itemId: context.itemId },
+      outcome,
+      level: finding.level,
+      phase: finding.phase,
+      ...context.tool === void 0 ? {} : { tool: context.tool },
+      ...command === void 0 ? {} : { command },
+      message: finding.messages.plain,
+      ...overrideReason === void 0 || overrideReason === "" ? {} : { overrideReason }
+    };
+  });
+}
+
+// src/lib/build-constants.ts
+var HOOK_VARIANTS = ["cli", "http"];
+function isHookVariant(value) {
+  return typeof value === "string" && HOOK_VARIANTS.includes(value);
+}
+var HOOK_PROTOCOL = Object.freeze({
+  cli: Object.freeze({ current: 1, minSupported: 1 }),
+  http: Object.freeze({ current: 1, minSupported: 1 })
+});
+var SHIPPED_HOOK_PROTOCOL_VERSION = 1;
+
+// src/lib/telemetry/contract.ts
+var MAX_COMMAND_CHARS = 4096;
+var MAX_PATHS = 64;
+var MAX_PATH_CHARS = 256;
+var MAX_TOOL_CHARS = 200;
+var MAX_SESSION_ID_CHARS = 128;
+var MAX_BATCH_SIZE = 500;
+var TRUNCATION_MARKER = "\u2026[truncated]";
+function capText(value, limit) {
+  if (value.length <= limit) return value;
+  if (limit <= TRUNCATION_MARKER.length) return value.slice(0, limit);
+  return value.slice(0, limit - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
+}
+function capPaths(paths) {
+  return paths.slice(0, MAX_PATHS).map((path) => capText(path, MAX_PATH_CHARS));
+}
+
+// src/lib/interventions/scoring.ts
+var INTERVENTION_SCORE_MEANINGS = Object.freeze({
+  5: "I would have gone down the wrong path and wasted a lot of tokens, or done something incorrect, if not for this nudge",
+  4: "Saved me some time/tokens or got me somewhere quicker, but I wasn't about to do anything dangerous anyway",
+  3: "Neutral \u2014 it helped, but I could probably have figured it out myself",
+  2: "Didn't help; the nudge was incorrect or misleading and I wasted more time because of it",
+  1: "Actively wrong or harmful \u2014 a block I had to route around, a stumbling block that took too long to work around. Please remove"
+});
+var MIN_INTERVENTION_SCORE = 1;
+var MAX_INTERVENTION_SCORE = 5;
+function isValidInterventionScore(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= MIN_INTERVENTION_SCORE && value <= MAX_INTERVENTION_SCORE;
+}
+function isHumanOrAgentTestimony(population) {
+  return population !== "derived";
+}
+function emptyDistribution() {
+  return { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
+}
+var SCALE_POINTS = [5, 4, 3, 2, 1];
+function summariseScores(firings) {
+  const byEntry = /* @__PURE__ */ new Map();
+  for (const firing of firings) {
+    if (!isValidInterventionScore(firing.score)) continue;
+    const bucket = byEntry.get(firing.entryId) ?? {
+      scores: [],
+      notes: [],
+      testimony: [],
+      derived: []
+    };
+    bucket.scores.push(firing.score);
+    if (isHumanOrAgentTestimony(firing.population ?? "person")) {
+      bucket.testimony.push(firing.score);
+    } else {
+      bucket.derived.push(firing.score);
+    }
+    if (firing.note !== void 0 && firing.note.trim() !== "") {
+      bucket.notes.push(firing.note.trim());
+    }
+    byEntry.set(firing.entryId, bucket);
+  }
+  const summaries = [];
+  for (const [entryId, bucket] of byEntry) {
+    const distribution = emptyDistribution();
+    let total = 0;
+    for (const score of bucket.scores) {
+      distribution[score] += 1;
+      total += score;
+    }
+    const count = bucket.scores.length;
+    summaries.push({
+      entryId,
+      count,
+      mean: total / count,
+      distribution,
+      removalSignals: distribution[1],
+      unhelpful: distribution[1] + distribution[2],
+      notes: bucket.notes,
+      testimony: summarisePopulation(bucket.testimony),
+      derived: summarisePopulation(bucket.derived)
+    });
+  }
+  return summaries.sort((a, b) => a.entryId.localeCompare(b.entryId));
+}
+function summarisePopulation(scores) {
+  if (scores.length === 0) return null;
+  const distribution = emptyDistribution();
+  let total = 0;
+  for (const score of scores) {
+    distribution[score] += 1;
+    total += score;
+  }
+  return {
+    count: scores.length,
+    mean: total / scores.length,
+    distribution,
+    removalSignals: distribution[1],
+    unhelpful: distribution[1] + distribution[2]
+  };
+}
+var DEFAULT_REVIEW_THRESHOLD = 3;
+var DEFAULT_REVIEW_MEAN = 2.5;
+function flagEntriesForReview(summaries, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_REVIEW_THRESHOLD;
+  const meanAtOrBelow = options.meanAtOrBelow ?? DEFAULT_REVIEW_MEAN;
+  const flagged = [];
+  for (const summary of summaries) {
+    if (summary.count < threshold) continue;
+    const reasons = [];
+    if (summary.mean <= meanAtOrBelow) {
+      reasons.push(`mean ${summary.mean.toFixed(2)} over ${summary.count} ratings`);
+    }
+    if (summary.removalSignals > 0) {
+      reasons.push(
+        summary.removalSignals === 1 ? "1 rater asked for it to be removed" : `${summary.removalSignals} raters asked for it to be removed`
+      );
+    }
+    if (reasons.length === 0) continue;
+    flagged.push({ entryId: summary.entryId, summary, reason: reasons.join("; ") });
+  }
+  return flagged.sort((a, b) => a.summary.mean - b.summary.mean);
+}
+
+export {
+  HOOK_VARIANTS,
+  isHookVariant,
+  HOOK_PROTOCOL,
+  SHIPPED_HOOK_PROTOCOL_VERSION,
+  MAX_COMMAND_CHARS,
+  MAX_PATHS,
+  MAX_TOOL_CHARS,
+  MAX_SESSION_ID_CHARS,
+  MAX_BATCH_SIZE,
+  TRUNCATION_MARKER,
+  capText,
+  capPaths,
+  INTERVENTION_LEVELS,
+  INTERVENTION_TIMINGS,
+  isBlockingLevel,
+  INTERVENTION_OUTCOMES,
+  MAX_CAPTURED_COMMAND,
+  buildCaptures,
+  INTERVENTION_SCORE_MEANINGS,
+  MIN_INTERVENTION_SCORE,
+  MAX_INTERVENTION_SCORE,
+  isValidInterventionScore,
+  SCALE_POINTS,
+  summariseScores,
+  flagEntriesForReview
+};