Multi condition supports. Allow smart categories in rules

.github/workflows/test.yml

@@ -0,0 +1,50 @@
+name: Run Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
+        with:
+          version: 8
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=\"$(pnpm store path --silent)\"" >> $GITHUB_ENV
+
+      - uses: actions/cache@v4
+        name: Setup pnpm cache
+        with:
+          path: ~/.pnpm-store
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Run tests
+        run: pnpm -F inbox-zero-ai test
+        env:
+          RUN_AI_TESTS: false
+          DATABASE_URL: "postgresql://postgres:postgres@localhost:5432/postgres"
+          NEXTAUTH_SECRET: "secret"
+          GOOGLE_CLIENT_ID: "client_id"
+          GOOGLE_CLIENT_SECRET: "client_secret"
+          GOOGLE_PUBSUB_TOPIC_NAME: "topic"

apps/web/__tests__/ai-categorize-senders.test.ts

@@ -6,9 +6,12 @@ import {
 import { defaultCategory } from "@/utils/categories";
 import { aiCategorizeSender } from "@/utils/ai/categorize-sender/ai-categorize-single-sender";
 
+// pnpm test-ai ai-categorize-senders
+
+const isAiTest = process.env.RUN_AI_TESTS === "true";
+
 vi.mock("server-only", () => ({}));
 
-// Test data setup
 const testUser = {
   email: "user@test.com",
   aiProvider: null,
@@ -44,7 +47,7 @@ const testSenders = [
   },
 ];
 
-describe("AI Sender Categorization", () => {
+describe.skipIf(!isAiTest)("AI Sender Categorization", () => {
   describe("Bulk Categorization", () => {
     it("should categorize senders with snippets using AI", async () => {
       const result = await aiCategorizeSenders({
@@ -125,7 +128,7 @@ describe("AI Sender Categorization", () => {
           expect(result?.category).toBe(expectedCategory);
         }
       }
-    }, 15_000);
+    }, 30_000);
 
     it("should handle unknown sender appropriately", async () => {
       const unknownSender = testSenders.find(

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

@@ -1,10 +1,15 @@
 import { describe, expect, test, vi } from "vitest";
 import { getActionItemsWithAiArgs } from "@/utils/ai/choose-rule/ai-choose-args";
-import { type Action, ActionType, RuleType } from "@prisma/client";
+import { type Action, ActionType, LogicalOperator } from "@prisma/client";
+import type { RuleWithActions } from "@/utils/types";
+
+// pnpm test-ai ai-choose-args
+
+const isAiTest = process.env.RUN_AI_TESTS === "true";
 
 vi.mock("server-only", () => ({}));
 
-describe("getActionItemsWithAiArgs", () => {
+describe.skipIf(!isAiTest)("getActionItemsWithAiArgs", () => {
   test("should return actions unchanged when no AI args needed", async () => {
     const actions = [getAction({})];
     const rule = getRule("Test rule", actions);
@@ -167,7 +172,10 @@ function getAction(action: Partial<Action> = {}): Action {
   };
 }
 
-function getRule(instructions: string, actions: Action[] = []) {
+function getRule(
+  instructions: string,
+  actions: Action[] = [],
+): RuleWithActions {
   return {
     instructions,
     name: "Test Rule",
@@ -183,9 +191,10 @@ function getRule(instructions: string, actions: Action[] = []) {
     subject: null,
     body: null,
     to: null,
-    type: RuleType.AI,
     enabled: true,
     categoryFilterType: null,
+    conditionalOperator: LogicalOperator.AND,
+    type: null,
   };
 }
 

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

@@ -1,114 +1,101 @@
-import { expect, test, vi } from "vitest";
-import { chooseRule } from "@/utils/ai/choose-rule/choose";
-import { type Action, ActionType, RuleType } from "@prisma/client";
+import { describe, expect, test, vi } from "vitest";
+import { aiChooseRule } from "@/utils/ai/choose-rule/ai-choose-rule";
+import { type Action, ActionType, LogicalOperator } from "@prisma/client";
 
-vi.mock("server-only", () => ({}));
-
-test("Should return no rule when no rules passed", async () => {
-  const result = await chooseRule({
-    rules: [],
-    email: getEmail(),
-    user: getUser(),
-  });
-
-  expect(result).toEqual({ reason: "No rules" });
-});
+// pnpm test-ai ai-choose-rule
 
-test("Should return correct rule when only one rule passed", async () => {
-  const rule = getRule(
-    "Match emails that have the word 'test' in the subject line",
-  );
+const isAiTest = process.env.RUN_AI_TESTS === "true";
 
-  const result = await chooseRule({
-    email: getEmail({ subject: "test" }),
-    rules: [rule],
-    user: getUser(),
-  });
+vi.mock("server-only", () => ({}));
 
-  expect(result).toEqual({ rule, reason: expect.any(String), actionItems: [] });
-});
+describe.skipIf(!isAiTest)("aiChooseRule", () => {
+  test("Should return no rule when no rules passed", async () => {
+    const result = await aiChooseRule({
+      rules: [],
+      email: getEmail(),
+      user: getUser(),
+    });
 
-test("Should return correct rule when multiple rules passed", async () => {
-  const rule1 = getRule(
-    "Match emails that have the word 'test' in the subject line",
-  );
-  const rule2 = getRule(
-    "Match emails that have the word 'remember' in the subject line",
-  );
-
-  const result = await chooseRule({
-    rules: [rule1, rule2],
-    email: getEmail({ subject: "remember that call" }),
-    user: getUser(),
+    expect(result).toEqual({ reason: "No rules" });
   });
 
-  expect(result).toEqual({
-    rule: rule2,
-    reason: expect.any(String),
-    actionItems: [],
+  test("Should return correct rule when only one rule passed", async () => {
+    const rule = getRule(
+      "Match emails that have the word 'test' in the subject line",
+    );
+
+    const result = await aiChooseRule({
+      email: getEmail({ subject: "test" }),
+      rules: [rule],
+      user: getUser(),
+    });
+
+    expect(result).toEqual({
+      rule,
+      reason: expect.any(String),
+    });
   });
-});
 
-test("Should generate action arguments", async () => {
-  const rule1 = getRule(
-    "Match emails that have the word 'question' in the subject line",
-  );
-  const rule2 = getRule("Match emails asking for a joke", [
-    {
-      id: "id",
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      type: ActionType.REPLY,
-      ruleId: "ruleId",
-      label: null,
-      subject: null,
-      content: "{{Write a joke}}",
-      to: null,
-      cc: null,
-      bcc: null,
-
-      labelPrompt: null,
-      subjectPrompt: null,
-      contentPrompt: null,
-      toPrompt: null,
-      ccPrompt: null,
-      bccPrompt: null,
-    },
-  ]);
-
-  const result = await chooseRule({
-    rules: [rule1, rule2],
-    email: getEmail({ subject: "Joke", content: "Tell me a joke about sheep" }),
-    user: getUser(),
+  test("Should return correct rule when multiple rules passed", async () => {
+    const rule1 = getRule(
+      "Match emails that have the word 'test' in the subject line",
+    );
+    const rule2 = getRule(
+      "Match emails that have the word 'remember' in the subject line",
+    );
+
+    const result = await aiChooseRule({
+      rules: [rule1, rule2],
+      email: getEmail({ subject: "remember that call" }),
+      user: getUser(),
+    });
+
+    expect(result).toEqual({
+      rule: rule2,
+      reason: expect.any(String),
+    });
   });
 
-  console.debug("Generated content:\n", result.actionItems?.[0].content);
-
-  expect(result).toEqual({
-    rule: rule2,
-    reason: expect.any(String),
-    actionItems: [
+  test("Should generate action arguments", async () => {
+    const rule1 = getRule(
+      "Match emails that have the word 'question' in the subject line",
+    );
+    const rule2 = getRule("Match emails asking for a joke", [
       {
-        bcc: null,
-        cc: null,
-        content: expect.any(String),
+        id: "id",
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        type: ActionType.REPLY,
+        ruleId: "ruleId",
         label: null,
         subject: null,
+        content: "{{Write a joke}}",
         to: null,
-        type: "REPLY",
+        cc: null,
+        bcc: null,
 
         labelPrompt: null,
         subjectPrompt: null,
         contentPrompt: null,
         toPrompt: null,
         ccPrompt: null,
         bccPrompt: null,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        id: "id",
-        ruleId: "ruleId",
       },
-    ],
+    ]);
+
+    const result = await aiChooseRule({
+      rules: [rule1, rule2],
+      email: getEmail({
+        subject: "Joke",
+        content: "Tell me a joke about sheep",
+      }),
+      user: getUser(),
+    });
+
+    expect(result).toEqual({
+      rule: rule2,
+      reason: expect.any(String),
+    });
   });
 });
 
@@ -129,9 +116,9 @@ function getRule(instructions: string, actions: Action[] = []) {
     subject: null,
     body: null,
     to: null,
-    type: RuleType.AI,
     enabled: true,
     categoryFilterType: null,
+    conditionalOperator: LogicalOperator.AND,
   };
 }
 

apps/web/__tests__/ai-create-group.test.ts

@@ -4,12 +4,16 @@ import { aiGenerateGroupItems } from "@/utils/ai/group/create-group";
 import { queryBatchMessages } from "@/utils/gmail/message";
 import type { ParsedMessage } from "@/utils/types";
 
+// pnpm test-ai ai-create-group
+
+const isAiTest = process.env.RUN_AI_TESTS === "true";
+
 vi.mock("server-only", () => ({}));
 vi.mock("@/utils/gmail/message", () => ({
   queryBatchMessages: vi.fn(),
 }));
 
-describe("aiGenerateGroupItems", () => {
+describe.skipIf(!isAiTest)("aiGenerateGroupItems", () => {
   it("should generate group items based on user prompt", async () => {
     const user = {
       email: "user@test.com",

apps/web/__tests__/ai-diff-rules.test.ts

@@ -1,9 +1,13 @@
 import { describe, it, expect, vi } from "vitest";
 import { aiDiffRules } from "@/utils/ai/rule/diff-rules";
 
+// pnpm test-ai ai-diff-rules
+
+const isAiTest = process.env.RUN_AI_TESTS === "true";
+
 vi.mock("server-only", () => ({}));
 
-describe("aiDiffRules", () => {
+describe.skipIf(!isAiTest)("aiDiffRules", () => {
   it("should correctly identify added, edited, and removed rules", async () => {
     const user = {
       email: "user@test.com",

apps/web/__tests__/ai-example-matches.test.ts

@@ -5,12 +5,16 @@ import { queryBatchMessages } from "@/utils/gmail/message";
 import type { ParsedMessage } from "@/utils/types";
 import { findExampleMatchesSchema } from "@/utils/ai/example-matches/find-example-matches";
 
+// pnpm test-ai ai-find-example-matches
+
+const isAiTest = process.env.RUN_AI_TESTS === "true";
+
 vi.mock("server-only", () => ({}));
 vi.mock("@/utils/gmail/message", () => ({
   queryBatchMessages: vi.fn(),
 }));
 
-describe("aiFindExampleMatches", () => {
+describe.skipIf(!isAiTest)("aiFindExampleMatches", () => {
   it("should find example matches based on user prompt", async () => {
     const user = {
       email: "user@test.com",

apps/web/__tests__/ai-find-snippets.test.ts

@@ -2,11 +2,13 @@ import { describe, expect, test, vi } from "vitest";
 import { aiFindSnippets } from "@/utils/ai/snippets/find-snippets";
 import type { EmailForLLM } from "@/utils/ai/choose-rule/stringify-email";
 
-// pnpm test ai-find-snippets
+// pnpm test-ai ai-find-snippets
+
+const isAiTest = process.env.RUN_AI_TESTS === "true";
 
 vi.mock("server-only", () => ({}));
 
-describe("aiFindSnippets", () => {
+describe.skipIf(!isAiTest)("aiFindSnippets", () => {
   test("should find snippets in similar emails", async () => {
     const emails = [
       getEmail({