corporateai 0.0.1

package/server/src/services/execution-workspaces.ts

@@ -0,0 +1,100 @@
+import { and, desc, eq, inArray } from "drizzle-orm";
+import type { Db } from "@corporateai/db";
+import { executionWorkspaces } from "@corporateai/db";
+import type { ExecutionWorkspace } from "@corporateai/shared";
+
+type ExecutionWorkspaceRow = typeof executionWorkspaces.$inferSelect;
+
+function toExecutionWorkspace(row: ExecutionWorkspaceRow): ExecutionWorkspace {
+  return {
+    id: row.id,
+    companyId: row.companyId,
+    projectId: row.projectId,
+    projectWorkspaceId: row.projectWorkspaceId ?? null,
+    sourceIssueId: row.sourceIssueId ?? null,
+    mode: row.mode as ExecutionWorkspace["mode"],
+    strategyType: row.strategyType as ExecutionWorkspace["strategyType"],
+    name: row.name,
+    status: row.status as ExecutionWorkspace["status"],
+    cwd: row.cwd ?? null,
+    repoUrl: row.repoUrl ?? null,
+    baseRef: row.baseRef ?? null,
+    branchName: row.branchName ?? null,
+    providerType: row.providerType as ExecutionWorkspace["providerType"],
+    providerRef: row.providerRef ?? null,
+    derivedFromExecutionWorkspaceId: row.derivedFromExecutionWorkspaceId ?? null,
+    lastUsedAt: row.lastUsedAt,
+    openedAt: row.openedAt,
+    closedAt: row.closedAt ?? null,
+    cleanupEligibleAt: row.cleanupEligibleAt ?? null,
+    cleanupReason: row.cleanupReason ?? null,
+    metadata: (row.metadata as Record<string, unknown> | null) ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+export function executionWorkspaceService(db: Db) {
+  return {
+    list: async (companyId: string, filters?: {
+      projectId?: string;
+      projectWorkspaceId?: string;
+      issueId?: string;
+      status?: string;
+      reuseEligible?: boolean;
+    }) => {
+      const conditions = [eq(executionWorkspaces.companyId, companyId)];
+      if (filters?.projectId) conditions.push(eq(executionWorkspaces.projectId, filters.projectId));
+      if (filters?.projectWorkspaceId) {
+        conditions.push(eq(executionWorkspaces.projectWorkspaceId, filters.projectWorkspaceId));
+      }
+      if (filters?.issueId) conditions.push(eq(executionWorkspaces.sourceIssueId, filters.issueId));
+      if (filters?.status) {
+        const statuses = filters.status.split(",").map((value) => value.trim()).filter(Boolean);
+        if (statuses.length === 1) conditions.push(eq(executionWorkspaces.status, statuses[0]!));
+        else if (statuses.length > 1) conditions.push(inArray(executionWorkspaces.status, statuses));
+      }
+      if (filters?.reuseEligible) {
+        conditions.push(inArray(executionWorkspaces.status, ["active", "idle", "in_review"]));
+      }
+
+      const rows = await db
+        .select()
+        .from(executionWorkspaces)
+        .where(and(...conditions))
+        .orderBy(desc(executionWorkspaces.lastUsedAt), desc(executionWorkspaces.createdAt));
+      return rows.map(toExecutionWorkspace);
+    },
+
+    getById: async (id: string) => {
+      const row = await db
+        .select()
+        .from(executionWorkspaces)
+        .where(eq(executionWorkspaces.id, id))
+        .then((rows) => rows[0] ?? null);
+      return row ? toExecutionWorkspace(row) : null;
+    },
+
+    create: async (data: typeof executionWorkspaces.$inferInsert) => {
+      const row = await db
+        .insert(executionWorkspaces)
+        .values(data)
+        .returning()
+        .then((rows) => rows[0] ?? null);
+      return row ? toExecutionWorkspace(row) : null;
+    },
+
+    update: async (id: string, patch: Partial<typeof executionWorkspaces.$inferInsert>) => {
+      const row = await db
+        .update(executionWorkspaces)
+        .set({ ...patch, updatedAt: new Date() })
+        .where(eq(executionWorkspaces.id, id))
+        .returning()
+        .then((rows) => rows[0] ?? null);
+      return row ? toExecutionWorkspace(row) : null;
+    },
+  };
+}
+
+export { toExecutionWorkspace };
+

package/server/src/services/finance.ts

@@ -0,0 +1,135 @@
+import { and, desc, eq, gte, lte, sql } from "drizzle-orm";
+import type { Db } from "@corporateai/db";
+import { agents, costEvents, financeEvents, goals, heartbeatRuns, issues, projects } from "@corporateai/db";
+import { notFound, unprocessable } from "../errors.js";
+
+export interface FinanceDateRange {
+  from?: Date;
+  to?: Date;
+}
+
+async function assertBelongsToCompany(
+  db: Db,
+  table: any,
+  id: string,
+  companyId: string,
+  label: string,
+) {
+  const row = await db
+    .select()
+    .from(table)
+    .where(eq(table.id, id))
+    .then((rows) => rows[0] ?? null);
+
+  if (!row) throw notFound(`${label} not found`);
+  if ((row as unknown as { companyId: string }).companyId !== companyId) {
+    throw unprocessable(`${label} does not belong to company`);
+  }
+}
+
+function rangeConditions(companyId: string, range?: FinanceDateRange) {
+  const conditions: ReturnType<typeof eq>[] = [eq(financeEvents.companyId, companyId)];
+  if (range?.from) conditions.push(gte(financeEvents.occurredAt, range.from));
+  if (range?.to) conditions.push(lte(financeEvents.occurredAt, range.to));
+  return conditions;
+}
+
+export function financeService(db: Db) {
+  const debitExpr = sql<number>`coalesce(sum(case when ${financeEvents.direction} = 'debit' then ${financeEvents.amountCents} else 0 end), 0)::int`;
+  const creditExpr = sql<number>`coalesce(sum(case when ${financeEvents.direction} = 'credit' then ${financeEvents.amountCents} else 0 end), 0)::int`;
+  const estimatedDebitExpr = sql<number>`coalesce(sum(case when ${financeEvents.direction} = 'debit' and ${financeEvents.estimated} = true then ${financeEvents.amountCents} else 0 end), 0)::int`;
+
+  return {
+    createEvent: async (companyId: string, data: Omit<typeof financeEvents.$inferInsert, "companyId">) => {
+      if (data.agentId) await assertBelongsToCompany(db, agents, data.agentId, companyId, "Agent");
+      if (data.issueId) await assertBelongsToCompany(db, issues, data.issueId, companyId, "Issue");
+      if (data.projectId) await assertBelongsToCompany(db, projects, data.projectId, companyId, "Project");
+      if (data.goalId) await assertBelongsToCompany(db, goals, data.goalId, companyId, "Goal");
+      if (data.heartbeatRunId) await assertBelongsToCompany(db, heartbeatRuns, data.heartbeatRunId, companyId, "Heartbeat run");
+      if (data.costEventId) await assertBelongsToCompany(db, costEvents, data.costEventId, companyId, "Cost event");
+
+      const event = await db
+        .insert(financeEvents)
+        .values({
+          ...data,
+          companyId,
+          currency: data.currency ?? "USD",
+          direction: data.direction ?? "debit",
+          estimated: data.estimated ?? false,
+        })
+        .returning()
+        .then((rows) => rows[0]);
+
+      return event;
+    },
+
+    summary: async (companyId: string, range?: FinanceDateRange) => {
+      const conditions = rangeConditions(companyId, range);
+      const [row] = await db
+        .select({
+          debitCents: debitExpr,
+          creditCents: creditExpr,
+          estimatedDebitCents: estimatedDebitExpr,
+          eventCount: sql<number>`count(*)::int`,
+        })
+        .from(financeEvents)
+        .where(and(...conditions));
+
+      return {
+        companyId,
+        debitCents: Number(row?.debitCents ?? 0),
+        creditCents: Number(row?.creditCents ?? 0),
+        netCents: Number(row?.debitCents ?? 0) - Number(row?.creditCents ?? 0),
+        estimatedDebitCents: Number(row?.estimatedDebitCents ?? 0),
+        eventCount: Number(row?.eventCount ?? 0),
+      };
+    },
+
+    byBiller: async (companyId: string, range?: FinanceDateRange) => {
+      const conditions = rangeConditions(companyId, range);
+      return db
+        .select({
+          biller: financeEvents.biller,
+          debitCents: debitExpr,
+          creditCents: creditExpr,
+          estimatedDebitCents: estimatedDebitExpr,
+          eventCount: sql<number>`count(*)::int`,
+          kindCount: sql<number>`count(distinct ${financeEvents.eventKind})::int`,
+          netCents: sql<number>`(${debitExpr} - ${creditExpr})::int`,
+        })
+        .from(financeEvents)
+        .where(and(...conditions))
+        .groupBy(financeEvents.biller)
+        .orderBy(desc(sql`(${debitExpr} - ${creditExpr})::int`), financeEvents.biller);
+    },
+
+    byKind: async (companyId: string, range?: FinanceDateRange) => {
+      const conditions = rangeConditions(companyId, range);
+      return db
+        .select({
+          eventKind: financeEvents.eventKind,
+          debitCents: debitExpr,
+          creditCents: creditExpr,
+          estimatedDebitCents: estimatedDebitExpr,
+          eventCount: sql<number>`count(*)::int`,
+          billerCount: sql<number>`count(distinct ${financeEvents.biller})::int`,
+          netCents: sql<number>`(${debitExpr} - ${creditExpr})::int`,
+        })
+        .from(financeEvents)
+        .where(and(...conditions))
+        .groupBy(financeEvents.eventKind)
+        .orderBy(desc(sql`(${debitExpr} - ${creditExpr})::int`), financeEvents.eventKind);
+    },
+
+    list: async (companyId: string, range?: FinanceDateRange, limit: number = 100) => {
+      const conditions = rangeConditions(companyId, range);
+      return db
+        .select()
+        .from(financeEvents)
+        .where(and(...conditions))
+        .orderBy(desc(financeEvents.occurredAt), desc(financeEvents.createdAt))
+        .limit(limit);
+    },
+  };
+}
+

package/server/src/services/goals.ts

@@ -0,0 +1,81 @@
+import { and, asc, eq, isNull } from "drizzle-orm";
+import type { Db } from "@corporateai/db";
+import { goals } from "@corporateai/db";
+
+type GoalReader = Pick<Db, "select">;
+
+export async function getDefaultCompanyGoal(db: GoalReader, companyId: string) {
+  const activeRootGoal = await db
+    .select()
+    .from(goals)
+    .where(
+      and(
+        eq(goals.companyId, companyId),
+        eq(goals.level, "company"),
+        eq(goals.status, "active"),
+        isNull(goals.parentId),
+      ),
+    )
+    .orderBy(asc(goals.createdAt))
+    .then((rows) => rows[0] ?? null);
+  if (activeRootGoal) return activeRootGoal;
+
+  const anyRootGoal = await db
+    .select()
+    .from(goals)
+    .where(
+      and(
+        eq(goals.companyId, companyId),
+        eq(goals.level, "company"),
+        isNull(goals.parentId),
+      ),
+    )
+    .orderBy(asc(goals.createdAt))
+    .then((rows) => rows[0] ?? null);
+  if (anyRootGoal) return anyRootGoal;
+
+  return db
+    .select()
+    .from(goals)
+    .where(and(eq(goals.companyId, companyId), eq(goals.level, "company")))
+    .orderBy(asc(goals.createdAt))
+    .then((rows) => rows[0] ?? null);
+}
+
+export function goalService(db: Db) {
+  return {
+    list: (companyId: string) => db.select().from(goals).where(eq(goals.companyId, companyId)),
+
+    getById: (id: string) =>
+      db
+        .select()
+        .from(goals)
+        .where(eq(goals.id, id))
+        .then((rows) => rows[0] ?? null),
+
+    getDefaultCompanyGoal: (companyId: string) => getDefaultCompanyGoal(db, companyId),
+
+    create: (companyId: string, data: Omit<typeof goals.$inferInsert, "companyId">) =>
+      db
+        .insert(goals)
+        .values({ ...data, companyId })
+        .returning()
+        .then((rows) => rows[0]),
+
+    update: (id: string, data: Partial<typeof goals.$inferInsert>) =>
+      db
+        .update(goals)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(goals.id, id))
+        .returning()
+        .then((rows) => rows[0] ?? null),
+
+    remove: (id: string) =>
+      db
+        .delete(goals)
+        .where(eq(goals.id, id))
+        .returning()
+        .then((rows) => rows[0] ?? null),
+  };
+}
+

package/server/src/services/heartbeat-run-summary.ts

@@ -0,0 +1,35 @@
+function truncateSummaryText(value: unknown, maxLength = 500) {
+  if (typeof value !== "string") return null;
+  return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+
+function readNumericField(record: Record<string, unknown>, key: string) {
+  return key in record ? record[key] ?? null : undefined;
+}
+
+export function summarizeHeartbeatRunResultJson(
+  resultJson: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | null {
+  if (!resultJson || typeof resultJson !== "object" || Array.isArray(resultJson)) {
+    return null;
+  }
+
+  const summary: Record<string, unknown> = {};
+  const textFields = ["summary", "result", "message", "error"] as const;
+  for (const key of textFields) {
+    const value = truncateSummaryText(resultJson[key]);
+    if (value !== null) {
+      summary[key] = value;
+    }
+  }
+
+  const numericFieldAliases = ["total_cost_usd", "cost_usd", "costUsd"] as const;
+  for (const key of numericFieldAliases) {
+    const value = readNumericField(resultJson, key);
+    if (value !== undefined && value !== null) {
+      summary[key] = value;
+    }
+  }
+
+  return Object.keys(summary).length > 0 ? summary : null;
+}