builder.io 1.6.28 → 1.6.29

package/types/cli/codegen.d.ts

@@ -1,71 +1,99 @@
 import type { DevToolsSys } from "../types";
 import type { CLIArgs } from "./index";
 import { type Credentials } from "./credentials";
-import { type Checkpoint } from "./incremental-tsc";
-import type { ApplyActionsResult, Attachment, CodebaseSearchResponse, ContentMessageItemToolResult, CustomInstruction, GenerateCompletionStep, GenerateUserMessage, ProjectFile, UserContext } from "$/ai-utils";
+import type { CodegenTurn, CustomInstruction, GenerateCompletionStep, GenerateUserMessage, UserContext } from "$/ai-utils";
 import prettier from "prettier";
-interface Turn {
-    completionId: string;
-    nextUrl: string | undefined;
-    originalFiles: {
-        path: string;
-        content: Uint8Array | null;
-    }[];
-    isUserMessage: boolean;
-    toolResults: ContentMessageItemToolResult[];
-    sentiment?: "positive" | "negative" | "undo";
-    applyResults: ApplyActionsResult[];
-    projectFiles: ProjectFile[];
-    userInput: UserInput;
-}
 type State = "unknown" | "initial-with-url" | "initial-without-url" | "generating" | "success" | "abort" | "error";
 export interface SessionContext {
     sessionId: string;
-    turns: Turn[];
+    turns: CodegenTurn[];
     selectedFilePaths: Map<string, number>;
     customInstructions: CustomInstruction[];
     userContext: UserContext;
     prettierConfig: prettier.Config | null;
     state: State;
 }
-export interface UserInput {
-    userPrompt: string;
-    attachments: Attachment[];
-    sentiment: "positive" | "negative" | "undo";
-    files: ProjectFile[];
-    searchResponse: CodebaseSearchResponse | null;
-    rerankFiles?: number;
-    mostRelevantFile: string | null;
-    role: "user" | "agent";
+export interface CodeGenSessionOptionsBase {
+    sys: DevToolsSys;
+    credentials: Credentials;
+    args: CLIArgs;
+    position: string;
+    mode?: "quality" | "quality-v3" | "fast";
+    fusion?: boolean;
+    fusionRemote?: string;
+    fusionAutoInitGit?: boolean;
+    featureBranch?: string;
+}
+export interface CodeGenSessionOptionsSession extends CodeGenSessionOptionsBase {
+    sessionOrCompletionId?: string;
+}
+export interface CodeGenSessionOptionsInitialUrl extends CodeGenSessionOptionsBase {
+    initialUrl: string;
 }
+export type CodeGenSessionOptions = CodeGenSessionOptionsSession | CodeGenSessionOptionsInitialUrl;
+export declare function createCodeSession(options: CodeGenSessionOptions): Promise<CodeGenSession>;
 export declare class CodeGenSession {
     #private;
-    constructor(sys: DevToolsSys, credentials: Credentials, args: CLIArgs, position: string, initialUrl?: string, mode?: "quality" | "quality-v3" | "fast");
+    constructor(options: CodeGenSessionOptions);
+    initializeSession(): Promise<void>;
+    /**
+     * Get the current commit hash
+     */
+    getCurrentCommitHash(): Promise<string | undefined>;
+    /**
+     * Get the feature branch name
+     */
+    getFeatureBranch(): string | undefined;
+    /**
+     * Get the AI branch name
+     */
+    getAiBranch(): string | undefined;
+    /**
+     * Helper to run git commands
+     */
+    runGitCommand(command: string): Promise<string>;
+    /**
+     * Check if Fusion is enabled for this session
+     */
+    isFusionEnabled(): boolean;
     setDebug(debug: boolean): void;
     getAllFiles(): Promise<string[]>;
     isNextPage(): boolean;
-    getSessionId(): Promise<string>;
+    getSessionId(): string;
     getSpaceId(): string | undefined;
-    undoLastUserMessage(dryRun?: boolean): Promise<string[]>;
+    /**
+     * Core function to restore the codebase to a state that matches a predicate.
+     * This is the main function that handles both git-based and file-based restoration.
+     *
+     * @param predicate Function that takes a turn and its index and returns true if we should restore up to that turn
+     * @param dryRun If true, only simulate the restoration without making changes
+     * @returns Array of file paths that were changed
+     */
+    restore(location: "before" | "after", predicate: (turn: CodegenTurn | null, index: number) => boolean, dryRun?: boolean): Promise<string[] | null>;
+    restoreHEAD(): Promise<string[] | null>;
+    restoreAll(): Promise<string[] | null>;
+    restoreBeforeCompletionId(completionId: string): Promise<string[] | null>;
+    /**
+     * Undo all changes back to the last user message
+     */
+    undoLastUserMessage(dryRun?: boolean): Promise<string[] | null>;
     getLastCompletionId(): string | undefined;
     getCurrentState(): State;
-    getLastTurn(): Turn | undefined;
+    getLastTurn(): CodegenTurn | undefined;
     getNextUrl(): string | undefined;
     getNextMessage(): Promise<GenerateUserMessage>;
     sendFeedback(sentiment: "positive" | "negative" | "undo", message?: string, lastCompletionId?: string | undefined): Promise<void>;
     hasUndoChanges(): Promise<boolean>;
     isBusy(): boolean;
     sendMessage(message: GenerateUserMessage): void;
-    isEventLoopRunning(): boolean;
-    getTurns(): void;
-    getSessionContext(): Promise<SessionContext>;
+    getTurns(): CodegenTurn[];
+    getSessionContext(): SessionContext;
     abort(): void;
-    stopEventLoop(): void;
-    startEventLoop(onStep: (step: GenerateCompletionStep) => void): Promise<void>;
-    agentCompletion(userMessage: GenerateUserMessage, baselineCheckpoint: Checkpoint, signal: AbortSignal | undefined, onStep: (step: GenerateCompletionStep) => Promise<void> | void): Promise<Checkpoint>;
-    getUserInput(userMessage: GenerateUserMessage, signal: AbortSignal | undefined): Promise<UserInput>;
+    stopEventLoop(): Promise<void>;
+    connectToEventLoop(shouldReplay: boolean, onStep: (step: GenerateCompletionStep) => void): () => void;
+    waitForEventLoop(): Promise<void>;
+    agentCompletion(userMessage: GenerateUserMessage, signal: AbortSignal | undefined, onStep: (step: GenerateCompletionStep) => Promise<void> | void): Promise<void>;
 }
-export declare const createSessionContext: (sys: DevToolsSys) => Promise<SessionContext>;
 export declare function transformStream(body: ReadableStream<Uint8Array> | null): AsyncGenerator<string, void, unknown>;
 export declare function getUserContext(sys: DevToolsSys): Promise<UserContext>;
 export declare function makeAsyncIterator<T>(): readonly [AsyncGenerator<T, void, void>, (event: T) => void, () => void];

package/types/cli/index.d.ts

@@ -61,4 +61,14 @@ export interface CLIArgs {
     silent?: boolean;
     /** Fusion project ID */
     projectId?: string;
+    /** Enable Fusion side-car branch workflow */
+    fusion?: boolean;
+    /** Remote URL for Fusion side-car branch storage */
+    fusionRemote?: string;
+    /** Auto-commit changes when session ends (for Fusion) */
+    fusionAutoCommit?: boolean;
+    /** Auto-initialize a git repository if none exists (for Fusion) */
+    fusionAutoInitGit?: boolean;
+    /** Push changes to origin after squash merge (for Fusion) */
+    fusionPushToOrigin?: boolean;
 }

package/types/cli/server-ws.d.ts

@@ -0,0 +1,56 @@
+import type { Duplex } from "node:stream";
+import type { IncomingMessage } from "node:http";
+export type SocketRequest = {
+    id: number;
+    jsonrpc: string;
+    method: string;
+    params: any;
+};
+export type SocketResponse<T = any> = {
+    id?: number | null;
+    jsonrpc: string;
+    result?: T;
+    notification?: string;
+    params?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+};
+export type SocketSendOptions = {
+    timeout?: number;
+};
+export type SocketQueue = {
+    type: "request" | "notification";
+    result?: SocketResponse["result"];
+    error?: SocketResponse["error"];
+};
+import type { ServerOptions } from "ws";
+import type { WebSocket } from "ws";
+type RegisterFn<T = any> = (params: T, socketId: string) => Promise<any> | any;
+type SocketEvents = {
+    listening: () => Promise<void> | void;
+    connection: (socket: WebSocket, socketId: string) => Promise<void> | void;
+    disconnection: (socketId: string) => Promise<void> | void;
+    error: (error: Error) => Promise<void> | void;
+    "socket-error": (socketId: string, error: Error) => Promise<void> | void;
+    close: () => Promise<void> | void;
+};
+export declare function Server(opts: ServerOptions): {
+    on: <EventKey extends keyof SocketEvents>(event: EventKey, cb: SocketEvents[EventKey]) => void;
+    of: (ns: string) => {
+        emit: (name: string, ...params: any[]) => void;
+        clients: () => Map<string, WebSocket>;
+        register: <T = any>(method: string, fn: RegisterFn<T>) => void;
+        event: (name: string) => void;
+    };
+    event: (e: string) => void;
+    handleUpgrade: (req: IncomingMessage, socket: Duplex, upgradeHead: Buffer, callback?: (client: WebSocket, request: IncomingMessage) => void) => Promise<void>;
+    clients: () => Map<string, WebSocket>;
+    register: <T = any>(method: string, fn: RegisterFn<T>) => void;
+    emit: (name: string, ...params: any[]) => void;
+    notify: (name: string, socketId: string, ...params: any[]) => void;
+    close: () => Promise<unknown>;
+};
+export {};