bopodev-db 0.1.12 → 0.1.14

package/src/repositories.ts

@@ -1,4 +1,4 @@
-import { and, desc, eq, inArray, notInArray, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gt, inArray, notInArray, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import type { BopoDb } from "./client";
 import {
@@ -11,8 +11,14 @@ import {
   costLedger,
   goals,
   heartbeatRuns,
+  heartbeatRunMessages,
+  issueAttachments,
   issueComments,
   issues,
+  modelPricing,
+  pluginConfigs,
+  pluginRuns,
+  plugins,
   projects,
   touchUpdatedAtSql
 } from "./schema";
@@ -106,6 +112,7 @@ export async function listProjects(db: BopoDb, companyId: string) {
 export async function createProject(
   db: BopoDb,
   input: {
+    id?: string;
     companyId: string;
     name: string;
     description?: string | null;
@@ -303,6 +310,76 @@ export async function deleteIssue(db: BopoDb, companyId: string, id: string) {
   return Boolean(deletedIssue);
 }
 
+export async function addIssueAttachment(
+  db: BopoDb,
+  input: {
+    id?: string;
+    companyId: string;
+    issueId: string;
+    projectId: string;
+    fileName: string;
+    mimeType?: string | null;
+    fileSizeBytes: number;
+    relativePath: string;
+    uploadedByActorType?: "human" | "agent" | "system";
+    uploadedByActorId?: string | null;
+  }
+) {
+  await assertIssueBelongsToCompany(db, input.companyId, input.issueId);
+  await assertProjectBelongsToCompany(db, input.companyId, input.projectId);
+  const id = input.id ?? nanoid(14);
+  await db.insert(issueAttachments).values({
+    id,
+    companyId: input.companyId,
+    issueId: input.issueId,
+    projectId: input.projectId,
+    fileName: input.fileName,
+    mimeType: input.mimeType ?? null,
+    fileSizeBytes: input.fileSizeBytes,
+    relativePath: input.relativePath,
+    uploadedByActorType: input.uploadedByActorType ?? "human",
+    uploadedByActorId: input.uploadedByActorId ?? null
+  });
+  return { id, ...input };
+}
+
+export async function listIssueAttachments(db: BopoDb, companyId: string, issueId: string) {
+  return db
+    .select()
+    .from(issueAttachments)
+    .where(and(eq(issueAttachments.companyId, companyId), eq(issueAttachments.issueId, issueId)))
+    .orderBy(desc(issueAttachments.createdAt));
+}
+
+export async function getIssueAttachment(db: BopoDb, companyId: string, issueId: string, attachmentId: string) {
+  const [attachment] = await db
+    .select()
+    .from(issueAttachments)
+    .where(
+      and(
+        eq(issueAttachments.companyId, companyId),
+        eq(issueAttachments.issueId, issueId),
+        eq(issueAttachments.id, attachmentId)
+      )
+    )
+    .limit(1);
+  return attachment ?? null;
+}
+
+export async function deleteIssueAttachment(db: BopoDb, companyId: string, issueId: string, attachmentId: string) {
+  const [deletedAttachment] = await db
+    .delete(issueAttachments)
+    .where(
+      and(
+        eq(issueAttachments.companyId, companyId),
+        eq(issueAttachments.issueId, issueId),
+        eq(issueAttachments.id, attachmentId)
+      )
+    )
+    .returning();
+  return deletedAttachment ?? null;
+}
+
 export async function addIssueComment(
   db: BopoDb,
   input: {
@@ -461,7 +538,16 @@ export async function createAgent(
     managerAgentId?: string | null;
     role: string;
     name: string;
-    providerType: "claude_code" | "codex" | "cursor" | "opencode" | "http" | "shell";
+    providerType:
+      | "claude_code"
+      | "codex"
+      | "cursor"
+      | "opencode"
+      | "gemini_cli"
+      | "openai_api"
+      | "anthropic_api"
+      | "http"
+      | "shell";
     heartbeatCron: string;
     monthlyBudgetUsd: string;
     canHireAgents?: boolean;
@@ -523,7 +609,16 @@ export async function updateAgent(
     managerAgentId?: string | null;
     role?: string;
     name?: string;
-    providerType?: "claude_code" | "codex" | "cursor" | "opencode" | "http" | "shell";
+    providerType?:
+      | "claude_code"
+      | "codex"
+      | "cursor"
+      | "opencode"
+      | "gemini_cli"
+      | "openai_api"
+      | "anthropic_api"
+      | "http"
+      | "shell";
     status?: string;
     heartbeatCron?: string;
     monthlyBudgetUsd?: string;
@@ -751,6 +846,10 @@ export async function appendCost(
   input: {
     companyId: string;
     providerType: string;
+    runtimeModelId?: string | null;
+    pricingProviderType?: string | null;
+    pricingModelId?: string | null;
+    pricingSource?: "exact" | "missing" | null;
     tokenInput: number;
     tokenOutput: number;
     usdCost: string;
@@ -764,6 +863,10 @@ export async function appendCost(
     id,
     companyId: input.companyId,
     providerType: input.providerType,
+    runtimeModelId: input.runtimeModelId ?? null,
+    pricingProviderType: input.pricingProviderType ?? null,
+    pricingModelId: input.pricingModelId ?? null,
+    pricingSource: input.pricingSource ?? null,
     tokenInput: input.tokenInput,
     tokenOutput: input.tokenOutput,
     usdCost: input.usdCost,
@@ -792,6 +895,177 @@ export async function listHeartbeatRuns(db: BopoDb, companyId: string, limit = 1
     .limit(limit);
 }
 
+export async function getHeartbeatRun(db: BopoDb, companyId: string, runId: string) {
+  const [run] = await db
+    .select()
+    .from(heartbeatRuns)
+    .where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.id, runId)))
+    .limit(1);
+  return run ?? null;
+}
+
+export async function appendHeartbeatRunMessages(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    runId: string;
+    messages: Array<{
+      id?: string;
+      sequence: number;
+      kind: string;
+      label?: string | null;
+      text?: string | null;
+      payloadJson?: string | null;
+      signalLevel?: "high" | "medium" | "low" | "noise" | null;
+      groupKey?: string | null;
+      source?: "stdout" | "stderr" | "trace_fallback" | null;
+      createdAt?: Date;
+    }>;
+  }
+) {
+  if (input.messages.length === 0) {
+    return [] as string[];
+  }
+  const values = input.messages.map((message) => ({
+    id: message.id ?? nanoid(14),
+    companyId: input.companyId,
+    runId: input.runId,
+    sequence: message.sequence,
+    kind: message.kind,
+    label: message.label ?? null,
+    text: message.text ?? null,
+    payloadJson: message.payloadJson ?? null,
+    signalLevel: message.signalLevel ?? null,
+    groupKey: message.groupKey ?? null,
+    source: message.source ?? null,
+    createdAt: message.createdAt ?? new Date()
+  }));
+  await db.insert(heartbeatRunMessages).values(values);
+  return values.map((message) => message.id);
+}
+
+export async function listHeartbeatRunMessages(
+  db: BopoDb,
+  input: { companyId: string; runId: string; afterSequence?: number; limit?: number }
+) {
+  const limit = Math.min(Math.max(input.limit ?? 200, 1), 500);
+  const whereClause =
+    input.afterSequence !== undefined
+      ? and(
+          eq(heartbeatRunMessages.companyId, input.companyId),
+          eq(heartbeatRunMessages.runId, input.runId),
+          gt(heartbeatRunMessages.sequence, input.afterSequence)
+        )
+      : and(eq(heartbeatRunMessages.companyId, input.companyId), eq(heartbeatRunMessages.runId, input.runId));
+  const rows = await db
+    .select()
+    .from(heartbeatRunMessages)
+    .where(whereClause)
+    .orderBy(asc(heartbeatRunMessages.sequence))
+    .limit(limit + 1);
+  const hasMore = rows.length > limit;
+  const items = hasMore ? rows.slice(0, limit) : rows;
+  return {
+    items,
+    nextCursor: hasMore ? String(items[items.length - 1]?.sequence ?? "") : null
+  };
+}
+
+export async function listHeartbeatRunMessagesForRuns(
+  db: BopoDb,
+  input: { companyId: string; runIds: string[]; perRunLimit?: number }
+) {
+  const runIds = Array.from(new Set(input.runIds.filter((runId) => runId.trim().length > 0)));
+  if (runIds.length === 0) {
+    return new Map<string, { items: Array<(typeof heartbeatRunMessages.$inferSelect)>; nextCursor: string | null }>();
+  }
+  const perRunLimit = Math.min(Math.max(input.perRunLimit ?? 60, 1), 500);
+  const runIdValues = sql.join(runIds.map((runId) => sql`(${runId})`), sql`, `);
+  const rankedRows = await db.execute(sql`
+    WITH requested(run_id) AS (
+      VALUES ${runIdValues}
+    ),
+    ranked AS (
+      SELECT
+        m.id,
+        m.company_id,
+        m.run_id,
+        m.sequence,
+        m.kind,
+        m.label,
+        m.text,
+        m.payload_json,
+        m.signal_level,
+        m.group_key,
+        m.source,
+        m.created_at,
+        ROW_NUMBER() OVER (PARTITION BY m.run_id ORDER BY m.sequence DESC) AS rn,
+        COUNT(*) OVER (PARTITION BY m.run_id) AS total_count
+      FROM heartbeat_run_messages m
+      JOIN requested r ON r.run_id = m.run_id
+      WHERE m.company_id = ${input.companyId}
+    )
+    SELECT
+      id,
+      company_id,
+      run_id,
+      sequence,
+      kind,
+      label,
+      text,
+      payload_json,
+      signal_level,
+      group_key,
+      source,
+      created_at,
+      total_count
+    FROM ranked
+    WHERE rn <= ${perRunLimit}
+    ORDER BY run_id ASC, sequence ASC
+  `);
+  const rows = (rankedRows.rows ?? []) as Array<{
+    id: string;
+    company_id: string;
+    run_id: string;
+    sequence: number;
+    kind: string;
+    label: string | null;
+    text: string | null;
+    payload_json: string | null;
+    signal_level: string | null;
+    group_key: string | null;
+    source: string | null;
+    created_at: Date | string;
+    total_count: number;
+  }>;
+  const grouped = new Map<string, { items: Array<(typeof heartbeatRunMessages.$inferSelect)>; nextCursor: string | null }>();
+  for (const runId of runIds) {
+    grouped.set(runId, { items: [], nextCursor: null });
+  }
+  for (const row of rows) {
+    const bucket = grouped.get(row.run_id) ?? { items: [], nextCursor: null };
+    bucket.items.push({
+      id: row.id,
+      companyId: row.company_id,
+      runId: row.run_id,
+      sequence: row.sequence,
+      kind: row.kind,
+      label: row.label,
+      text: row.text,
+      payloadJson: row.payload_json,
+      signalLevel: row.signal_level,
+      groupKey: row.group_key,
+      source: row.source,
+      createdAt: row.created_at instanceof Date ? row.created_at : new Date(row.created_at)
+    });
+    if (row.total_count > perRunLimit) {
+      bucket.nextCursor = String(row.sequence);
+    }
+    grouped.set(row.run_id, bucket);
+  }
+  return grouped;
+}
+
 export async function appendActivity(
   db: BopoDb,
   input: {
@@ -816,6 +1090,238 @@ export async function appendActivity(
   return id;
 }
 
+export async function upsertPlugin(
+  db: BopoDb,
+  input: {
+    id: string;
+    name: string;
+    version: string;
+    kind: string;
+    runtimeType: string;
+    runtimeEntrypoint: string;
+    hooksJson?: string;
+    capabilitiesJson?: string;
+    manifestJson?: string;
+  }
+) {
+  await db
+    .insert(plugins)
+    .values({
+      id: input.id,
+      name: input.name,
+      version: input.version,
+      kind: input.kind,
+      runtimeType: input.runtimeType,
+      runtimeEntrypoint: input.runtimeEntrypoint,
+      hooksJson: input.hooksJson ?? "[]",
+      capabilitiesJson: input.capabilitiesJson ?? "[]",
+      manifestJson: input.manifestJson ?? "{}"
+    })
+    .onConflictDoUpdate({
+      target: plugins.id,
+      set: {
+        name: input.name,
+        version: input.version,
+        kind: input.kind,
+        runtimeType: input.runtimeType,
+        runtimeEntrypoint: input.runtimeEntrypoint,
+        hooksJson: input.hooksJson ?? "[]",
+        capabilitiesJson: input.capabilitiesJson ?? "[]",
+        manifestJson: input.manifestJson ?? "{}",
+        updatedAt: touchUpdatedAtSql
+      }
+    });
+  return input.id;
+}
+
+export async function listPlugins(db: BopoDb) {
+  return db.select().from(plugins).orderBy(asc(plugins.name));
+}
+
+export async function updatePluginConfig(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    pluginId: string;
+    enabled?: boolean;
+    priority?: number;
+    configJson?: string;
+    grantedCapabilitiesJson?: string;
+  }
+) {
+  await db
+    .insert(pluginConfigs)
+    .values({
+      companyId: input.companyId,
+      pluginId: input.pluginId,
+      enabled: input.enabled ?? false,
+      priority: input.priority ?? 100,
+      configJson: input.configJson ?? "{}",
+      grantedCapabilitiesJson: input.grantedCapabilitiesJson ?? "[]"
+    })
+    .onConflictDoUpdate({
+      target: [pluginConfigs.companyId, pluginConfigs.pluginId],
+      set: compactUpdate({
+        enabled: input.enabled,
+        priority: input.priority,
+        configJson: input.configJson,
+        grantedCapabilitiesJson: input.grantedCapabilitiesJson,
+        updatedAt: touchUpdatedAtSql
+      })
+    });
+}
+
+export async function deletePluginConfig(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    pluginId: string;
+  }
+) {
+  await db
+    .delete(pluginConfigs)
+    .where(and(eq(pluginConfigs.companyId, input.companyId), eq(pluginConfigs.pluginId, input.pluginId)));
+}
+
+export async function deletePluginById(db: BopoDb, pluginId: string) {
+  await db.delete(plugins).where(eq(plugins.id, pluginId));
+}
+
+export async function listCompanyPluginConfigs(db: BopoDb, companyId: string) {
+  return db
+    .select({
+      companyId: pluginConfigs.companyId,
+      pluginId: pluginConfigs.pluginId,
+      enabled: pluginConfigs.enabled,
+      priority: pluginConfigs.priority,
+      configJson: pluginConfigs.configJson,
+      grantedCapabilitiesJson: pluginConfigs.grantedCapabilitiesJson,
+      pluginName: plugins.name,
+      pluginVersion: plugins.version,
+      pluginKind: plugins.kind,
+      runtimeType: plugins.runtimeType,
+      runtimeEntrypoint: plugins.runtimeEntrypoint,
+      hooksJson: plugins.hooksJson,
+      capabilitiesJson: plugins.capabilitiesJson,
+      manifestJson: plugins.manifestJson
+    })
+    .from(pluginConfigs)
+    .innerJoin(plugins, eq(pluginConfigs.pluginId, plugins.id))
+    .where(eq(pluginConfigs.companyId, companyId))
+    .orderBy(asc(pluginConfigs.priority), asc(pluginConfigs.pluginId));
+}
+
+export async function appendPluginRun(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    runId?: string | null;
+    pluginId: string;
+    hook: string;
+    status: string;
+    durationMs: number;
+    error?: string | null;
+    diagnosticsJson?: string;
+  }
+) {
+  const id = nanoid(14);
+  await db.insert(pluginRuns).values({
+    id,
+    companyId: input.companyId,
+    runId: input.runId ?? null,
+    pluginId: input.pluginId,
+    hook: input.hook,
+    status: input.status,
+    durationMs: Math.max(0, Math.floor(input.durationMs)),
+    error: input.error ?? null,
+    diagnosticsJson: input.diagnosticsJson ?? "{}"
+  });
+  return id;
+}
+
+export async function listPluginRuns(
+  db: BopoDb,
+  input: { companyId: string; pluginId?: string; runId?: string; limit?: number }
+) {
+  const limit = Math.min(Math.max(input.limit ?? 200, 1), 1000);
+  return db
+    .select()
+    .from(pluginRuns)
+    .where(
+      and(
+        eq(pluginRuns.companyId, input.companyId),
+        input.pluginId ? eq(pluginRuns.pluginId, input.pluginId) : undefined,
+        input.runId ? eq(pluginRuns.runId, input.runId) : undefined
+      )
+    )
+    .orderBy(desc(pluginRuns.createdAt))
+    .limit(limit);
+}
+
+export async function listModelPricing(db: BopoDb, companyId: string) {
+  return db
+    .select()
+    .from(modelPricing)
+    .where(eq(modelPricing.companyId, companyId))
+    .orderBy(asc(modelPricing.providerType), asc(modelPricing.modelId));
+}
+
+export async function getModelPricing(
+  db: BopoDb,
+  input: { companyId: string; providerType: string; modelId: string }
+) {
+  const rows = await db
+    .select()
+    .from(modelPricing)
+    .where(
+      and(
+        eq(modelPricing.companyId, input.companyId),
+        eq(modelPricing.providerType, input.providerType),
+        eq(modelPricing.modelId, input.modelId)
+      )
+    )
+    .limit(1);
+  return rows[0] ?? null;
+}
+
+export async function upsertModelPricing(
+  db: BopoDb,
+  input: {
+    companyId: string;
+    providerType: string;
+    modelId: string;
+    displayName?: string | null;
+    inputUsdPer1M?: string | null;
+    outputUsdPer1M?: string | null;
+    currency?: string | null;
+    updatedBy?: string | null;
+  }
+) {
+  await db
+    .insert(modelPricing)
+    .values({
+      companyId: input.companyId,
+      providerType: input.providerType,
+      modelId: input.modelId,
+      displayName: input.displayName ?? null,
+      inputUsdPer1M: input.inputUsdPer1M ?? "0.000000",
+      outputUsdPer1M: input.outputUsdPer1M ?? "0.000000",
+      currency: input.currency ?? "USD",
+      updatedBy: input.updatedBy ?? null
+    })
+    .onConflictDoUpdate({
+      target: [modelPricing.companyId, modelPricing.providerType, modelPricing.modelId],
+      set: compactUpdate({
+        displayName: input.displayName ?? null,
+        inputUsdPer1M: input.inputUsdPer1M ?? "0.000000",
+        outputUsdPer1M: input.outputUsdPer1M ?? "0.000000",
+        currency: input.currency ?? "USD",
+        updatedBy: input.updatedBy ?? null,
+        updatedAt: touchUpdatedAtSql
+      })
+    });
+}
+
 function compactUpdate<T extends Record<string, unknown>>(input: T) {
   return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
 }