@nghyane/arcane 0.1.13 → 0.1.14

package/src/commit/git/diff.ts

@@ -1,148 +0,0 @@
-import type { DiffHunk, FileDiff, FileHunks, NumstatEntry } from "../../commit/types";
-
-export function parseNumstat(output: string): NumstatEntry[] {
-	const entries: NumstatEntry[] = [];
-	for (const line of output.split("\n")) {
-		if (!line.trim()) continue;
-		const parts = line.split("\t");
-		if (parts.length < 3) continue;
-		const [addedRaw, deletedRaw, pathRaw] = parts;
-		const additions = Number.parseInt(addedRaw, 10);
-		const deletions = Number.parseInt(deletedRaw, 10);
-		const path = extractPathFromRename(pathRaw);
-		entries.push({
-			path,
-			additions: Number.isNaN(additions) ? 0 : additions,
-			deletions: Number.isNaN(deletions) ? 0 : deletions,
-		});
-	}
-	return entries;
-}
-
-export function parseFileDiffs(diff: string): FileDiff[] {
-	const sections: FileDiff[] = [];
-	const parts = diff.split("\ndiff --git ");
-	for (let index = 0; index < parts.length; index += 1) {
-		const part = index === 0 ? parts[index] : `diff --git ${parts[index]}`;
-		if (!part.trim()) continue;
-		const lines = part.split("\n");
-		const header = lines[0] ?? "";
-		const match = header.match(/diff --git a\/(.+?) b\/(.+)$/);
-		if (!match) continue;
-		const filename = match[2];
-		const content = part;
-		const isBinary = lines.some(line => line.startsWith("Binary files "));
-		let additions = 0;
-		let deletions = 0;
-		for (const line of lines) {
-			if (line.startsWith("+++") || line.startsWith("---")) continue;
-			if (line.startsWith("+")) additions += 1;
-			else if (line.startsWith("-")) deletions += 1;
-		}
-		sections.push({
-			filename,
-			content,
-			additions,
-			deletions,
-			isBinary,
-		});
-	}
-	return sections;
-}
-
-export function parseDiffHunks(diff: string): FileHunks[] {
-	const files = parseFileDiffs(diff);
-	return files.map(file => parseFileHunks(file));
-}
-
-export function parseFileHunks(fileDiff: FileDiff): FileHunks {
-	if (fileDiff.isBinary) {
-		return { filename: fileDiff.filename, isBinary: true, hunks: [] };
-	}
-
-	const lines = fileDiff.content.split("\n");
-	const hunks: DiffHunk[] = [];
-	let current: DiffHunk | null = null;
-	let buffer: string[] = [];
-	let index = 0;
-
-	for (const line of lines) {
-		if (line.startsWith("@@")) {
-			if (current) {
-				current.content = buffer.join("\n");
-				hunks.push(current);
-			}
-			const headerData = parseHunkHeader(line);
-			current = {
-				index,
-				header: line,
-				oldStart: headerData.oldStart,
-				oldLines: headerData.oldLines,
-				newStart: headerData.newStart,
-				newLines: headerData.newLines,
-				content: "",
-			};
-			buffer = [line];
-			index += 1;
-			continue;
-		}
-		if (current) {
-			buffer.push(line);
-		}
-	}
-
-	if (current) {
-		current.content = buffer.join("\n");
-		hunks.push(current);
-	}
-
-	return {
-		filename: fileDiff.filename,
-		isBinary: fileDiff.isBinary,
-		hunks,
-	};
-}
-
-function extractPathFromRename(pathPart: string): string {
-	const braceStart = pathPart.indexOf("{");
-	if (braceStart !== -1) {
-		const arrowPos = pathPart.indexOf(" => ", braceStart);
-		if (arrowPos !== -1) {
-			const braceEnd = pathPart.indexOf("}", arrowPos);
-			if (braceEnd !== -1) {
-				const prefix = pathPart.slice(0, braceStart);
-				const newName = pathPart.slice(arrowPos + 4, braceEnd).trim();
-				return `${prefix}${newName}`;
-			}
-		}
-	}
-
-	if (pathPart.includes(" => ")) {
-		const parts = pathPart.split(" => ");
-		return parts[1]?.trim() ?? pathPart.trim();
-	}
-
-	return pathPart.trim();
-}
-
-function parseHunkHeader(line: string): {
-	oldStart: number;
-	oldLines: number;
-	newStart: number;
-	newLines: number;
-} {
-	const match = line.match(/@@\s-([0-9]+)(?:,([0-9]+))?\s\+([0-9]+)(?:,([0-9]+))?\s@@/);
-	if (!match) {
-		return { oldStart: 0, oldLines: 0, newStart: 0, newLines: 0 };
-	}
-	const oldStart = Number.parseInt(match[1] ?? "0", 10);
-	const oldLines = Number.parseInt(match[2] ?? "1", 10);
-	const newStart = Number.parseInt(match[3] ?? "0", 10);
-	const newLines = Number.parseInt(match[4] ?? "1", 10);
-	return {
-		oldStart: Number.isNaN(oldStart) ? 0 : oldStart,
-		oldLines: Number.isNaN(oldLines) ? 0 : oldLines,
-		newStart: Number.isNaN(newStart) ? 0 : newStart,
-		newLines: Number.isNaN(newLines) ? 0 : newLines,
-	};
-}

package/src/commit/git/errors.ts

@@ -1,9 +0,0 @@
-export class GitError extends Error {
-	constructor(
-		readonly command: string,
-		readonly stderr: string,
-	) {
-		super(`${command} failed: ${stderr || "unknown error"}`);
-		this.name = "GitError";
-	}
-}

package/src/commit/git/index.ts

@@ -1,211 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { logger, Snowflake } from "@nghyane/arcane-utils";
-import type { FileDiff, FileHunks, NumstatEntry } from "../../commit/types";
-import { parseDiffHunks, parseFileDiffs, parseFileHunks, parseNumstat } from "./diff";
-import { GitError } from "./errors";
-import { commit, push, resetStaging, runGitCommand, stageFiles } from "./operations";
-
-export type HunkSelection = {
-	path: string;
-	hunks: { type: "all" } | { type: "indices"; indices: number[] } | { type: "lines"; start: number; end: number };
-};
-
-export class ControlledGit {
-	constructor(private readonly cwd: string) {}
-
-	async getDiff(staged: boolean): Promise<string> {
-		const args = staged ? ["diff", "--cached"] : ["diff"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff");
-		return result.stdout;
-	}
-
-	async getDiffForFiles(files: string[], staged = true): Promise<string> {
-		const args = staged ? ["diff", "--cached", "--", ...files] : ["diff", "--", ...files];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff (files)");
-		return result.stdout;
-	}
-
-	async getChangedFiles(staged: boolean): Promise<string[]> {
-		const args = staged ? ["diff", "--cached", "--name-only"] : ["diff", "--name-only"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --name-only");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async getStat(staged: boolean): Promise<string> {
-		const args = staged ? ["diff", "--cached", "--stat"] : ["diff", "--stat"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --stat");
-		return result.stdout;
-	}
-
-	async getStatForFiles(files: string[], staged = true): Promise<string> {
-		const args = staged ? ["diff", "--cached", "--stat", "--", ...files] : ["diff", "--stat", "--", ...files];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --stat (files)");
-		return result.stdout;
-	}
-
-	async getNumstat(staged: boolean): Promise<NumstatEntry[]> {
-		const args = staged ? ["diff", "--cached", "--numstat"] : ["diff", "--numstat"];
-		const result = await runGitCommand(this.cwd, args);
-		this.#ensureSuccess(result, "git diff --numstat");
-		return parseNumstat(result.stdout);
-	}
-
-	async getRecentCommits(count: number): Promise<string[]> {
-		const result = await runGitCommand(this.cwd, ["log", `-n${count}`, "--pretty=format:%s"]);
-		this.#ensureSuccess(result, "git log");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async getStagedFiles(): Promise<string[]> {
-		const result = await runGitCommand(this.cwd, ["diff", "--cached", "--name-only"]);
-		this.#ensureSuccess(result, "git diff --cached --name-only");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async getUntrackedFiles(): Promise<string[]> {
-		const result = await runGitCommand(this.cwd, ["ls-files", "--others", "--exclude-standard"]);
-		this.#ensureSuccess(result, "git ls-files --others --exclude-standard");
-		return result.stdout
-			.split("\n")
-			.map(line => line.trim())
-			.filter(Boolean);
-	}
-
-	async stageAll(): Promise<void> {
-		const result = await stageFiles(this.cwd, []);
-		this.#ensureSuccess(result, "git add -A");
-	}
-
-	async stageFiles(files: string[]): Promise<void> {
-		const result = await stageFiles(this.cwd, files);
-		this.#ensureSuccess(result, "git add");
-	}
-
-	async stageHunks(selections: HunkSelection[]): Promise<void> {
-		if (selections.length === 0) return;
-		const diff = await this.getDiff(false);
-		const fileDiffs = parseFileDiffs(diff);
-		const fileDiffMap = new Map(fileDiffs.map(entry => [entry.filename, entry]));
-		const patchParts: string[] = [];
-		for (const selection of selections) {
-			const fileDiff = fileDiffMap.get(selection.path);
-			if (!fileDiff) {
-				throw new GitError("git apply --cached", `No diff found for ${selection.path}`);
-			}
-			if (fileDiff.isBinary) {
-				if (selection.hunks.type !== "all") {
-					throw new GitError("git apply --cached", `Cannot select hunks for binary file ${selection.path}`);
-				}
-				patchParts.push(fileDiff.content);
-				continue;
-			}
-
-			if (selection.hunks.type === "all") {
-				patchParts.push(fileDiff.content);
-				continue;
-			}
-
-			const fileHunks = parseFileHunks(fileDiff);
-			const selectedHunks = selectHunks(fileHunks, selection.hunks);
-			if (selectedHunks.length === 0) {
-				throw new GitError("git apply --cached", `No hunks selected for ${selection.path}`);
-			}
-			const header = extractFileHeader(fileDiff.content);
-			const filePatch = [header, ...selectedHunks.map(hunk => hunk.content)].join("\n");
-			patchParts.push(filePatch);
-		}
-
-		const patch = joinPatch(patchParts);
-		if (!patch.trim()) return;
-		const tempPath = path.join(os.tmpdir(), `omp-hunks-${Snowflake.next()}.patch`);
-		try {
-			await Bun.write(tempPath, patch);
-			const result = await runGitCommand(this.cwd, ["apply", "--cached", "--binary", tempPath]);
-			this.#ensureSuccess(result, "git apply --cached");
-		} finally {
-			await fs.rm(tempPath, { force: true });
-		}
-	}
-
-	async resetStaging(files: string[] = []): Promise<void> {
-		const result = await resetStaging(this.cwd, files);
-		this.#ensureSuccess(result, "git reset");
-	}
-
-	async commit(message: string): Promise<void> {
-		const result = await commit(this.cwd, message);
-		this.#ensureSuccess(result, "git commit");
-	}
-
-	async push(): Promise<void> {
-		const result = await push(this.cwd);
-		this.#ensureSuccess(result, "git push");
-	}
-
-	parseDiffFiles(diff: string): FileDiff[] {
-		return parseFileDiffs(diff);
-	}
-
-	parseDiffHunks(diff: string): FileHunks[] {
-		return parseDiffHunks(diff);
-	}
-
-	async getHunks(files: string[], staged = true): Promise<FileHunks[]> {
-		const diff = await this.getDiffForFiles(files, staged);
-		return this.parseDiffHunks(diff);
-	}
-
-	#ensureSuccess(result: { exitCode: number; stderr: string }, label: string): void {
-		if (result.exitCode !== 0) {
-			logger.error("commit git command failed", { label, stderr: result.stderr });
-			throw new GitError(label, result.stderr);
-		}
-	}
-}
-
-function extractFileHeader(diff: string): string {
-	const lines = diff.split("\n");
-	const headerLines: string[] = [];
-	for (const line of lines) {
-		if (line.startsWith("@@")) break;
-		headerLines.push(line);
-	}
-	return headerLines.join("\n");
-}
-
-function joinPatch(parts: string[]): string {
-	return parts
-		.map(part => (part.endsWith("\n") ? part : `${part}\n`))
-		.join("\n")
-		.trimEnd()
-		.concat("\n");
-}
-
-function selectHunks(file: FileHunks, selector: HunkSelection["hunks"]): FileHunks["hunks"] {
-	if (selector.type === "indices") {
-		const wanted = new Set(selector.indices.map(value => Math.max(1, Math.floor(value))));
-		return file.hunks.filter(hunk => wanted.has(hunk.index + 1));
-	}
-	if (selector.type === "lines") {
-		const start = Math.floor(selector.start);
-		const end = Math.floor(selector.end);
-		return file.hunks.filter(hunk => hunk.newStart <= end && hunk.newStart + hunk.newLines - 1 >= start);
-	}
-	return file.hunks;
-}

package/src/commit/git/operations.ts

@@ -1,54 +0,0 @@
-import { $ } from "bun";
-
-interface GitResult {
-	exitCode: number;
-	stdout: string;
-	stderr: string;
-}
-
-export async function runGitCommand(cwd: string, args: string[]): Promise<GitResult> {
-	const result = await $`git ${args}`.cwd(cwd).quiet().nothrow();
-	const stdout = result.text();
-	const stderr = result.stderr?.toString() ?? "";
-	return {
-		exitCode: result.exitCode ?? 0,
-		stdout,
-		stderr,
-	};
-}
-
-export async function stageFiles(cwd: string, files: string[]): Promise<GitResult> {
-	const args = files.length === 0 ? ["add", "-A"] : ["add", "--", ...files];
-	return runGitCommand(cwd, args);
-}
-
-export async function resetStaging(cwd: string, files: string[]): Promise<GitResult> {
-	const args = files.length === 0 ? ["reset"] : ["reset", "--", ...files];
-	return runGitCommand(cwd, args);
-}
-
-export async function push(cwd: string): Promise<GitResult> {
-	return runGitCommand(cwd, ["push"]);
-}
-
-export async function commit(cwd: string, message: string): Promise<GitResult> {
-	const child = Bun.spawn(["git", "commit", "-F", "-"], {
-		cwd,
-		stdin: Buffer.from(message),
-		stdout: "pipe",
-		stderr: "pipe",
-		windowsHide: true,
-	});
-
-	const [stdout, stderr, exitCode] = await Promise.all([
-		new Response(child.stdout).text(),
-		new Response(child.stderr).text(),
-		child.exited,
-	]);
-
-	return {
-		exitCode: exitCode ?? 0,
-		stdout: stdout.trim(),
-		stderr: stderr.trim(),
-	};
-}

package/src/commit/index.ts

@@ -1,5 +0,0 @@
-/**
- * Entry points for the arcane commit command.
- */
-
-export { runCommitCommand } from "./pipeline";

package/src/commit/map-reduce/index.ts

@@ -1,64 +0,0 @@
-import type { Api, Model } from "@nghyane/arcane-ai";
-import { $env } from "@nghyane/arcane-utils";
-import { parseFileDiffs } from "../../commit/git/diff";
-import type { ConventionalAnalysis } from "../../commit/types";
-import { isExcludedFile } from "../../commit/utils/exclusions";
-import { runMapPhase } from "./map-phase";
-import { runReducePhase } from "./reduce-phase";
-import { estimateTokens } from "./utils";
-
-const MIN_FILES_FOR_MAP_REDUCE = 4;
-const MAX_FILE_TOKENS = 50_000;
-
-export interface MapReduceSettings {
-	enabled?: boolean;
-	minFiles?: number;
-	maxFileTokens?: number;
-	maxConcurrency?: number;
-	timeoutMs?: number;
-}
-
-export interface MapReduceInput {
-	model: Model<Api>;
-	apiKey: string;
-	fastModel: Model<Api>;
-	fastApiKey: string;
-	diff: string;
-	stat: string;
-	scopeCandidates: string;
-	typesDescription?: string;
-	settings?: MapReduceSettings;
-}
-
-export function shouldUseMapReduce(diff: string, settings?: MapReduceSettings): boolean {
-	if ($env.ARCANE_COMMIT_MAP_REDUCE?.toLowerCase() === "false") return false;
-	if (settings?.enabled === false) return false;
-	const minFiles = settings?.minFiles ?? MIN_FILES_FOR_MAP_REDUCE;
-	const maxFileTokens = settings?.maxFileTokens ?? MAX_FILE_TOKENS;
-	const files = parseFileDiffs(diff).filter(file => !isExcludedFile(file.filename));
-	const fileCount = files.length;
-	if (fileCount >= minFiles) return true;
-	return files.some(file => estimateTokens(file.content) > maxFileTokens);
-}
-
-/**
- * Run map-reduce analysis for large diffs using fast + primary models.
- */
-
-export async function runMapReduceAnalysis(input: MapReduceInput): Promise<ConventionalAnalysis> {
-	const fileDiffs = parseFileDiffs(input.diff).filter(file => !isExcludedFile(file.filename));
-	const observations = await runMapPhase({
-		model: input.fastModel,
-		apiKey: input.fastApiKey,
-		files: fileDiffs,
-		config: input.settings,
-	});
-	return runReducePhase({
-		model: input.model,
-		apiKey: input.apiKey,
-		observations,
-		stat: input.stat,
-		scopeCandidates: input.scopeCandidates,
-		typesDescription: input.typesDescription,
-	});
-}

package/src/commit/map-reduce/map-phase.ts

@@ -1,178 +0,0 @@
-import type { Api, AssistantMessage, Message, Model } from "@nghyane/arcane-ai";
-import { completeSimple } from "@nghyane/arcane-ai";
-import fileObserverSystemPrompt from "../../commit/prompts/file-observer-system.md" with { type: "text" };
-import fileObserverUserPrompt from "../../commit/prompts/file-observer-user.md" with { type: "text" };
-import type { FileDiff, FileObservation } from "../../commit/types";
-import { isExcludedFile } from "../../commit/utils/exclusions";
-import { renderPromptTemplate } from "../../config/prompt-templates";
-import { truncateToTokenLimit } from "./utils";
-
-const MAX_FILE_TOKENS = 50_000;
-const MAX_CONTEXT_FILES = 20;
-const MAX_CONCURRENCY = 5;
-const MAP_PHASE_TIMEOUT_MS = 120_000;
-const MAX_RETRIES = 3;
-const RETRY_BACKOFF_MS = 1000;
-
-export interface MapPhaseInput {
-	model: Model<Api>;
-	apiKey: string;
-	files: FileDiff[];
-	config?: {
-		maxFileTokens?: number;
-		maxConcurrency?: number;
-		timeoutMs?: number;
-		maxRetries?: number;
-		retryBackoffMs?: number;
-	};
-}
-
-export async function runMapPhase({ model, apiKey, files, config }: MapPhaseInput): Promise<FileObservation[]> {
-	const filtered = files.filter(file => !isExcludedFile(file.filename));
-	const systemPrompt = renderPromptTemplate(fileObserverSystemPrompt);
-	const maxFileTokens = config?.maxFileTokens ?? MAX_FILE_TOKENS;
-	const maxConcurrency = config?.maxConcurrency ?? MAX_CONCURRENCY;
-	const timeoutMs = config?.timeoutMs ?? MAP_PHASE_TIMEOUT_MS;
-	const maxRetries = config?.maxRetries ?? MAX_RETRIES;
-	const retryBackoffMs = config?.retryBackoffMs ?? RETRY_BACKOFF_MS;
-	return runWithConcurrency(filtered, maxConcurrency, async file => {
-		if (file.isBinary) {
-			return {
-				file: file.filename,
-				observations: ["Binary file changed."],
-				additions: file.additions,
-				deletions: file.deletions,
-			};
-		}
-
-		const contextHeader = generateContextHeader(filtered, file.filename);
-		const truncated = truncateToTokenLimit(file.content, maxFileTokens);
-		const prompt = renderPromptTemplate(fileObserverUserPrompt, {
-			filename: file.filename,
-			diff: truncated,
-			context_header: contextHeader,
-		});
-		const request = {
-			systemPrompt,
-			messages: [{ role: "user", content: prompt, timestamp: Date.now() }] as Message[],
-		};
-
-		const response = await withRetry(
-			() => completeSimple(model, request, { apiKey, maxTokens: 400, signal: AbortSignal.timeout(timeoutMs) }),
-			maxRetries,
-			retryBackoffMs,
-		);
-
-		const observations = parseObservations(response);
-		return {
-			file: file.filename,
-			observations,
-			additions: file.additions,
-			deletions: file.deletions,
-		};
-	});
-}
-
-function parseObservations(message: AssistantMessage): string[] {
-	const text = message.content
-		.filter(content => content.type === "text")
-		.map(content => content.text)
-		.join("")
-		.trim();
-
-	if (!text) return [];
-
-	const lines = text
-		.split("\n")
-		.map(line => line.trim())
-		.filter(Boolean)
-		.map(line => line.replace(/^[-*]\s+/, ""))
-		.filter(Boolean);
-
-	return lines.slice(0, 5);
-}
-
-function generateContextHeader(files: FileDiff[], currentFile: string): string {
-	if (files.length > 100) {
-		return `(Large commit with ${files.length} total files)`;
-	}
-
-	const otherFiles = files.filter(file => file.filename !== currentFile);
-	if (otherFiles.length === 0) return "";
-
-	const sorted = [...otherFiles].sort((a, b) => b.additions + b.deletions - (a.additions + a.deletions));
-	const toShow = sorted.length > MAX_CONTEXT_FILES ? sorted.slice(0, MAX_CONTEXT_FILES) : sorted;
-
-	const lines = ["OTHER FILES IN THIS CHANGE:"];
-	for (const file of toShow) {
-		const lineCount = file.additions + file.deletions;
-		const description = inferFileDescription(file);
-		lines.push(`- ${file.filename} (${lineCount} lines): ${description}`);
-	}
-
-	if (toShow.length < sorted.length) {
-		lines.push(`... and ${sorted.length - toShow.length} more files`);
-	}
-
-	return lines.join("\n");
-}
-
-function inferFileDescription(file: FileDiff): string {
-	const filenameLower = file.filename.toLowerCase();
-	if (filenameLower.includes("test")) return "test file";
-	if (filenameLower.endsWith(".md")) return "documentation";
-	if (
-		filenameLower.includes("config") ||
-		filenameLower.endsWith(".toml") ||
-		filenameLower.endsWith(".yaml") ||
-		filenameLower.endsWith(".yml")
-	) {
-		return "configuration";
-	}
-	if (filenameLower.includes("error")) return "error definitions";
-	if (filenameLower.includes("type")) return "type definitions";
-	if (filenameLower.endsWith("mod.rs") || filenameLower.endsWith("lib.rs")) return "module exports";
-	if (filenameLower.endsWith("main.rs") || filenameLower.endsWith("main.go") || filenameLower.endsWith("main.py")) {
-		return "entry point";
-	}
-
-	const content = file.content;
-	if (content.includes("interface ") || content.includes("type ")) return "type definitions";
-	if (content.includes("class ") || content.includes("function ") || content.includes("fn ")) return "implementation";
-	if (content.includes("async ") || content.includes("await")) return "async code";
-	return "source code";
-}
-
-async function runWithConcurrency<T, R>(
-	items: T[],
-	limit: number,
-	worker: (item: T, index: number) => Promise<R>,
-): Promise<R[]> {
-	const results = new Array<R>(items.length);
-	let nextIndex = 0;
-	const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
-		while (true) {
-			const current = nextIndex;
-			nextIndex += 1;
-			if (current >= items.length) return;
-			results[current] = await worker(items[current] as T, current);
-		}
-	});
-	await Promise.all(runners);
-	return results;
-}
-
-async function withRetry<T>(fn: () => Promise<T>, attempts: number, backoffMs: number): Promise<T> {
-	let lastError: unknown;
-	for (let attempt = 0; attempt < attempts; attempt += 1) {
-		try {
-			return await fn();
-		} catch (error) {
-			lastError = error;
-			if (attempt < attempts - 1) {
-				await Bun.sleep(backoffMs * (attempt + 1));
-			}
-		}
-	}
-	throw lastError;
-}