Store match metadata

apps/web/__tests__/ai-choose-rule.test.ts

@@ -17,7 +17,7 @@ describe.runIf(isAiTest)("aiChooseRule", () => {
       emailAccount: getEmailAccount(),
     });
 
-    expect(result).toEqual({ rules: [], reason: "" });
+    expect(result).toEqual({ rules: [], reason: "No rules to evaluate" });
   });
 
   test("Should return correct rule when only one rule passed", async () => {

apps/web/__tests__/helpers.ts

@@ -11,7 +11,7 @@ export function getEmailAccount(
     userId: "user1",
     email: overrides.email || "user@test.com",
     about: null,
-    multiRuleSelectionEnabled: false,
+    multiRuleSelectionEnabled: overrides.multiRuleSelectionEnabled ?? false,
     user: {
       aiModel: null,
       aiProvider: null,

apps/web/prisma/migrations/20251024092349_match_metadata/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "ExecutedRule" ADD COLUMN     "matchMetadata" JSONB;

apps/web/prisma/schema.prisma

@@ -469,14 +469,15 @@ model RuleHistory {
 // Rule/Action models represent the rules and actions that the AI can take.
 // ExecutedRule/ExecutedAction models represent the rules/actions that have been planned or executed by the AI.
 model ExecutedRule {
-  id        String             @id @default(cuid())
-  createdAt DateTime           @default(now())
-  updatedAt DateTime           @updatedAt
-  threadId  String
-  messageId String
-  status    ExecutedRuleStatus
-  automated Boolean
-  reason    String?
+  id            String             @id @default(cuid())
+  createdAt     DateTime           @default(now())
+  updatedAt     DateTime           @updatedAt
+  threadId      String
+  messageId     String
+  status        ExecutedRuleStatus
+  automated     Boolean
+  reason        String?
+  matchMetadata Json? // Stores structured match information (e.g., learned patterns, match types)
 
   // may be null if the rule was deleted
   ruleId String?

apps/web/utils/ai/choose-rule/ai-choose-rule.ts

@@ -29,7 +29,7 @@ export async function aiChooseRule<
   rules: { rule: T; isPrimary?: boolean }[];
   reason: string;
 }> {
-  if (!rules.length) return { rules: [], reason: "" };
+  if (!rules.length) return { rules: [], reason: "No rules to evaluate" };
 
   const { result: aiResponse } = await getAiResponse({
     email,
@@ -38,7 +38,12 @@ export async function aiChooseRule<
     modelType,
   });
 
-  if (aiResponse.noMatchFound) return { rules: [], reason: "" };
+  if (aiResponse.noMatchFound) {
+    return {
+      rules: [],
+      reason: aiResponse.reasoning || "AI determined no rules matched",
+    };
+  }
 
   const rulesWithMetadata = aiResponse.matchedRules
     .map((match) => {

apps/web/utils/ai/choose-rule/match-rules.ts

@@ -75,7 +75,12 @@ export async function findMatchingRules({
       });
 
       return {
-        matches: [{ rule: coldRule, matchReasons: [] }],
+        matches: [
+          {
+            rule: coldRule,
+            matchReasons: [{ type: ConditionType.AI }],
+          },
+        ],
         reasoning: coldEmailResult.reason,
       };
     }
@@ -345,6 +350,8 @@ function getMatchReason(matchReasons?: MatchReason[]): string | undefined {
           return `Matched learned pattern: "${reason.groupItem.type}: ${reason.groupItem.value}"`;
         case ConditionType.PRESET:
           return "Matched a system preset";
+        case ConditionType.AI:
+          return "Matched via AI";
       }
     })
     .join(", ");

apps/web/utils/ai/choose-rule/run-rules.ts

@@ -9,6 +9,7 @@ import { executeAct } from "@/utils/ai/choose-rule/execute";
 import prisma from "@/utils/prisma";
 import { createScopedLogger } from "@/utils/logger";
 import type { MatchReason } from "@/utils/ai/choose-rule/types";
+import { serializeMatchReasons } from "@/utils/ai/choose-rule/types";
 import { sanitizeActionFields } from "@/utils/action-item";
 import { extractEmailAddress } from "@/utils/email";
 import { filterNullProperties } from "@/utils";
@@ -94,6 +95,7 @@ export async function runRules({
           messageId: message.id,
           automated: true,
           reason,
+          matchMetadata: undefined,
           status: ExecutedRuleStatus.SKIPPED,
           emailAccount: { connect: { id: emailAccount.id } },
         },
@@ -259,6 +261,7 @@ async function executeMatchedRule(
       automated: true,
       status: ExecutedRuleStatus.APPLYING, // Changed from PENDING - rules are now always automated
       reason,
+      matchMetadata: serializeMatchReasons(matchReasons),
       rule: rule?.id ? { connect: { id: rule.id } } : undefined,
       emailAccount: { connect: { id: emailAccount.id } },
       createdAt: batchTimestamp, // Use batch timestamp for grouping

apps/web/utils/ai/choose-rule/types.ts

@@ -36,3 +36,55 @@ export type MatchingRuleResult = {
     instructions: string;
   })[];
 };
+
+/**
+ * Serializable version of MatchReason for database storage
+ */
+export type SerializedMatchReason =
+  | { type: "STATIC" }
+  | {
+      type: "LEARNED_PATTERN";
+      group: { id: string; name: string };
+      groupItem: {
+        id: string;
+        type: string;
+        value: string;
+        exclude: boolean;
+      };
+    }
+  | { type: "AI" }
+  | { type: "PRESET"; systemType: string };
+
+/**
+ * Serializes match reasons to a JSON-safe format for database storage
+ */
+export function serializeMatchReasons(
+  matchReasons?: MatchReason[],
+): SerializedMatchReason[] | undefined {
+  if (!matchReasons || matchReasons.length === 0) return undefined;
+
+  return matchReasons.map((reason): SerializedMatchReason => {
+    switch (reason.type) {
+      case "STATIC":
+        return { type: "STATIC" };
+      case "LEARNED_PATTERN":
+        return {
+          type: "LEARNED_PATTERN",
+          group: {
+            id: reason.group.id,
+            name: reason.group.name,
+          },
+          groupItem: {
+            id: reason.groupItem.id,
+            type: reason.groupItem.type,
+            value: reason.groupItem.value,
+            exclude: reason.groupItem.exclude,
+          },
+        };
+      case "AI":
+        return { type: "AI" };
+      case "PRESET":
+        return { type: "PRESET", systemType: reason.systemType };
+    }
+  });
+}

apps/web/utils/date.ts

@@ -95,8 +95,12 @@ export function sortByInternalDate<T extends { internalDate?: string | null }>(
   direction: "asc" | "desc" = "asc",
 ) {
   return (a: T, b: T): number => {
-    const aTime = internalDateToDate(a.internalDate).getTime() || 0;
-    const bTime = internalDateToDate(b.internalDate).getTime() || 0;
+    const aTime = a.internalDate
+      ? internalDateToDate(a.internalDate).getTime()
+      : 0;
+    const bTime = b.internalDate
+      ? internalDateToDate(b.internalDate).getTime()
+      : 0;
     return direction === "asc" ? aTime - bTime : bTime - aTime;
   };
 }

version.txt

@@ -1 +1 @@
-v2.17.11
+v2.17.12