corporateai 0.0.1

package/server/src/services/companies.ts

@@ -0,0 +1,313 @@
+import { and, count, eq, gte, inArray, lt, sql } from "drizzle-orm";
+import type { Db } from "@corporateai/db";
+import {
+  companies,
+  companyLogos,
+  assets,
+  agents,
+  agentApiKeys,
+  agentRuntimeState,
+  agentTaskSessions,
+  agentWakeupRequests,
+  issues,
+  issueComments,
+  projects,
+  goals,
+  heartbeatRuns,
+  heartbeatRunEvents,
+  costEvents,
+  financeEvents,
+  approvalComments,
+  approvals,
+  activityLog,
+  companySecrets,
+  joinRequests,
+  invites,
+  principalPermissionGrants,
+  companyMemberships,
+} from "@corporateai/db";
+import { notFound, unprocessable } from "../errors.js";
+
+export function companyService(db: Db) {
+  const ISSUE_PREFIX_FALLBACK = "CMP";
+
+  const companySelection = {
+    id: companies.id,
+    name: companies.name,
+    description: companies.description,
+    status: companies.status,
+    issuePrefix: companies.issuePrefix,
+    issueCounter: companies.issueCounter,
+    budgetMonthlyCents: companies.budgetMonthlyCents,
+    spentMonthlyCents: companies.spentMonthlyCents,
+    requireBoardApprovalForNewAgents: companies.requireBoardApprovalForNewAgents,
+    brandColor: companies.brandColor,
+    logoAssetId: companyLogos.assetId,
+    createdAt: companies.createdAt,
+    updatedAt: companies.updatedAt,
+  };
+
+  function enrichCompany<T extends { logoAssetId: string | null }>(company: T) {
+    return {
+      ...company,
+      logoUrl: company.logoAssetId ? `/api/assets/${company.logoAssetId}/content` : null,
+    };
+  }
+
+  function currentUtcMonthWindow(now = new Date()) {
+    const year = now.getUTCFullYear();
+    const month = now.getUTCMonth();
+    return {
+      start: new Date(Date.UTC(year, month, 1, 0, 0, 0, 0)),
+      end: new Date(Date.UTC(year, month + 1, 1, 0, 0, 0, 0)),
+    };
+  }
+
+  async function getMonthlySpendByCompanyIds(
+    companyIds: string[],
+    database: Pick<Db, "select"> = db,
+  ) {
+    if (companyIds.length === 0) return new Map<string, number>();
+    const { start, end } = currentUtcMonthWindow();
+    const rows = await database
+      .select({
+        companyId: costEvents.companyId,
+        spentMonthlyCents: sql<number>`coalesce(sum(${costEvents.costCents}), 0)::int`,
+      })
+      .from(costEvents)
+      .where(
+        and(
+          inArray(costEvents.companyId, companyIds),
+          gte(costEvents.occurredAt, start),
+          lt(costEvents.occurredAt, end),
+        ),
+      )
+      .groupBy(costEvents.companyId);
+    return new Map(rows.map((row) => [row.companyId, Number(row.spentMonthlyCents ?? 0)]));
+  }
+
+  async function hydrateCompanySpend<T extends { id: string; spentMonthlyCents: number }>(
+    rows: T[],
+    database: Pick<Db, "select"> = db,
+  ) {
+    const spendByCompanyId = await getMonthlySpendByCompanyIds(rows.map((row) => row.id), database);
+    return rows.map((row) => ({
+      ...row,
+      spentMonthlyCents: spendByCompanyId.get(row.id) ?? 0,
+    }));
+  }
+
+  function getCompanyQuery(database: Pick<Db, "select">) {
+    return database
+      .select(companySelection)
+      .from(companies)
+      .leftJoin(companyLogos, eq(companyLogos.companyId, companies.id));
+  }
+
+  function deriveIssuePrefixBase(name: string) {
+    const normalized = name.toUpperCase().replace(/[^A-Z]/g, "");
+    return normalized.slice(0, 3) || ISSUE_PREFIX_FALLBACK;
+  }
+
+  function suffixForAttempt(attempt: number) {
+    if (attempt <= 1) return "";
+    return "A".repeat(attempt - 1);
+  }
+
+  function isIssuePrefixConflict(error: unknown) {
+    const constraint = typeof error === "object" && error !== null && "constraint" in error
+      ? (error as { constraint?: string }).constraint
+      : typeof error === "object" && error !== null && "constraint_name" in error
+        ? (error as { constraint_name?: string }).constraint_name
+        : undefined;
+    return typeof error === "object"
+      && error !== null
+      && "code" in error
+      && (error as { code?: string }).code === "23505"
+      && constraint === "companies_issue_prefix_idx";
+  }
+
+  async function createCompanyWithUniquePrefix(data: typeof companies.$inferInsert) {
+    const base = deriveIssuePrefixBase(data.name);
+    let suffix = 1;
+    while (suffix < 10000) {
+      const candidate = `${base}${suffixForAttempt(suffix)}`;
+      try {
+        const rows = await db
+          .insert(companies)
+          .values({ ...data, issuePrefix: candidate })
+          .returning();
+        return rows[0];
+      } catch (error) {
+        if (!isIssuePrefixConflict(error)) throw error;
+      }
+      suffix += 1;
+    }
+    throw new Error("Unable to allocate unique issue prefix");
+  }
+
+  return {
+    list: async () => {
+      const rows = await getCompanyQuery(db);
+      const hydrated = await hydrateCompanySpend(rows);
+      return hydrated.map((row) => enrichCompany(row));
+    },
+
+    getById: async (id: string) => {
+      const row = await getCompanyQuery(db)
+        .where(eq(companies.id, id))
+        .then((rows) => rows[0] ?? null);
+      if (!row) return null;
+      const [hydrated] = await hydrateCompanySpend([row], db);
+      return enrichCompany(hydrated);
+    },
+
+    create: async (data: typeof companies.$inferInsert) => {
+      const created = await createCompanyWithUniquePrefix(data);
+      const row = await getCompanyQuery(db)
+        .where(eq(companies.id, created.id))
+        .then((rows) => rows[0] ?? null);
+      if (!row) throw notFound("Company not found after creation");
+      const [hydrated] = await hydrateCompanySpend([row], db);
+      return enrichCompany(hydrated);
+    },
+
+    update: (
+      id: string,
+      data: Partial<typeof companies.$inferInsert> & { logoAssetId?: string | null },
+    ) =>
+      db.transaction(async (tx) => {
+        const existing = await getCompanyQuery(tx)
+          .where(eq(companies.id, id))
+          .then((rows) => rows[0] ?? null);
+        if (!existing) return null;
+
+        const { logoAssetId, ...companyPatch } = data;
+
+        if (logoAssetId !== undefined && logoAssetId !== null) {
+          const nextLogoAsset = await tx
+            .select({ id: assets.id, companyId: assets.companyId })
+            .from(assets)
+            .where(eq(assets.id, logoAssetId))
+            .then((rows) => rows[0] ?? null);
+          if (!nextLogoAsset) throw notFound("Logo asset not found");
+          if (nextLogoAsset.companyId !== existing.id) {
+            throw unprocessable("Logo asset must belong to the same company");
+          }
+        }
+
+        const updated = await tx
+          .update(companies)
+          .set({ ...companyPatch, updatedAt: new Date() })
+          .where(eq(companies.id, id))
+          .returning()
+          .then((rows) => rows[0] ?? null);
+        if (!updated) return null;
+
+        if (logoAssetId === null) {
+          await tx.delete(companyLogos).where(eq(companyLogos.companyId, id));
+        } else if (logoAssetId !== undefined) {
+          await tx
+            .insert(companyLogos)
+            .values({
+              companyId: id,
+              assetId: logoAssetId,
+            })
+            .onConflictDoUpdate({
+              target: companyLogos.companyId,
+              set: {
+                assetId: logoAssetId,
+                updatedAt: new Date(),
+              },
+            });
+        }
+
+        if (logoAssetId !== undefined && existing.logoAssetId && existing.logoAssetId !== logoAssetId) {
+          await tx.delete(assets).where(eq(assets.id, existing.logoAssetId));
+        }
+
+        const [hydrated] = await hydrateCompanySpend([{
+          ...updated,
+          logoAssetId: logoAssetId === undefined ? existing.logoAssetId : logoAssetId,
+        }], tx);
+
+        return enrichCompany(hydrated);
+      }),
+
+    archive: (id: string) =>
+      db.transaction(async (tx) => {
+        const updated = await tx
+          .update(companies)
+          .set({ status: "archived", updatedAt: new Date() })
+          .where(eq(companies.id, id))
+          .returning()
+          .then((rows) => rows[0] ?? null);
+        if (!updated) return null;
+        const row = await getCompanyQuery(tx)
+          .where(eq(companies.id, id))
+          .then((rows) => rows[0] ?? null);
+        if (!row) return null;
+        const [hydrated] = await hydrateCompanySpend([row], tx);
+        return enrichCompany(hydrated);
+      }),
+
+    remove: (id: string) =>
+      db.transaction(async (tx) => {
+        // Delete from child tables in dependency order
+        await tx.delete(heartbeatRunEvents).where(eq(heartbeatRunEvents.companyId, id));
+        await tx.delete(agentTaskSessions).where(eq(agentTaskSessions.companyId, id));
+        await tx.delete(heartbeatRuns).where(eq(heartbeatRuns.companyId, id));
+        await tx.delete(agentWakeupRequests).where(eq(agentWakeupRequests.companyId, id));
+        await tx.delete(agentApiKeys).where(eq(agentApiKeys.companyId, id));
+        await tx.delete(agentRuntimeState).where(eq(agentRuntimeState.companyId, id));
+        await tx.delete(issueComments).where(eq(issueComments.companyId, id));
+        await tx.delete(costEvents).where(eq(costEvents.companyId, id));
+        await tx.delete(financeEvents).where(eq(financeEvents.companyId, id));
+        await tx.delete(approvalComments).where(eq(approvalComments.companyId, id));
+        await tx.delete(approvals).where(eq(approvals.companyId, id));
+        await tx.delete(companySecrets).where(eq(companySecrets.companyId, id));
+        await tx.delete(joinRequests).where(eq(joinRequests.companyId, id));
+        await tx.delete(invites).where(eq(invites.companyId, id));
+        await tx.delete(principalPermissionGrants).where(eq(principalPermissionGrants.companyId, id));
+        await tx.delete(companyMemberships).where(eq(companyMemberships.companyId, id));
+        await tx.delete(issues).where(eq(issues.companyId, id));
+        await tx.delete(companyLogos).where(eq(companyLogos.companyId, id));
+        await tx.delete(assets).where(eq(assets.companyId, id));
+        await tx.delete(goals).where(eq(goals.companyId, id));
+        await tx.delete(projects).where(eq(projects.companyId, id));
+        await tx.delete(agents).where(eq(agents.companyId, id));
+        await tx.delete(activityLog).where(eq(activityLog.companyId, id));
+        const rows = await tx
+          .delete(companies)
+          .where(eq(companies.id, id))
+          .returning();
+        return rows[0] ?? null;
+      }),
+
+    stats: () =>
+      Promise.all([
+        db
+          .select({ companyId: agents.companyId, count: count() })
+          .from(agents)
+          .groupBy(agents.companyId),
+        db
+          .select({ companyId: issues.companyId, count: count() })
+          .from(issues)
+          .groupBy(issues.companyId),
+      ]).then(([agentRows, issueRows]) => {
+        const result: Record<string, { agentCount: number; issueCount: number }> = {};
+        for (const row of agentRows) {
+          result[row.companyId] = { agentCount: row.count, issueCount: 0 };
+        }
+        for (const row of issueRows) {
+          if (result[row.companyId]) {
+            result[row.companyId].issueCount = row.count;
+          } else {
+            result[row.companyId] = { agentCount: 0, issueCount: row.count };
+          }
+        }
+        return result;
+      }),
+  };
+}
+

package/server/src/services/company-export-readme.ts

@@ -0,0 +1,173 @@
+/**
+ * Generates README.md with Mermaid org chart for company exports.
+ */
+import type { CompanyPortabilityManifest } from "@corporateai/shared";
+
+const ROLE_LABELS: Record<string, string> = {
+  ceo: "CEO",
+  cto: "CTO",
+  cmo: "CMO",
+  cfo: "CFO",
+  coo: "COO",
+  vp: "VP",
+  manager: "Manager",
+  engineer: "Engineer",
+  agent: "Agent",
+};
+
+/**
+ * Generate a Mermaid flowchart (TD = top-down) representing the org chart.
+ * Returns null if there are no agents.
+ */
+export function generateOrgChartMermaid(agents: CompanyPortabilityManifest["agents"]): string | null {
+  if (agents.length === 0) return null;
+
+  const lines: string[] = [];
+  lines.push("```mermaid");
+  lines.push("graph TD");
+
+  // Node definitions with role labels
+  for (const agent of agents) {
+    const roleLabel = ROLE_LABELS[agent.role] ?? agent.role;
+    const id = mermaidId(agent.slug);
+    lines.push(`    ${id}["${mermaidEscape(agent.name)}<br/><small>${mermaidEscape(roleLabel)}</small>"]`);
+  }
+
+  // Edges from parent to child
+  const slugSet = new Set(agents.map((a) => a.slug));
+  for (const agent of agents) {
+    if (agent.reportsToSlug && slugSet.has(agent.reportsToSlug)) {
+      lines.push(`    ${mermaidId(agent.reportsToSlug)} --> ${mermaidId(agent.slug)}`);
+    }
+  }
+
+  lines.push("```");
+  return lines.join("\n");
+}
+
+/** Sanitize slug for use as a Mermaid node ID (alphanumeric + underscore). */
+function mermaidId(slug: string): string {
+  return slug.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+/** Escape text for Mermaid node labels. */
+function mermaidEscape(s: string): string {
+  return s.replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+/** Build a display label for a skill's source, linking to GitHub when available. */
+function skillSourceLabel(skill: CompanyPortabilityManifest["skills"][number]): string {
+  if (skill.sourceLocator) {
+    // For GitHub or URL sources, render as a markdown link
+    if (skill.sourceType === "github" || skill.sourceType === "skills_sh" || skill.sourceType === "url") {
+      return `[${skill.sourceType}](${skill.sourceLocator})`;
+    }
+    return skill.sourceLocator;
+  }
+  if (skill.sourceType === "local") return "local";
+  return skill.sourceType ?? "\u2014";
+}
+
+/**
+ * Generate the README.md content for a company export.
+ */
+export function generateReadme(
+  manifest: CompanyPortabilityManifest,
+  options: {
+    companyName: string;
+    companyDescription: string | null;
+  },
+): string {
+  const lines: string[] = [];
+
+  lines.push(`# ${options.companyName}`);
+  lines.push("");
+  if (options.companyDescription) {
+    lines.push(`> ${options.companyDescription}`);
+    lines.push("");
+  }
+
+  // Org chart image (generated during export as images/org-chart.png)
+  if (manifest.agents.length > 0) {
+    lines.push("![Org Chart](images/org-chart.png)");
+    lines.push("");
+  }
+
+  // What's Inside table
+  lines.push("## What's Inside");
+  lines.push("");
+  lines.push("> This is an [Agent Company](https://agentcompanies.io) package from Corporate.");
+  lines.push("");
+
+  const counts: Array<[string, number]> = [];
+  if (manifest.agents.length > 0) counts.push(["Agents", manifest.agents.length]);
+  if (manifest.projects.length > 0) counts.push(["Projects", manifest.projects.length]);
+  if (manifest.skills.length > 0) counts.push(["Skills", manifest.skills.length]);
+  if (manifest.issues.length > 0) counts.push(["Tasks", manifest.issues.length]);
+
+  if (counts.length > 0) {
+    lines.push("| Content | Count |");
+    lines.push("|---------|-------|");
+    for (const [label, count] of counts) {
+      lines.push(`| ${label} | ${count} |`);
+    }
+    lines.push("");
+  }
+
+  // Agents table
+  if (manifest.agents.length > 0) {
+    lines.push("### Agents");
+    lines.push("");
+    lines.push("| Agent | Role | Reports To |");
+    lines.push("|-------|------|------------|");
+    for (const agent of manifest.agents) {
+      const roleLabel = ROLE_LABELS[agent.role] ?? agent.role;
+      const reportsTo = agent.reportsToSlug ?? "\u2014";
+      lines.push(`| ${agent.name} | ${roleLabel} | ${reportsTo} |`);
+    }
+    lines.push("");
+  }
+
+  // Projects list
+  if (manifest.projects.length > 0) {
+    lines.push("### Projects");
+    lines.push("");
+    for (const project of manifest.projects) {
+      const desc = project.description ? ` \u2014 ${project.description}` : "";
+      lines.push(`- **${project.name}**${desc}`);
+    }
+    lines.push("");
+  }
+
+  // Skills list
+  if (manifest.skills.length > 0) {
+    lines.push("### Skills");
+    lines.push("");
+    lines.push("| Skill | Description | Source |");
+    lines.push("|-------|-------------|--------|");
+    for (const skill of manifest.skills) {
+      const desc = skill.description ?? "\u2014";
+      const source = skillSourceLabel(skill);
+      lines.push(`| ${skill.name} | ${desc} | ${source} |`);
+    }
+    lines.push("");
+  }
+
+  // Getting Started
+  lines.push("## Getting Started");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("pnpm corporateai company import this-github-url-or-folder");
+  lines.push("```");
+  lines.push("");
+  lines.push("See Corporate docs for more information.");
+  lines.push("");
+
+  // Footer
+  lines.push("---");
+  lines.push(`Exported from Corporate on ${new Date().toISOString().split("T")[0]}`);
+  lines.push("");
+
+  return lines.join("\n");
+}
+