Allow multiple rule matches

apps/web/__tests__/helpers.ts

@@ -41,10 +41,14 @@ export function getEmail({
   };
 }
 
-export function getRule(instructions: string, actions: Action[] = []) {
+export function getRule(
+  instructions: string,
+  actions: Action[] = [],
+  name?: string,
+) {
   return {
     instructions,
-    name: "Joke requests",
+    name: name || "Joke requests",
     actions,
     id: "id",
     userId: "userId",
@@ -57,7 +61,6 @@ export function getRule(instructions: string, actions: Action[] = []) {
     body: null,
     to: null,
     enabled: true,
-    categoryFilterType: null,
     conditionalOperator: LogicalOperator.AND,
   };
 }

apps/web/app/(app)/[emailAccountId]/assistant/ConditionSummaryCard.tsx

@@ -1,16 +1,12 @@
 import { BotIcon, FilterIcon } from "lucide-react";
-import { capitalCase } from "capital-case";
 import type { CreateRuleBody } from "@/utils/actions/rule.validation";
 import { ConditionType } from "@/utils/config";
 import { CardBasic } from "@/components/ui/card";
-import { CategoryFilterType } from "@prisma/client";
 
 export function ConditionSummaryCard({
   condition,
-  categories,
 }: {
   condition: CreateRuleBody["conditions"][number];
-  categories?: Array<{ id: string; name: string }>;
 }) {
   let summaryContent: React.ReactNode = condition.type;
   let Icon = FilterIcon;
@@ -57,36 +53,6 @@ export function ConditionSummaryCard({
       break;
     }
 
-    case ConditionType.CATEGORY: {
-      textColorClass = "text-green-500";
-      const filterType =
-        condition.categoryFilterType || CategoryFilterType.INCLUDE;
-      const categoryFilters = condition.categoryFilters || [];
-
-      if (categoryFilters.length > 0 && categories && categories.length > 0) {
-        const categoryNames = categoryFilters
-          .map((id) => {
-            const category = categories.find((cat) => cat.id === id);
-            return category ? capitalCase(category.name) : null;
-          })
-          .filter(Boolean)
-          .join(", ");
-
-        summaryContent = (
-          <>
-            <span>Category Condition</span>
-            <span className="mt-2 block text-muted-foreground">
-              {filterType === CategoryFilterType.INCLUDE ? "Match" : "Skip"}{" "}
-              categories: {categoryNames || "Unknown"}
-            </span>
-          </>
-        );
-      } else {
-        summaryContent = "Category Condition (no categories selected)";
-      }
-      break;
-    }
-
     default:
       summaryContent = `${condition.type} Condition`;
   }

apps/web/app/(app)/[emailAccountId]/assistant/ExecutedRulesTable.tsx

@@ -1,6 +1,6 @@
 import Link from "next/link";
 import { ExternalLinkIcon, EyeIcon } from "lucide-react";
-import type { PlanHistoryResponse } from "@/app/api/user/planned/history/route";
+import type { GetExecutedRulesResponse } from "@/app/api/user/executed-rules/history/route";
 import { decodeSnippet } from "@/utils/gmail/decode";
 import { ActionBadgeExpanded } from "@/components/PlanBadge";
 import { Tooltip } from "@/components/Tooltip";
@@ -63,12 +63,14 @@ export function EmailCell({
 
 export function RuleCell({
   rule,
+  executedAt,
   status,
   reason,
   message,
   setInput,
 }: {
-  rule: PlanHistoryResponse["executedRules"][number]["rule"];
+  rule: GetExecutedRulesResponse["executedRules"][number]["rule"];
+  executedAt: Date;
   status: ExecutedRuleStatus;
   reason?: string | null;
   message: ParsedMessage;
@@ -136,7 +138,7 @@ export function RuleCell({
       <FixWithChat
         setInput={setInput}
         message={message}
-        result={{ rule, reason }}
+        results={[{ rule, reason, createdAt: executedAt }]}
       />
       <RuleDialogComponent />
     </div>
@@ -147,7 +149,7 @@ export function ActionItemsCell({
   actionItems,
   provider,
 }: {
-  actionItems: PlanHistoryResponse["executedRules"][number]["actionItems"];
+  actionItems: GetExecutedRulesResponse["executedRules"][number]["actionItems"];
   provider: string;
 }) {
   return (

apps/web/app/(app)/[emailAccountId]/assistant/FixWithChat.tsx

@@ -1,9 +1,8 @@
 import { MessageCircleIcon } from "lucide-react";
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { Button } from "@/components/ui/button";
 import type { ParsedMessage } from "@/utils/types";
 import type { RunRulesResult } from "@/utils/ai/choose-rule/run-rules";
-import { truncate } from "@/utils/string";
 import {
   Dialog,
   DialogContent,
@@ -23,15 +22,21 @@ import { NONE_RULE_ID } from "@/app/(app)/[emailAccountId]/assistant/consts";
 import { useSidebar } from "@/components/ui/sidebar";
 import { Textarea } from "@/components/ui/textarea";
 import { Badge } from "@/components/ui/badge";
+import { useChat } from "@/providers/ChatProvider";
+import {
+  NEW_RULE_ID as CONST_NEW_RULE_ID,
+  NONE_RULE_ID as CONST_NONE_RULE_ID,
+} from "@/app/(app)/[emailAccountId]/assistant/consts";
+import type { MessageContext } from "@/app/api/chat/validation";
 
 export function FixWithChat({
   setInput,
   message,
-  result,
+  results,
 }: {
   setInput: (input: string) => void;
   message: ParsedMessage;
-  result: RunRulesResult | null;
+  results: RunRulesResult[];
 }) {
   const { data, isLoading, error } = useRules();
   const { isModalOpen, setIsModalOpen } = useModal();
@@ -40,6 +45,14 @@ export function FixWithChat({
   const [showExplanation, setShowExplanation] = useState(false);
 
   const { setOpen } = useSidebar();
+  const { setContext } = useChat();
+
+  const selectedRuleName = useMemo(() => {
+    if (!data) return null;
+    if (selectedRuleId === NEW_RULE_ID) return "New rule";
+    if (selectedRuleId === NONE_RULE_ID) return "None";
+    return data.find((r) => r.id === selectedRuleId)?.name ?? null;
+  }, [data, selectedRuleId]);
 
   const handleRuleSelect = (ruleId: string | null) => {
     setSelectedRuleId(ruleId);
@@ -50,24 +63,55 @@ export function FixWithChat({
     if (!selectedRuleId) return;
 
     let input: string;
-    if (selectedRuleId === NEW_RULE_ID) {
-      input = getFixMessage({
-        message,
-        result,
-        expectedRuleName: NEW_RULE_ID,
-        explanation,
-      });
+
+    if (selectedRuleId === CONST_NEW_RULE_ID) {
+      input = explanation?.trim()
+        ? `Create a new rule for emails like this: ${explanation.trim()}`
+        : "Create a new rule for emails like this: ";
+    } else if (selectedRuleId === CONST_NONE_RULE_ID) {
+      input = explanation?.trim()
+        ? `This email shouldn't have matched any rule because ${explanation.trim()}`
+        : "This email shouldn't have matched any rule because ";
     } else {
-      const expectedRule = data?.find((rule) => rule.id === selectedRuleId);
-
-      input = getFixMessage({
-        message,
-        result,
-        expectedRuleName: expectedRule?.name ?? null,
-        explanation,
-      });
+      const rulePart = selectedRuleName
+        ? `the "${selectedRuleName}" rule`
+        : "a different rule";
+      input = explanation?.trim()
+        ? `This email should have matched ${rulePart} because ${explanation.trim()}`
+        : `This email should have matched ${rulePart} because `;
     }
 
+    const context: MessageContext = {
+      type: "fix-rule",
+      message: {
+        id: message.id,
+        threadId: message.threadId,
+        snippet: message.snippet,
+        textPlain: message.textPlain,
+        textHtml: message.textHtml,
+        headers: {
+          from: message.headers.from,
+          to: message.headers.to,
+          subject: message.headers.subject,
+          cc: message.headers.cc,
+          date: message.headers.date,
+          "reply-to": message.headers["reply-to"],
+        },
+        internalDate: message.internalDate,
+      },
+      results: results.map((r) => ({
+        ruleName: r.rule?.name ?? null,
+        reason: r.reason ?? "",
+      })),
+      expected:
+        selectedRuleId === CONST_NEW_RULE_ID
+          ? "new"
+          : selectedRuleId === CONST_NONE_RULE_ID
+            ? "none"
+            : { name: selectedRuleName || "Unknown" },
+    };
+    setContext(context);
+
     setInput(input);
     setOpen((arr) => [...arr, "chat-sidebar"]);
     setIsModalOpen(false);
@@ -105,7 +149,7 @@ export function FixWithChat({
         <LoadingContent loading={isLoading} error={error}>
           {data && !showExplanation ? (
             <RuleMismatch
-              result={result}
+              results={results}
               rules={data}
               onSelectExpectedRuleId={handleRuleSelect}
             />
@@ -165,61 +209,21 @@ export function FixWithChat({
   );
 }
 
-function getFixMessage({
-  message,
-  result,
-  expectedRuleName,
-  explanation,
-}: {
-  message: ParsedMessage;
-  result: RunRulesResult | null;
-  expectedRuleName: string | null;
-  explanation?: string;
-}) {
-  // Truncate content if it's too long
-  // TODO: HTML text / text plain
-  const getMessageContent = () => {
-    const content = message.snippet || message.textPlain || "";
-    return truncate(content, 500).trim();
-  };
-
-  return `You applied the wrong rule to this email.
-Fix our rules so this type of email is handled correctly in the future.
-
-Email details:
-*From*: ${message.headers.from}
-*Subject*: ${message.headers.subject}
-*Content*: ${getMessageContent()}
-
-Current rule applied: ${result?.rule?.name || "No rule"}
-
-Reason the rule was chosen:
-${result?.reason || "-"}
-
-${
-  expectedRuleName === NEW_RULE_ID
-    ? "I'd like to create a new rule to handle this type of email."
-    : expectedRuleName
-      ? `The rule that should have been applied was: "${expectedRuleName}"`
-      : "Instead, no rule should have been applied."
-}${explanation ? `\n\nExplanation: ${explanation}` : ""}`.trim();
-}
-
 function RuleMismatch({
-  result,
+  results,
   rules,
   onSelectExpectedRuleId,
 }: {
-  result: RunRulesResult | null;
+  results: RunRulesResult[];
   rules: RulesResponse;
   onSelectExpectedRuleId: (ruleId: string | null) => void;
 }) {
   return (
     <div>
       <Label name="matchedRule" label="Matched:" />
       <div className="mt-1">
-        {result ? (
-          <ProcessResultDisplay result={result} />
+        {results.length > 0 ? (
+          <ProcessResultDisplay results={results} />
         ) : (
           <p>No rule matched</p>
         )}

apps/web/app/(app)/[emailAccountId]/assistant/History.tsx

@@ -1,9 +1,8 @@
 "use client";
 
-import useSWR from "swr";
 import { useQueryState, parseAsInteger, parseAsString } from "nuqs";
 import { LoadingContent } from "@/components/LoadingContent";
-import type { PlanHistoryResponse } from "@/app/api/user/planned/history/route";
+import type { GetExecutedRulesResponse } from "@/app/api/user/executed-rules/history/route";
 import { AlertBasic } from "@/components/Alert";
 import { Card } from "@/components/ui/card";
 import {
@@ -23,14 +22,13 @@ import { Badge } from "@/components/Badge";
 import { RulesSelect } from "@/app/(app)/[emailAccountId]/assistant/RulesSelect";
 import { useAccount } from "@/providers/EmailAccountProvider";
 import { useChat } from "@/providers/ChatProvider";
+import { useExecutedRules } from "@/hooks/useExecutedRules";
 
 export function History() {
   const [page] = useQueryState("page", parseAsInteger.withDefault(1));
   const [ruleId] = useQueryState("ruleId", parseAsString.withDefault("all"));
 
-  const { data, isLoading, error } = useSWR<PlanHistoryResponse>(
-    `/api/user/planned/history?page=${page}&ruleId=${ruleId}`,
-  );
+  const { data, isLoading, error } = useExecutedRules({ page, ruleId });
 
   return (
     <>
@@ -62,7 +60,7 @@ function HistoryTable({
   data,
   totalPages,
 }: {
-  data: PlanHistoryResponse["executedRules"];
+  data: GetExecutedRulesResponse["executedRules"];
   totalPages: number;
 }) {
   const { userEmail } = useAccount();
@@ -78,30 +76,31 @@ function HistoryTable({
           </TableRow>
         </TableHeader>
         <TableBody>
-          {data.map((p) => (
-            <TableRow key={p.id}>
+          {data.map((er) => (
+            <TableRow key={er.id}>
               <TableCell>
                 <EmailCell
-                  from={p.message.headers.from}
-                  subject={p.message.headers.subject}
-                  snippet={p.message.snippet}
-                  threadId={p.message.threadId}
-                  messageId={p.message.id}
+                  from={er.message.headers.from}
+                  subject={er.message.headers.subject}
+                  snippet={er.message.snippet}
+                  threadId={er.message.threadId}
+                  messageId={er.message.id}
                   userEmail={userEmail}
-                  createdAt={p.createdAt}
+                  createdAt={er.createdAt}
                 />
-                {!p.automated && (
+                {!er.automated && (
                   <Badge color="yellow" className="mt-2">
                     Applied manually
                   </Badge>
                 )}
               </TableCell>
               <TableCell>
                 <RuleCell
-                  rule={p.rule}
-                  status={p.status}
-                  reason={p.reason}
-                  message={p.message}
+                  rule={er.rule}
+                  executedAt={er.createdAt}
+                  status={er.status}
+                  reason={er.reason}
+                  message={er.message}
                   setInput={setInput}
                 />
                 {/* <ActionItemsCell actionItems={p.actionItems} /> */}