bopodev-api 0.1.27 → 0.1.29

package/src/services/heartbeat-service/budget-override.ts

@@ -0,0 +1,46 @@
+import { and, eq, inArray, approvalRequests, issues } from "bopodev-db";
+import type { BopoDb } from "bopodev-db";
+
+export async function findPendingProjectBudgetOverrideBlocksForAgent(
+  db: BopoDb,
+  companyId: string,
+  agentId: string
+) {
+  const assignedRows = await db
+    .select({ projectId: issues.projectId })
+    .from(issues)
+    .where(
+      and(
+        eq(issues.companyId, companyId),
+        eq(issues.assigneeAgentId, agentId),
+        inArray(issues.status, ["todo", "in_progress"])
+      )
+    );
+  const assignedProjectIds = new Set(assignedRows.map((row) => row.projectId));
+  if (assignedProjectIds.size === 0) {
+    return [] as string[];
+  }
+  const pendingOverrides = await db
+    .select({ payloadJson: approvalRequests.payloadJson })
+    .from(approvalRequests)
+    .where(
+      and(
+        eq(approvalRequests.companyId, companyId),
+        eq(approvalRequests.action, "override_budget"),
+        eq(approvalRequests.status, "pending")
+      )
+    );
+  const blockedProjectIds = new Set<string>();
+  for (const approval of pendingOverrides) {
+    try {
+      const payload = JSON.parse(approval.payloadJson) as Record<string, unknown>;
+      const projectId = typeof payload.projectId === "string" ? payload.projectId.trim() : "";
+      if (projectId && assignedProjectIds.has(projectId)) {
+        blockedProjectIds.add(projectId);
+      }
+    } catch {
+      // Ignore malformed payloads to keep enforcement resilient.
+    }
+  }
+  return Array.from(blockedProjectIds);
+}

package/src/services/heartbeat-service/claims.ts

@@ -0,0 +1,61 @@
+import { and, eq, inArray, issues, sql } from "bopodev-db";
+import type { BopoDb } from "bopodev-db";
+
+export async function claimIssuesForAgent(
+  db: BopoDb,
+  companyId: string,
+  agentId: string,
+  heartbeatRunId: string,
+  maxItems = 5
+) {
+  const result = await db.execute(sql`
+    WITH candidate AS (
+      SELECT id
+      FROM issues
+      WHERE company_id = ${companyId}
+        AND assignee_agent_id = ${agentId}
+        AND status IN ('todo', 'in_progress')
+        AND is_claimed = false
+      ORDER BY
+        CASE priority
+          WHEN 'urgent' THEN 0
+          WHEN 'high' THEN 1
+          WHEN 'medium' THEN 2
+          WHEN 'low' THEN 3
+          ELSE 4
+        END ASC,
+        updated_at ASC
+      LIMIT ${maxItems}
+      FOR UPDATE SKIP LOCKED
+    )
+    UPDATE issues i
+    SET is_claimed = true,
+        claimed_by_heartbeat_run_id = ${heartbeatRunId},
+        updated_at = CURRENT_TIMESTAMP
+    FROM candidate c
+    WHERE i.id = c.id
+    RETURNING i.id, i.project_id, i.parent_issue_id, i.title, i.body, i.status, i.priority, i.labels_json, i.tags_json;
+  `);
+
+  return result as unknown as Array<{
+    id: string;
+    project_id: string;
+    parent_issue_id: string | null;
+    title: string;
+    body: string | null;
+    status: string;
+    priority: string;
+    labels_json: string;
+    tags_json: string;
+  }>;
+}
+
+export async function releaseClaimedIssues(db: BopoDb, companyId: string, issueIds: string[]) {
+  if (issueIds.length === 0) {
+    return;
+  }
+  await db
+    .update(issues)
+    .set({ isClaimed: false, claimedByHeartbeatRunId: null, updatedAt: new Date() })
+    .where(and(eq(issues.companyId, companyId), inArray(issues.id, issueIds)));
+}

package/src/services/heartbeat-service/cron.ts

@@ -0,0 +1,58 @@
+export function isHeartbeatDue(cronExpression: string, lastRunAt: Date | null, now: Date) {
+  const normalizedNow = truncateToMinute(now);
+  if (!matchesCronExpression(cronExpression, normalizedNow)) {
+    return false;
+  }
+  if (!lastRunAt) {
+    return true;
+  }
+  return truncateToMinute(lastRunAt).getTime() !== normalizedNow.getTime();
+}
+
+function truncateToMinute(date: Date) {
+  const clone = new Date(date);
+  clone.setSeconds(0, 0);
+  return clone;
+}
+
+function matchesCronExpression(expression: string, date: Date) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    return false;
+  }
+
+  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts as [string, string, string, string, string];
+  return (
+    matchesCronField(minute, date.getMinutes(), 0, 59) &&
+    matchesCronField(hour, date.getHours(), 0, 23) &&
+    matchesCronField(dayOfMonth, date.getDate(), 1, 31) &&
+    matchesCronField(month, date.getMonth() + 1, 1, 12) &&
+    matchesCronField(dayOfWeek, date.getDay(), 0, 6)
+  );
+}
+
+function matchesCronField(field: string, value: number, min: number, max: number) {
+  return field.split(",").some((part) => matchesCronPart(part.trim(), value, min, max));
+}
+
+function matchesCronPart(part: string, value: number, min: number, max: number): boolean {
+  if (part === "*") {
+    return true;
+  }
+
+  const stepMatch = part.match(/^\*\/(\d+)$/);
+  if (stepMatch) {
+    const step = Number(stepMatch[1]);
+    return Number.isInteger(step) && step > 0 ? (value - min) % step === 0 : false;
+  }
+
+  const rangeMatch = part.match(/^(\d+)-(\d+)$/);
+  if (rangeMatch) {
+    const start = Number(rangeMatch[1]);
+    const end = Number(rangeMatch[2]);
+    return start <= value && value <= end;
+  }
+
+  const exact = Number(part);
+  return Number.isInteger(exact) && exact >= min && exact <= max && exact === value;
+}

package/src/services/heartbeat-service/heartbeat-realtime.ts

@@ -0,0 +1,28 @@
+import type { RealtimeHub } from "../../realtime/hub";
+import { createHeartbeatRunsRealtimeEvent } from "../../realtime/heartbeat-runs";
+
+export function publishHeartbeatRunStatus(
+  realtimeHub: RealtimeHub | undefined,
+  input: {
+    companyId: string;
+    runId: string;
+    status: "started" | "completed" | "failed" | "skipped";
+    message?: string | null;
+    startedAt?: Date;
+    finishedAt?: Date;
+  }
+) {
+  if (!realtimeHub) {
+    return;
+  }
+  realtimeHub.publish(
+    createHeartbeatRunsRealtimeEvent(input.companyId, {
+      type: "run.status.updated",
+      runId: input.runId,
+      status: input.status,
+      message: input.message ?? null,
+      startedAt: input.startedAt?.toISOString(),
+      finishedAt: input.finishedAt?.toISOString() ?? null
+    })
+  );
+}

package/src/services/heartbeat-service/heartbeat-run-summary-text.ts

@@ -0,0 +1,53 @@
+const AGENT_COMMENT_EMOJI_REGEX = /[\p{Extended_Pictographic}\uFE0F\u200D]/gu;
+
+export function sanitizeAgentSummaryCommentBody(body: string) {
+  const sanitized = body.replace(AGENT_COMMENT_EMOJI_REGEX, "").trim();
+  return sanitized.length > 0 ? sanitized : "Run update.";
+}
+
+function extractSummaryFromJsonLikeText(input: string) {
+  const fencedMatch = input.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidate = fencedMatch?.[1]?.trim() ?? input.match(/\{[\s\S]*\}\s*$/)?.[0]?.trim();
+  if (!candidate) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(candidate) as Record<string, unknown>;
+    const summary = parsed.summary;
+    if (typeof summary === "string" && summary.trim().length > 0) {
+      return summary.trim();
+    }
+  } catch {
+    // Fall through to regex extraction for loosely-formatted JSON.
+  }
+  const summaryMatch = candidate.match(/"summary"\s*:\s*"([\s\S]*?)"/);
+  const summary = summaryMatch?.[1]
+    ?.replace(/\\"/g, "\"")
+    .replace(/\\n/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  return summary && summary.length > 0 ? summary : null;
+}
+
+export function extractNaturalRunUpdate(executionSummary: string) {
+  const normalized = executionSummary.trim();
+  const jsonSummary = extractSummaryFromJsonLikeText(normalized);
+  const source = jsonSummary ?? normalized;
+  const lines = source
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .filter((line) => !line.startsWith("{") && !line.startsWith("}"));
+  const compact = (lines.length > 0 ? lines.slice(0, 2).join(" ") : source)
+    .replace(/^run (failure )?summary\s*:\s*/i, "")
+    .replace(/^completed all assigned issue steps\s*:\s*/i, "")
+    .replace(/^issue status\s*:\s*/i, "")
+    .replace(/`+/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  const bounded = compact.length > 260 ? `${compact.slice(0, 257).trimEnd()}...` : compact;
+  if (!bounded) {
+    return "Run update.";
+  }
+  return /[.!?]$/.test(bounded) ? bounded : `${bounded}.`;
+}