@lenylvt/pi-coding-agent 0.64.0

package/src/core/tools/tool-definition-wrapper.ts

@@ -0,0 +1,43 @@
+import type { AgentTool } from "@lenylvt/pi-agent-core";
+import type { ExtensionContext, ToolDefinition } from "../extensions/types.js";
+
+/** Wrap a ToolDefinition into an AgentTool for the core runtime. */
+export function wrapToolDefinition<TDetails = unknown>(
+	definition: ToolDefinition<any, TDetails>,
+	ctxFactory?: () => ExtensionContext,
+): AgentTool<any, TDetails> {
+	return {
+		name: definition.name,
+		label: definition.label,
+		description: definition.description,
+		parameters: definition.parameters,
+		prepareArguments: definition.prepareArguments,
+		execute: (toolCallId, params, signal, onUpdate) =>
+			definition.execute(toolCallId, params, signal, onUpdate, ctxFactory?.() as ExtensionContext),
+	};
+}
+
+/** Wrap multiple ToolDefinitions into AgentTools for the core runtime. */
+export function wrapToolDefinitions(
+	definitions: ToolDefinition<any, any>[],
+	ctxFactory?: () => ExtensionContext,
+): AgentTool<any>[] {
+	return definitions.map((definition) => wrapToolDefinition(definition, ctxFactory));
+}
+
+/**
+ * Synthesize a minimal ToolDefinition from an AgentTool.
+ *
+ * This keeps AgentSession's internal registry definition-first even when a caller
+ * provides plain AgentTool overrides that do not include prompt metadata or renderers.
+ */
+export function createToolDefinitionFromAgentTool(tool: AgentTool<any>): ToolDefinition<any, unknown> {
+	return {
+		name: tool.name,
+		label: tool.label,
+		description: tool.description,
+		parameters: tool.parameters as any,
+		prepareArguments: tool.prepareArguments,
+		execute: async (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
+	};
+}

package/src/core/tools/truncate.ts

@@ -0,0 +1,265 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Truncation is based on two independent limits - whichever is hit first wins:
+ * - Line limit (default: 2000 lines)
+ * - Byte limit (default: 50KB)
+ *
+ * Never returns partial lines (except bash tail truncation edge case).
+ */
+
+export const DEFAULT_MAX_LINES = 2000;
+export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
+export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
+
+export interface TruncationResult {
+	/** The truncated content */
+	content: string;
+	/** Whether truncation occurred */
+	truncated: boolean;
+	/** Which limit was hit: "lines", "bytes", or null if not truncated */
+	truncatedBy: "lines" | "bytes" | null;
+	/** Total number of lines in the original content */
+	totalLines: number;
+	/** Total number of bytes in the original content */
+	totalBytes: number;
+	/** Number of complete lines in the truncated output */
+	outputLines: number;
+	/** Number of bytes in the truncated output */
+	outputBytes: number;
+	/** Whether the last line was partially truncated (only for tail truncation edge case) */
+	lastLinePartial: boolean;
+	/** Whether the first line exceeded the byte limit (for head truncation) */
+	firstLineExceedsLimit: boolean;
+	/** The max lines limit that was applied */
+	maxLines: number;
+	/** The max bytes limit that was applied */
+	maxBytes: number;
+}
+
+export interface TruncationOptions {
+	/** Maximum number of lines (default: 2000) */
+	maxLines?: number;
+	/** Maximum number of bytes (default: 50KB) */
+	maxBytes?: number;
+}
+
+/**
+ * Format bytes as human-readable size.
+ */
+export function formatSize(bytes: number): string {
+	if (bytes < 1024) {
+		return `${bytes}B`;
+	} else if (bytes < 1024 * 1024) {
+		return `${(bytes / 1024).toFixed(1)}KB`;
+	} else {
+		return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+	}
+}
+
+/**
+ * Truncate content from the head (keep first N lines/bytes).
+ * Suitable for file reads where you want to see the beginning.
+ *
+ * Never returns partial lines. If first line exceeds byte limit,
+ * returns empty content with firstLineExceedsLimit=true.
+ */
+export function truncateHead(content: string, options: TruncationOptions = {}): TruncationResult {
+	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+
+	const totalBytes = Buffer.byteLength(content, "utf-8");
+	const lines = content.split("\n");
+	const totalLines = lines.length;
+
+	// Check if no truncation needed
+	if (totalLines <= maxLines && totalBytes <= maxBytes) {
+		return {
+			content,
+			truncated: false,
+			truncatedBy: null,
+			totalLines,
+			totalBytes,
+			outputLines: totalLines,
+			outputBytes: totalBytes,
+			lastLinePartial: false,
+			firstLineExceedsLimit: false,
+			maxLines,
+			maxBytes,
+		};
+	}
+
+	// Check if first line alone exceeds byte limit
+	const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+	if (firstLineBytes > maxBytes) {
+		return {
+			content: "",
+			truncated: true,
+			truncatedBy: "bytes",
+			totalLines,
+			totalBytes,
+			outputLines: 0,
+			outputBytes: 0,
+			lastLinePartial: false,
+			firstLineExceedsLimit: true,
+			maxLines,
+			maxBytes,
+		};
+	}
+
+	// Collect complete lines that fit
+	const outputLinesArr: string[] = [];
+	let outputBytesCount = 0;
+	let truncatedBy: "lines" | "bytes" = "lines";
+
+	for (let i = 0; i < lines.length && i < maxLines; i++) {
+		const line = lines[i];
+		const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0); // +1 for newline
+
+		if (outputBytesCount + lineBytes > maxBytes) {
+			truncatedBy = "bytes";
+			break;
+		}
+
+		outputLinesArr.push(line);
+		outputBytesCount += lineBytes;
+	}
+
+	// If we exited due to line limit
+	if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+		truncatedBy = "lines";
+	}
+
+	const outputContent = outputLinesArr.join("\n");
+	const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+
+	return {
+		content: outputContent,
+		truncated: true,
+		truncatedBy,
+		totalLines,
+		totalBytes,
+		outputLines: outputLinesArr.length,
+		outputBytes: finalOutputBytes,
+		lastLinePartial: false,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes,
+	};
+}
+
+/**
+ * Truncate content from the tail (keep last N lines/bytes).
+ * Suitable for bash output where you want to see the end (errors, final results).
+ *
+ * May return partial first line if the last line of original content exceeds byte limit.
+ */
+export function truncateTail(content: string, options: TruncationOptions = {}): TruncationResult {
+	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+
+	const totalBytes = Buffer.byteLength(content, "utf-8");
+	const lines = content.split("\n");
+	const totalLines = lines.length;
+
+	// Check if no truncation needed
+	if (totalLines <= maxLines && totalBytes <= maxBytes) {
+		return {
+			content,
+			truncated: false,
+			truncatedBy: null,
+			totalLines,
+			totalBytes,
+			outputLines: totalLines,
+			outputBytes: totalBytes,
+			lastLinePartial: false,
+			firstLineExceedsLimit: false,
+			maxLines,
+			maxBytes,
+		};
+	}
+
+	// Work backwards from the end
+	const outputLinesArr: string[] = [];
+	let outputBytesCount = 0;
+	let truncatedBy: "lines" | "bytes" = "lines";
+	let lastLinePartial = false;
+
+	for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+		const line = lines[i];
+		const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0); // +1 for newline
+
+		if (outputBytesCount + lineBytes > maxBytes) {
+			truncatedBy = "bytes";
+			// Edge case: if we haven't added ANY lines yet and this line exceeds maxBytes,
+			// take the end of the line (partial)
+			if (outputLinesArr.length === 0) {
+				const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+				outputLinesArr.unshift(truncatedLine);
+				outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+				lastLinePartial = true;
+			}
+			break;
+		}
+
+		outputLinesArr.unshift(line);
+		outputBytesCount += lineBytes;
+	}
+
+	// If we exited due to line limit
+	if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
+		truncatedBy = "lines";
+	}
+
+	const outputContent = outputLinesArr.join("\n");
+	const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+
+	return {
+		content: outputContent,
+		truncated: true,
+		truncatedBy,
+		totalLines,
+		totalBytes,
+		outputLines: outputLinesArr.length,
+		outputBytes: finalOutputBytes,
+		lastLinePartial,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes,
+	};
+}
+
+/**
+ * Truncate a string to fit within a byte limit (from the end).
+ * Handles multi-byte UTF-8 characters correctly.
+ */
+function truncateStringToBytesFromEnd(str: string, maxBytes: number): string {
+	const buf = Buffer.from(str, "utf-8");
+	if (buf.length <= maxBytes) {
+		return str;
+	}
+
+	// Start from the end, skip maxBytes back
+	let start = buf.length - maxBytes;
+
+	// Find a valid UTF-8 boundary (start of a character)
+	while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
+		start++;
+	}
+
+	return buf.slice(start).toString("utf-8");
+}
+
+/**
+ * Truncate a single line to max characters, adding [truncated] suffix.
+ * Used for grep match lines.
+ */
+export function truncateLine(
+	line: string,
+	maxChars: number = GREP_MAX_LINE_LENGTH,
+): { text: string; wasTruncated: boolean } {
+	if (line.length <= maxChars) {
+		return { text: line, wasTruncated: false };
+	}
+	return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}

package/src/core/tools/write.ts

@@ -0,0 +1,285 @@
+import type { AgentTool } from "@lenylvt/pi-agent-core";
+import { Container, Text } from "@lenylvt/pi-tui";
+import { type Static, Type } from "@sinclair/typebox";
+import { mkdir as fsMkdir, writeFile as fsWriteFile } from "fs/promises";
+import { dirname } from "path";
+import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";
+import { getLanguageFromPath, highlightCode } from "../../modes/interactive/theme/theme.js";
+import type { ToolDefinition, ToolRenderResultOptions } from "../extensions/types.js";
+import { withFileMutationQueue } from "./file-mutation-queue.js";
+import { resolveToCwd } from "./path-utils.js";
+import { invalidArgText, normalizeDisplayText, replaceTabs, shortenPath, str } from "./render-utils.js";
+import { wrapToolDefinition } from "./tool-definition-wrapper.js";
+
+const writeSchema = Type.Object({
+	path: Type.String({ description: "Path to the file to write (relative or absolute)" }),
+	content: Type.String({ description: "Content to write to the file" }),
+});
+
+export type WriteToolInput = Static<typeof writeSchema>;
+
+/**
+ * Pluggable operations for the write tool.
+ * Override these to delegate file writing to remote systems (for example SSH).
+ */
+export interface WriteOperations {
+	/** Write content to a file */
+	writeFile: (absolutePath: string, content: string) => Promise<void>;
+	/** Create directory recursively */
+	mkdir: (dir: string) => Promise<void>;
+}
+
+const defaultWriteOperations: WriteOperations = {
+	writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),
+	mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => {}),
+};
+
+export interface WriteToolOptions {
+	/** Custom operations for file writing. Default: local filesystem */
+	operations?: WriteOperations;
+}
+
+type WriteHighlightCache = {
+	rawPath: string | null;
+	lang: string;
+	rawContent: string;
+	normalizedLines: string[];
+	highlightedLines: string[];
+};
+
+class WriteCallRenderComponent extends Text {
+	cache?: WriteHighlightCache;
+
+	constructor() {
+		super("", 0, 0);
+	}
+}
+
+const WRITE_PARTIAL_FULL_HIGHLIGHT_LINES = 50;
+
+function highlightSingleLine(line: string, lang: string): string {
+	const highlighted = highlightCode(line, lang);
+	return highlighted[0] ?? "";
+}
+
+function refreshWriteHighlightPrefix(cache: WriteHighlightCache): void {
+	const prefixCount = Math.min(WRITE_PARTIAL_FULL_HIGHLIGHT_LINES, cache.normalizedLines.length);
+	if (prefixCount === 0) return;
+	const prefixSource = cache.normalizedLines.slice(0, prefixCount).join("\n");
+	const prefixHighlighted = highlightCode(prefixSource, cache.lang);
+	for (let i = 0; i < prefixCount; i++) {
+		cache.highlightedLines[i] =
+			prefixHighlighted[i] ?? highlightSingleLine(cache.normalizedLines[i] ?? "", cache.lang);
+	}
+}
+
+function rebuildWriteHighlightCacheFull(rawPath: string | null, fileContent: string): WriteHighlightCache | undefined {
+	const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+	if (!lang) return undefined;
+	const displayContent = normalizeDisplayText(fileContent);
+	const normalized = replaceTabs(displayContent);
+	return {
+		rawPath,
+		lang,
+		rawContent: fileContent,
+		normalizedLines: normalized.split("\n"),
+		highlightedLines: highlightCode(normalized, lang),
+	};
+}
+
+function updateWriteHighlightCacheIncremental(
+	cache: WriteHighlightCache | undefined,
+	rawPath: string | null,
+	fileContent: string,
+): WriteHighlightCache | undefined {
+	const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+	if (!lang) return undefined;
+	if (!cache) return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+	if (cache.lang !== lang || cache.rawPath !== rawPath) return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+	if (!fileContent.startsWith(cache.rawContent)) return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+	if (fileContent.length === cache.rawContent.length) return cache;
+
+	const deltaRaw = fileContent.slice(cache.rawContent.length);
+	const deltaDisplay = normalizeDisplayText(deltaRaw);
+	const deltaNormalized = replaceTabs(deltaDisplay);
+	cache.rawContent = fileContent;
+	if (cache.normalizedLines.length === 0) {
+		cache.normalizedLines.push("");
+		cache.highlightedLines.push("");
+	}
+
+	const segments = deltaNormalized.split("\n");
+	const lastIndex = cache.normalizedLines.length - 1;
+	cache.normalizedLines[lastIndex] += segments[0];
+	cache.highlightedLines[lastIndex] = highlightSingleLine(cache.normalizedLines[lastIndex], cache.lang);
+	for (let i = 1; i < segments.length; i++) {
+		cache.normalizedLines.push(segments[i]);
+		cache.highlightedLines.push(highlightSingleLine(segments[i], cache.lang));
+	}
+	refreshWriteHighlightPrefix(cache);
+	return cache;
+}
+
+function trimTrailingEmptyLines(lines: string[]): string[] {
+	let end = lines.length;
+	while (end > 0 && lines[end - 1] === "") {
+		end--;
+	}
+	return lines.slice(0, end);
+}
+
+function formatWriteCall(
+	args: { path?: string; file_path?: string; content?: string } | undefined,
+	options: ToolRenderResultOptions,
+	theme: typeof import("../../modes/interactive/theme/theme.js").theme,
+	cache: WriteHighlightCache | undefined,
+): string {
+	const rawPath = str(args?.file_path ?? args?.path);
+	const fileContent = str(args?.content);
+	const path = rawPath !== null ? shortenPath(rawPath) : null;
+	const invalidArg = invalidArgText(theme);
+	let text = `${theme.fg("toolTitle", theme.bold("write"))} ${path === null ? invalidArg : path ? theme.fg("accent", path) : theme.fg("toolOutput", "...")}`;
+
+	if (fileContent === null) {
+		text += `\n\n${theme.fg("error", "[invalid content arg - expected string]")}`;
+	} else if (fileContent) {
+		const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
+		const renderedLines = lang
+			? (cache?.highlightedLines ?? highlightCode(replaceTabs(normalizeDisplayText(fileContent)), lang))
+			: normalizeDisplayText(fileContent).split("\n");
+		const lines = trimTrailingEmptyLines(renderedLines);
+		const totalLines = lines.length;
+		const maxLines = options.expanded ? lines.length : 10;
+		const displayLines = lines.slice(0, maxLines);
+		const remaining = lines.length - maxLines;
+		text += `\n\n${displayLines.map((line) => (lang ? line : theme.fg("toolOutput", replaceTabs(line)))).join("\n")}`;
+		if (remaining > 0) {
+			text += `${theme.fg("muted", `\n... (${remaining} more lines, ${totalLines} total,`)} ${keyHint("app.tools.expand", "to expand")})`;
+		}
+	}
+
+	return text;
+}
+
+function formatWriteResult(
+	result: { content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>; isError?: boolean },
+	theme: typeof import("../../modes/interactive/theme/theme.js").theme,
+): string | undefined {
+	if (!result.isError) {
+		return undefined;
+	}
+	const output = result.content
+		.filter((c) => c.type === "text")
+		.map((c) => c.text || "")
+		.join("\n");
+	if (!output) {
+		return undefined;
+	}
+	return `\n${theme.fg("error", output)}`;
+}
+
+export function createWriteToolDefinition(
+	cwd: string,
+	options?: WriteToolOptions,
+): ToolDefinition<typeof writeSchema, undefined> {
+	const ops = options?.operations ?? defaultWriteOperations;
+	return {
+		name: "write",
+		label: "write",
+		description:
+			"Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+		promptSnippet: "Create or overwrite files",
+		promptGuidelines: ["Use write only for new files or complete rewrites."],
+		parameters: writeSchema,
+		async execute(
+			_toolCallId,
+			{ path, content }: { path: string; content: string },
+			signal?: AbortSignal,
+			_onUpdate?,
+			_ctx?,
+		) {
+			const absolutePath = resolveToCwd(path, cwd);
+			const dir = dirname(absolutePath);
+			return withFileMutationQueue(
+				absolutePath,
+				() =>
+					new Promise<{ content: Array<{ type: "text"; text: string }>; details: undefined }>(
+						(resolve, reject) => {
+							if (signal?.aborted) {
+								reject(new Error("Operation aborted"));
+								return;
+							}
+							let aborted = false;
+							const onAbort = () => {
+								aborted = true;
+								reject(new Error("Operation aborted"));
+							};
+							signal?.addEventListener("abort", onAbort, { once: true });
+							(async () => {
+								try {
+									// Create parent directories if needed.
+									await ops.mkdir(dir);
+									if (aborted) return;
+									// Write the file contents.
+									await ops.writeFile(absolutePath, content);
+									if (aborted) return;
+									signal?.removeEventListener("abort", onAbort);
+									resolve({
+										content: [
+											{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path}` },
+										],
+										details: undefined,
+									});
+								} catch (error: any) {
+									signal?.removeEventListener("abort", onAbort);
+									if (!aborted) reject(error);
+								}
+							})();
+						},
+					),
+			);
+		},
+		renderCall(args, theme, context) {
+			const renderArgs = args as { path?: string; file_path?: string; content?: string } | undefined;
+			const rawPath = str(renderArgs?.file_path ?? renderArgs?.path);
+			const fileContent = str(renderArgs?.content);
+			const component =
+				(context.lastComponent as WriteCallRenderComponent | undefined) ?? new WriteCallRenderComponent();
+			if (fileContent !== null) {
+				component.cache = context.argsComplete
+					? rebuildWriteHighlightCacheFull(rawPath, fileContent)
+					: updateWriteHighlightCacheIncremental(component.cache, rawPath, fileContent);
+			} else {
+				component.cache = undefined;
+			}
+			component.setText(
+				formatWriteCall(
+					renderArgs,
+					{ expanded: context.expanded, isPartial: context.isPartial },
+					theme,
+					component.cache,
+				),
+			);
+			return component;
+		},
+		renderResult(result, _options, theme, context) {
+			const output = formatWriteResult({ ...result, isError: context.isError }, theme);
+			if (!output) {
+				const component = (context.lastComponent as Container | undefined) ?? new Container();
+				component.clear();
+				return component;
+			}
+			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+			text.setText(output);
+			return text;
+		},
+	};
+}
+
+export function createWriteTool(cwd: string, options?: WriteToolOptions): AgentTool<typeof writeSchema> {
+	return wrapToolDefinition(createWriteToolDefinition(cwd, options));
+}
+
+/** Default write tool using process.cwd() for backwards compatibility. */
+export const writeToolDefinition = createWriteToolDefinition(process.cwd());
+export const writeTool = createWriteTool(process.cwd());

package/src/core/version-check.ts

@@ -0,0 +1,85 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { getVersionCheckCachePath, PACKAGE_NAME, VERSION } from "../config.js";
+
+const VERSION_CHECK_TTL_MS = 12 * 60 * 60 * 1000;
+
+interface VersionCheckCache {
+	checkedAt: number;
+	latestVersion?: string;
+}
+
+function parseVersion(version: string): number[] | undefined {
+	const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].+)?$/.exec(version.trim());
+	if (!match) return undefined;
+	return match.slice(1, 4).map((segment) => Number.parseInt(segment, 10));
+}
+
+function isNewerVersion(candidate: string, current: string): boolean {
+	const candidateParts = parseVersion(candidate);
+	const currentParts = parseVersion(current);
+	if (!candidateParts || !currentParts) return candidate !== current;
+
+	for (let i = 0; i < Math.max(candidateParts.length, currentParts.length); i++) {
+		const candidateValue = candidateParts[i] ?? 0;
+		const currentValue = currentParts[i] ?? 0;
+		if (candidateValue > currentValue) return true;
+		if (candidateValue < currentValue) return false;
+	}
+
+	return false;
+}
+
+async function readCache(): Promise<VersionCheckCache | undefined> {
+	try {
+		const content = await readFile(getVersionCheckCachePath(), "utf8");
+		const parsed = JSON.parse(content) as VersionCheckCache;
+		return typeof parsed.checkedAt === "number" ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+async function writeCache(cache: VersionCheckCache): Promise<void> {
+	const path = getVersionCheckCachePath();
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
+}
+
+export async function checkForPublishedCliUpdate(
+	currentVersion: string = VERSION,
+	packageName: string = PACKAGE_NAME,
+): Promise<string | undefined> {
+	if (process.env.PI_SKIP_VERSION_CHECK || process.env.PI_OFFLINE) return undefined;
+
+	const cached = await readCache();
+	const now = Date.now();
+	if (cached && now - cached.checkedAt < VERSION_CHECK_TTL_MS) {
+		return cached.latestVersion && isNewerVersion(cached.latestVersion, currentVersion)
+			? cached.latestVersion
+			: undefined;
+	}
+
+	try {
+		const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+			signal: AbortSignal.timeout(10000),
+		});
+		if (!response.ok) {
+			return cached?.latestVersion && isNewerVersion(cached.latestVersion, currentVersion)
+				? cached.latestVersion
+				: undefined;
+		}
+
+		const data = (await response.json()) as { version?: string };
+		await writeCache({
+			checkedAt: now,
+			latestVersion: data.version,
+		});
+
+		return data.version && isNewerVersion(data.version, currentVersion) ? data.version : undefined;
+	} catch {
+		return cached?.latestVersion && isNewerVersion(cached.latestVersion, currentVersion)
+			? cached.latestVersion
+			: undefined;
+	}
+}