@gonzih/meet-the-one-ai 1.0.0

package/src/jobs/compact-identity.ts

@@ -0,0 +1,211 @@
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+import { complete, extract_json } from "../lib/anthropic.js";
+import { embed } from "../lib/openai.js";
+import { download_json, upload_json } from "../lib/r2.js";
+import {
+  SYSTEM_SIGNAL_EXTRACTION,
+  SYSTEM_IDENTITY_MERGE,
+  SYSTEM_MODALITY_RENDER,
+} from "../lib/prompts.js";
+import type { BaseIdentityProfile, ModalityWeights, Modality } from "../types/index.js";
+
+// Triggered after transcription completes (or after text submission)
+// Pass 1: Extract signals from session
+// Pass 2: Merge signals into compacted identity
+// Pass 3: Render modality-specific portraits → embed per modality
+export const compact_identity = inngest.createFunction(
+  { id: "compact-identity", retries: 2 },
+  { event: "session/transcribed" },
+  async ({ event, step }) => {
+    const { user_id, session_id, transcript_r2_key } = event.data;
+
+    await step.run("mark-processing", async () => {
+      await supabase
+        .from("sessions")
+        .update({ analysis_status: "processing" })
+        .eq("id", session_id);
+    });
+
+    // Load transcript or raw text
+    const user_transcript = await step.run("load-transcript", async () => {
+      if (transcript_r2_key) {
+        const data = await download_json<{ text: string }>(transcript_r2_key);
+        return data.text;
+      }
+      const { data, error } = await supabase
+        .from("sessions")
+        .select("raw_text")
+        .eq("id", session_id)
+        .single();
+      if (error || !data?.raw_text) throw new Error("No transcript or raw_text found");
+      return data.raw_text;
+    });
+
+    const session_meta = await step.run("load-session-meta", async () => {
+      const { data, error } = await supabase
+        .from("sessions")
+        .select("time_of_day, duration_seconds, source")
+        .eq("id", session_id)
+        .single();
+      if (error || !data) throw new Error("Session not found");
+      return data;
+    });
+
+    const { count: completed_count } = await supabase
+      .from("sessions")
+      .select("*", { count: "exact", head: true })
+      .eq("user_id", user_id)
+      .eq("analysis_status", "complete");
+
+    const session_number = (completed_count ?? 0) + 1;
+
+    // ── Pass 1: Signal extraction ─────────────────────────────────────────────
+    const session_signals_raw = await step.run("extract-signals", async () => {
+      const is_late_night = session_meta.time_of_day === "late_night";
+      return complete(
+        "analysis",
+        SYSTEM_SIGNAL_EXTRACTION,
+        [
+          `Session #${session_number} (source: ${session_meta.source})`,
+          `Time: ${session_meta.time_of_day}${is_late_night ? " [HIGH SIGNAL — 4AM PRINCIPLE]" : ""}`,
+          `Duration: ${session_meta.duration_seconds ?? "unknown"}s`,
+          `\nTranscript:\n${user_transcript}`,
+        ].join("\n")
+      );
+    });
+
+    const existing_identity = await step.run("load-identity", async () => {
+      const { data } = await supabase
+        .from("identities")
+        .select("base_profile, modality_weights, session_count")
+        .eq("user_id", user_id)
+        .single();
+      return data;
+    });
+
+    // ── Pass 2: Identity merge ────────────────────────────────────────────────
+    const merged_raw = await step.run("merge-identity", async () => {
+      const existing_str = existing_identity
+        ? JSON.stringify(existing_identity.base_profile, null, 2)
+        : "null (first session)";
+
+      return complete(
+        "analysis",
+        SYSTEM_IDENTITY_MERGE,
+        [
+          `Existing identity:\n${existing_str}`,
+          `\nNew session signals:\n${session_signals_raw}`,
+          `\nSession metadata: ${JSON.stringify(session_meta)}`,
+          `\nTotal sessions completed: ${session_number}`,
+        ].join("\n\n")
+      );
+    });
+
+    const { base_profile, modality_weights } = await step.run(
+      "parse-output",
+      async () => {
+        try {
+          return JSON.parse(extract_json(merged_raw)) as {
+            base_profile: BaseIdentityProfile;
+            modality_weights: ModalityWeights;
+          };
+        } catch {
+          throw new Error(`LLM returned invalid JSON for identity merge: ${merged_raw.slice(0, 200)}`);
+        }
+      }
+    );
+
+    const completeness = compute_completeness(base_profile);
+    const ready =
+      completeness >= 0.5 &&
+      base_profile.worldview.world_danger_adventure !== undefined;
+
+    const new_session_count = (existing_identity?.session_count ?? 0) + 1;
+
+    // ── Pass 3: Modality-specific portraits + embeddings ──────────────────────
+    const active_modalities = Object.entries(modality_weights)
+      .filter(([, w]) => (w as number) > 0.1)
+      .map(([m]) => m as Modality);
+
+    await step.run("upsert-modality-embeddings", async () => {
+      for (const modality of active_modalities) {
+        // Render a focused portrait through this modality's lens
+        const portrait = await complete(
+          "analysis",
+          SYSTEM_MODALITY_RENDER,
+          [
+            `Target modality: ${modality}`,
+            `\nFull identity profile:\n${JSON.stringify(base_profile, null, 2)}`,
+            `\nModality weights: ${JSON.stringify(modality_weights)}`,
+          ].join("\n\n"),
+          512 // short output — dense paragraph only
+        );
+
+        const vec = await embed(portrait);
+
+        await supabase.rpc("upsert_modality_embedding", {
+          p_user_id: user_id,
+          p_modality: modality,
+          p_embedding: vec,
+        });
+      }
+    });
+
+    // ── Save identity ─────────────────────────────────────────────────────────
+    await step.run("save-identity", async () => {
+      await supabase.from("identities").upsert(
+        {
+          user_id,
+          base_profile,
+          modality_weights,
+          signal_completeness_score: completeness,
+          session_count: new_session_count,
+          ready_for_matching: ready,
+          last_updated: new Date().toISOString(),
+        },
+        { onConflict: "user_id" }
+      );
+    });
+
+    // Audit trail to R2
+    await step.run("archive-signals", async () => {
+      await upload_json(`signals/${user_id}/${session_id}.json`, {
+        session_id,
+        signals_raw: session_signals_raw,
+        base_profile,
+        modality_weights,
+        completeness,
+        merged_at: new Date().toISOString(),
+      });
+    });
+
+    await step.run("mark-complete", async () => {
+      await supabase
+        .from("sessions")
+        .update({ analysis_status: "complete" })
+        .eq("id", session_id);
+    });
+
+    await step.sendEvent("trigger-matching", {
+      name: "identity/updated",
+      data: { user_id },
+    });
+
+    return { user_id, completeness, ready_for_matching: ready, session_count: new_session_count };
+  }
+);
+
+function compute_completeness(profile: BaseIdentityProfile): number {
+  const domain_scores = [
+    profile.relationships.confidence,
+    profile.desire.confidence,
+    profile.money.confidence,
+    profile.health.confidence,
+  ];
+  const domain_avg =
+    domain_scores.reduce((a, b) => a + b, 0) / domain_scores.length;
+  const has_worldview =
+    profile.worldview.world_danger_adventure !== undefined ? 1 : 0;
+  return domain_avg * 0.7 + has_worldview * 0.3;
+}

package/src/jobs/consent-call.ts

@@ -0,0 +1,87 @@
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+import { trigger_consent_call } from "../lib/vapi.js";
+import { send_sms } from "../lib/twilio.js";
+
+// Triggered when a match is confirmed by the matching engine
+// Calls both users via Vapi consent assistant — sequentially with a gap
+// If Vapi call fails, falls back to SMS consent
+export const consent_call = inngest.createFunction(
+  { id: "consent-call", retries: 2 },
+  { event: "match/confirmed" },
+  async ({ event, step }) => {
+    const { match_id } = event.data;
+
+    // Load match + both users' phones
+    const match = await step.run("load-match", async () => {
+      const { data, error } = await supabase
+        .from("matches")
+        .select(`
+          id,
+          user_a_id,
+          user_b_id,
+          primary_modality,
+          confidence_score,
+          consent_call_framing,
+          status
+        `)
+        .eq("id", match_id)
+        .single();
+      if (error || !data) throw new Error(`Match not found: ${match_id}`);
+      return data;
+    });
+
+    // Only proceed if still pending consent
+    if (match.status !== "pending_consent") {
+      return { skipped: true, reason: `match status is ${match.status}` };
+    }
+
+    const users = await step.run("load-users", async () => {
+      const { data, error } = await supabase
+        .from("users")
+        .select("id, phone, brand")
+        .in("id", [match.user_a_id, match.user_b_id]);
+      if (error || !data || data.length !== 2) {
+        throw new Error("Failed to load both users for consent call");
+      }
+      return data;
+    });
+
+    const user_a = users.find((u) => u.id === match.user_a_id)!;
+    const user_b = users.find((u) => u.id === match.user_b_id)!;
+    const framing = match.consent_call_framing ?? "";
+
+    // ── Call user A ───────────────────────────────────────────────────────────
+    await step.run("call-user-a", async () => {
+      try {
+        await trigger_consent_call(user_a.phone, match_id, framing);
+      } catch (err) {
+        console.error("Vapi consent call failed for user_a, falling back to SMS", err);
+        await send_sms(
+          user_a.phone,
+          `We found someone interesting for you. Reply ACCEPT to connect or DECLINE to pass. [match:${match_id}]`,
+          user_a.brand as Parameters<typeof send_sms>[2]
+        );
+      }
+    });
+
+    // Small delay between calls so they don't land simultaneously
+    await step.sleep("gap-between-calls", "2m");
+
+    // ── Call user B ───────────────────────────────────────────────────────────
+    await step.run("call-user-b", async () => {
+      try {
+        await trigger_consent_call(user_b.phone, match_id, framing);
+      } catch (err) {
+        console.error("Vapi consent call failed for user_b, falling back to SMS", err);
+        await send_sms(
+          user_b.phone,
+          `We found someone interesting for you. Reply ACCEPT to connect or DECLINE to pass. [match:${match_id}]`,
+          user_b.brand as Parameters<typeof send_sms>[2]
+        );
+      }
+    });
+
+    return { match_id, called: [user_a.id, user_b.id] };
+  }
+);

package/src/jobs/export-identity.ts

@@ -0,0 +1,166 @@
+import archiver from "archiver";
+import { PassThrough } from "stream";
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+import { complete } from "../lib/anthropic.js";
+import { upload_buffer, generate_presigned_get_url } from "../lib/r2.js";
+import { send_sms } from "../lib/twilio.js";
+import { SYSTEM_IDENTITY_NARRATIVE } from "../lib/prompts.js";
+import type { BaseIdentityProfile, ModalityWeights, Brand } from "../types/index.js";
+
+// Triggered by identity/export event (SMS "EXPORT" or web portal)
+// Renders 7 markdown files → zips → uploads to R2 → sends SMS download link
+export const export_identity = inngest.createFunction(
+  { id: "export-identity", retries: 1 },
+  { event: "identity/export" },
+  async ({ event, step }) => {
+    const { user_id } = event.data;
+
+    // Load identity + user
+    const { identity, user } = await step.run("load-data", async () => {
+      const [id_res, user_res] = await Promise.all([
+        supabase
+          .from("identities")
+          .select("base_profile, modality_weights, signal_completeness_score, session_count")
+          .eq("user_id", user_id)
+          .single(),
+        supabase
+          .from("users")
+          .select("id, phone, brand")
+          .eq("id", user_id)
+          .single(),
+      ]);
+      if (id_res.error || !id_res.data) throw new Error("Identity not found");
+      if (user_res.error || !user_res.data) throw new Error("User not found");
+      return { identity: id_res.data, user: user_res.data };
+    });
+
+    const profile = identity.base_profile as BaseIdentityProfile;
+    const weights = identity.modality_weights as ModalityWeights;
+
+    // ── Render all narrative files in parallel ────────────────────────────────
+    const files = await step.run("render-narratives", async () => {
+      const domains = [
+        { name: "relationships", data: profile.relationships },
+        { name: "desire", data: profile.desire },
+        { name: "money", data: profile.money },
+        { name: "health", data: profile.health },
+        { name: "worldview", data: profile.worldview },
+      ];
+
+      const rendered = await Promise.all(
+        domains.map(async ({ name, data }) => {
+          const content = await complete(
+            "analysis",
+            SYSTEM_IDENTITY_NARRATIVE,
+            [
+              `Domain: ${name}`,
+              `\nProfile data:\n${JSON.stringify(data, null, 2)}`,
+              `\nFull context (other domains):\n${JSON.stringify(profile, null, 2)}`,
+            ].join("\n\n"),
+            1024
+          );
+          return { filename: `${name}.md`, content: `# My ${capitalize(name)} Identity\n\n${content}` };
+        })
+      );
+
+      // Modality weights file
+      const modality_content = await complete(
+        "analysis",
+        SYSTEM_IDENTITY_NARRATIVE,
+        [
+          `Domain: modality_weights`,
+          `\nModality weights:\n${JSON.stringify(weights, null, 2)}`,
+          `\nFull profile context:\n${JSON.stringify(profile, null, 2)}`,
+        ].join("\n\n"),
+        512
+      );
+
+      rendered.push({
+        filename: "modality_weights.md",
+        content: `# How I Approach Connection\n\n${modality_content}`,
+      });
+
+      // README
+      const completeness_pct = Math.round((identity.signal_completeness_score ?? 0) * 100);
+      rendered.push({
+        filename: "README.md",
+        content: [
+          `# My Identity — meet-the-one.ai`,
+          ``,
+          `Generated: ${new Date().toISOString().slice(0, 10)}`,
+          `Sessions: ${identity.session_count ?? 0}`,
+          `Completeness: ${completeness_pct}%`,
+          ``,
+          `## What This Is`,
+          ``,
+          `This is your portable identity — built from your own words across ${identity.session_count ?? 0} conversation sessions.`,
+          `It belongs to you. You can read it, keep it, share it, or import it into compatible platforms.`,
+          ``,
+          `## Files`,
+          ``,
+          `- \`relationships.md\` — how you attach, trust, and connect`,
+          `- \`desire.md\` — what you want and how you want it`,
+          `- \`money.md\` — your relationship with resources and risk`,
+          `- \`health.md\` — how you inhabit your body and energy`,
+          `- \`worldview.md\` — how you see the world and people in it`,
+          `- \`modality_weights.md\` — how you orient toward different kinds of connection`,
+          ``,
+          `## Privacy`,
+          ``,
+          `To delete all your data: text DELETE MY DATA to the number you enrolled with.`,
+          ``,
+          `---`,
+          `meet-the-one.ai`,
+        ].join("\n"),
+      });
+
+      return rendered;
+    });
+
+    // ── Zip all files + upload to R2 (single step — Buffer can't cross step boundary) ──
+    const export_key = `exports/${user_id}/${Date.now()}.zip`;
+    await step.run("zip-and-upload", async () => {
+      const zip_buf = await new Promise<Buffer>((resolve, reject) => {
+        const archive = archiver("zip", { zlib: { level: 6 } });
+        const pass = new PassThrough();
+        const chunks: Buffer[] = [];
+
+        pass.on("data", (chunk: Buffer) => chunks.push(chunk));
+        pass.on("end", () => resolve(Buffer.concat(chunks)));
+        pass.on("error", reject);
+        archive.on("error", reject);
+
+        archive.pipe(pass);
+
+        for (const { filename, content } of files) {
+          archive.append(content, { name: `my-identity/${filename}` });
+        }
+
+        archive.finalize();
+      });
+
+      await upload_buffer(export_key, zip_buf, "application/zip");
+    });
+
+    // ── Generate presigned download URL (24h) ─────────────────────────────────
+    const download_url = await step.run("presign-url", async () => {
+      return generate_presigned_get_url(export_key, 86400);
+    });
+
+    // ── Send SMS with download link ───────────────────────────────────────────
+    await step.run("send-sms", async () => {
+      await send_sms(
+        user.phone,
+        `Your identity export is ready. Download it here (link expires in 24h):\n${download_url}`,
+        user.brand as Brand
+      );
+    });
+
+    return { user_id, export_key, files: files.length };
+  }
+);
+
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/src/jobs/introduction-call.ts

@@ -0,0 +1,101 @@
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+import { twilio } from "../lib/twilio.js";
+import { send_sms } from "../lib/twilio.js";
+import { config } from "../lib/config.js";
+
+// Triggered when both users have accepted the match
+// Creates a Twilio conference and calls both in
+export const introduction_call = inngest.createFunction(
+  { id: "introduction-call", retries: 2 },
+  { event: "match/both-accepted" },
+  async ({ event, step }) => {
+    const { match_id } = event.data;
+
+    const match = await step.run("load-match", async () => {
+      const { data, error } = await supabase
+        .from("matches")
+        .select("id, user_a_id, user_b_id, status")
+        .eq("id", match_id)
+        .single();
+      if (error || !data) throw new Error(`Match not found: ${match_id}`);
+      return data;
+    });
+
+    if (match.status !== "both_accepted") {
+      return { skipped: true, reason: `match status is ${match.status}` };
+    }
+
+    const users = await step.run("load-users", async () => {
+      const { data, error } = await supabase
+        .from("users")
+        .select("id, phone, brand")
+        .in("id", [match.user_a_id, match.user_b_id]);
+      if (error || !data || data.length !== 2) {
+        throw new Error("Failed to load users for introduction call");
+      }
+      return data;
+    });
+
+    const user_a = users.find((u) => u.id === match.user_a_id)!;
+    const user_b = users.find((u) => u.id === match.user_b_id)!;
+
+    // Conference room name is deterministic from match_id
+    const conference_name = `intro-${match_id}`;
+    const from_number = config.twilio.numbers["meet-the-one"];
+
+    // TwiML to join a named conference
+    const conference_twiml = (participant_name: string) =>
+      `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+  <Say voice="Polly.Joanna">Please hold while we connect you with your match.</Say>
+  <Dial>
+    <Conference
+      startConferenceOnEnter="false"
+      endConferenceOnExit="true"
+      waitUrl="https://twimlets.com/holdmusic?Bucket=com.twilio.music.soft-rock"
+      statusCallback="${config.app.url}/api/webhooks/twilio/conference"
+      statusCallbackEvent="end"
+      friendlyName="${participant_name}"
+    >${conference_name}</Conference>
+  </Dial>
+</Response>`;
+
+    // Call both users into the conference
+    await step.run("dial-both", async () => {
+      await Promise.all([
+        twilio.calls.create({
+          to: user_a.phone,
+          from: from_number,
+          twiml: conference_twiml("You"),
+        }),
+        twilio.calls.create({
+          to: user_b.phone,
+          from: from_number,
+          twiml: conference_twiml("You"),
+        }),
+      ]);
+    });
+
+    // Update match status
+    await step.run("mark-introduced", async () => {
+      await supabase
+        .from("matches")
+        .update({ status: "introduced", updated_at: new Date().toISOString() })
+        .eq("id", match_id);
+    });
+
+    // Send follow-up SMS to both after the call
+    await step.sleep("post-call-delay", "30m");
+
+    await step.run("send-followup-sms", async () => {
+      const msg = "Hope that went well. Let us know how it went — your feedback helps us improve.";
+      await Promise.all([
+        send_sms(user_a.phone, msg, user_a.brand as Parameters<typeof send_sms>[2]),
+        send_sms(user_b.phone, msg, user_b.brand as Parameters<typeof send_sms>[2]),
+      ]);
+    });
+
+    return { match_id, introduced: [user_a.id, user_b.id] };
+  }
+);

package/src/jobs/reanalyze-identity.ts

@@ -0,0 +1,65 @@
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+
+// Triggered manually or after prompt changes
+// Replays all completed sessions through the current prompt version
+// by re-firing session/transcribed for each session in order
+export const reanalyze_identity = inngest.createFunction(
+  { id: "reanalyze-identity", retries: 1 },
+  { event: "identity/reanalyze" },
+  async ({ event, step }) => {
+    const { user_id } = event.data;
+
+    // Load all completed sessions in chronological order
+    const sessions = await step.run("load-sessions", async () => {
+      const { data, error } = await supabase
+        .from("sessions")
+        .select("id, transcript_r2_key, raw_text, analysis_status")
+        .eq("user_id", user_id)
+        .in("analysis_status", ["complete", "error"])
+        .order("created_at", { ascending: true });
+      if (error) throw new Error(`Failed to load sessions: ${error.message}`);
+      return data ?? [];
+    });
+
+    if (sessions.length === 0) {
+      return { skipped: true, reason: "no completed sessions" };
+    }
+
+    // Reset identity
+    await step.run("reset-identity", async () => {
+      await supabase
+        .from("identities")
+        .update({
+          base_profile: {},
+          modality_weights: {},
+          signal_completeness_score: 0,
+          session_count: 0,
+          ready_for_matching: false,
+          last_updated: new Date().toISOString(),
+        })
+        .eq("user_id", user_id);
+
+      // Clear all modality embeddings
+      await supabase
+        .from("identity_modality_embeddings")
+        .delete()
+        .eq("user_id", user_id);
+    });
+
+    // Re-fire each session through compact-identity sequentially
+    // Inngest will process them in order via event fan-out
+    for (const session of sessions) {
+      await step.sendEvent(`replay-${session.id}`, {
+        name: "session/transcribed",
+        data: {
+          user_id,
+          session_id: session.id,
+          transcript_r2_key: session.transcript_r2_key ?? "",
+        },
+      });
+    }
+
+    return { user_id, replayed: sessions.length };
+  }
+);