@builder.io/dev-tools 1.18.11-dev.202511202306.80563b8f8 → 1.18.11-dev.202511202319.621aec6ae

package/types/packages/dev-tools/cli/backup.d.ts

@@ -0,0 +1,172 @@
+import type { DevToolsSys } from "../types";
+import type { Credentials } from "./credentials";
+import {
+	type GitBackupUploadUrlResult,
+	type GitBackupUploadUrlOptions,
+	type GitBackupRecordOptions,
+	type GitBackupRecordResult,
+	type BackupMetadata,
+	type WorkspaceConfiguration,
+	type CodegenRuntimeStatus,
+	type BackupGitRepoResult,
+} from "$/ai-utils";
+interface BackupGitRepoOptions {
+	sys: DevToolsSys;
+	credentials: Credentials;
+	projectId: string;
+	branchName: string;
+	repoPath: string;
+	aiBranch: string;
+	featureBranch: string;
+	workspace: WorkspaceConfiguration | undefined;
+	/**
+	 * If true, the system is connected to the git provider.
+	 * If false, the system is offline and will not fetch any branches from origin.
+	 */
+	isConnectedToProvider: boolean;
+	debug: boolean;
+	forcedFullBackup: boolean;
+	canAbortMerge: boolean;
+}
+/**
+ * Creates a backup of git repository changes made by the AI system.
+ *
+ * This function handles both partial and full backups:
+ * - Partial backups: Only include commits created locally (on aiBranch) that aren't in upstream.
+ *   This keeps backups small and doesn't store the entire repo's code. Requires a clone from
+ *   upstream plus applying the backup to restore.
+ * - Full backups: Complete repo backup that can be directly cloned from.
+ *
+ * The aiBranch is where the AI creates commits as work progresses, while featureBranch
+ * is the base branch where work started (usually "main").
+ */
+export declare function backupGitRepo({
+	sys,
+	credentials,
+	projectId,
+	branchName,
+	repoPath,
+	aiBranch,
+	featureBranch,
+	workspace,
+	isConnectedToProvider,
+	debug,
+	forcedFullBackup,
+	canAbortMerge,
+}: BackupGitRepoOptions): Promise<BackupGitRepoResult>;
+type InitialCommitHashResult =
+	| {
+			initialBranch: string;
+			initialCommitHash: string | undefined;
+			partial: false;
+			forcedFullBackup: true;
+	  }
+	| {
+			initialBranch: string;
+			initialCommitHash: string;
+			partial: boolean;
+			forcedFullBackup: false;
+	  };
+/**
+ * Determines the initial commit hash and whether to create a partial or full backup.
+ *
+ * Partial backups are preferred to keep backup sizes small, but full backups are needed when:
+ * - The repo is an example/starter template (users can't push to origin, need to fork)
+ * - There's no origin remote configured
+ *
+ * For partial backups, we fetch the latest state of the chosen upstream branch from origin
+ * to ensure the backup has the correct commit range reference.
+ */
+export declare function getInitialCommitHash({
+	sys,
+	repoPath,
+	featureBranch,
+	debug,
+	workspace,
+	isConnectedToProvider,
+	forcedFullBackup,
+	credentials,
+	projectId,
+}: {
+	sys: DevToolsSys;
+	repoPath: string;
+	featureBranch: string;
+	debug: boolean;
+	workspace: WorkspaceConfiguration | undefined;
+	isConnectedToProvider: boolean;
+	forcedFullBackup: boolean;
+	credentials: Credentials;
+	projectId: string;
+}): Promise<InitialCommitHashResult>;
+/**
+ * Requests a signed upload URL for git backup
+ */
+export declare function requestSignedUploadUrl(
+	credentials: Credentials,
+	body: GitBackupUploadUrlOptions,
+): Promise<GitBackupUploadUrlResult | null>;
+/**
+ * Records a successful git backup in Firebase
+ */
+export declare function recordBackup(
+	credentials: Credentials,
+	body: GitBackupRecordOptions,
+): Promise<GitBackupRecordResult>;
+export interface GitBackupDownloadResultValid {
+	success: true;
+	partial: boolean;
+	bundlePath: string | undefined;
+	bundleSize: number;
+	gitBranchName: string;
+	lastCommitHash: string;
+}
+export interface GitBackupDownloadResultInvalid {
+	success: false;
+	error: Error;
+}
+export type GitBackupDownloadResult =
+	| GitBackupDownloadResultValid
+	| GitBackupDownloadResultInvalid;
+/**
+ * Downloads a git backup bundle from remote storage.
+ * Handles both empty backups (no bundle file) and regular backups with bundle files.
+ * @returns The path to the downloaded bundle file, or undefined if it's an empty backup
+ */
+export declare function downloadGitBackup(
+	sys: DevToolsSys,
+	response: BackupMetadata,
+): Promise<GitBackupDownloadResult>;
+/**
+ * Uploads a file stream to a signed URL (Google Cloud Storage).
+ * Uses MD5 hash for content verification as required by GCS.
+ */
+export declare function uploadFileStream(
+	filePath: string,
+	signedUrl: string,
+	size: number,
+	contentMd5: string,
+): Promise<Response>;
+export declare function computeMD5Hash(bundlePath: string): Promise<{
+	contentMd5: string;
+	size: number;
+}>;
+/**
+ * Updates the last commit hash in the database for tracking purposes.
+ * This is called frequently throughout the codebase (after every commit creation)
+ * to track the current state and determine if backups are up-to-date.
+ */
+export declare function setRuntimeStatus(
+	sys: DevToolsSys,
+	credentials: Credentials,
+	data: CodegenRuntimeStatus,
+): Promise<any>;
+/**
+ * Computes a unique backup reference string that combines version, repo URL, and commit hash.
+ * This reference can be used to identify and retrieve specific backups.
+ */
+export declare function computeBackupRef(input: {
+	version: string | undefined;
+	originalRepoUrl: string | undefined;
+	commitHash: string | undefined;
+}): string | undefined;
+export {};

package/types/packages/dev-tools/cli/builder-add/interface.d.ts

@@ -0,0 +1,22 @@
+import type {
+	AddCliOptions,
+	FileNode,
+	FolderNode,
+	Snippet,
+	SyncInfo,
+} from "../../types";
+export declare function addCommand(
+	opts: AddCliOptions,
+): Promise<SyncInfo | undefined>;
+export declare function fetchSnippet(id: string): Promise<Snippet | null>;
+export declare function writeFiles(
+	appRootDir: string,
+	snippet: Snippet,
+	files: Array<FileNode | FolderNode>,
+	rootPath: string,
+	addSessionLink: boolean,
+): Promise<FileNode[]>;
+export declare function suggestRootPath(
+	appRootDir: string,
+	framework: string,
+): string;

package/types/packages/dev-tools/cli/builder-add/options.d.ts

@@ -0,0 +1,2 @@
+import type { AddCliOptions } from "../../types";
+export declare function getOptions(cwd: string, args: string[]): AddCliOptions;

package/types/packages/dev-tools/cli/code-file-utils.d.ts

@@ -0,0 +1,20 @@
+import type { DevToolsSys } from "../types";
+import type { Credentials } from "./credentials";
+import type { CodebaseSearchOptions, CodebaseSearchResponse } from "$/ai-utils";
+export declare function shouldIncludeFile(
+	inputFile: string,
+	ctx: {
+		foundFiles: string[];
+		allFiles: string[];
+		selectedFilePaths: Map<string, number>;
+		cwd: string;
+		appRootDir: string;
+		fallbackImportance: number | 0;
+	},
+): number | 0;
+export declare function searchCodeBase(
+	sys: DevToolsSys,
+	credentials: Credentials,
+	signal: AbortSignal | undefined,
+	body: CodebaseSearchOptions,
+): Promise<CodebaseSearchResponse | null>;

package/types/packages/dev-tools/cli/code-file-utils.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/types/packages/dev-tools/cli/code-tools.d.ts

@@ -0,0 +1,131 @@
+import type {
+	AccessResult,
+	CodeGenPosition,
+	CodeGenTools,
+	CodegenTurn,
+	ContentMessageItemToolResult,
+	FusionConfig,
+	GenerateCompletionStep,
+	Permission,
+	ProjectFile,
+	UserSource,
+	WorkspaceFolder,
+} from "$/ai-utils";
+import type { DevToolsSys } from "../core";
+import { type DevServerOrchestrator } from "./launch/dev-server-orchestrator";
+import type { CodeGenEventEmitter } from "./codegen";
+import type { Credentials } from "./credentials";
+export interface LLMToolCalls {
+	name: CodeGenTools;
+	input: Record<string, any>;
+	id: string;
+	abortController: AbortController;
+}
+export interface ToolResolution {
+	toolResult: string;
+	isError: boolean;
+	title?: string;
+}
+export interface FusionContext {
+	devServerOrchestrator?: DevServerOrchestrator;
+	git: boolean;
+	gitRemote?: string;
+	gitAutoInit?: boolean;
+}
+export interface ToolContext extends Partial<FusionContext> {
+	sys: DevToolsSys;
+	credentials: Credentials;
+	files: ProjectFile[];
+	user: UserSource;
+	position: CodeGenPosition;
+	emitter: CodeGenEventEmitter;
+	fusionConfig: FusionConfig | undefined;
+	canCollapseWorkspace: boolean;
+	signal: AbortSignal;
+	workingDirectory: string;
+	allowedCommands: RegExp[];
+	getAllFiles: (options: {
+		getDotFiles?: boolean;
+		pattern?: string;
+	}) => Promise<string[]>;
+	restore: (options: {
+		location: "before" | "after";
+		predicate: (turn: CodegenTurn | null, index: number) => boolean;
+		dryRun?: boolean;
+		revert?: boolean;
+		forceReplay?: boolean;
+		debug?: string;
+	}) => Promise<{
+		undone: string[] | null;
+		message: string;
+	}>;
+	bashWorkingDirectory: string;
+	filterText: (text: string) => string;
+	resolveWorkspacePath: (
+		path: string,
+		forceWorkspace: boolean,
+	) => {
+		resolvedPath: string;
+		workspaceFolder?: WorkspaceFolder;
+	};
+	absolutePathToWorkspaceUrl: (absolutePath: string) => string | undefined;
+	workspaceFolders: Array<{
+		path: string;
+		name?: string;
+	}>;
+	patchFusionConfig: (patch: Partial<FusionConfig>) => void;
+	passThrough: (
+		toolCall: LLMToolCalls,
+		signal: AbortSignal,
+	) => Promise<ToolResolution>;
+	readFile: (filePath: string) => Promise<string | null>;
+	writeFile: (
+		filePath: string,
+		content: string | Uint8Array,
+	) => Promise<string | null>;
+	deleteFile: (filePath: string) => Promise<string | null>;
+	fileExists: (filePath: string) => Promise<{
+		absolutePath: string | undefined;
+		recommendedPath: string | undefined;
+		workspaceFolder: WorkspaceFolder | undefined;
+		virtual: boolean;
+	}>;
+	listDir: (dirPath: string) => Promise<string[]>;
+	evaluateAccess: (resource: string, permission: Permission) => AccessResult;
+	stat: (filePath: string) => Promise<{
+		isDirectory: () => boolean;
+		isFile: () => boolean;
+		size: number;
+	} | null>;
+}
+export declare function resolveToolCalls(
+	toolContext: ToolContext,
+	toolCalls: LLMToolCalls[],
+	existingToolResults: ContentMessageItemToolResult[] | undefined,
+	onStep: (step: GenerateCompletionStep) => void,
+): Promise<ContentMessageItemToolResult[]>;
+interface RipgrepMatch {
+	path: string;
+	lineNumber: number;
+	lineContent: string;
+}
+interface RipgrepResult {
+	matches: RipgrepMatch[];
+}
+export declare function runRipgrep(
+	sys: DevToolsSys,
+	bashWorkingDirectory: string,
+	pattern: string,
+	includeGlob?: string,
+	excludeGlob?: string,
+): Promise<RipgrepResult>;
+/**
+ * Returns true if query is likely a string literal rather than a regex.
+ * Returns false otherwise.
+ * This is intended to ensure that queries such as "import {" do not get
+ * interpreted as invalid regex values by ripgrep.
+ * @param query - The query to check
+ */
+export declare const isLikelyFixedString: (query: string) => boolean;
+export declare function newAbortError(): Error;
+export {};

package/types/packages/dev-tools/cli/code.d.ts

@@ -0,0 +1,17 @@
+import type { DevToolsSys } from "../types";
+import type { CLIArgs } from "./index";
+import { type UserContext } from "$/ai-utils";
+export declare const runCodeCommand: (
+	sys: DevToolsSys,
+	subCommand: string,
+	args: CLIArgs,
+) => Promise<void>;
+export declare const runCodeGen: (
+	sys: DevToolsSys,
+	args: CLIArgs,
+) => Promise<undefined>;
+export declare function checkProjectRoot(
+	sys: DevToolsSys,
+	interactive: boolean,
+): Promise<void>;
+export declare function getUserContext(sys: DevToolsSys): Promise<UserContext>;