@whisperr/wizard 0.1.3 → 0.1.5

package/dist/index.js

@@ -522,10 +522,11 @@ function sleep(ms) {
 }
 
 // src/core/manifest.ts
-async function fetchManifest(config, session, targetId) {
+async function fetchManifest(config, session, targetId, repoFingerprint2) {
   if (config.offline) return mockManifest(session.appId, config);
   const url = new URL(`${config.apiBaseUrl}/wizard/manifest`);
   if (targetId) url.searchParams.set("target", targetId);
+  if (repoFingerprint2) url.searchParams.set("repo", repoFingerprint2);
   const res = await fetch(url, {
     headers: { authorization: `Bearer ${session.token}` }
   });
@@ -597,41 +598,53 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 // src/core/playbooks/shared-prompt.ts
 var BASE_WIZARD_PROMPT = `
 You are the Whisperr Wizard \u2014 an expert integration agent running INSIDE a
-customer's code repository. Your job: wire up the Whisperr SDK so the product
-sends the right events to Whisperr, then stop. Whisperr is a churn-prevention
-engine that needs identify() (who the user is) and track() (what they do).
+customer's code repository.
 
-You are billed per step and the user is watching the clock. Work FAST and
-DECISIVELY. Most failures come from over-exploring \u2014 do not do that.
+MISSION:
+Whisperr predicts churn and fires retention interventions from product events.
+Two things make that work: (1) identify() tying events to a real user, and
+(2) track() events fired at the right moment WITH the properties that give them
+meaning. A well-placed event carrying its real properties is gold; a bare or
+mis-placed event is noise that corrupts the customer's churn data. Your mission:
+wire up everything in the plan that genuinely exists in this app, and for each
+event you place, capture the properties that are actually available right there
+in the code. You will NOT find everything \u2014 some events live server-side or
+aren't in this codebase at all. That is expected and fine. Get what is here, get
+it right, report the rest. Know exactly what you're doing; never hunt blindly.
+
+You are billed per step and the user is watching. Work FAST and DECISIVELY.
 
 EFFICIENCY \u2014 non-negotiable:
 - Use Grep and Glob to find code. Do NOT read whole files; read the smallest
   slice you need.
 - NEVER re-read a file you just edited. Trust your edit.
-- Do not run the app, build, or heavy test suites. At most one quick static
-  check, and only if the SDK guide tells you to.
+- Do not run the app, build, or the analyzer/test suites. The human reviews the
+  diff.
 - Make several related edits in a row before pausing to think.
 
 DECISIVENESS:
 - When you find the right spot, edit it and move on immediately.
-- If you cannot find a clear place for something within ~2 searches, STOP
-  looking for it. Either drop a single-line \`// TODO(whisperr): track(...)\`
-  if an obvious spot exists, or just note it as a follow-up. Do not keep hunting.
+- If you can't find a clear place for something within ~2 searches, STOP looking.
+  Leave a one-line \`// TODO(whisperr): ...\` only if an obvious spot exists,
+  otherwise just note it as a follow-up. Do not keep hunting.
 
-SCOPE REALISM:
-- Not every event exists in THIS app. Many are server-side (billing webhooks,
-  delivery callbacks) or simply absent. That is expected. Instrument what
-  clearly exists on the client; list the rest as follow-ups. Do not treat a
-  missing call site as a problem to solve.
+PROPERTY CAPTURE (this is the craft):
+- For each event you place, look at what's in scope AT THAT CALL SITE \u2014 function
+  arguments, the object/model/state you're inside, nearby local variables \u2014 and
+  populate every listed property you can source from those values.
+- Omit a property only if it genuinely isn't available there. Do NOT fetch,
+  compute, or invent data to fill a property, and do NOT wander off to find it.
+- If a property marked (required) can't be sourced at your chosen site, that's a
+  strong hint you've picked the wrong site \u2014 reconsider; if it's still the best
+  spot, add the track() call and note the missing property.
 
 CORRECTNESS:
 - Match the app's existing conventions (imports, state management, file layout).
 - Use the EXACT snake_case event names given. Never invent or rename events.
-- A wrongly-placed business event corrupts churn data \u2014 worse than a missing one.
-  Only place an event where you are confident the user action truly happens.
+- Only place an event where you're confident the user action truly happens.
 
-End every task with a short summary: what you changed, and any follow-ups the
-human should handle (events you intentionally skipped + why).
+End every task with a short summary: what you changed, which events you wired
+(and the properties you attached), and the follow-ups you intentionally left.
 `.trim();
 function renderIdentifyBrief(m) {
   const lines = [];
@@ -640,14 +653,14 @@ function renderIdentifyBrief(m) {
   lines.push(`Ingestion API key:  ${m.ingestionApiKey}`);
   if (m.businessContext) {
     lines.push("");
-    lines.push(`Context: ${m.businessContext}`);
+    lines.push(`Business context: ${m.businessContext}`);
   }
   lines.push("");
   lines.push("identify():");
   if (m.identify.traits?.length) {
-    lines.push("  Send these traits when available:");
+    lines.push("  Send these traits when readily available:");
     for (const t of m.identify.traits) {
-      lines.push(`    - ${t.name}${t.description ? ` (${t.description})` : ""}`);
+      lines.push(`    - ${t.name}${t.description ? ` \u2014 ${t.description}` : ""}`);
     }
   }
   if (m.identify.channels?.length) {
@@ -661,22 +674,46 @@ function renderEventsBrief(m) {
     (a, b) => (b.importance ?? 0) - (a.importance ?? 0)
   );
   const lines = [];
+  if (m.businessContext) {
+    lines.push(`Business context: ${m.businessContext}`);
+    lines.push("");
+  }
   lines.push(
-    `${events.length} candidate events (highest-impact first). Emit each with its EXACT name via track('<event_type>', { ...properties }).`
+    `${events.length} candidate events (highest-impact first). For each: fire track('<event_type>', { ...properties }) at the real moment it happens, and attach every listed property you can source from values in scope there. Skip an event entirely if it has no clear client-side trigger.`
   );
-  lines.push("");
+  if (events.some((e) => e.coverage?.length)) {
+    lines.push("");
+    lines.push(
+      "Some events are already instrumented elsewhere (noted inline). Skip any marked [already wired here]; for [wired on <surface>], only add it if this codebase ALSO genuinely triggers it."
+    );
+  }
   for (const e of events) {
-    const drivers = e.interventions?.length ? `  \u2014 drives: ${e.interventions.map((i) => i.label ?? i.code).join(", ")}` : "";
-    lines.push(`- ${e.eventType}${e.label ? `  (${e.label})` : ""}${drivers}`);
-    if (e.description) lines.push(`    ${e.description}`);
+    lines.push("");
+    const why = e.interventions?.length ? `  \xB7  drives: ${e.interventions.map((i) => i.label ?? i.code).join(", ")}` : "";
+    const cov = coverageNote(e.coverage);
+    lines.push(`\u25A0 ${e.eventType}${e.label ? `  (${e.label})` : ""}${why}${cov}`);
+    if (e.description) lines.push(`  ${e.description}`);
     if (e.properties?.length) {
-      lines.push(
-        `    properties: ${e.properties.map((p2) => p2.name).join(", ")}`
-      );
+      lines.push("  properties to capture if available:");
+      for (const p2 of e.properties) {
+        const req = p2.required ? " (required)" : "";
+        const desc = p2.description ? ` \u2014 ${p2.description}` : "";
+        lines.push(`    \xB7 ${p2.name}${req}${desc}`);
+      }
     }
   }
   return lines.join("\n");
 }
+function coverageNote(coverage) {
+  if (!coverage?.length) return "";
+  const here = coverage.find((c) => c.sameSurface && c.status === "wired");
+  if (here) return "  [already wired here]";
+  const elsewhere = coverage.filter((c) => c.status === "wired");
+  if (elsewhere.length) {
+    return `  [wired on ${elsewhere.map((c) => c.target).join(", ")}]`;
+  }
+  return "";
+}
 
 // src/core/agent.ts
 async function runIntegrationAgent(opts) {
@@ -724,17 +761,15 @@ ${core.summary}`);
   if (manifest.events.length > 0) {
     progress?.onPhase?.("Instrumenting your events");
     const eventsPrompt = [
-      `The Whisperr ${playbook.target.displayName} SDK is already installed,`,
-      "initialized, and identify() is wired. Now add track() calls for product",
-      "events.",
+      `The Whisperr ${playbook.target.displayName} SDK is already installed and`,
+      "initialized, and identify() is wired. Now instrument the product events",
+      "below with track().",
       "",
-      "How to work:",
-      "- Go in the order listed (highest-impact first).",
-      "- For each event, Grep for where that user action happens. If there is a",
-      "  clear client-side call site, add the track() call with the exact name.",
-      "  If not, SKIP it (most server-side events won't exist here) \u2014 do not hunt.",
-      "- You have a limited number of steps; spend them placing events, not",
-      "  exploring. Stop once the events that clearly exist in this app are wired.",
+      "Work in importance order. Place each event at its real call site and",
+      "attach the properties you can source from what's in scope there (see the",
+      "property-capture rule in your instructions). Skip fast when an event has",
+      "no clear client-side trigger \u2014 spend steps placing events, not exploring.",
+      "Stop once the events that clearly exist in this app are wired.",
       "",
       "----- EVENTS -----",
       renderEventsBrief(manifest),
@@ -850,6 +885,9 @@ function short(s, max = 60) {
 
 // src/core/git.ts
 import { spawn } from "child_process";
+import { createHash } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import { basename, join as join2 } from "path";
 async function takeCheckpoint(repoPath) {
   const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
   if (!isRepo) return { isRepo: false };
@@ -880,6 +918,38 @@ function revertHint(checkpoint) {
   if (!checkpoint.isRepo || !checkpoint.baseRef) return void 0;
   return `git restore . && git clean -fd   (back to ${checkpoint.baseRef.slice(0, 7)})`;
 }
+async function repoFingerprint(repoPath) {
+  const remote = await run(repoPath, ["remote", "get-url", "origin"]);
+  const seed = remote.ok && remote.stdout.trim() ? normalizeRemote(remote.stdout.trim()) : `dir:${basename(repoPath)}`;
+  return createHash("sha256").update(seed).digest("hex").slice(0, 16);
+}
+function normalizeRemote(url) {
+  return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
+}
+async function scanWiredEvents(repoPath, files, eventTypes) {
+  const wired = /* @__PURE__ */ new Map();
+  const patterns = eventTypes.map((e) => ({
+    eventType: e,
+    re: new RegExp(`track\\s*\\(\\s*['"\`]${escapeRegExp(e)}['"\`]`)
+  }));
+  for (const file of files) {
+    let content = "";
+    try {
+      content = await readFile2(join2(repoPath, file), "utf8");
+    } catch {
+      continue;
+    }
+    for (const { eventType, re } of patterns) {
+      if (!wired.has(eventType) && re.test(content)) {
+        wired.set(eventType, file);
+      }
+    }
+  }
+  return wired;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function run(cwd, args) {
   return new Promise((resolve2) => {
     const child = spawn("git", args, { cwd });
@@ -917,6 +987,22 @@ async function pollFirstEvent(config, session, opts = {}) {
   return { received: false };
 }
 
+// src/core/report.ts
+async function postRunReport(config, session, report) {
+  if (config.offline) return;
+  try {
+    await fetch(`${config.apiBaseUrl}/wizard/report`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${session.token}`
+      },
+      body: JSON.stringify(report)
+    });
+  } catch {
+  }
+}
+
 // src/ui/banner.ts
 function banner() {
   const wave = theme.signal("\u223F\u223F\u223F");
@@ -980,9 +1066,10 @@ Flutter is live today; ${theme.bright(
     p.cancel(theme.alert(err.message));
     return 1;
   }
+  const fingerprint = await repoFingerprint(repoPath);
   const manifest = await withSpinner(
     "Loading your onboarding context",
-    () => fetchManifest(config, session, chosen.playbook.target.id)
+    () => fetchManifest(config, session, chosen.playbook.target.id, fingerprint)
   );
   p.note(
     summarizeManifest(manifest),
@@ -1038,9 +1125,28 @@ Flutter is live today; ${theme.bright(
   if (outcome.summary.trim()) {
     p.log.message(outcome.summary.trim());
   }
+  const wiredMap = await scanWiredEvents(
+    repoPath,
+    files,
+    manifest.events.map((e) => e.eventType)
+  );
+  const reportEvents = manifest.events.map((e) => ({
+    event_type: e.eventType,
+    status: wiredMap.has(e.eventType) ? "wired" : "skipped",
+    file: wiredMap.get(e.eventType)
+  }));
+  await postRunReport(config, session, {
+    target: chosen.playbook.target.id,
+    repo_fingerprint: fingerprint,
+    identify_wired: outcome.coreOk,
+    cost_usd: outcome.costUsd,
+    duration_ms: outcome.durationMs,
+    summary: outcome.summary.slice(0, 4e3),
+    events: reportEvents
+  });
   p.log.info(
     theme.muted(
-      `${files.length} file${files.length === 1 ? "" : "s"} changed \xB7 ~$${outcome.costUsd.toFixed(2)} \xB7 ${Math.round(outcome.durationMs / 1e3)}s`
+      `${wiredMap.size}/${manifest.events.length} events wired \xB7 ${files.length} file${files.length === 1 ? "" : "s"} changed \xB7 ~$${outcome.costUsd.toFixed(2)} \xB7 ${Math.round(outcome.durationMs / 1e3)}s`
     )
   );
   if (!config.offline) {
@@ -1209,7 +1315,7 @@ async function main() {
     return;
   }
   if ("version" in parsed) {
-    console.log("0.1.3");
+    console.log("0.1.5");
     return;
   }
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whisperr/wizard",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Whisperr Wizard — one command to integrate the Whisperr SDK into your app. Authenticates with your onboarded account and uses an AI coding agent to wire up identify() and your business events automatically.",
   "license": "UNLICENSED",
   "private": false,