agent-relay 1.1.0 → 1.2.3

package/dist/cloud/db/drizzle.d.ts

@@ -6,7 +6,7 @@
  */
 import { Pool } from 'pg';
 import * as schema from './schema.js';
-export type { User, NewUser, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, } from './schema.js';
+export type { User, NewUser, GitHubInstallation, NewGitHubInstallation, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, AgentSession, NewAgentSession, AgentSummary, NewAgentSummary, } from './schema.js';
 export * from './schema.js';
 export declare function getDb(): import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
     $client: Pool;
@@ -16,10 +16,29 @@ export interface UserQueries {
     findByGithubId(githubId: string): Promise<schema.User | null>;
     findByGithubUsername(username: string): Promise<schema.User | null>;
     findByEmail(email: string): Promise<schema.User | null>;
+    findByNangoConnectionId(connectionId: string): Promise<schema.User | null>;
+    findByIncomingConnectionId(connectionId: string): Promise<schema.User | null>;
     upsert(data: schema.NewUser): Promise<schema.User>;
+    update(id: string, data: Partial<Omit<schema.User, 'id' | 'createdAt'>>): Promise<void>;
     completeOnboarding(userId: string): Promise<void>;
+    clearIncomingConnectionId(userId: string): Promise<void>;
+    setPendingInstallationRequest(userId: string): Promise<void>;
+    clearPendingInstallationRequest(userId: string): Promise<void>;
 }
 export declare const userQueries: UserQueries;
+export interface GitHubInstallationQueries {
+    findById(id: string): Promise<schema.GitHubInstallation | null>;
+    findByInstallationId(installationId: string): Promise<schema.GitHubInstallation | null>;
+    findByAccountLogin(accountLogin: string): Promise<schema.GitHubInstallation | null>;
+    findByInstalledBy(userId: string): Promise<schema.GitHubInstallation[]>;
+    findAll(): Promise<schema.GitHubInstallation[]>;
+    upsert(data: schema.NewGitHubInstallation): Promise<schema.GitHubInstallation>;
+    updatePermissions(installationId: string, permissions: Record<string, string>, events: string[]): Promise<void>;
+    suspend(installationId: string, suspendedBy: string): Promise<void>;
+    unsuspend(installationId: string): Promise<void>;
+    delete(installationId: string): Promise<void>;
+}
+export declare const githubInstallationQueries: GitHubInstallationQueries;
 export interface CredentialQueries {
     findByUserId(userId: string): Promise<schema.Credential[]>;
     findByUserAndProvider(userId: string, provider: string): Promise<schema.Credential | null>;
@@ -38,6 +57,7 @@ export interface WorkspaceQueries {
         publicUrl?: string;
         errorMessage?: string;
     }): Promise<void>;
+    updateConfig(id: string, config: schema.WorkspaceConfig): Promise<void>;
     setCustomDomain(id: string, customDomain: string, status?: string): Promise<void>;
     updateCustomDomainStatus(id: string, status: string): Promise<void>;
     removeCustomDomain(id: string): Promise<void>;
@@ -116,6 +136,7 @@ export interface ProjectGroupQueries {
 export declare const projectGroupQueries: ProjectGroupQueries;
 export interface RepositoryQueries {
     findById(id: string): Promise<schema.Repository | null>;
+    findByFullName(fullName: string): Promise<schema.Repository | null>;
     findByUserId(userId: string): Promise<schema.Repository[]>;
     findByWorkspaceId(workspaceId: string): Promise<schema.Repository[]>;
     findByProjectGroupId(projectGroupId: string): Promise<schema.Repository[]>;
@@ -127,6 +148,68 @@ export interface RepositoryQueries {
     delete(id: string): Promise<void>;
 }
 export declare const repositoryQueries: RepositoryQueries;
+export interface AgentSessionQueries {
+    findById(id: string): Promise<schema.AgentSession | null>;
+    findByWorkspaceId(workspaceId: string): Promise<schema.AgentSession[]>;
+    findActiveByWorkspace(workspaceId: string): Promise<schema.AgentSession[]>;
+    create(data: schema.NewAgentSession): Promise<schema.AgentSession>;
+    endSession(id: string, endMarker?: {
+        summary?: string;
+        completedTasks?: string[];
+    }): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const agentSessionQueries: AgentSessionQueries;
+export interface AgentSummaryQueries {
+    findBySessionId(sessionId: string): Promise<schema.AgentSummary[]>;
+    findLatestByAgent(agentName: string): Promise<schema.AgentSummary | null>;
+    create(data: schema.NewAgentSummary): Promise<schema.AgentSummary>;
+    deleteBySession(sessionId: string): Promise<void>;
+}
+export declare const agentSummaryQueries: AgentSummaryQueries;
+export interface CIFailureEventQueries {
+    findById(id: string): Promise<schema.CIFailureEvent | null>;
+    findByRepository(repository: string, limit?: number): Promise<schema.CIFailureEvent[]>;
+    findByPR(repository: string, prNumber: number): Promise<schema.CIFailureEvent[]>;
+    findRecentUnprocessed(limit?: number): Promise<schema.CIFailureEvent[]>;
+    create(data: schema.NewCIFailureEvent): Promise<schema.CIFailureEvent>;
+    markProcessed(id: string, agentSpawned: boolean): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const ciFailureEventQueries: CIFailureEventQueries;
+export interface CIFixAttemptQueries {
+    findById(id: string): Promise<schema.CIFixAttempt | null>;
+    findByFailureEvent(failureEventId: string): Promise<schema.CIFixAttempt[]>;
+    findActiveByRepository(repository: string): Promise<schema.CIFixAttempt[]>;
+    create(data: schema.NewCIFixAttempt): Promise<schema.CIFixAttempt>;
+    updateStatus(id: string, status: string, errorMessage?: string): Promise<void>;
+    complete(id: string, status: 'success' | 'failed', commitSha?: string, errorMessage?: string): Promise<void>;
+}
+export declare const ciFixAttemptQueries: CIFixAttemptQueries;
+export interface IssueAssignmentQueries {
+    findById(id: string): Promise<schema.IssueAssignment | null>;
+    findByRepository(repository: string, limit?: number): Promise<schema.IssueAssignment[]>;
+    findByIssue(repository: string, issueNumber: number): Promise<schema.IssueAssignment | null>;
+    findByAgent(agentId: string): Promise<schema.IssueAssignment[]>;
+    findPending(limit?: number): Promise<schema.IssueAssignment[]>;
+    create(data: schema.NewIssueAssignment): Promise<schema.IssueAssignment>;
+    assignAgent(id: string, agentId: string, agentName: string): Promise<void>;
+    updateStatus(id: string, status: string, resolution?: string): Promise<void>;
+    linkPR(id: string, prNumber: number): Promise<void>;
+}
+export declare const issueAssignmentQueries: IssueAssignmentQueries;
+export interface CommentMentionQueries {
+    findById(id: string): Promise<schema.CommentMention | null>;
+    findByRepository(repository: string, limit?: number): Promise<schema.CommentMention[]>;
+    findBySource(sourceType: string, sourceId: number): Promise<schema.CommentMention | null>;
+    findPending(limit?: number): Promise<schema.CommentMention[]>;
+    findByMentionedAgent(mentionedAgent: string, limit?: number): Promise<schema.CommentMention[]>;
+    create(data: schema.NewCommentMention): Promise<schema.CommentMention>;
+    markProcessing(id: string, agentId: string, agentName: string): Promise<void>;
+    markResponded(id: string, responseCommentId: number, responseBody: string): Promise<void>;
+    markIgnored(id: string): Promise<void>;
+}
+export declare const commentMentionQueries: CommentMentionQueries;
 export declare function runMigrations(): Promise<void>;
 export declare function closeDb(): Promise<void>;
 //# sourceMappingURL=drizzle.d.ts.map

package/dist/cloud/db/drizzle.js

@@ -48,6 +48,19 @@ export const userQueries = {
         const result = await db.select().from(schema.users).where(eq(schema.users.email, email));
         return result[0] ?? null;
     },
+    async findByNangoConnectionId(connectionId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.users)
+            .where(eq(schema.users.nangoConnectionId, connectionId));
+        return result[0] ?? null;
+    },
+    async findByIncomingConnectionId(connectionId) {
+        const db = getDb();
+        const result = await db.select().from(schema.users).where(eq(schema.users.incomingConnectionId, connectionId));
+        return result[0] ?? null;
+    },
     async upsert(data) {
         const db = getDb();
         const result = await db
@@ -72,6 +85,113 @@ export const userQueries = {
             .set({ onboardingCompletedAt: new Date(), updatedAt: new Date() })
             .where(eq(schema.users.id, userId));
     },
+    async update(id, data) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(schema.users.id, id));
+    },
+    async clearIncomingConnectionId(userId) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ incomingConnectionId: null, updatedAt: new Date() })
+            .where(eq(schema.users.id, userId));
+    },
+    async setPendingInstallationRequest(userId) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ pendingInstallationRequest: new Date(), updatedAt: new Date() })
+            .where(eq(schema.users.id, userId));
+    },
+    async clearPendingInstallationRequest(userId) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ pendingInstallationRequest: null, updatedAt: new Date() })
+            .where(eq(schema.users.id, userId));
+    },
+};
+export const githubInstallationQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.githubInstallations).where(eq(schema.githubInstallations.id, id));
+        return result[0] ?? null;
+    },
+    async findByInstallationId(installationId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.githubInstallations)
+            .where(eq(schema.githubInstallations.installationId, installationId));
+        return result[0] ?? null;
+    },
+    async findByAccountLogin(accountLogin) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.githubInstallations)
+            .where(eq(schema.githubInstallations.accountLogin, accountLogin));
+        return result[0] ?? null;
+    },
+    async findByInstalledBy(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.githubInstallations)
+            .where(eq(schema.githubInstallations.installedById, userId));
+    },
+    async findAll() {
+        const db = getDb();
+        return db.select().from(schema.githubInstallations).orderBy(schema.githubInstallations.accountLogin);
+    },
+    async upsert(data) {
+        const db = getDb();
+        const result = await db
+            .insert(schema.githubInstallations)
+            .values(data)
+            .onConflictDoUpdate({
+            target: schema.githubInstallations.installationId,
+            set: {
+                accountType: data.accountType,
+                accountLogin: data.accountLogin,
+                accountId: data.accountId,
+                permissions: data.permissions,
+                events: data.events,
+                installedById: data.installedById,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return result[0];
+    },
+    async updatePermissions(installationId, permissions, events) {
+        const db = getDb();
+        await db
+            .update(schema.githubInstallations)
+            .set({ permissions, events, updatedAt: new Date() })
+            .where(eq(schema.githubInstallations.installationId, installationId));
+    },
+    async suspend(installationId, suspendedBy) {
+        const db = getDb();
+        await db
+            .update(schema.githubInstallations)
+            .set({ suspended: true, suspendedAt: new Date(), suspendedBy, updatedAt: new Date() })
+            .where(eq(schema.githubInstallations.installationId, installationId));
+    },
+    async unsuspend(installationId) {
+        const db = getDb();
+        await db
+            .update(schema.githubInstallations)
+            .set({ suspended: false, suspendedAt: null, suspendedBy: null, updatedAt: new Date() })
+            .where(eq(schema.githubInstallations.installationId, installationId));
+    },
+    async delete(installationId) {
+        const db = getDb();
+        await db.delete(schema.githubInstallations).where(eq(schema.githubInstallations.installationId, installationId));
+    },
 };
 export const credentialQueries = {
     async findByUserId(userId) {
@@ -170,6 +290,16 @@ export const workspaceQueries = {
         })
             .where(eq(schema.workspaces.id, id));
     },
+    async updateConfig(id, config) {
+        const db = getDb();
+        await db
+            .update(schema.workspaces)
+            .set({
+            config,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.workspaces.id, id));
+    },
     async setCustomDomain(id, customDomain, status = 'pending') {
         const db = getDb();
         await db
@@ -514,6 +644,14 @@ export const repositoryQueries = {
         const result = await db.select().from(schema.repositories).where(eq(schema.repositories.id, id));
         return result[0] ?? null;
     },
+    async findByFullName(fullName) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.repositories)
+            .where(eq(schema.repositories.githubFullName, fullName));
+        return result[0] ?? null;
+    },
     async findByUserId(userId) {
         const db = getDb();
         return db
@@ -591,6 +729,338 @@ export const repositoryQueries = {
         await db.delete(schema.repositories).where(eq(schema.repositories.id, id));
     },
 };
+export const agentSessionQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.agentSessions).where(eq(schema.agentSessions.id, id));
+        return result[0] ?? null;
+    },
+    async findByWorkspaceId(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.agentSessions)
+            .where(eq(schema.agentSessions.workspaceId, workspaceId))
+            .orderBy(desc(schema.agentSessions.startedAt));
+    },
+    async findActiveByWorkspace(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.agentSessions)
+            .where(and(eq(schema.agentSessions.workspaceId, workspaceId), eq(schema.agentSessions.status, 'active')));
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.agentSessions).values(data).returning();
+        return result[0];
+    },
+    async endSession(id, endMarker) {
+        const db = getDb();
+        await db
+            .update(schema.agentSessions)
+            .set({
+            status: 'ended',
+            endedAt: new Date(),
+            endMarker: endMarker ?? null,
+        })
+            .where(eq(schema.agentSessions.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.agentSessions).where(eq(schema.agentSessions.id, id));
+    },
+};
+export const agentSummaryQueries = {
+    async findBySessionId(sessionId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.agentSummaries)
+            .where(eq(schema.agentSummaries.sessionId, sessionId))
+            .orderBy(schema.agentSummaries.createdAt);
+    },
+    async findLatestByAgent(agentName) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.agentSummaries)
+            .where(eq(schema.agentSummaries.agentName, agentName))
+            .orderBy(desc(schema.agentSummaries.createdAt))
+            .limit(1);
+        return result[0] ?? null;
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.agentSummaries).values(data).returning();
+        return result[0];
+    },
+    async deleteBySession(sessionId) {
+        const db = getDb();
+        await db.delete(schema.agentSummaries).where(eq(schema.agentSummaries.sessionId, sessionId));
+    },
+};
+export const ciFailureEventQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.ciFailureEvents).where(eq(schema.ciFailureEvents.id, id));
+        return result[0] ?? null;
+    },
+    async findByRepository(repository, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFailureEvents)
+            .where(eq(schema.ciFailureEvents.repository, repository))
+            .orderBy(desc(schema.ciFailureEvents.createdAt))
+            .limit(limit);
+    },
+    async findByPR(repository, prNumber) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFailureEvents)
+            .where(and(eq(schema.ciFailureEvents.repository, repository), eq(schema.ciFailureEvents.prNumber, prNumber)))
+            .orderBy(desc(schema.ciFailureEvents.createdAt));
+    },
+    async findRecentUnprocessed(limit = 100) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFailureEvents)
+            .where(isNull(schema.ciFailureEvents.processedAt))
+            .orderBy(schema.ciFailureEvents.createdAt)
+            .limit(limit);
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.ciFailureEvents).values(data).returning();
+        return result[0];
+    },
+    async markProcessed(id, agentSpawned) {
+        const db = getDb();
+        await db
+            .update(schema.ciFailureEvents)
+            .set({ processedAt: new Date(), agentSpawned })
+            .where(eq(schema.ciFailureEvents.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.ciFailureEvents).where(eq(schema.ciFailureEvents.id, id));
+    },
+};
+export const ciFixAttemptQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.ciFixAttempts).where(eq(schema.ciFixAttempts.id, id));
+        return result[0] ?? null;
+    },
+    async findByFailureEvent(failureEventId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFixAttempts)
+            .where(eq(schema.ciFixAttempts.failureEventId, failureEventId))
+            .orderBy(desc(schema.ciFixAttempts.startedAt));
+    },
+    async findActiveByRepository(repository) {
+        const db = getDb();
+        // Find active fix attempts by joining with failure events
+        return db
+            .select({
+            id: schema.ciFixAttempts.id,
+            failureEventId: schema.ciFixAttempts.failureEventId,
+            agentId: schema.ciFixAttempts.agentId,
+            agentName: schema.ciFixAttempts.agentName,
+            status: schema.ciFixAttempts.status,
+            commitSha: schema.ciFixAttempts.commitSha,
+            errorMessage: schema.ciFixAttempts.errorMessage,
+            startedAt: schema.ciFixAttempts.startedAt,
+            completedAt: schema.ciFixAttempts.completedAt,
+        })
+            .from(schema.ciFixAttempts)
+            .innerJoin(schema.ciFailureEvents, eq(schema.ciFixAttempts.failureEventId, schema.ciFailureEvents.id))
+            .where(and(eq(schema.ciFailureEvents.repository, repository), sql `${schema.ciFixAttempts.status} IN ('pending', 'in_progress')`));
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.ciFixAttempts).values(data).returning();
+        return result[0];
+    },
+    async updateStatus(id, status, errorMessage) {
+        const db = getDb();
+        const updates = { status };
+        if (errorMessage) {
+            updates.errorMessage = errorMessage;
+        }
+        await db
+            .update(schema.ciFixAttempts)
+            .set(updates)
+            .where(eq(schema.ciFixAttempts.id, id));
+    },
+    async complete(id, status, commitSha, errorMessage) {
+        const db = getDb();
+        await db
+            .update(schema.ciFixAttempts)
+            .set({
+            status,
+            completedAt: new Date(),
+            commitSha: commitSha ?? null,
+            errorMessage: errorMessage ?? null,
+        })
+            .where(eq(schema.ciFixAttempts.id, id));
+    },
+};
+export const issueAssignmentQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.issueAssignments).where(eq(schema.issueAssignments.id, id));
+        return result[0] ?? null;
+    },
+    async findByRepository(repository, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.issueAssignments)
+            .where(eq(schema.issueAssignments.repository, repository))
+            .orderBy(desc(schema.issueAssignments.createdAt))
+            .limit(limit);
+    },
+    async findByIssue(repository, issueNumber) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.issueAssignments)
+            .where(and(eq(schema.issueAssignments.repository, repository), eq(schema.issueAssignments.issueNumber, issueNumber)));
+        return result[0] ?? null;
+    },
+    async findByAgent(agentId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.issueAssignments)
+            .where(eq(schema.issueAssignments.agentId, agentId))
+            .orderBy(desc(schema.issueAssignments.createdAt));
+    },
+    async findPending(limit = 100) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.issueAssignments)
+            .where(eq(schema.issueAssignments.status, 'pending'))
+            .orderBy(schema.issueAssignments.createdAt)
+            .limit(limit);
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.issueAssignments).values(data).returning();
+        return result[0];
+    },
+    async assignAgent(id, agentId, agentName) {
+        const db = getDb();
+        await db
+            .update(schema.issueAssignments)
+            .set({
+            agentId,
+            agentName,
+            assignedAt: new Date(),
+            status: 'assigned',
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.issueAssignments.id, id));
+    },
+    async updateStatus(id, status, resolution) {
+        const db = getDb();
+        const updates = { status, updatedAt: new Date() };
+        if (resolution) {
+            updates.resolution = resolution;
+        }
+        await db
+            .update(schema.issueAssignments)
+            .set(updates)
+            .where(eq(schema.issueAssignments.id, id));
+    },
+    async linkPR(id, prNumber) {
+        const db = getDb();
+        await db
+            .update(schema.issueAssignments)
+            .set({ linkedPrNumber: prNumber, updatedAt: new Date() })
+            .where(eq(schema.issueAssignments.id, id));
+    },
+};
+export const commentMentionQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.commentMentions).where(eq(schema.commentMentions.id, id));
+        return result[0] ?? null;
+    },
+    async findByRepository(repository, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.commentMentions)
+            .where(eq(schema.commentMentions.repository, repository))
+            .orderBy(desc(schema.commentMentions.createdAt))
+            .limit(limit);
+    },
+    async findBySource(sourceType, sourceId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.commentMentions)
+            .where(and(eq(schema.commentMentions.sourceType, sourceType), eq(schema.commentMentions.sourceId, sourceId)));
+        return result[0] ?? null;
+    },
+    async findPending(limit = 100) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.commentMentions)
+            .where(eq(schema.commentMentions.status, 'pending'))
+            .orderBy(schema.commentMentions.createdAt)
+            .limit(limit);
+    },
+    async findByMentionedAgent(mentionedAgent, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.commentMentions)
+            .where(eq(schema.commentMentions.mentionedAgent, mentionedAgent))
+            .orderBy(desc(schema.commentMentions.createdAt))
+            .limit(limit);
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.commentMentions).values(data).returning();
+        return result[0];
+    },
+    async markProcessing(id, agentId, agentName) {
+        const db = getDb();
+        await db
+            .update(schema.commentMentions)
+            .set({ status: 'processing', agentId, agentName })
+            .where(eq(schema.commentMentions.id, id));
+    },
+    async markResponded(id, responseCommentId, responseBody) {
+        const db = getDb();
+        await db
+            .update(schema.commentMentions)
+            .set({
+            status: 'responded',
+            responseCommentId,
+            responseBody,
+            respondedAt: new Date(),
+        })
+            .where(eq(schema.commentMentions.id, id));
+    },
+    async markIgnored(id) {
+        const db = getDb();
+        await db
+            .update(schema.commentMentions)
+            .set({ status: 'ignored' })
+            .where(eq(schema.commentMentions.id, id));
+    },
+};
 // ============================================================================
 // Migration helper
 // ============================================================================

package/dist/cloud/db/index.d.ts

@@ -7,24 +7,29 @@
  * Generate migrations: npm run db:generate
  * Run migrations: npm run db:migrate
  */
-export type { User, NewUser, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, } from './schema.js';
-export { users as usersTable, credentials as credentialsTable, workspaces as workspacesTable, workspaceMembers as workspaceMembersTable, projectGroups as projectGroupsTable, repositories as repositoriesTable, linkedDaemons as linkedDaemonsTable, subscriptions as subscriptionsTable, usageRecords as usageRecordsTable, } from './schema.js';
-import { getDb, closeDb, runMigrations, userQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, linkedDaemonQueries, projectGroupQueries, repositoryQueries } from './drizzle.js';
+export type { User, NewUser, GitHubInstallation, NewGitHubInstallation, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceAgentPolicy, AgentPolicyRule, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, CIAnnotation, CIFailureEvent, NewCIFailureEvent, CIFixAttempt, NewCIFixAttempt, CICheckStrategy, CIWebhookConfig, IssueAssignment, NewIssueAssignment, CommentMention, NewCommentMention, AgentTriggerConfig, } from './schema.js';
+export { users as usersTable, githubInstallations as githubInstallationsTable, credentials as credentialsTable, workspaces as workspacesTable, workspaceMembers as workspaceMembersTable, projectGroups as projectGroupsTable, repositories as repositoriesTable, linkedDaemons as linkedDaemonsTable, subscriptions as subscriptionsTable, usageRecords as usageRecordsTable, ciFailureEvents as ciFailureEventsTable, ciFixAttempts as ciFixAttemptsTable, issueAssignments as issueAssignmentsTable, commentMentions as commentMentionsTable, } from './schema.js';
+import { getDb, closeDb, runMigrations, userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, linkedDaemonQueries, projectGroupQueries, repositoryQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries } from './drizzle.js';
 export type PlanType = 'free' | 'pro' | 'team' | 'enterprise';
 export type WorkspaceMemberRole = 'owner' | 'admin' | 'member' | 'viewer';
 export declare const db: {
     users: import("./drizzle.js").UserQueries;
+    githubInstallations: import("./drizzle.js").GitHubInstallationQueries;
     credentials: import("./drizzle.js").CredentialQueries;
     workspaces: import("./drizzle.js").WorkspaceQueries;
     workspaceMembers: import("./drizzle.js").WorkspaceMemberQueries;
     projectGroups: import("./drizzle.js").ProjectGroupQueries;
     repositories: import("./drizzle.js").RepositoryQueries;
     linkedDaemons: import("./drizzle.js").LinkedDaemonQueries;
+    ciFailureEvents: import("./drizzle.js").CIFailureEventQueries;
+    ciFixAttempts: import("./drizzle.js").CIFixAttemptQueries;
+    issueAssignments: import("./drizzle.js").IssueAssignmentQueries;
+    commentMentions: import("./drizzle.js").CommentMentionQueries;
     getDb: typeof getDb;
     close: typeof closeDb;
     runMigrations: typeof runMigrations;
 };
-export { userQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, projectGroupQueries, repositoryQueries, linkedDaemonQueries, };
+export { userQueries, githubInstallationQueries, credentialQueries, workspaceQueries, workspaceMemberQueries, projectGroupQueries, repositoryQueries, linkedDaemonQueries, ciFailureEventQueries, ciFixAttemptQueries, issueAssignmentQueries, commentMentionQueries, };
 export { getDb, closeDb, runMigrations };
 export declare function initializeDatabase(): Promise<void>;
 //# sourceMappingURL=index.d.ts.map