feat: add generic method to fetch issues by project, document and status

- Add findByProjectDocumentAndStatus method to IssuesRepository
- Method accepts IssueStatus parameter (active/inactive) for flexibility
- Implement buildStatusCondition helper to build SQL conditions based on status
- Update filterOutInactiveCandidates to use the new generic method
- Remove unused imports from discover.ts

Author: geclos

packages/core/src/repositories/issuesRepository.ts

@@ -227,6 +227,29 @@ export class IssuesRepository extends Repository<Issue> {
       .limit(20)
   }
 
+  async findByProjectDocumentAndStatus({
+    project,
+    documentUuid,
+    status,
+  }: {
+    project: Project
+    documentUuid: string
+    status: IssueGroup
+  }) {
+    const statusCondition = this.buildGroupConditions(status)
+    return this.db
+      .select({ uuid: issues.uuid })
+      .from(issues)
+      .where(
+        and(
+          this.scopeFilter,
+          eq(issues.projectId, project.id),
+          eq(issues.documentUuid, documentUuid),
+          statusCondition,
+        ),
+      )
+  }
+
   async fetchIssuesFiltered({
     project,
     commit,

packages/core/src/services/issues/discover.test.ts

@@ -4,11 +4,14 @@ import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
 import { SpanType } from '../../constants'
 import { createEvaluationResultV2 } from '../../tests/factories/evaluationResultsV2'
 import { createEvaluationV2 } from '../../tests/factories/evaluationsV2'
+import { createIssue } from '../../tests/factories/issues'
 import { createProject } from '../../tests/factories/projects'
 import { createSpan } from '../../tests/factories/spans'
+import { createUser } from '../../tests/factories/users'
 import { createWorkspace } from '../../tests/factories/workspaces'
 import * as weaviate from '../../weaviate'
 import { discoverIssue } from './discover'
+import { ignoreIssue } from './ignore'
 import * as sharedModule from './shared'
 
 vi.mock('../../voyage', () => ({
@@ -383,5 +386,124 @@ describe('discoverIssue', () => {
       expect(embedding).toBeDefined()
       expect(issue).toBeUndefined()
     })
+
+    it('filters out inactive candidates from discovery results', async () => {
+      const { workspace } = await createWorkspace({ features: ['issues'] })
+      const projectResult = await createProject({
+        workspace,
+        documents: {
+          'test-prompt': 'This is a test prompt',
+        },
+      })
+      const { project, commit, documents } = projectResult
+      const document = documents[0]!
+
+      const evaluation = await createEvaluationV2({
+        document,
+        commit,
+        workspace,
+      })
+
+      const span = await createSpan({
+        workspaceId: workspace.id,
+        documentUuid: document.documentUuid,
+        commitUuid: commit.uuid,
+        type: SpanType.Prompt,
+      })
+
+      const result = await createEvaluationResultV2({
+        evaluation,
+        span,
+        commit,
+        workspace,
+        hasPassed: false,
+      })
+
+      // Create an active issue
+      const { issue: activeIssue } = await createIssue({
+        workspace,
+        project,
+        document,
+        createdAt: new Date(),
+        histograms: [
+          {
+            commitId: commit.id,
+            date: new Date(),
+            count: 1,
+          },
+        ],
+      })
+
+      // Create an inactive issue (ignored)
+      const { issue: inactiveIssue } = await createIssue({
+        workspace,
+        project,
+        document,
+        createdAt: new Date(),
+        histograms: [
+          {
+            commitId: commit.id,
+            date: new Date(),
+            count: 1,
+          },
+        ],
+      })
+
+      const user = await createUser()
+      await ignoreIssue({ issue: inactiveIssue, user }).then((r) => r.unwrap())
+
+      const mockEmbedding = Array(2048).fill(0.1)
+      vi.spyOn(sharedModule, 'embedReason').mockResolvedValue({
+        ok: true,
+        value: mockEmbedding,
+        unwrap: () => mockEmbedding,
+      } as any)
+
+      // Mock Weaviate to return both active and inactive issues as candidates
+      const mockHybrid = vi.fn().mockResolvedValue({
+        objects: [
+          {
+            uuid: activeIssue.uuid,
+            properties: {
+              title: activeIssue.title,
+              description: activeIssue.description,
+            },
+            metadata: { score: 0.95 },
+          },
+          {
+            uuid: inactiveIssue.uuid,
+            properties: {
+              title: inactiveIssue.title,
+              description: inactiveIssue.description,
+            },
+            metadata: { score: 0.9 },
+          },
+        ],
+      })
+
+      const mockCollection = {
+        query: {
+          hybrid: mockHybrid,
+        },
+      }
+
+      vi.spyOn(weaviate, 'getIssuesCollection').mockResolvedValue(
+        mockCollection as any,
+      )
+
+      const discovering = await discoverIssue({
+        result: { result, evaluation },
+        document,
+        project,
+      })
+
+      expect(discovering.error).toBeFalsy()
+      const { embedding, issue } = discovering.unwrap()
+      expect(embedding).toBeDefined()
+      // Should only return the active issue, not the inactive one
+      expect(issue).toBeDefined()
+      expect(issue?.uuid).toBe(activeIssue.uuid)
+      expect(issue?.uuid).not.toBe(inactiveIssue.uuid)
+    })
   })
 })

packages/core/src/services/issues/discover.ts

@@ -19,6 +19,7 @@ import {
 import { UnprocessableEntityError } from '../../lib/errors'
 import { hashContent } from '../../lib/hashContent'
 import { Result, TypedResult } from '../../lib/Result'
+import { IssuesRepository } from '../../repositories'
 import { type DocumentVersion } from '../../schema/models/types/DocumentVersion'
 import { type Project } from '../../schema/models/types/Project'
 import { type ResultWithEvaluationV2 } from '../../schema/types'
@@ -76,7 +77,12 @@ export async function discoverIssue<
 
   embedding = normalizeEmbedding(embedding)
 
-  const finding = await findCandidates({ reason, embedding, document, project })
+  const finding = await findCandidates({
+    reason,
+    embedding,
+    document,
+    project,
+  })
   if (finding.error) {
     return Result.error(finding.error)
   }
@@ -114,11 +120,23 @@ async function findCandidates({
   document: DocumentVersion
   project: Project
 }) {
+  async function filterOutInactiveCandidates(
+    candidates: IssueCandidate[],
+  ): Promise<IssueCandidate[]> {
+    const issuesRepo = new IssuesRepository(project.workspaceId)
+    const inactiveIssues = await issuesRepo.findByProjectDocumentAndStatus({
+      project,
+      documentUuid: document.documentUuid,
+      status: 'inactive',
+    })
+    const inactiveUuids = new Set(inactiveIssues.map((issue) => issue.uuid))
+    return candidates.filter((candidate) => !inactiveUuids.has(candidate.uuid))
+  }
+
   try {
     const tenantName = ISSUES_COLLECTION_TENANT_NAME(project.workspaceId, project.id, document.documentUuid) // prettier-ignore
-    const issues = await getIssuesCollection({ tenantName })
-
-    const { objects } = await issues.query.hybrid(reason, {
+    const issuesCollection = await getIssuesCollection({ tenantName })
+    const { objects } = await issuesCollection.query.hybrid(reason, {
       vector: embedding,
       alpha: ISSUE_DISCOVERY_SEARCH_RATIO,
       maxVectorDistance: 1 - ISSUE_DISCOVERY_MIN_SIMILARITY,
@@ -130,7 +148,6 @@ async function findCandidates({
       returnProperties: ['title', 'description'],
       returnMetadata: ['score'],
     })
-
     const candidates = objects
       .map((object) => ({
         uuid: object.uuid,
@@ -139,8 +156,11 @@ async function findCandidates({
         score: object.metadata!.score!,
       }))
       .slice(0, ISSUE_DISCOVERY_MAX_CANDIDATES)
+    if (candidates.length === 0) return Result.ok<IssueCandidate[]>([])
 
-    return Result.ok<IssueCandidate[]>(candidates)
+    const activeCandidates = await filterOutInactiveCandidates(candidates)
+
+    return Result.ok<IssueCandidate[]>(activeCandidates)
   } catch (error) {
     return Result.error(error as Error)
   }