@whisperr/wizard 0.1.0

package/dist/index.js

@@ -0,0 +1,1149 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { resolve } from "path";
+import * as p from "@clack/prompts";
+
+// src/core/config.ts
+var DEFAULT_API_BASE = "https://api.whisperr.net";
+var DEFAULT_MODEL = "claude-opus-4-8";
+function resolveConfig(flags = {}) {
+  const apiBaseUrl = (flags.apiBaseUrl ?? process.env.WHISPERR_WIZARD_API_BASE ?? DEFAULT_API_BASE).replace(/\/+$/, "");
+  const llmBaseUrl = (process.env.WHISPERR_WIZARD_LLM_BASE ?? `${apiBaseUrl}/wizard/llm`).replace(/\/+$/, "");
+  const directAnthropicKey = process.env.WHISPERR_WIZARD_DIRECT_ANTHROPIC_KEY ?? process.env.ANTHROPIC_API_KEY;
+  const offline = flags.offline ?? ["1", "true", "yes"].includes(
+    (process.env.WHISPERR_WIZARD_OFFLINE ?? "").toLowerCase()
+  );
+  return {
+    apiBaseUrl,
+    llmBaseUrl,
+    model: flags.model ?? process.env.WHISPERR_WIZARD_MODEL ?? DEFAULT_MODEL,
+    maxTurns: Number(process.env.WHISPERR_WIZARD_MAX_TURNS ?? 40),
+    directAnthropicKey,
+    offline
+  };
+}
+
+// src/core/detect.ts
+import { readFile, stat, readdir } from "fs/promises";
+import { join } from "path";
+
+// src/core/playbooks/flutter.ts
+var target = {
+  id: "flutter",
+  displayName: "Flutter",
+  language: "dart",
+  availability: "available"
+};
+async function detect(ctx) {
+  const evidence = [];
+  let confidence = 0;
+  if (await ctx.exists("pubspec.yaml")) {
+    evidence.push("pubspec.yaml");
+    confidence += 0.6;
+    const pubspec = await ctx.read("pubspec.yaml");
+    if (/\bflutter\s*:/.test(pubspec) || /sdk:\s*flutter/.test(pubspec)) {
+      evidence.push("flutter sdk in pubspec");
+      confidence += 0.3;
+    }
+  }
+  if (await ctx.exists("lib/main.dart")) {
+    evidence.push("lib/main.dart");
+    confidence += 0.2;
+  }
+  if (confidence === 0) return null;
+  return { target, confidence: Math.min(confidence, 1), evidence };
+}
+var systemPrompt = `
+## SDK: Whisperr for Flutter (Dart) \u2014 package \`whisperr\`
+
+This SDK is published on pub.dev. Integrate it as follows.
+
+1) Dependency. Add to pubspec.yaml under dependencies:
+     whisperr: ^0.2.0
+   Then the SDK expects \`flutter pub get\` to be run (run it via bash).
+
+2) Initialize once, early, before runApp(), in lib/main.dart:
+     import 'package:whisperr/whisperr.dart';
+     await Whisperr.initialize(
+       apiKey: '<INGESTION_API_KEY from manifest>',
+       baseUrl: '<INGESTION_BASE_URL from manifest>', // omit if it equals the SDK default
+     );
+   If main() is not async, make it async and \`await\` the initialize call, or use
+   WidgetsFlutterBinding.ensureInitialized() first.
+
+3) identify(). Call right after the end-user is known \u2014 after successful
+   login/signup and on session restore at startup:
+     await Whisperr.instance.identify(
+       '<stable external user id>',
+       traits: { /* manifest traits, e.g. 'plan': user.plan */ },
+       email: user.email,        // optional shortcut -> opted-in email channel
+       phone: user.phone,        // optional shortcut -> SMS channel
+       pushToken: fcmToken,      // optional shortcut -> push channel
+     );
+   Use the app's real stable id (auth uid / customer id), never a device id.
+   On logout call \`await Whisperr.instance.reset();\`.
+
+4) track(). For each manifest event, find where that user action actually
+   happens and add:
+     await Whisperr.instance.track('event_type_from_manifest', properties: { ... });
+   event_type must be snake_case and copied verbatim from the manifest.
+
+Notes / gotchas:
+- The SDK queues + batches automatically; you do NOT need to await every track
+  for delivery \u2014 awaiting just enqueues. Fire-and-forget is fine in UI handlers.
+- Do not call track() inside build() methods or render loops \u2014 only in event
+  handlers / business logic (onPressed, on success of an API call, in a bloc/
+  cubit/provider action, etc.).
+- Hardcoding the API key in Dart is acceptable for a client SDK (it is an
+  ingestion key, scoped + rate-limited), but prefer --dart-define / a config
+  file if the project already uses one.
+- Verify with \`flutter analyze\`.
+`.trim();
+var flutterPlaybook = {
+  target,
+  detect,
+  packageRef: "whisperr (pub.dev)",
+  systemPrompt,
+  verifyCommand: "flutter analyze"
+};
+
+// src/core/playbooks/nextjs.ts
+var target2 = {
+  id: "nextjs",
+  displayName: "Next.js",
+  language: "typescript",
+  availability: "planned"
+};
+async function detect2(ctx) {
+  if (!await ctx.exists("package.json")) return null;
+  const pkgJson = await ctx.read("package.json");
+  let isNext = false;
+  try {
+    const pkg = JSON.parse(pkgJson);
+    const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    isNext = "next" in all;
+  } catch {
+    isNext = false;
+  }
+  if (!isNext && !await ctx.exists("next.config.js") && !await ctx.exists("next.config.mjs"))
+    return null;
+  const evidence = ["next dependency"];
+  let confidence = 0.85;
+  if (await ctx.exists("app")) {
+    evidence.push("app/ router");
+    confidence += 0.1;
+  } else if (await ctx.exists("pages")) {
+    evidence.push("pages/ router");
+    confidence += 0.05;
+  }
+  return { target: target2, confidence: Math.min(confidence, 1), evidence };
+}
+var systemPrompt2 = `
+## SDK: Whisperr for Web in Next.js \u2014 package \`@whisperr/web\`
+
+Same SDK as plain web, with Next-specific wiring.
+
+1) Install \`@whisperr/web\`. Put the key in NEXT_PUBLIC_WHISPERR_KEY in
+   .env.local (and add it to .env.example).
+
+2) Whisperr runs client-side. Create a client provider:
+   - App Router: a 'use client' component (e.g. app/whisperr-provider.tsx) that
+     calls Whisperr.init(...) in a useEffect and renders children; mount it in
+     app/layout.tsx.
+   - Pages Router: init in pages/_app.tsx inside a useEffect.
+
+3) identify() after auth resolves on the client (e.g. in your auth/session
+   hook). reset() on sign-out.
+
+4) track() in client components / event handlers / mutation callbacks. Do NOT
+   call track from server components, route handlers, or getServerSideProps \u2014
+   this SDK is a browser client. Copy event_type verbatim from the manifest.
+
+Notes:
+- Guard against double-init under React Strict Mode (init is idempotent, but
+  wire it so it only runs once).
+`.trim();
+var nextjsPlaybook = {
+  target: target2,
+  detect: detect2,
+  packageRef: "@whisperr/web (npm)",
+  systemPrompt: systemPrompt2
+};
+
+// src/core/playbooks/web.ts
+var target3 = {
+  id: "web-js",
+  displayName: "Web (JavaScript / TypeScript)",
+  language: "typescript",
+  // Flip to "available" once @whisperr/web ships (Phase 2).
+  availability: "planned"
+};
+function dependsOn(pkgJson, names) {
+  try {
+    const pkg = JSON.parse(pkgJson);
+    const all = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    return names.some((n) => n in all);
+  } catch {
+    return false;
+  }
+}
+async function detect3(ctx) {
+  if (!await ctx.exists("package.json")) return null;
+  const pkgJson = await ctx.read("package.json");
+  const evidence = ["package.json"];
+  let confidence = 0.4;
+  if (dependsOn(pkgJson, ["next"])) return null;
+  if (dependsOn(pkgJson, ["react-native", "expo"])) return null;
+  if (dependsOn(pkgJson, ["react", "vue", "svelte", "@angular/core"])) {
+    evidence.push("frontend framework dependency");
+    confidence += 0.4;
+  }
+  if (await ctx.exists("index.html")) {
+    evidence.push("index.html");
+    confidence += 0.1;
+  }
+  return { target: target3, confidence: Math.min(confidence, 0.95), evidence };
+}
+var systemPrompt3 = `
+## SDK: Whisperr for Web (TypeScript/JavaScript) \u2014 package \`@whisperr/web\`
+
+1) Dependency. Install with the repo's package manager (detect pnpm/yarn/npm
+   from the lockfile): \`<pm> add @whisperr/web\`.
+
+2) Initialize once at app entry (e.g. src/main.tsx, src/index.ts, or the root
+   layout). Create a singleton client:
+     import { Whisperr } from '@whisperr/web';
+     export const whisperr = Whisperr.init({
+       apiKey: import.meta.env.VITE_WHISPERR_KEY, // or process.env.NEXT_PUBLIC_... etc
+       baseUrl: '<INGESTION_BASE_URL from manifest>',
+     });
+   Put the key in the project's env mechanism (Vite VITE_*, CRA REACT_APP_*,
+   plain .env) and write the example var into .env / .env.example.
+
+3) identify(). After auth resolves (login success, and on app load if a session
+   is restored):
+     whisperr.identify(user.id, {
+       traits: { /* manifest traits */ },
+       email: user.email, phone: user.phone,
+     });
+   Call whisperr.reset() on logout.
+
+4) track(). For each manifest event, instrument the real handler:
+     whisperr.track('event_type_from_manifest', { /* properties */ });
+   In React, this belongs in event handlers / effects / mutation callbacks, not
+   in render. Copy event_type verbatim (snake_case) from the manifest.
+
+Notes:
+- The SDK batches via /v1/events/batch and flushes on a timer + on
+  visibilitychange/unload (sendBeacon). Fire-and-forget is fine.
+- Only the NEXT_PUBLIC_/VITE_-style public env vars are exposed to the browser;
+  the ingestion key is a public, rate-limited key so that is expected.
+- If the project uses an analytics wrapper/provider pattern, follow it rather
+  than scattering raw whisperr.track calls.
+`.trim();
+var webPlaybook = {
+  target: target3,
+  detect: detect3,
+  packageRef: "@whisperr/web (npm)",
+  systemPrompt: systemPrompt3,
+  verifyCommand: void 0
+};
+
+// src/core/playbooks/react-native.ts
+var target4 = {
+  id: "react-native",
+  displayName: "React Native",
+  language: "typescript",
+  availability: "planned"
+};
+async function detect4(ctx) {
+  if (!await ctx.exists("package.json")) return null;
+  const pkgJson = await ctx.read("package.json");
+  let match = false;
+  try {
+    const pkg = JSON.parse(pkgJson);
+    const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    match = "react-native" in all || "expo" in all;
+  } catch {
+    match = false;
+  }
+  if (!match) return null;
+  const evidence = ["react-native / expo dependency"];
+  let confidence = 0.85;
+  if (await ctx.exists("app.json")) {
+    evidence.push("app.json");
+    confidence += 0.1;
+  }
+  return { target: target4, confidence: Math.min(confidence, 1), evidence };
+}
+var systemPrompt4 = `
+## SDK: Whisperr for React Native \u2014 package \`@whisperr/react-native\`
+
+1) Install \`@whisperr/react-native\` with the repo's package manager. If it has
+   native modules, run pod install for iOS (mention it; don't attempt to build).
+
+2) Initialize once at the app root (App.tsx / app/_layout.tsx for Expo Router):
+     import { Whisperr } from '@whisperr/react-native';
+     Whisperr.init({ apiKey: <key from manifest/env>, baseUrl: <manifest baseUrl> });
+
+3) identify() after auth resolves / on session restore; reset() on logout.
+   For channels: email/phone where known, and the push token (expo-notifications
+   or @react-native-firebase/messaging) if the app has push set up.
+
+4) track() in event handlers / business logic, never in render. event_type
+   verbatim from the manifest.
+
+Notes:
+- Persisted offline queue is built in (AsyncStorage); fire-and-forget is fine.
+- Prefer an env/config mechanism (react-native-config, app.config) for the key
+  if one exists; otherwise a constants file is acceptable.
+`.trim();
+var reactNativePlaybook = {
+  target: target4,
+  detect: detect4,
+  packageRef: "@whisperr/react-native (npm)",
+  systemPrompt: systemPrompt4
+};
+
+// src/core/playbooks/swift.ts
+var target5 = {
+  id: "swift",
+  displayName: "Swift (iOS)",
+  language: "swift",
+  availability: "planned"
+};
+async function detect5(ctx) {
+  const evidence = [];
+  let confidence = 0;
+  if (await ctx.exists("Package.swift")) {
+    evidence.push("Package.swift");
+    confidence += 0.6;
+  }
+  const root = await ctx.list(".");
+  if (root.some((f) => f.endsWith(".xcodeproj"))) {
+    evidence.push("xcodeproj");
+    confidence += 0.5;
+  }
+  if (root.some((f) => f.endsWith(".xcworkspace"))) {
+    evidence.push("xcworkspace");
+    confidence += 0.3;
+  }
+  if (await ctx.exists("Podfile")) {
+    evidence.push("Podfile");
+    confidence += 0.2;
+  }
+  if (confidence === 0) return null;
+  return { target: target5, confidence: Math.min(confidence, 1), evidence };
+}
+var systemPrompt5 = `
+## SDK: Whisperr for Swift (iOS) \u2014 Swift Package \`Whisperr\`
+
+1) Add the Swift Package dependency (github.com/WhisperrAI/whisperr-swift). If the
+   project uses Package.swift, add it there; if it's an .xcodeproj/.xcworkspace,
+   you cannot edit the project graph reliably from the shell \u2014 instead leave a
+   clearly commented setup note and the exact import + init code, and report it
+   as a manual follow-up.
+
+2) Initialize once at launch in the App struct (SwiftUI) or
+   application(_:didFinishLaunchingWithOptions:) (UIKit):
+     import Whisperr
+     Whisperr.initialize(apiKey: "<key>", baseUrl: "<manifest baseUrl>")
+
+3) identify() after the user is known / on session restore:
+     Whisperr.shared.identify("<external user id>", traits: [...], email: ..., phone: ...)
+   reset() on logout. Push channel = APNs device token if the app registers for
+   remote notifications.
+
+4) track() in action handlers / view-model methods, not in view body:
+     Whisperr.shared.track("event_type_from_manifest", properties: [ ... ])
+   event_type verbatim (snake_case) from the manifest.
+
+Notes:
+- Prefer reading the key from Info.plist / an xcconfig if the project uses one.
+- Do not attempt to run xcodebuild; verification is the human's step here.
+`.trim();
+var swiftPlaybook = {
+  target: target5,
+  detect: detect5,
+  packageRef: "Whisperr (Swift Package)",
+  systemPrompt: systemPrompt5
+};
+
+// src/core/playbooks/index.ts
+var ALL_PLAYBOOKS = [
+  flutterPlaybook,
+  nextjsPlaybook,
+  reactNativePlaybook,
+  webPlaybook,
+  swiftPlaybook
+];
+function playbookByTargetId(id) {
+  return ALL_PLAYBOOKS.find((p2) => p2.target.id === id);
+}
+
+// src/core/detect.ts
+function makeDetectContext(repoPath) {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    repoPath,
+    async read(relPath) {
+      if (cache.has(relPath)) return cache.get(relPath);
+      let content = "";
+      try {
+        content = await readFile(join(repoPath, relPath), "utf8");
+      } catch {
+        content = "";
+      }
+      cache.set(relPath, content);
+      return content;
+    },
+    async exists(relPath) {
+      try {
+        await stat(join(repoPath, relPath));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async list(relDir) {
+      try {
+        const entries = await readdir(join(repoPath, relDir), {
+          withFileTypes: true
+        });
+        return entries.map((e) => e.name);
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+async function detectStack(repoPath) {
+  const ctx = makeDetectContext(repoPath);
+  const results = await Promise.all(
+    ALL_PLAYBOOKS.map((p2) => p2.detect(ctx).catch(() => null))
+  );
+  return results.filter((d) => d !== null).sort((a, b) => b.confidence - a.confidence);
+}
+
+// src/core/auth.ts
+import open from "open";
+
+// src/ui/theme.ts
+import pc from "picocolors";
+var truecolor = process.env.COLORTERM === "truecolor" || process.env.COLORTERM === "24bit";
+function rgb(r, g, b, text) {
+  if (!truecolor || !pc.isColorSupported) return text;
+  return `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
+}
+var theme = {
+  /** Signal blue — the one accent. */
+  signal: (s) => rgb(91, 141, 239, s),
+  /** Muted hairline grey for secondary text. */
+  muted: (s) => rgb(140, 140, 150, s),
+  /** Near-white primary text. */
+  bright: (s) => pc.white(pc.bold(s)),
+  dim: (s) => pc.dim(s),
+  success: (s) => rgb(110, 207, 159, s),
+  warn: (s) => rgb(240, 191, 105, s),
+  alert: (s) => rgb(248, 113, 113, s),
+  bold: (s) => pc.bold(s)
+};
+var wordmark = (() => {
+  const mark = theme.signal("\u2301");
+  return `${mark} ${theme.bright("whisperr")} ${theme.muted("wizard")}`;
+})();
+var divider = theme.dim("\u2500".repeat(48));
+
+// src/core/auth.ts
+async function authenticate(config) {
+  if (config.offline) return offlineSession();
+  const authorize = await fetchJson(
+    `${config.apiBaseUrl}/wizard/device/authorize`,
+    { method: "POST", body: JSON.stringify({ client: "whisperr-wizard" }) }
+  );
+  const url = authorize.verification_uri_complete ?? authorize.verification_uri;
+  const intervalMs = (authorize.interval ?? 5) * 1e3;
+  const deadline = Date.now() + (authorize.expires_in ?? 600) * 1e3;
+  try {
+    await open(url);
+  } catch {
+  }
+  let wait = intervalMs;
+  while (Date.now() < deadline) {
+    await sleep(wait);
+    const res = await fetch(
+      `${config.apiBaseUrl}/wizard/device/token`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ device_code: authorize.device_code })
+      }
+    );
+    if (res.ok) {
+      const tok = await res.json();
+      return { token: tok.token, appId: tok.app_id, expiresAt: tok.expires_at };
+    }
+    if (res.status === 429) {
+      wait += 2e3;
+      continue;
+    }
+    if (res.status === 428) continue;
+    throw new Error(
+      `Authorization failed (${res.status}). Run the wizard again to retry.`
+    );
+  }
+  throw new Error("Authorization timed out. Run the wizard again.");
+}
+function offlineSession() {
+  return {
+    token: "offline-dev-token",
+    appId: "app_offline_dev",
+    expiresAt: Math.floor(Date.now() / 1e3) + 3600
+  };
+}
+async function fetchJson(url, init) {
+  const res = await fetch(url, {
+    ...init,
+    headers: { "content-type": "application/json", ...init.headers ?? {} }
+  });
+  if (!res.ok) {
+    throw new Error(
+      `${theme.alert("Request failed")}: ${init.method ?? "GET"} ${url} -> ${res.status}`
+    );
+  }
+  return await res.json();
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/core/manifest.ts
+async function fetchManifest(config, session, targetId) {
+  if (config.offline) return mockManifest(session.appId, config);
+  const url = new URL(`${config.apiBaseUrl}/wizard/manifest`);
+  if (targetId) url.searchParams.set("target", targetId);
+  const res = await fetch(url, {
+    headers: { authorization: `Bearer ${session.token}` }
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Could not load your integration manifest (${res.status}). Make sure onboarding is complete for this app.`
+    );
+  }
+  return await res.json();
+}
+function mockManifest(appId, config) {
+  return {
+    appId,
+    appName: "Acme (dev)",
+    ingestionApiKey: "wrk_offline_demo_key_do_not_use",
+    ingestionBaseUrl: config.apiBaseUrl,
+    businessContext: "B2C subscription app. Free trial converts to a paid monthly plan. Churn risk concentrates around trial end and the first failed payment.",
+    identify: {
+      traits: [
+        { name: "plan", description: "free | trial | pro" },
+        { name: "signup_date", description: "ISO date the user signed up" }
+      ],
+      channels: ["email", "push"],
+      notes: "Call identify on login and on session restore. Send email always; push token when notifications are enabled."
+    },
+    events: [
+      {
+        eventType: "trial_started",
+        label: "Trial started",
+        description: "User begins their free trial.",
+        importance: 0.7,
+        properties: [{ name: "plan", description: "trial tier chosen" }],
+        interventions: [{ code: "onboarding_nudge", label: "Onboarding nudge" }]
+      },
+      {
+        eventType: "feature_activated",
+        label: "Core feature activated",
+        description: "User completes the core 'aha' action for the first time. Strong retention signal; fire on first successful completion only.",
+        importance: 0.6,
+        interventions: [{ code: "activation_boost", label: "Activation boost" }]
+      },
+      {
+        eventType: "payment_failed",
+        label: "Payment failed",
+        description: "A subscription charge was declined. Fire from the billing webhook handler / failed-charge path.",
+        importance: 0.95,
+        properties: [
+          { name: "amount", description: "charge amount" },
+          { name: "reason", description: "decline reason if known" }
+        ],
+        interventions: [{ code: "dunning_recovery", label: "Dunning recovery", weight: 0.9 }]
+      },
+      {
+        eventType: "subscription_cancelled",
+        label: "Subscription cancelled",
+        description: "User cancels their paid plan. Fire at the moment of cancel.",
+        importance: 1,
+        properties: [{ name: "reason", description: "stated cancel reason" }],
+        interventions: [{ code: "win_back", label: "Win-back", weight: 1 }]
+      }
+    ],
+    supportedTargets: ["flutter", "web-js", "nextjs", "react-native", "swift"]
+  };
+}
+
+// src/core/agent.ts
+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. You are running
+INSIDE a customer's code repository. Your single job: integrate the Whisperr SDK
+so the product starts sending the right events to Whisperr, then stop.
+
+Whisperr is a churn-prevention engine. It needs two things from the app:
+  1. identify() \u2014 tell Whisperr who the end-user is (a stable external user id)
+     plus traits and contact channels, called right after the user is known
+     (login / session restore / signup).
+  2. track() \u2014 emit the specific business events listed in the integration
+     manifest, at the exact places in the code where those user actions happen.
+     These named events drive the customer's churn interventions, so placing
+     them at the correct call sites matters more than anything else you do.
+
+Operating rules:
+- Work autonomously. Make the edits directly; do not ask for confirmation.
+- Be surgical. Add the SDK dependency, initialize it once at app startup, wire
+  identify() where the user becomes known, and add track() calls for the
+  manifest events. Do not refactor unrelated code, restyle, or "improve" things.
+- Find the RIGHT call site for each named event by reading the code, not by
+  guessing. If you genuinely cannot find where an event occurs, add a clearly
+  commented TODO with the exact Whisperr call to make, and report it at the end
+  rather than firing the event from a wrong place.
+- Never invent event types. Use the exact snake_case event_type strings from the
+  manifest. Custom data goes under properties.
+- Keep the API key out of source where the SDK/platform supports env/secrets;
+  otherwise place it where the manifest guidance says and flag it.
+- Match the repository's existing conventions (imports, formatting, state
+  management, file layout).
+
+When done, output a concise summary:
+  - files changed
+  - where identify() was wired
+  - each manifest event -> the call site you instrumented (or TODO + reason)
+  - any follow-ups the human must do (env var, push token, etc.)
+`.trim();
+function renderManifestBrief(m) {
+  const lines = [];
+  lines.push(`# Whisperr integration manifest for app: ${m.appName ?? m.appId}`);
+  lines.push("");
+  lines.push(`Ingestion base URL: ${m.ingestionBaseUrl}`);
+  lines.push(`Ingestion API key:  ${m.ingestionApiKey}`);
+  if (m.businessContext) {
+    lines.push("");
+    lines.push("## Business context");
+    lines.push(m.businessContext);
+  }
+  lines.push("");
+  lines.push("## identify()");
+  if (m.identify.traits?.length) {
+    lines.push("Traits to send when available:");
+    for (const t of m.identify.traits) {
+      lines.push(`  - ${t.name}${t.description ? ` \u2014 ${t.description}` : ""}`);
+    }
+  }
+  if (m.identify.channels?.length) {
+    lines.push(`Channels in use: ${m.identify.channels.join(", ")}`);
+  }
+  if (m.identify.notes) lines.push(m.identify.notes);
+  lines.push("");
+  lines.push("## Events to instrument (use these exact event_type strings)");
+  const events = [...m.events].sort(
+    (a, b) => (b.importance ?? 0) - (a.importance ?? 0)
+  );
+  for (const e of events) {
+    lines.push("");
+    lines.push(`### ${e.eventType}${e.label ? `  (${e.label})` : ""}`);
+    if (e.description) lines.push(e.description);
+    if (e.properties?.length) {
+      lines.push("Properties:");
+      for (const p2 of e.properties) {
+        lines.push(
+          `  - ${p2.name}${p2.required ? " (required)" : ""}${p2.description ? ` \u2014 ${p2.description}` : ""}`
+        );
+      }
+    }
+    if (e.interventions?.length) {
+      const drv = e.interventions.map((i) => i.label ?? i.code).join(", ");
+      lines.push(`Drives: ${drv}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/core/agent.ts
+async function runIntegrationAgent(opts) {
+  const { repoPath, config, session, playbook, manifest, progress } = opts;
+  applyModelAuthEnv(config, session);
+  const systemPrompt6 = [BASE_WIZARD_PROMPT, playbook.systemPrompt].join("\n\n");
+  const verifyHint = playbook.verifyCommand ? `
+
+When finished, run \`${playbook.verifyCommand}\` and fix anything it flags.` : "";
+  const prompt = [
+    `Integrate the Whisperr ${playbook.target.displayName} SDK into this repository.`,
+    `Project root: ${repoPath}`,
+    "",
+    "Here is the integration manifest derived from this customer's Whisperr",
+    "onboarding. Wire identify() and instrument every event below at the correct",
+    "call site, following the SDK guide in your system prompt.",
+    "",
+    "----- MANIFEST -----",
+    renderManifestBrief(manifest),
+    "----- END MANIFEST -----",
+    verifyHint
+  ].join("\n");
+  const started = Date.now();
+  let summary = "";
+  let costUsd;
+  let ok = false;
+  const response = query({
+    prompt,
+    options: {
+      model: config.model,
+      cwd: repoPath,
+      systemPrompt: systemPrompt6,
+      // Full file-system agent toolset.
+      allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
+      // Fully autonomous edits (the user opted into auto-apply; the wizard takes
+      // a git checkpoint before this runs so revert is one command).
+      permissionMode: "bypassPermissions",
+      maxTurns: config.maxTurns,
+      // Don't pick up the user's own CLAUDE.md / settings — the wizard's prompt
+      // is the single source of truth.
+      settingSources: []
+    }
+  });
+  for await (const message of response) {
+    if (message.type === "assistant") {
+      for (const block of message.message?.content ?? []) {
+        if (isTextBlock(block) && block.text?.trim()) {
+          progress?.onActivity?.(firstLine(block.text));
+        } else if (isToolUseBlock(block)) {
+          progress?.onActivity?.(describeToolUse(block));
+        }
+      }
+    } else if (message.type === "result") {
+      ok = message.subtype === "success";
+      costUsd = message.total_cost_usd;
+      summary = message.result ?? extractLastText(message) ?? summary;
+    }
+  }
+  progress?.onResult?.(summary, costUsd);
+  return { summary, costUsd, ok, durationMs: Date.now() - started };
+}
+function applyModelAuthEnv(config, session) {
+  if (config.directAnthropicKey) {
+    process.env.ANTHROPIC_API_KEY = config.directAnthropicKey;
+    delete process.env.ANTHROPIC_AUTH_TOKEN;
+    return;
+  }
+  process.env.ANTHROPIC_BASE_URL = config.llmBaseUrl;
+  process.env.ANTHROPIC_AUTH_TOKEN = session.token;
+  delete process.env.ANTHROPIC_API_KEY;
+}
+function isTextBlock(b) {
+  return b.type === "text";
+}
+function isToolUseBlock(b) {
+  return b.type === "tool_use";
+}
+function describeToolUse(block) {
+  const file = block.input?.file_path ?? block.input?.path ?? block.input?.pattern ?? "";
+  switch (block.name) {
+    case "Edit":
+      return `Editing ${short(file)}`;
+    case "Write":
+      return `Writing ${short(file)}`;
+    case "Read":
+      return `Reading ${short(file)}`;
+    case "Bash":
+      return `Running ${short(block.input?.command ?? "command")}`;
+    case "Grep":
+      return `Searching for ${short(file)}`;
+    case "Glob":
+      return `Scanning ${short(file)}`;
+    default:
+      return `${block.name ?? "Working"}\u2026`;
+  }
+}
+function extractLastText(message) {
+  const blocks = message.message?.content ?? [];
+  for (let i = blocks.length - 1; i >= 0; i--) {
+    const b = blocks[i];
+    if (b?.type === "text" && b.text) return b.text;
+  }
+  return void 0;
+}
+function firstLine(text) {
+  const line = text.split("\n").find((l) => l.trim()) ?? text;
+  return short(line.trim(), 100);
+}
+function short(s, max = 60) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+
+// src/core/git.ts
+import { spawn } from "child_process";
+async function takeCheckpoint(repoPath) {
+  const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
+  if (!isRepo) return { isRepo: false };
+  const branch = (await run(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
+  const head = await run(repoPath, ["rev-parse", "HEAD"]);
+  return {
+    isRepo: true,
+    baseRef: head.ok ? head.stdout.trim() : void 0,
+    branch: branch || void 0
+  };
+}
+async function changedFiles(repoPath, checkpoint) {
+  if (!checkpoint.isRepo) return [];
+  const tracked = await run(repoPath, ["diff", "--name-only"]);
+  const untracked = await run(repoPath, [
+    "ls-files",
+    "--others",
+    "--exclude-standard"
+  ]);
+  const set = /* @__PURE__ */ new Set();
+  for (const f of `${tracked.stdout}
+${untracked.stdout}`.split("\n")) {
+    if (f.trim()) set.add(f.trim());
+  }
+  return [...set];
+}
+function revertHint(checkpoint) {
+  if (!checkpoint.isRepo || !checkpoint.baseRef) return void 0;
+  return `git restore . && git clean -fd   (back to ${checkpoint.baseRef.slice(0, 7)})`;
+}
+function run(cwd, args) {
+  return new Promise((resolve2) => {
+    const child = spawn("git", args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", (code) => resolve2({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve2({ ok: false, stdout, stderr }));
+  });
+}
+
+// src/core/verify.ts
+async function pollFirstEvent(config, session, opts = {}) {
+  if (config.offline) return { received: false };
+  const timeoutMs = opts.timeoutMs ?? 12e4;
+  const intervalMs = opts.intervalMs ?? 3e3;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (opts.signal?.aborted) return { received: false };
+    try {
+      const res = await fetch(`${config.apiBaseUrl}/wizard/first-event`, {
+        headers: { authorization: `Bearer ${session.token}` }
+      });
+      if (res.ok) {
+        const body = await res.json();
+        if (body.received) {
+          return { received: true, eventType: body.event_type };
+        }
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return { received: false };
+}
+
+// src/ui/banner.ts
+function banner() {
+  const wave = theme.signal("\u223F\u223F\u223F");
+  const title = `${theme.bright("Whisperr")} ${theme.signal("Wizard")}`;
+  const tagline = theme.muted(
+    "Integrate Whisperr into your app \u2014 one command, fully wired."
+  );
+  return [
+    "",
+    `  ${wave}  ${title}`,
+    `  ${tagline}`,
+    ""
+  ].join("\n");
+}
+
+// src/cli.ts
+async function run2(options) {
+  const repoPath = resolve(options.path ?? process.cwd());
+  const config = resolveConfig(options);
+  console.log(banner());
+  p.intro(theme.signal("Let's wire Whisperr into your app."));
+  if (config.offline) {
+    p.log.warn(
+      theme.warn("offline mode") + theme.muted(" \u2014 using a demo manifest, no account needed.")
+    );
+  }
+  const detections = await withSpinner(
+    "Scanning your repository",
+    () => detectStack(repoPath)
+  );
+  const chosen = await chooseTarget(detections);
+  if (!chosen) {
+    p.cancel("No supported stack selected.");
+    return 1;
+  }
+  if (chosen.playbook.target.availability === "planned") {
+    p.note(
+      `We can detect ${theme.bright(chosen.playbook.target.displayName)} but the Whisperr SDK for it isn't shipped yet.
+Flutter is live today; ${theme.bright(
+        chosen.playbook.target.displayName
+      )} is next on the roadmap.`,
+      theme.warn("SDK coming soon")
+    );
+    const cont = await p.confirm({
+      message: "Continue anyway and let the agent scaffold against the planned SDK?",
+      initialValue: false
+    });
+    if (p.isCancel(cont) || !cont) {
+      p.outro(theme.muted("No problem \u2014 come back when the SDK lands."));
+      return 0;
+    }
+  } else {
+    p.log.success(
+      `Detected ${theme.bright(chosen.playbook.target.displayName)} ` + theme.muted(`(${chosen.detection?.evidence.join(", ") ?? "selected"})`)
+    );
+  }
+  let session;
+  try {
+    session = config.offline ? await authenticate(config) : await withBrowserAuth(config);
+  } catch (err) {
+    p.cancel(theme.alert(err.message));
+    return 1;
+  }
+  const manifest = await withSpinner(
+    "Loading your onboarding context",
+    () => fetchManifest(config, session, chosen.playbook.target.id)
+  );
+  p.note(
+    summarizeManifest(manifest),
+    theme.signal(`Plan for ${manifest.appName ?? manifest.appId}`)
+  );
+  const checkpoint = await takeCheckpoint(repoPath);
+  if (!checkpoint.isRepo) {
+    p.log.warn(
+      theme.warn("not a git repo") + theme.muted(" \u2014 edits will apply with no automatic undo.")
+    );
+  }
+  const spin = p.spinner();
+  spin.start(theme.bright("Integrating") + theme.muted(" \u2014 the agent is working in your code"));
+  let lastLine = "";
+  const outcome = await runIntegrationAgent({
+    repoPath,
+    config,
+    session,
+    playbook: chosen.playbook,
+    manifest,
+    progress: {
+      onActivity(line) {
+        lastLine = line;
+        spin.message(theme.bright("Integrating") + theme.muted(` \u2014 ${line}`));
+      }
+    }
+  }).catch((err) => {
+    spin.stop(theme.alert("Integration failed"));
+    p.log.error(err.message);
+    return null;
+  });
+  if (!outcome) return 1;
+  spin.stop(
+    outcome.ok ? theme.success("Integration complete") : theme.warn("Integration finished with notes")
+  );
+  const files = await changedFiles(repoPath, checkpoint);
+  if (files.length) {
+    p.note(files.map((f) => theme.muted("\u2022 ") + f).join("\n"), "Files changed");
+  }
+  if (outcome.summary.trim()) {
+    p.log.message(outcome.summary.trim());
+  }
+  if (!config.offline) {
+    p.log.step(
+      theme.bright("Run your app once") + theme.muted(" and trigger any tracked action \u2014 I'll watch for the first event.")
+    );
+    const verifySpin = p.spinner();
+    verifySpin.start("Waiting for the first event from your app");
+    const first = await pollFirstEvent(config, session, { timeoutMs: 12e4 });
+    if (first.received) {
+      verifySpin.stop(
+        theme.success(
+          `Whisperr is receiving events \u2713` + (first.eventType ? theme.muted(`  (first: ${first.eventType})`) : "")
+        )
+      );
+    } else {
+      verifySpin.stop(
+        theme.warn(
+          "No events yet \u2014 that's fine. They'll flow once you run the app with the changes."
+        )
+      );
+    }
+  }
+  const undo = revertHint(checkpoint);
+  const nextSteps = [
+    `${theme.signal("1.")} Review the diff above.`,
+    `${theme.signal("2.")} Run / rebuild your app to start sending events.`,
+    `${theme.signal("3.")} Commit & deploy \u2014 Whisperr starts working on real users.`,
+    undo ? theme.muted(`Undo everything: ${undo}`) : ""
+  ].filter(Boolean).join("\n");
+  p.note(nextSteps, theme.bright("Next"));
+  p.outro(theme.signal("\u2301 ") + theme.bright("Whisperr is wired in."));
+  void lastLine;
+  return 0;
+}
+async function chooseTarget(detections) {
+  const top = detections[0];
+  if (top && (detections.length === 1 || top.confidence >= 0.9)) {
+    const playbook2 = playbookByTargetId(top.target.id);
+    if (playbook2) return { playbook: playbook2, detection: top };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const options = [];
+  for (const d of detections) {
+    if (seen.has(d.target.id)) continue;
+    seen.add(d.target.id);
+    options.push({
+      value: d.target.id,
+      label: d.target.displayName,
+      hint: (d.target.availability === "available" ? "" : "coming soon \xB7 ") + `${Math.round(d.confidence * 100)}% match`
+    });
+  }
+  for (const pb of ALL_PLAYBOOKS) {
+    if (seen.has(pb.target.id)) continue;
+    options.push({
+      value: pb.target.id,
+      label: pb.target.displayName,
+      hint: pb.target.availability === "available" ? void 0 : "coming soon"
+    });
+  }
+  const answer = await p.select({
+    message: detections.length ? "I found more than one possible stack \u2014 which should I integrate?" : "I couldn't auto-detect your stack. Which are you using?",
+    options
+  });
+  if (p.isCancel(answer)) return null;
+  const playbook = playbookByTargetId(answer);
+  if (!playbook) return null;
+  return {
+    playbook,
+    detection: detections.find((d) => d.target.id === answer)
+  };
+}
+async function withBrowserAuth(config) {
+  p.log.step(
+    theme.bright("Authenticate") + theme.muted(" \u2014 opening your browser to approve this device\u2026")
+  );
+  const spin = p.spinner();
+  spin.start("Waiting for you to approve in the browser");
+  try {
+    const session = await authenticate(config);
+    spin.stop(theme.success("Authenticated \u2713"));
+    return session;
+  } catch (err) {
+    spin.stop(theme.alert("Authentication failed"));
+    throw err;
+  }
+}
+async function withSpinner(label, fn) {
+  const spin = p.spinner();
+  spin.start(label);
+  try {
+    const result = await fn();
+    spin.stop(theme.muted(label) + " " + theme.success("\u2713"));
+    return result;
+  } catch (err) {
+    spin.stop(theme.alert(`${label} \u2014 failed`));
+    throw err;
+  }
+}
+function summarizeManifest(m) {
+  const events = [...m.events].sort((a, b) => (b.importance ?? 0) - (a.importance ?? 0)).map((e) => theme.muted("\u2022 ") + e.eventType);
+  const channels = m.identify.channels?.length ? theme.muted(`channels: ${m.identify.channels.join(", ")}`) : "";
+  return [
+    theme.bright("identify()") + theme.muted(" + ") + theme.bright(`${m.events.length} events`),
+    ...events,
+    channels
+  ].filter(Boolean).join("\n");
+}
+
+// src/index.ts
+function parseArgs(argv) {
+  const args = [...argv];
+  const opts = {};
+  if (args[0] === "init") args.shift();
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    switch (a) {
+      case "-h":
+      case "--help":
+        return { help: true };
+      case "-v":
+      case "--version":
+        return { version: true };
+      case "--offline":
+        opts.offline = true;
+        break;
+      case "--api":
+        opts.apiBaseUrl = args[++i];
+        break;
+      case "--model":
+        opts.model = args[++i];
+        break;
+      default:
+        if (a && !a.startsWith("-") && !opts.path) {
+          opts.path = a;
+        }
+    }
+  }
+  return opts;
+}
+function printHelp() {
+  console.log(
+    [
+      "",
+      `  ${theme.bright("Whisperr Wizard")} \u2014 integrate Whisperr into your app.`,
+      "",
+      `  ${theme.bright("Usage")}`,
+      "    npx @whisperr/wizard [init] [path] [options]",
+      "",
+      `  ${theme.bright("Options")}`,
+      "    --offline         Use a demo manifest, no account/browser needed",
+      "    --api <url>       Override the Whisperr API base URL",
+      "    --model <id>      Override the coding-agent model",
+      "    -h, --help        Show this help",
+      "    -v, --version     Show version",
+      "",
+      `  ${theme.muted("The wizard detects your stack, authenticates with your")}`,
+      `  ${theme.muted("onboarded account, and wires up identify() + your events.")}`,
+      ""
+    ].join("\n")
+  );
+}
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if ("help" in parsed) {
+    printHelp();
+    return;
+  }
+  if ("version" in parsed) {
+    console.log("0.1.0");
+    return;
+  }
+  try {
+    const code = await run2(parsed);
+    process.exit(code);
+  } catch (err) {
+    console.error("\n" + theme.alert("Unexpected error: ") + err.message);
+    process.exit(1);
+  }
+}
+void main();
+//# sourceMappingURL=index.js.map