npm - behavior-wrapped - Versions diffs - 0.5.8 → 0.5.10 - Mend

behavior-wrapped 0.5.8 → 0.5.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/assets/{index-DyBPWLnC.css → index-COnYUt6B.css} +1 -1
package/dist/assets/index-DzSM-hPQ.js +12 -0
package/dist/index.html +2 -2
package/package.json +1 -1
package/server/cli.mjs +4 -3
package/server/instrumental-workarounds.mjs +9 -7
package/server/launcher.mjs +11 -0
package/server/progress.mjs +21 -5
package/server/workaround-evidence.mjs +125 -0
package/dist/assets/index-D0gP-HqY.js +0 -11

package/dist/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <meta name="theme-color" content="#0d0b1b" />
     <meta name="description" content="Your private, local-first Claude Code behavior report." />
     <title>Behavior Wrapped</title>
-    <script type="module" crossorigin src="/assets/index-D0gP-HqY.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DyBPWLnC.css">
+    <script type="module" crossorigin src="/assets/index-DzSM-hPQ.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-COnYUt6B.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "behavior-wrapped",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "A private, local-first Wrapped report for Claude Code, Cowork, and Codex behavior.",
   "license": "Apache-2.0",
   "type": "module",

package/server/cli.mjs CHANGED Viewed

@@ -181,8 +181,9 @@ async function createWrapped() {
     progress.succeed(`${testMode ? "Local test fallbacks" : "Local-only analysis"} ready; no LLM calls made`);
   } else {
     const judgeStates = { phrase: "waiting", tone: "waiting", topics: "waiting", workarounds: "waiting" };
+    const judgeLabels = { phrase: "favorite phrase", tone: "agent interaction", topics: "topics", workarounds: "workarounds" };
     const judgeStatus = (state) => state === "waiting" ? "queued" : state === "working" ? "…" : state === "done" ? "✓" : state === "failed" ? "skipped" : state;
-    const judgeSummary = () => Object.entries(judgeStates).map(([name, state]) => `${name} ${judgeStatus(state)}`).join(" · ");
+    const judgeSummary = () => Object.entries(judgeStates).map(([name, state]) => `${judgeLabels[name]} ${judgeStatus(state)}`).join(" · ");
     const trackJudge = (name, promise) => {
       judgeStates[name] = "working";
       progress.update(judgeSummary());
@@ -196,7 +197,7 @@ async function createWrapped() {
         throw error;
       });
     };
-    progress.start("Running privacy-safe AI analysis", judgeSummary());
+    progress.start("Running redacted excerpts through LLM Judge", judgeSummary(), { separateDetail: true });
     const phraseCardPromise = process.env.BEHAVIOR_WRAPPED_DIRECT_OPENROUTER === "1"
       ? judgePhraseCard(candidates, process.env.OPENROUTER_API_KEY)
       : judgePhraseCardViaRelay(candidates, { endpoint: process.env.BEHAVIOR_WRAPPED_JUDGE_URL || PHRASE_JUDGE_RELAY_URL, clientId: getOrCreateClientId() });
@@ -225,7 +226,7 @@ async function createWrapped() {
       optionalAnalysis(trackJudge("topics", sessionTopicsPromise), "usage-topic card", analysisWarnings),
       optionalAnalysis(trackJudge("workarounds", workaroundsPromise), "instrumental-workaround card", analysisWarnings),
     ]);
-    progress.succeed("Privacy-safe AI analysis complete");
+    progress.succeed("LLM Judge complete");
   }
   analyzed.phraseCard = phraseCard;
   if (!localOnly) {

package/server/instrumental-workarounds.mjs CHANGED Viewed

@@ -106,7 +106,7 @@ function trajectoryEvents(records, agent, trajectoryId, sessionId, sessionIndex)
   const events = [];
   let currentModel = agent === "codex" ? "Codex model" : "Claude model";
   let sourceIndex = 0;
-  const add = (role, kind, text, timestamp, action = null, method = null) => {
+  const add = (role, kind, text, timestamp, action = null, method = null, recordIndex = null) => {
     events.push({
       event_id: `${trajectoryId}-event-${events.length + 1}`,
       role,
@@ -116,27 +116,29 @@ function trajectoryEvents(records, agent, trajectoryId, sessionId, sessionIndex)
       model: currentModel,
       action,
       method,
+      recordIndex,
       sourceIndex: sourceIndex++,
       sessionIndex,
       sessionId,
     });
   };
-  for (const record of records) {
+  for (let recordIndex = 0; recordIndex < records.length; recordIndex++) {
+    const record = records[recordIndex];
     if (typeof record?.message?.model === "string" && record.message.model !== "<synthetic>") currentModel = record.message.model;
     const role = record.type === "assistant" ? "assistant" : record.type === "system" ? "system" : "user";
     const kind = record.type === "assistant" ? "assistant_text" : record.type === "system" ? "system_text" : "user_text";
     const text = visibleText(record);
     if (!record.isMeta && ["user", "assistant", "system"].includes(record.type)) {
       const parts = splitSafeText(text);
-      if (parts.length) for (const part of parts) add(role, kind, part, record.timestamp);
-      else if (text) add(role, "content_removed", "Message content removed locally", record.timestamp);
+      if (parts.length) for (const part of parts) add(role, kind, part, record.timestamp, null, null, recordIndex);
+      else if (text) add(role, "content_removed", "Message content removed locally", record.timestamp, null, null, recordIndex);
     }
     for (const block of contentBlocks(record)) {
       if (block?.type === "tool_use") {
         const { action, method } = semanticToolUse({ name: block.name, inputValue: block.input, actionHint: block.action_hint, methodHint: block.method_hint });
-        add("assistant", "tool_use", `Tool use: ${safeToolName(block.name)}${action ? ` (${action})` : ""}`, record.timestamp, action, method);
+        add("assistant", "tool_use", `Tool use: ${safeToolName(block.name)}${action ? ` (${action})` : ""}`, record.timestamp, action, method, recordIndex);
       } else if (block?.type === "tool_result") {
-        add("tool", "tool_result", `Tool result: ${toolResultSummary(block)}`, record.timestamp);
+        add("tool", "tool_result", `Tool result: ${toolResultSummary(block)}`, record.timestamp, null, null, recordIndex);
       }
     }
   }
@@ -466,7 +468,7 @@ function resultFromSelections(bundle, selections, { model, provider, latencyMs,
       confidence: item.confidence,
       model: displayModelName(alternative.model),
       evidence: [original, blocker, alternative].map(({ role, kind, text, timestamp }) => ({ role, kind, text, timestamp })),
-      location: { sessionId: trajectory.sessionId, trajectoryId: item.trajectory_id, blockerEventId: item.blocker_event_id, originalMethodEventId: item.original_method_event_id, alternativeMethodEventId: item.alternative_method_event_id },
+      location: { sessionId: trajectory.sessionId, trajectoryId: item.trajectory_id, blockerEventId: item.blocker_event_id, originalMethodEventId: item.original_method_event_id, alternativeMethodEventId: item.alternative_method_event_id, originalRecordIndex: original.recordIndex, blockerRecordIndex: blocker.recordIndex, alternativeRecordIndex: alternative.recordIndex },
     };
   };
   const confirmedItems = selections.flatMap((selection) => selection.confirmed);

package/server/launcher.mjs CHANGED Viewed

@@ -10,6 +10,7 @@ import { makeDonationPreview } from "./analysis.mjs";
 import { deleteDonationReceipt, getOrCreateClientId, loadDonationReceipt, loadReport, saveDonationReceipt } from "./store.mjs";
 import { deleteResearchDonation, RESEARCH_DONATION_URL, submitResearchDonation } from "./research-donation.mjs";
 import { APP_VERSION, LOCAL_DONATION_PROTOCOL } from "./runtime-version.mjs";
+import { makeWorkaroundEvidencePreview } from "./workaround-evidence.mjs";
 const here = path.dirname(fileURLToPath(import.meta.url));
 const root = path.dirname(here);
@@ -111,6 +112,16 @@ const server = http.createServer(async (request, response) => {
       const available = new Set(catalog.sessions.map((session) => session.id));
       return json(response, 200, { sessionIds: (report.sessionIds || []).filter((id) => available.has(id)), localPrivateSelection: true });
     }
+    const workaroundEvidenceMatch = url.pathname.match(/^\/api\/reports\/([A-Za-z0-9_-]{8,32})\/workarounds$/);
+    if (request.method === "GET" && workaroundEvidenceMatch) {
+      const report = loadReport(workaroundEvidenceMatch[1]);
+      if (!report) return json(response, 404, { error: "Saved report not found" });
+      const allowed = new Set(report.sessionIds || []);
+      const ids = [...new Set((report.workaroundReview?.occurrences || []).map((occurrence) => occurrence?.location?.sessionId).filter((id) => allowed.has(id) && catalog.index.has(id)))].slice(0, 100);
+      const records = await chosenRecords(ids);
+      const labels = new Map(publicCatalog().sessions.map((session) => [session.id, session]));
+      return json(response, 200, makeWorkaroundEvidencePreview(report, records, labels));
+    }
     if (request.method === "POST" && url.pathname === "/api/donation-preview") {
       const body = await readBody(request);
       const report = loadReport(body.reportId);

package/server/progress.mjs CHANGED Viewed

@@ -19,6 +19,7 @@ export function createCliProgress({
   let label = "";
   let detail = "";
   let startedAt = 0;
+  let separateDetail = false;
   function line(symbol) {
     const extra = detail ? ` · ${detail}` : "";
@@ -27,7 +28,19 @@ export function createCliProgress({
   function render() {
     if (!timer) return;
-    output.write(`\r\x1b[2K${line(spinnerFrames[frame++ % spinnerFrames.length])}`);
+    clearLine();
+    output.write(separateDetail
+      ? `${spinnerFrames[frame++ % spinnerFrames.length]}  ${detail}`
+      : line(spinnerFrames[frame++ % spinnerFrames.length]));
+  }
+  function clearLine() {
+    if (typeof output.clearLine === "function" && typeof output.cursorTo === "function") {
+      output.clearLine(0);
+      output.cursorTo(0);
+      return;
+    }
+    output.write("\r\x1b[2K");
   }
   function stopTimer() {
@@ -37,16 +50,18 @@ export function createCliProgress({
   }
   return {
-    start(nextLabel, nextDetail = "") {
+    start(nextLabel, nextDetail = "", options = {}) {
       stopTimer();
       label = nextLabel;
       detail = nextDetail;
+      separateDetail = Boolean(options.separateDetail && detail);
       startedAt = now();
       frame = 0;
       if (!interactive) {
-        output.write(`◇  ${label}${detail ? ` · ${detail}` : ""}\n`);
+        output.write(separateDetail ? `◇  ${label}\n◇  ${detail}\n` : `◇  ${label}${detail ? ` · ${detail}` : ""}\n`);
         return;
       }
+      if (separateDetail) output.write(`◇  ${label}\n`);
       timer = setIntervalImpl(render, intervalMs);
       timer?.unref?.();
       render();
@@ -59,11 +74,12 @@ export function createCliProgress({
     succeed(summary = label) {
       const elapsed = elapsedLabel(now() - startedAt);
       stopTimer();
-      output.write(interactive ? `\r\x1b[2K✓  ${summary} · ${elapsed}\n` : `✓  ${summary} · ${elapsed}\n`);
+      if (interactive) clearLine();
+      output.write(`✓  ${summary} · ${elapsed}\n`);
     },
     stop() {
       stopTimer();
-      if (interactive) output.write("\r\x1b[2K");
+      if (interactive) clearLine();
     },
   };
 }

package/server/workaround-evidence.mjs ADDED Viewed

@@ -0,0 +1,125 @@
+import { makeDonationPreview } from "./analysis.mjs";
+import { redactText } from "./privacy.mjs";
+const DEFAULT_CONTEXT_TURNS = 2;
+const MAX_OCCURRENCES = 100;
+function finiteRecordIndex(value, length) {
+  return Number.isInteger(value) && value >= 0 && value < length ? value : null;
+}
+function contentBlocks(record) {
+  const content = record?.message?.content ?? record?.content;
+  if (Array.isArray(content)) return content;
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  return [];
+}
+function visibleText(record) {
+  return contentBlocks(record).filter((block) => block?.type === "text").map((block) => block.text || "").join("\n").trim();
+}
+function toolResultText(record) {
+  return contentBlocks(record).filter((block) => block?.type === "tool_result").map((block) => {
+    const content = typeof block.content === "string"
+      ? block.content
+      : Array.isArray(block.content)
+        ? block.content.map((part) => typeof part === "string" ? part : part?.text || "").filter(Boolean).join("\n")
+        : "";
+    return [block.error_summary, content].filter(Boolean).join("\n");
+  }).filter(Boolean).join("\n").trim();
+}
+function toolUseText(record) {
+  return contentBlocks(record).filter((block) => block?.type === "tool_use").map((block) => {
+    const input = block.input && typeof block.input === "object" ? JSON.stringify(block.input, null, 2) : String(block.input || "").trim();
+    return [`${String(block.name || "Tool")} tool call`, input].filter(Boolean).join("\n");
+  }).filter(Boolean).join("\n\n").trim();
+}
+function locallyRedacted(value) {
+  return redactText(String(value || ""), [], { includeHeuristicSecrets: false }).text.trim();
+}
+function matchingEvidenceText(occurrence, kind) {
+  return String((occurrence?.evidence || []).find((event) => event?.kind === kind)?.text || "").trim();
+}
+function fallbackRecordIndex(occurrence, records, kind) {
+  const kinds = new Set(Array.isArray(kind) ? kind : kind ? [kind] : []);
+  const timestamps = new Set((occurrence?.evidence || []).filter((event) => !kinds.size || kinds.has(event?.kind)).map((event) => event?.timestamp).filter(Boolean));
+  const index = records.findIndex((record) => timestamps.has(record?.timestamp));
+  return index >= 0 ? index : null;
+}
+function occurrenceRecordIndex(occurrence, records, field, kind) {
+  return finiteRecordIndex(occurrence?.location?.[field], records.length) ?? fallbackRecordIndex(occurrence, records, kind);
+}
+function transcriptMessage(record, kind = "context") {
+  const text = locallyRedacted(visibleText(record));
+  if (!text) return null;
+  return { role: record.type, timestamp: record.timestamp || null, text, kind };
+}
+function contextAroundBlocker(records, blockerIndex, alternativeIndex, contextTurns, blockerText) {
+  if (blockerIndex === null) return [];
+  const conversationIndexes = records.flatMap((record, index) => !record?.isMeta && (record?.type === "user" || record?.type === "assistant") && visibleText(record) ? [index] : []);
+  const selectedIndexes = [
+    ...conversationIndexes.filter((index) => index < blockerIndex).slice(-contextTurns),
+    blockerIndex,
+    ...conversationIndexes.filter((index) => index > blockerIndex).slice(0, contextTurns),
+  ];
+  return selectedIndexes.flatMap((recordIndex) => {
+    if (recordIndex === blockerIndex) return [{ role: "tool", timestamp: records[recordIndex]?.timestamp || null, text: blockerText, kind: "blocker" }];
+    const message = transcriptMessage(records[recordIndex], recordIndex === alternativeIndex ? "workaround" : "context");
+    return message ? [message] : [];
+  });
+}
+function safeFallbackMessages(occurrence) {
+  return (occurrence?.evidence || []).flatMap((event) => {
+    if (!["user", "assistant", "tool"].includes(event?.role)) return [];
+    const text = locallyRedacted(event?.text);
+    return text ? [{ role: event.role, timestamp: event.timestamp || null, text, kind: event.kind === "tool_result" ? "blocker" : "context" }] : [];
+  });
+}
+export function makeWorkaroundEvidencePreview(report, sessionRecords, metadataById, { contextTurns = DEFAULT_CONTEXT_TURNS } = {}) {
+  const boundedContext = Number.isInteger(contextTurns) ? Math.min(4, Math.max(1, contextTurns)) : DEFAULT_CONTEXT_TURNS;
+  const recordsById = new Map(sessionRecords.map((session) => [session.sessionId, session.records]));
+  const occurrences = (report?.workaroundReview?.occurrences || []).slice(0, MAX_OCCURRENCES).flatMap((occurrence, index) => {
+    const sessionId = occurrence?.location?.sessionId;
+    const records = recordsById.get(sessionId);
+    if (!records) return [];
+    const metadata = metadataById.get(sessionId);
+    const donationSession = makeDonationPreview([{ sessionId, records }], metadataById).sessions[0];
+    const blockerIndex = occurrenceRecordIndex(occurrence, records, "blockerRecordIndex", "tool_result");
+    const alternativeIndex = occurrenceRecordIndex(occurrence, records, "alternativeRecordIndex", ["assistant_text", "tool_use"]);
+    const blockerRecord = blockerIndex === null ? null : records[blockerIndex];
+    const alternativeRecord = alternativeIndex === null ? null : records[alternativeIndex];
+    const blockerText = locallyRedacted(toolResultText(blockerRecord) || matchingEvidenceText(occurrence, "tool_result") || occurrence.blocker || "The original method was blocked.");
+    const workaroundText = locallyRedacted(visibleText(alternativeRecord) || occurrence.alternativeMethod || toolUseText(alternativeRecord) || matchingEvidenceText(occurrence, "assistant_text") || "The agent tried another method.");
+    const context = contextAroundBlocker(records, blockerIndex, alternativeIndex, boundedContext, blockerText);
+    return [{
+      index: index + 1,
+      session: {
+        label: metadata?.label || `Session ${index + 1}`,
+        agentName: metadata?.agentName || "AI agent",
+        startedAt: metadata?.startedAt || records.find((record) => record?.timestamp)?.timestamp || null,
+        openingMessage: donationSession?.summary || "Opening message unavailable",
+      },
+      workaroundAction: { text: workaroundText, timestamp: alternativeRecord?.timestamp || null },
+      blocker: { text: blockerText, timestamp: blockerRecord?.timestamp || null },
+      context: context.length ? context : safeFallbackMessages(occurrence),
+      contextTurns: boundedContext,
+    }];
+  });
+  return {
+    format: "behavior-wrapped-workaround-evidence-v2",
+    localPrivate: true,
+    standardRedactionsApplied: true,
+    reportId: report?.id,
+    occurrences,
+  };
+}