@builder.io/ai-utils 0.80.0 → 0.81.1

package/package.json

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

package/src/codegen.d.ts

@@ -945,6 +945,8 @@ export declare const ProposedConfigSchema: z.ZodObject<{
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>;
+    appliedAt: z.ZodOptional<z.ZodString>;
+    appliedBy: z.ZodOptional<z.ZodString>;
     sessionId: z.ZodString;
     orchestratorStates: z.ZodObject<{
         setupState: z.ZodEnum<{
@@ -3225,6 +3227,33 @@ export interface GenerateCompletionStepDevServerState {
     proxyServerReachable: boolean;
     validateState: ValidateCommandState;
 }
+/**
+ * Human-readable explanation of how each git-status decision was reached for a
+ * single repo, computed once in the CLI so the debug logs and the web UI
+ * (Merge-button tooltip + Fusion Debug Info) all read the same reasons. Rides
+ * along on the emitted git step; never persisted to Firebase.
+ */
+export interface GitStatusDiagnostics {
+    /** One-line human summary of this repo's overall git state. */
+    summary: string;
+    /** Base/parent branch used for ahead-of-base (e.g. "origin/main"). */
+    baseBranch?: string;
+    /** Merge-base commit between HEAD and baseBranch, when resolved. */
+    baseMergeBase?: string;
+    /** True if a fetch-and-retry was needed to resolve the base ref. */
+    baseRefFetched?: boolean;
+    /** Why aheadOfBase is what it is, incl. the fail-open reason when undefined. */
+    aheadOfBaseReason: string;
+    /** The branch's own remote tracking branch used for ahead/behind. */
+    remoteTrackingBranch?: string;
+    canPushReason: string;
+    canSyncReason: string;
+    canPullReason: string;
+    remoteReason: string;
+    mergeConflictReason?: string;
+    /** Why the Merge button is (or isn't) gated open, independent of the summary. */
+    mergeReason: string;
+}
 export interface GenerateCompletionStepGit {
     type: "git";
     folderName?: string;
@@ -3238,6 +3267,21 @@ export interface GenerateCompletionStepGit {
     canSync: boolean;
     ahead: number;
     behind: number;
+    /**
+     * Commits on HEAD not yet in the base/parent branch (e.g. main). Distinct from
+     * `ahead`, which counts commits ahead of this branch's own remote tracking
+     * branch. `undefined` only when it could not be determined even after a
+     * fetch-and-retry (rare) — consumers should fail open in that case.
+     */
+    aheadOfBase?: number;
+    /**
+     * True when HEAD's tree differs from the base/parent branch's tree (content
+     * diff, not commit count). Squash-merge safe: after a squash merge, HEAD's
+     * tree matches base's tree even though `aheadOfBase` commit-count stays >0.
+     * `undefined` only when it could not be determined; consumers should fail
+     * open (treat as `true`) in that case.
+     */
+    hasChangesAgainstBase?: boolean;
     commitMode: CommitMode;
     hasMergeConflict: boolean;
     currentCommit: string;
@@ -3245,6 +3289,11 @@ export interface GenerateCompletionStepGit {
     remoteBranch: string;
     pendingValidation: boolean;
     unmergedFiles: string[];
+    /**
+     * Human-readable "why" for each git decision above, used by CLI debug logs
+     * and the web UI. Optional so older CLIs that don't emit it still typecheck.
+     */
+    diagnostics?: GitStatusDiagnostics;
 }
 /**
  * A typed comment added to the session via the generic `AddComment` tool. The
@@ -4544,6 +4593,13 @@ export interface SearchFilesOptions {
     contextBefore?: number;
     /** Include context lines after each match */
     contextAfter?: number;
+    /**
+     * Return one result per matching file instead of one per match line. `maxResults` then caps
+     * distinct files rather than individual lines, so a query that hits many lines in a few files
+     * can't crowd out other matching files. Match metadata (line/column/ content/context) is not
+     * populated in this mode.
+     */
+    filesWithMatchesOnly?: boolean;
 }
 export interface SearchFileMatch {
     /** Relative file path */
@@ -4570,6 +4626,54 @@ export interface SearchFilesResult {
     filesWithMatches: number;
     /** Whether results were truncated */
     truncated: boolean;
+    /**
+     * True when ripgrep itself failed (spawn error, or exit code 2 or greater) rather than simply
+     * finding no matches (exit code 1). Lets callers distinguish "search couldn't run" from "search
+     * ran, found nothing".
+     */
+    searchError?: boolean;
+}
+/**
+ * Request to derive a stable AST structural key for the JSX element at a source coordinate, used
+ * to anchor a Fusion comment. See the "Fusion Comment Anchor Categorization" tech spec.
+ */
+export interface DeriveCommentAnchorKeyOptions {
+    /** Source file the commented element was captured from. */
+    filePath: string;
+    /** 1-indexed line of the element's opening tag (parsed from the captured `data-loc`). */
+    line: number;
+    /** Column of the opening tag, when known, to disambiguate multiple elements on one line. */
+    col?: number;
+}
+export interface DeriveCommentAnchorKeyResult {
+    /** `v1:<scope>/<tag>[<n>]/…`. Absent when the file has no JSX element at the coordinate. */
+    structuralKey?: string;
+    /** Nearest enclosing named component/function. */
+    componentName?: string;
+    /** `tag|sorted-static-attrs|static-text` — exact-match fallback when the key drifts. */
+    sourceSignature?: string;
+}
+/**
+ * Request to check whether a previously-anchored element still exists in the project source.
+ * Pure/read-only — never writes back. See the tech spec for the read cascade.
+ */
+export interface ResolveCommentAnchorOptions {
+    /** File the element was last known to live in. */
+    filePath?: string;
+    /** Stable AST key from capture (primary match). */
+    structuralKey?: string;
+    /** Static signature from capture (fallback when the key drifted). */
+    sourceSignature?: string;
+    /** Tag name, used only for logging/heuristics. */
+    tagName?: string;
+}
+export interface ResolveCommentAnchorResult {
+    /** `present` → element still in source (caller maps to UNREACHABLE if not rendered); `absent` → ORPHANED. */
+    state: "present" | "absent";
+    /** The file the element was found in (may differ from the input on a move/rename). */
+    filePath?: string;
+    /** The current structural key (may differ from the input when the key drifted). */
+    structuralKey?: string;
 }
 /**
  * Options for searching file tree (quick open functionality).

package/src/codegen.js

@@ -1035,6 +1035,13 @@ export const ProposedConfigSchema = z
     summary: z.string().meta({ description: "Summary from Exit tool" }),
     questions: z.array(ProposedQuestionSchema).optional(),
     configuration: ProposedConfigurationSchema,
+    // Application outcome — stamped by applyProposedConfigToProject
+    appliedAt: z.string().optional().meta({
+        description: "ISO timestamp of when this config was applied to the project",
+    }),
+    appliedBy: z.string().optional().meta({
+        description: "User id that applied this config, or 'auto-apply' for the on-exit auto-apply path",
+    }),
     // Metadata
     sessionId: z.string(),
     orchestratorStates: ProposedOrchestratorStatesSchema,

package/src/projects.d.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import type { BuilderConfigHosting } from "./builder-config.js";
 import type { ConnectivityErrorCode, CheckType, LikelyCause } from "./connectivity/types.js";
 import { type EnvironmentVariable, type SetupDependency } from "./common-schemas";
-import type { FileOverride, LaunchServerState, LaunchServerStatus, BranchBackup, CommitMode, CustomInstruction, CustomAgentDefinition, GitSnapshot, AutoPushMode, GenerateUserMessage, CodeGenToolMap, GenerateCompletionStep, ReviewEffort } from "./codegen";
+import type { FileOverride, LaunchServerState, LaunchServerStatus, BranchBackup, CommitMode, CustomInstruction, CustomAgentDefinition, GitSnapshot, AutoPushMode, GenerateUserMessage, CodeGenToolMap, GenerateCompletionStep, ReviewEffort, ExitState } from "./codegen";
 import type { FallbackTokensPrivate } from "./organization";
 /**
  * Temporary type for date fields during migration.
@@ -915,8 +915,12 @@ export interface Project {
     useBranchesCollection?: boolean;
     /** When true, the project is in code-only mode */
     codeOnlyMode?: boolean;
-    /** When true, analysis detected a mobile-only app (no usable web dev server path) */
-    mobileOnlyDetected?: boolean;
+    /**
+     * Why the project is in code-only mode: the setup-agent exit state that put it
+     * there (e.g. "mobile-project", "no-frontend"). Written by the propose-config
+     * apply path; null once setup verifies.
+     */
+    codeOnlyReason?: Exclude<ExitState, "verified"> | null;
     /** When true, this project is an org-level Claw agent */
     isOrgAgent?: boolean;
     /** Configuration for the org agent */
@@ -932,6 +936,8 @@ export interface Project {
     /** Settings related to Fusion first class hosting */
     hosting?: ProjectHosting;
     database?: ProjectDatabase;
+    /** @deprecated Use `codeOnlyReason` instead */
+    mobileOnlyDetected?: boolean;
 }
 export interface ProjectDatabase {
     ownerId: string;
@@ -1607,6 +1613,8 @@ export type DeployListItem = z.infer<typeof DeployListItemSchema>;
 export declare const DeployArtifactManifestSchema: z.ZodObject<{
     files: z.ZodRecord<z.ZodString, z.ZodString>;
     functions: z.ZodRecord<z.ZodString, z.ZodString>;
+    functions_config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    function_invocation_modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type DeployArtifactManifest = z.infer<typeof DeployArtifactManifestSchema>;
 /**

package/src/projects.js

@@ -462,6 +462,20 @@ export const DeployArtifactManifestSchema = z.object({
     functions: z.record(z.string(), z.string()).meta({
         description: "serverless function name → sha256 hash",
     }),
+    // Netlify Functions v2 routing config: function name → config object.
+    // Kept as a loose record so ai-utils does not need to depend on the Netlify
+    // API package for the exact functionConfig schema.
+    functions_config: z
+        .record(z.string(), z.record(z.string(), z.unknown()))
+        .optional()
+        .meta({
+        description: "Netlify Functions v2 routing config per function name",
+    }),
+    // Lambda invocation mode per function: "stream" for v2 functions using
+    // awslambda.streamifyResponse bootstrap; absent/undefined means buffered.
+    function_invocation_modes: z.record(z.string(), z.string()).optional().meta({
+        description: 'Lambda invocation mode per function name (e.g. "stream" for v2 streaming functions)',
+    }),
 });
 /**
  * Per-deploy overrides passed from ai-services to the deploy pod's build-and-upload endpoint.

package/src/single-tenancy.d.ts

@@ -89,4 +89,31 @@ export interface UpdateSingleTenancyConfigOpts {
     importCustomRoutes?: boolean;
     dedicatedNodePool?: DedicatedNodePoolConfig | null;
 }
+/** Status of a single provisioned VPC resource (bridge VPC, proxy VM, etc.). */
+export interface SingleTenancyLiveCheck {
+    label?: string;
+    status?: "ok" | "missing" | "running" | "stopped" | "active" | "inactive" | "error" | "unknown";
+    details?: string;
+    resourceName?: string;
+    resourceType?: string;
+}
+/**
+ * Aggregated live status of the resources backing a VPC connection. Which
+ * checks are present depends on the connection type: peering configs report
+ * `bridgeVpc`/`proxyVm`/`peering`, network-attachment configs report
+ * `proxyVm`/`networkAttachment`.
+ */
+export interface SingleTenancyLiveStatus {
+    bridgeVpc?: SingleTenancyLiveCheck;
+    proxyVm?: SingleTenancyLiveCheck;
+    peering?: SingleTenancyLiveCheck;
+    networkAttachment?: SingleTenancyLiveCheck;
+}
+/** Computed infrastructure resource names derived from a config id/type. */
+export interface SingleTenancyDerivedNames {
+    bridgeVpcName?: string;
+    proxyVmName?: string;
+    bridgePeeringName?: string;
+    networkAttachmentName?: string;
+}
 export {};