@prometheus-ai/utils 0.5.3 → 0.5.8

package/src/tab-spacing.ts

@@ -340,3 +340,54 @@ export function getIndentation(file?: string | null, projectDir?: string | null)
 	indentationCache.set(absKey, clamped);
 	return clamped;
 }
+
+/**
+ * `.editorconfig`-derived formatting options for an LSP `textDocument/formatting` request.
+ *
+ * Both fields are absent when the resolved `.editorconfig` chain does not pin them, so callers
+ * can layer their own fallbacks underneath.
+ */
+export interface EditorConfigFormatting {
+	/** Effective indent width in columns, from `indent_size` or `tab_width`. */
+	tabSize?: number;
+	/** `true` for `indent_style = space`, `false` for `indent_style = tab` or `indent_size = tab`. */
+	insertSpaces?: boolean;
+}
+
+/**
+ * Resolve `.editorconfig` formatting hints for `file` without falling back to any default.
+ */
+export function getEditorConfigFormatting(file?: string | null, projectDir?: string | null): EditorConfigFormatting {
+	if (file === undefined || file === null || file === "") {
+		return {};
+	}
+
+	const cwd = projectDir ?? process.cwd();
+	const absoluteFile = resolveFilePath(cwd, file);
+	if (hasOverlongPathComponent(absoluteFile)) {
+		return {};
+	}
+
+	const match = resolveEditorConfigMatch(absoluteFile);
+	if (match === undefined) {
+		return {};
+	}
+
+	const result: EditorConfigFormatting = {};
+
+	if (match.indentSize?.kind === "spaces") {
+		result.tabSize = clampTabWidth(match.indentSize.n);
+	} else if (match.tabWidth !== undefined) {
+		result.tabSize = clampTabWidth(match.tabWidth);
+	}
+
+	if (match.indentStyle === IndentStyle.Space) {
+		result.insertSpaces = true;
+	} else if (match.indentStyle === IndentStyle.Tab || match.indentSize?.kind === "tab") {
+		result.insertSpaces = false;
+	} else if (match.indentSize?.kind === "spaces") {
+		result.insertSpaces = true;
+	}
+
+	return result;
+}

package/src/temp.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 
@@ -13,7 +14,7 @@ export class TempDir {
 	}
 
 	static async create(prefix?: string): Promise<TempDir> {
-		return new TempDir(await fs.promises.mkdtemp(normalizePrefix(prefix)));
+		return new TempDir(await fsPromises.mkdtemp(normalizePrefix(prefix)));
 	}
 
 	#removePromise: Promise<void> | null = null;
@@ -30,13 +31,13 @@ export class TempDir {
 		if (this.#removePromise) {
 			return this.#removePromise;
 		}
-		const removePromise = fs.promises.rm(this.#path, { recursive: true, force: true });
+		const removePromise = removeWithRetries(this.#path);
 		this.#removePromise = removePromise;
 		return removePromise;
 	}
 
 	removeSync(): void {
-		fs.rmSync(this.#path, { recursive: true, force: true });
+		removeSyncWithRetries(this.#path);
 		this.#removePromise = Promise.resolve();
 	}
 
@@ -69,9 +70,61 @@ const kTempDir = os.tmpdir();
 
 function normalizePrefix(prefix?: string): string {
 	if (!prefix) {
-		return `${kTempDir}${path.sep}pi-temp-`;
+		return `${kTempDir}${path.sep}prometheus-temp-`;
 	} else if (prefix.startsWith("@")) {
 		return path.join(kTempDir, prefix.slice(1));
 	}
 	return prefix;
 }
+
+const kRemoveOptions = { recursive: true, force: true } as const;
+const kRemoveRetries = 4;
+const kRemoveRetryDelayMs = 10;
+const kRetryableRemoveErrorCodes = new Set(["EBUSY", "EPERM", "ENOTEMPTY"]);
+const kSleepBuffer = new Int32Array(new SharedArrayBuffer(4));
+
+async function removeWithRetries(target: string): Promise<void> {
+	for (let attempt = 0; ; attempt++) {
+		try {
+			await fsPromises.rm(target, kRemoveOptions);
+			return;
+		} catch (err) {
+			if (!shouldRetryRemove(err, attempt)) throw err;
+			await Bun.sleep(kRemoveRetryDelayMs);
+		}
+	}
+}
+
+function removeSyncWithRetries(target: string): void {
+	for (let attempt = 0; ; attempt++) {
+		try {
+			fs.rmSync(target, kRemoveOptions);
+			return;
+		} catch (err) {
+			if (!shouldRetryRemove(err, attempt)) throw err;
+			sleepSync(kRemoveRetryDelayMs);
+		}
+	}
+}
+
+function shouldRetryRemove(err: unknown, attempt: number): boolean {
+	return attempt < kRemoveRetries && process.platform === "win32" && isRetryableRemoveError(err);
+}
+
+function isRetryableRemoveError(err: unknown): boolean {
+	return (
+		typeof err === "object" &&
+		err !== null &&
+		"code" in err &&
+		typeof err.code === "string" &&
+		kRetryableRemoveErrorCodes.has(err.code)
+	);
+}
+
+function sleepSync(ms: number): void {
+	if ("sleepSync" in Bun && typeof Bun.sleepSync === "function") {
+		Bun.sleepSync(ms);
+		return;
+	}
+	Atomics.wait(kSleepBuffer, 0, 0, ms);
+}

package/src/timing-buffer.ts

@@ -0,0 +1,47 @@
+/**
+ * Shared contract between the {@link module-timer} preload and {@link logger}'s
+ * timing tree. Kept in its own dependency-free module so the preload can import
+ * it without pulling in winston (via logger) and the logger can drain the buffer
+ * without importing the Bun-plugin preload.
+ */
+
+export interface ModuleLoadEvent {
+	/** Absolute or Bun-resolved module path. */
+	path: string;
+	/** `performance.now()` timestamp captured at Bun `onLoad` entry. */
+	start: number;
+	/** Inclusive module window: `onLoad` entry → appended final marker. */
+	durationMs: number;
+	/** Own top-level body / TLA time: prepended body marker → appended final marker. */
+	bodyMs?: number;
+	/** Resolved static children imported by this module. */
+	imports: string[];
+}
+
+/**
+ * Registry-global key under which the preload accumulates module-load events.
+ * `Symbol.for` so both modules resolve the same symbol independently.
+ */
+const KEY: symbol = Symbol.for("prometheus.moduleLoadBuffer");
+
+type Store = Record<symbol, ModuleLoadEvent[] | undefined>;
+
+/** The append-only buffer the preload pushes into (created on first access). */
+export function moduleLoadBuffer(): ModuleLoadEvent[] {
+	const store = globalThis as unknown as Store;
+	let buffer = store[KEY];
+	if (!buffer) {
+		buffer = [];
+		store[KEY] = buffer;
+	}
+	return buffer;
+}
+
+/** Drain and return all buffered events, leaving the buffer empty. */
+export function drainModuleLoadEvents(): ModuleLoadEvent[] {
+	const store = globalThis as unknown as Store;
+	const buffer = store[KEY];
+	if (!buffer || buffer.length === 0) return [];
+	store[KEY] = [];
+	return buffer;
+}