@builder.io/ai-utils 0.85.0 → 0.85.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/ai-utils",
-  "version": "0.85.0",
+  "version": "0.85.1",
   "description": "Builder.io AI utils",
   "files": [
     "src"

package/src/events.d.ts

@@ -598,6 +598,8 @@ export type BotMentionGitHubInternalPrV1 = FusionEventVariant<"bot.mention.githu
     /** Numeric GitHub comment ID (for reaction / reply threading) */
     commentNumericId?: number;
     commentType: "issue" | "pr";
+    /** Whether the normal bot-mention pipeline should post successful agent text. */
+    postSuccessResultComment?: boolean;
     /** GitHub Enterprise hostname, if applicable */
     hostname?: string;
     /** For review comments: the comment being replied to */

package/src/organization.d.ts

@@ -450,6 +450,7 @@ interface Role {
 export interface Organization {
     name?: string;
     id?: string;
+    "@originId"?: string;
     createdDate?: number;
     intent?: string;
     ecommerceBackend?: string;

package/src/projects.d.ts

@@ -628,6 +628,70 @@ export interface NewBranch extends BranchSharedData, RequiredBranchSharedData {
  */
 export type Branch = NewBranch | LegacyBranch;
 export declare const checkIsNewBranch: (branch: Branch) => branch is NewBranch;
+/**
+ * Request options for `GET /projects/branches/list`. Owner/org scope comes from
+ * the authenticated request context; `ownerId` here is a superuser-only override.
+ */
+export declare const ListBranchesOptionsSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    projectIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    kanbanColumn: z.ZodOptional<z.ZodEnum<{
+        archived: "archived";
+        "awaiting-feedback": "awaiting-feedback";
+        "in-progress": "in-progress";
+        "in-review": "in-review";
+        merged: "merged";
+    }>>;
+    states: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        deleted: "deleted";
+    }>>>;
+    includeHidden: z.ZodOptional<z.ZodBoolean>;
+    search: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        feature: "feature";
+        fix: "fix";
+        other: "other";
+        research: "research";
+    }>>>;
+    prStatus: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        closed: "closed";
+        draft: "draft";
+        merged: "merged";
+        none: "none";
+        open: "open";
+    }>>>;
+    createdBy: z.ZodOptional<z.ZodString>;
+    assignedTo: z.ZodOptional<z.ZodString>;
+    notYetReviewed: z.ZodOptional<z.ZodBoolean>;
+    showOnlyRepoConnected: z.ZodOptional<z.ZodBoolean>;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        alphabetical: "alphabetical";
+        dateCreated: "dateCreated";
+        recentlyUpdated: "recentlyUpdated";
+    }>>;
+    sortByLastActivity: z.ZodOptional<z.ZodBoolean>;
+    sortDirection: z.ZodOptional<z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    ownerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListBranchesOptions = z.infer<typeof ListBranchesOptionsSchema>;
+/** Response body for the paginated branches list endpoint. */
+export interface ListBranchesResult {
+    branches: Branch[];
+    /** Opaque cursor to pass as `cursor` for the next page, or null when there is no next page. */
+    nextCursor: string | null;
+    hasNextPage: boolean;
+    /** Total number of branches matching the filters, across all pages. */
+    totalCount: number;
+    /** True when `totalCount` comes from the eventually-consistent Mongo index, so it may lag reality slightly. */
+    totalCountIsApproximate?: boolean;
+}
 export type CpuKind = "performance" | "standard" | "shared";
 export type MachineAutoStop = "stop" | "off" | "suspend";
 export interface ProjectRolePermissions {
@@ -1491,6 +1555,14 @@ export declare const ProjectHostingSchema: z.ZodObject<{
     }>>;
     publishedCommit: z.ZodOptional<z.ZodString>;
     autoDeploy: z.ZodOptional<z.ZodBoolean>;
+    unpublishTrigger: z.ZodOptional<z.ZodEnum<{
+        system: "system";
+        user: "user";
+    }>>;
+    systemUnpublishReason: z.ZodOptional<z.ZodEnum<{
+        "bandwidth-cap": "bandwidth-cap";
+        "web-request-cap": "web-request-cap";
+    }>>;
     domainIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type ProjectHosting = z.infer<typeof ProjectHostingSchema>;
@@ -1549,6 +1621,36 @@ export declare const HostingSlugSchema: z.ZodObject<{
     createdBy: z.ZodString;
 }, z.core.$strip>;
 export type HostingSlug = z.infer<typeof HostingSlugSchema>;
+/**
+ * Per-Neon-project charged-through watermarks inside a space's hosting usage
+ * snapshot. Storage folds root + child branch bytes-month into one field.
+ */
+export declare const HostingNeonProjectUsageSchema: z.ZodObject<{
+    computeUnitSecondsChargedThrough: z.ZodNumber;
+    storageBytesMonthChargedThrough: z.ZodNumber;
+    transferBytesChargedThrough: z.ZodNumber;
+}, z.core.$strip>;
+export type HostingNeonProjectUsage = z.infer<typeof HostingNeonProjectUsageSchema>;
+/**
+ * Reconciler idempotency watermark for a space's Netlify + Neon hosting costs,
+ * stored at `hostingUsageSnapshots/{spaceId}`. Netlify is one account-level
+ * scalar; Neon is a per-project map. `freeDeployCount` gates the free 5/mo
+ * deploy cap (cost itself is inside Netlify's partner_account_usage total).
+ */
+export declare const HostingUsageSnapshotSchema: z.ZodObject<{
+    ownerId: z.ZodString;
+    periodKey: z.ZodString;
+    netlifyConsumptionCycleStart: z.ZodString;
+    netlifyCreditsChargedThrough: z.ZodNumber;
+    neonByProject: z.ZodRecord<z.ZodString, z.ZodObject<{
+        computeUnitSecondsChargedThrough: z.ZodNumber;
+        storageBytesMonthChargedThrough: z.ZodNumber;
+        transferBytesChargedThrough: z.ZodNumber;
+    }, z.core.$strip>>;
+    freeDeployCount: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type HostingUsageSnapshot = z.infer<typeof HostingUsageSnapshotSchema>;
 /**
  * Deploy lease lock with fencing token, stored at
  * `hosting-locks/{projectId}__{checkoutBranch}` (the key uses the resolved ref

package/src/projects.js

@@ -49,6 +49,91 @@ export const EXAMPLE_OR_STARTER_REPOS_URLS = EXAMPLE_OR_STARTER_REPOS.map((repo)
 export const checkIsNewBranch = (branch) => {
     return "projectId" in branch;
 };
+/**
+ * Request options for `GET /projects/branches/list`. Owner/org scope comes from
+ * the authenticated request context; `ownerId` here is a superuser-only override.
+ */
+export const ListBranchesOptionsSchema = z.object({
+    projectId: z.string().optional().meta({
+        description: "Filter to a single project. Omit to list all branches in the owner's org.",
+    }),
+    projectIds: z.array(z.string()).optional().meta({
+        description: "Filter to any of these projects, unioned with projectId.",
+    }),
+    kanbanColumn: z
+        .enum([
+        "in-progress",
+        "in-review",
+        "awaiting-feedback",
+        "merged",
+        "archived",
+    ])
+        .optional()
+        .meta({
+        description: "Kanban column to scope to. Derives column membership from state, PR url/status and reviewers, and overrides `states`.",
+    }),
+    states: z
+        .array(z.enum(["active", "deleted", "archived"]))
+        .optional()
+        .meta({
+        description: 'Lifecycle states to include. Defaults to ["active"]. Ignored when kanbanColumn is set.',
+    }),
+    includeHidden: z.boolean().optional().meta({
+        description: "Superuser-only; superusers see hidden branches by default and pass false to opt out. Ignored for non-superusers.",
+    }),
+    search: z.string().optional().meta({
+        description: "Case-insensitive substring match over friendlyName, name and description.",
+    }),
+    category: z
+        .array(z.enum(["feature", "fix", "research", "other"]))
+        .optional()
+        .meta({ description: "Filter by auto-assigned work category." }),
+    prStatus: z
+        .array(z.enum(["open", "draft", "merged", "closed", "none"]))
+        .optional()
+        .meta({
+        description: "Filter by derived PR status (none = no PR opened yet).",
+    }),
+    createdBy: z
+        .string()
+        .optional()
+        .meta({ description: "Only branches created by this user id." }),
+    assignedTo: z
+        .string()
+        .optional()
+        .meta({ description: "Only branches where this user id is a reviewer." }),
+    notYetReviewed: z.boolean().optional().meta({
+        description: "With assignedTo, exclude branches whose reviews already contain that user.",
+    }),
+    showOnlyRepoConnected: z.boolean().optional().meta({
+        description: "Exclude the default main branch and commit-mode branches.",
+    }),
+    sortBy: z
+        .enum(["recentlyUpdated", "alphabetical", "dateCreated"])
+        .optional()
+        .meta({
+        description: "Sort key. recentlyUpdated (default) sorts by lastUpdatedAt.",
+    }),
+    sortByLastActivity: z.boolean().optional().meta({
+        description: "When true, recentlyUpdated keys off lastActivityAt (falling back to lastUpdatedAt). Ignored for other sort keys.",
+    }),
+    sortDirection: z.enum(["asc", "desc"]).optional().meta({
+        description: "Defaults to desc for date sorts, asc for alphabetical.",
+    }),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional()
+        .meta({ description: "Page size, clamped to 1–200. Defaults to 50." }),
+    cursor: z.string().optional().meta({
+        description: "Opaque pagination cursor from a prior response's nextCursor.",
+    }),
+    ownerId: z.string().optional().meta({
+        description: "Superuser-only: list branches for a different owner/org.",
+    }),
+});
 /** Grace period before scheduled Neon deletions run (reconciler + schedule APIs). */
 export const NEON_DELETION_GRACE_PERIOD_MS = 30 * 24 * 60 * 60 * 1000;
 /**
@@ -328,6 +413,26 @@ export const ProjectHostingSchema = z.object({
         .boolean()
         .optional()
         .meta({ description: "auto-deploy on push/merge" }),
+    /**
+     * Who last drove the site into `publishStatus: "unpublished"`. Absent is
+     * treated as `"user"`. `"system"` means free-tier usage-cap enforcement took
+     * the site down (deleted the HTTPRoute, kept the Netlify site) and the
+     * reconciler **may** auto-restore it — routing-only, no rebuild — once the cap
+     * clears. `"user"` (or absent) means the user unpublished, so the reconciler
+     * must leave it down. The publish/unpublish hosting lock keeps this honest:
+     * whichever operation wins the lock is the one that writes `publishStatus`
+     * and this field, so they never disagree.
+     */
+    unpublishTrigger: z.enum(["system", "user"]).optional().meta({
+        description: "Who last unpublished the site. Absent === user. 'system' lets the reconciler auto-restore a usage-cap takedown; 'user' does not.",
+    }),
+    /**
+     * Why the system unpublished the site. Set iff `unpublishTrigger === "system"`;
+     * drives the projects-grid "suspended" card and takedown observability.
+     */
+    systemUnpublishReason: z
+        .enum(["bandwidth-cap", "web-request-cap"])
+        .optional(),
     domainIds: z.array(z.string()).optional().meta({
         description: "Doc keys (normalized domains) in `hosting-domains` attached to this project. The domain docs are the source of truth; this is only the back-pointer.",
     }),
@@ -411,6 +516,42 @@ export const HostingSlugSchema = z.object({
         description: "user ID of the user who first clicked Publish on the project",
     }),
 });
+/**
+ * Per-Neon-project charged-through watermarks inside a space's hosting usage
+ * snapshot. Storage folds root + child branch bytes-month into one field.
+ */
+export const HostingNeonProjectUsageSchema = z.object({
+    computeUnitSecondsChargedThrough: z.number(),
+    storageBytesMonthChargedThrough: z.number().meta({
+        description: "root + child branch bytes-month already billed",
+    }),
+    transferBytesChargedThrough: z.number().meta({
+        description: "public network transfer bytes already billed",
+    }),
+});
+/**
+ * Reconciler idempotency watermark for a space's Netlify + Neon hosting costs,
+ * stored at `hostingUsageSnapshots/{spaceId}`. Netlify is one account-level
+ * scalar; Neon is a per-project map. `freeDeployCount` gates the free 5/mo
+ * deploy cap (cost itself is inside Netlify's partner_account_usage total).
+ */
+export const HostingUsageSnapshotSchema = z.object({
+    ownerId: z.string(),
+    periodKey: z.string().meta({
+        description: "Builder billing cycle; resets the Neon watermarks",
+    }),
+    netlifyConsumptionCycleStart: z.string().meta({
+        description: "Netlify consumption_cycle_start_date; watermark resets when this advances",
+    }),
+    netlifyCreditsChargedThrough: z.number().meta({
+        description: "Netlify credits already billed this Netlify cycle",
+    }),
+    neonByProject: z.record(z.string(), HostingNeonProjectUsageSchema),
+    freeDeployCount: z.number().meta({
+        description: "Deploys this Builder cycle, for the free 5/mo cap",
+    }),
+    updatedAt: z.number(),
+});
 /**
  * Deploy lease lock with fencing token, stored at
  * `hosting-locks/{projectId}__{checkoutBranch}` (the key uses the resolved ref