@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/utils/block-context.ts

@@ -0,0 +1,312 @@
+import { enclosingBlockBoundaries } from "@prometheus-ai/natives";
+import { logger } from "@prometheus-ai/utils";
+
+const OPEN_TO_CLOSE: Record<string, string> = {
+	"(": ")",
+	"[": "]",
+	"{": "}",
+};
+
+const CLOSE_TO_OPEN: Record<string, string> = {
+	")": "(",
+	"]": "[",
+	"}": "{",
+};
+
+export interface LineSpan {
+	startLine: number;
+	endLine: number;
+}
+
+/** Where the source came from, so tree-sitter can pick a grammar. */
+export interface BlockContextSource {
+	path?: string;
+	lang?: string;
+}
+
+export type LineEntry = { kind: "line"; lineNumber: number; text: string; context: boolean } | { kind: "ellipsis" };
+
+interface StackEntry {
+	opener: string;
+	lineNumber: number;
+	text: string;
+	visible: boolean;
+}
+
+type ScannerMode = "code" | "single" | "double" | "template" | "blockComment";
+
+function normalizeLineSpans(spans: readonly LineSpan[], totalLines: number): LineSpan[] {
+	if (totalLines <= 0) return [];
+	const normalized: LineSpan[] = [];
+	for (const span of spans) {
+		const startLine = Math.max(1, Math.trunc(span.startLine));
+		const endLine = Math.min(totalLines, Math.trunc(span.endLine));
+		if (endLine < startLine) continue;
+		normalized.push({ startLine, endLine });
+	}
+	if (normalized.length <= 1) return normalized;
+	normalized.sort((left, right) => left.startLine - right.startLine || left.endLine - right.endLine);
+	const merged: LineSpan[] = [];
+	for (const span of normalized) {
+		const previous = merged[merged.length - 1];
+		if (previous && span.startLine <= previous.endLine + 1) {
+			previous.endLine = Math.max(previous.endLine, span.endLine);
+			continue;
+		}
+		merged.push({ ...span });
+	}
+	return merged;
+}
+
+function visibleLineNumbers(spans: readonly LineSpan[]): Set<number> {
+	const visible = new Set<number>();
+	for (const span of spans) {
+		for (let line = span.startLine; line <= span.endLine; line++) {
+			visible.add(line);
+		}
+	}
+	return visible;
+}
+
+function hasEveryLineVisible(visible: ReadonlySet<number>, totalLines: number): boolean {
+	return totalLines > 0 && visible.size >= totalLines;
+}
+
+/** Collapse a set of visible line numbers into sorted, merged inclusive spans. */
+function visibleSetToSpans(visible: ReadonlySet<number>): LineSpan[] {
+	const sorted = [...visible].sort((left, right) => left - right);
+	const spans: LineSpan[] = [];
+	for (const line of sorted) {
+		const previous = spans[spans.length - 1];
+		if (previous && line <= previous.endLine + 1) {
+			previous.endLine = line;
+			continue;
+		}
+		spans.push({ startLine: line, endLine: line });
+	}
+	return spans;
+}
+
+/**
+ * Tree-sitter-backed block boundaries. For each multi-line named node whose
+ * span crosses the visible window, the native side returns the boundary line
+ * outside that window (closer when the opener is shown, opener when the closer
+ * is shown). Returns `null` when the language is unrecognized or the source has
+ * a syntax error so the caller can fall back to a lexical bracket scan.
+ */
+function nativeBlockContext(
+	fullLines: readonly string[],
+	visible: ReadonlySet<number>,
+	source: BlockContextSource,
+): Map<number, string> | null {
+	if (!source.path && !source.lang) return null;
+	const ranges = visibleSetToSpans(visible);
+	if (ranges.length === 0) return new Map();
+	let boundaries: number[] | null;
+	try {
+		boundaries = enclosingBlockBoundaries({
+			code: fullLines.join("\n"),
+			path: source.path,
+			lang: source.lang,
+			ranges,
+		});
+	} catch (error) {
+		logger.debug("enclosingBlockBoundaries failed; using lexical bracket fallback", { error });
+		return null;
+	}
+	if (boundaries === null) return null;
+	const context = new Map<number, string>();
+	for (const lineNumber of boundaries) {
+		if (visible.has(lineNumber)) continue;
+		context.set(lineNumber, fullLines[lineNumber - 1] ?? "");
+	}
+	return context;
+}
+
+function findMatchingStackIndex(stack: readonly StackEntry[], opener: string): number {
+	for (let index = stack.length - 1; index >= 0; index--) {
+		if (stack[index].opener === opener) return index;
+	}
+	return -1;
+}
+
+function isHashCommentStart(line: string, index: number): boolean {
+	if (line[index] !== "#") return false;
+	for (let i = 0; i < index; i++) {
+		const ch = line[i];
+		if (ch !== " " && ch !== "\t") return false;
+	}
+	return true;
+}
+
+/**
+ * Lexical bracket-matching fallback for sources tree-sitter can't parse
+ * (unknown extensions, syntax errors). Pairs `()[]{}` while skipping strings
+ * and line/block comments, and reports the matching line when one endpoint is
+ * visible and the other is not.
+ */
+function lexicalBracketContext(fullLines: readonly string[], visible: ReadonlySet<number>): Map<number, string> {
+	const context = new Map<number, string>();
+	const stack: StackEntry[] = [];
+	let mode: ScannerMode = "code";
+	let escaped = false;
+
+	for (let lineIndex = 0; lineIndex < fullLines.length; lineIndex++) {
+		const lineNumber = lineIndex + 1;
+		const line = fullLines[lineIndex] ?? "";
+		const lineVisible = visible.has(lineNumber);
+		let index = 0;
+		while (index < line.length) {
+			const ch = line[index];
+			const next = index + 1 < line.length ? line[index + 1] : "";
+
+			if (mode === "blockComment") {
+				if (ch === "*" && next === "/") {
+					mode = "code";
+					index += 2;
+					continue;
+				}
+				index++;
+				continue;
+			}
+
+			if (mode === "single" || mode === "double" || mode === "template") {
+				if (escaped) {
+					escaped = false;
+					index++;
+					continue;
+				}
+				if (ch === "\\") {
+					escaped = true;
+					index++;
+					continue;
+				}
+				if (
+					(mode === "single" && ch === "'") ||
+					(mode === "double" && ch === '"') ||
+					(mode === "template" && ch === "`")
+				) {
+					mode = "code";
+				}
+				index++;
+				continue;
+			}
+
+			if (ch === "/" && next === "/") break;
+			if (ch === "/" && next === "*") {
+				mode = "blockComment";
+				index += 2;
+				continue;
+			}
+			if (isHashCommentStart(line, index)) break;
+			if (ch === "'") {
+				mode = "single";
+				escaped = false;
+				index++;
+				continue;
+			}
+			if (ch === '"') {
+				mode = "double";
+				escaped = false;
+				index++;
+				continue;
+			}
+			if (ch === "`") {
+				mode = "template";
+				escaped = false;
+				index++;
+				continue;
+			}
+
+			if (OPEN_TO_CLOSE[ch]) {
+				stack.push({ opener: ch, lineNumber, text: line, visible: lineVisible });
+				index++;
+				continue;
+			}
+
+			const opener = CLOSE_TO_OPEN[ch];
+			if (opener) {
+				const matchIndex = findMatchingStackIndex(stack, opener);
+				if (matchIndex !== -1) {
+					const [matched] = stack.splice(matchIndex);
+					if (matched) {
+						if (lineVisible && !matched.visible) context.set(matched.lineNumber, matched.text);
+						if (matched.visible && !lineVisible) context.set(lineNumber, line);
+					}
+				}
+			}
+
+			index++;
+		}
+
+		if (mode === "single" || mode === "double") {
+			mode = "code";
+			escaped = false;
+		}
+	}
+
+	for (const lineNumber of visible) context.delete(lineNumber);
+	return context;
+}
+
+/**
+ * Resolve the off-window boundary lines for a visible window: tree-sitter
+ * syntactic spans first (covers brace and indentation languages), falling back
+ * to a lexical bracket scan when the grammar is unavailable. Returns a map of
+ * `lineNumber → source text` for the lines to surface, never including a line
+ * already visible.
+ */
+export function findBlockContextLines(
+	fullLines: readonly string[],
+	visibleInput: ReadonlySet<number> | readonly number[],
+	source: BlockContextSource = {},
+): Map<number, string> {
+	const visible = visibleInput instanceof Set ? visibleInput : new Set(visibleInput);
+	if (visible.size === 0 || hasEveryLineVisible(visible, fullLines.length)) return new Map();
+	return nativeBlockContext(fullLines, visible, source) ?? lexicalBracketContext(fullLines, visible);
+}
+
+/**
+ * Build display entries for `visibleSpans` plus any off-window block-boundary
+ * lines, in source order, with `{ kind: "ellipsis" }` markers inserted across
+ * non-contiguous gaps. `options.lineText` lets callers substitute display text
+ * (e.g. column-truncated lines) for a given line number.
+ */
+export function buildLineEntriesWithBlockContext(
+	fullLines: readonly string[],
+	visibleSpans: readonly LineSpan[],
+	source: BlockContextSource = {},
+	options: {
+		lineText?: (lineNumber: number, sourceText: string, context: boolean) => string;
+	} = {},
+): LineEntry[] {
+	const spans = normalizeLineSpans(visibleSpans, fullLines.length);
+	const visible = visibleLineNumbers(spans);
+	const context = findBlockContextLines(fullLines, visible, source);
+	const allLines = new Set<number>(visible);
+	for (const lineNumber of context.keys()) allLines.add(lineNumber);
+
+	const sorted = [...allLines].sort((left, right) => left - right);
+	const entries: LineEntry[] = [];
+	let previousLine: number | undefined;
+	for (const lineNumber of sorted) {
+		if (previousLine !== undefined && lineNumber > previousLine + 1) {
+			entries.push({ kind: "ellipsis" });
+		}
+		const sourceText = fullLines[lineNumber - 1] ?? "";
+		const isContext = context.has(lineNumber);
+		entries.push({
+			kind: "line",
+			lineNumber,
+			text: options.lineText?.(lineNumber, sourceText, isContext) ?? sourceText,
+			context: isContext,
+		});
+		previousLine = lineNumber;
+	}
+
+	return entries;
+}
+
+export function lineEntriesToPlainText(entries: readonly LineEntry[], ellipsis = "…"): string {
+	return entries.map(entry => (entry.kind === "ellipsis" ? ellipsis : entry.text)).join("\n");
+}

package/src/utils/changelog.ts

@@ -1,4 +1,4 @@
-import { isEnoent, logger } from "@prometheus-ai/utils";
+import { getLastChangelogVersionPath, isEnoent, logger } from "@prometheus-ai/utils";
 
 export interface ChangelogEntry {
 	major: number;
@@ -104,3 +104,29 @@ export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): C
 
 // Re-export getChangelogPath from paths.ts for convenience
 export { getChangelogPath } from "../config";
+
+/**
+ * Last prometheus version whose changelog the user has seen. Stored as a plain-text
+ * marker file (`~/.prometheus/agent/last-changelog-version`) rather than in
+ * `config.yml`, so version bumps never dirty user-tracked config files.
+ */
+export async function readLastChangelogVersion(agentDir?: string): Promise<string | undefined> {
+	try {
+		const value = (await Bun.file(getLastChangelogVersionPath(agentDir)).text()).trim();
+		return value || undefined;
+	} catch (error) {
+		if (!isEnoent(error)) {
+			logger.warn("Failed to read last-changelog-version marker", { error: String(error) });
+		}
+		return undefined;
+	}
+}
+
+/** Persist the last-seen changelog version marker. Best-effort: failures are logged, never thrown. */
+export async function writeLastChangelogVersion(version: string, agentDir?: string): Promise<void> {
+	try {
+		await Bun.write(getLastChangelogVersionPath(agentDir), version);
+	} catch (error) {
+		logger.warn("Failed to persist last-changelog-version marker", { error: String(error) });
+	}
+}

package/src/utils/clipboard.ts

@@ -66,9 +66,10 @@ export async function copyToClipboard(text: string): Promise<void> {
 	}
 }
 
-// PowerShell one-liner that emits the clipboard image as base64-encoded PNG on
-// stdout, or nothing when the clipboard does not hold image data. Used as the
-// WSL bridge — arboard cannot read the Windows clipboard through WSLg.
+// PowerShell one-liner that emits the Windows clipboard image as base64-encoded
+// PNG on stdout, or nothing when the clipboard does not hold image data. Used
+// for native Windows fallback and WSL interop because arboard can miss host
+// clipboard image payloads in those terminal paths.
 const POWERSHELL_IMAGE_SCRIPT = `
 $ErrorActionPreference = 'Stop'
 Add-Type -AssemblyName System.Windows.Forms
@@ -84,31 +85,36 @@ if ($img -ne $null) {
 const POWERSHELL_TIMEOUT_MS = 8000;
 
 /**
- * Read a clipboard image through the Windows host's PowerShell.
+ * Read an image through the Windows host's PowerShell.
  *
- * WSLg exposes a Wayland socket but no native clipboard image transport, so
- * `arboard` returns `ContentNotAvailable`. PowerShell, reached via WSL interop,
- * can read the Windows clipboard directly and round-trip the bitmap as PNG.
+ * Native Windows uses this as a fallback when arboard reports no image or
+ * cannot access the clipboard. WSLg exposes a Wayland socket but no native
+ * clipboard image transport, so arboard returns `ContentNotAvailable` there;
+ * PowerShell, reached via WSL interop, can read the Windows clipboard directly
+ * and round-trip the bitmap as PNG.
  *
  * Returns null when no image is on the clipboard, the host PowerShell is
  * missing, or the bridge times out.
  */
 async function readImageViaPowerShell(): Promise<ClipboardImage | null> {
 	try {
-		const proc = Bun.spawn(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", POWERSHELL_IMAGE_SCRIPT], {
-			stdout: "pipe",
-			stderr: "ignore",
-			stdin: "ignore",
-		});
+		const proc = Bun.spawn(
+			["powershell.exe", "-NoProfile", "-NonInteractive", "-Sta", "-Command", POWERSHELL_IMAGE_SCRIPT],
+			{
+				stdout: "pipe",
+				stderr: "ignore",
+				stdin: "ignore",
+			},
+		);
 		const timer = setTimeout(() => proc.kill(), POWERSHELL_TIMEOUT_MS);
 		let stdout = "";
 		try {
 			stdout = await new Response(proc.stdout).text();
 			await proc.exited;
 		} catch (err) {
-			// powershell.exe is a Windows process reached over WSL interop; if it
-			// doesn't reap cleanly, swallow the error so the dispatcher can fall
-			// through to the native bridge instead of throwing.
+			// powershell.exe can be a Windows process reached either natively or
+			// over WSL interop; if it doesn't reap cleanly, report no image instead
+			// of surfacing an opaque bridge failure to the prompt.
 			logger.warn("clipboard: powershell read failed", { error: String(err) });
 			return null;
 		} finally {
@@ -125,13 +131,64 @@ async function readImageViaPowerShell(): Promise<ClipboardImage | null> {
 	}
 }
 
+// PowerShell one-liner that emits the clipboard text verbatim on stdout, or
+// nothing when the clipboard holds no text. `[Console]::Out.Write` avoids the
+// trailing newline Write-Output would add; output encoding is forced to UTF-8
+// so non-ASCII text survives the interop boundary regardless of console
+// codepage.
+const POWERSHELL_TEXT_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+[Console]::OutputEncoding = [Text.Encoding]::UTF8
+[Console]::Out.Write([string](Get-Clipboard -Raw))
+`;
+
+/**
+ * Read clipboard text through Windows PowerShell — native win32 or the WSL
+ * host over interop.
+ *
+ * Same rationale as `readImageViaPowerShell`: under WSL, the WSLg Wayland
+ * clipboard only works when `wl-clipboard` happens to be installed in the
+ * distro, while `powershell.exe` is always reachable. Forcing UTF-8 output
+ * encoding keeps non-ASCII text intact regardless of the console codepage
+ * (the legacy win32 `Get-Clipboard` shell-out mangled it), and `Bun.spawn`
+ * keeps a cold PowerShell start off the TUI event loop.
+ *
+ * Returns null when the bridge fails (WSL callers fall through to
+ * wl-paste/xclip); an empty string is a successful "no text" read.
+ */
+async function readTextViaPowerShell(): Promise<string | null> {
+	try {
+		const proc = Bun.spawn(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", POWERSHELL_TEXT_SCRIPT], {
+			stdout: "pipe",
+			stderr: "ignore",
+			stdin: "ignore",
+		});
+		const timer = setTimeout(() => proc.kill(), POWERSHELL_TIMEOUT_MS);
+		let stdout = "";
+		try {
+			stdout = await new Response(proc.stdout).text();
+			await proc.exited;
+		} catch (err) {
+			logger.warn("clipboard: powershell text read failed", { error: String(err) });
+			return null;
+		} finally {
+			clearTimeout(timer);
+		}
+		if (proc.exitCode !== 0) return null;
+		return stdout.replaceAll("\r\n", "\n");
+	} catch {
+		return null;
+	}
+}
+
 /**
  * Read an image from the system clipboard.
  *
  * Returns null on Termux (no image clipboard support) or when no display
- * server is available (headless/SSH without forwarding). Under WSL the
- * Windows clipboard is reached through `powershell.exe`, since WSLg's
- * Wayland clipboard does not carry image payloads through to `arboard`.
+ * server is available (headless/SSH without forwarding). Under native Windows
+ * and WSL, the Windows clipboard is also reached through `powershell.exe`
+ * because terminal clipboard paths can leave image payloads invisible to the
+ * native bridge.
  *
  * @returns PNG payload or null when no image is available.
  */
@@ -148,6 +205,16 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 		// no display, so arboard would reject anyway.
 	}
 
+	if (process.platform === "win32") {
+		try {
+			const image = await native.readImageFromClipboard();
+			if (image) return image;
+		} catch (err) {
+			logger.warn("clipboard: native Windows image read failed", { error: String(err) });
+		}
+		return await readImageViaPowerShell();
+	}
+
 	if (!hasDisplay()) {
 		return null;
 	}
@@ -165,14 +232,16 @@ export async function readTextFromClipboard(): Promise<string> {
 			return execSync("pbpaste", { encoding: "utf8", timeout: 2000 }).toString();
 		}
 		if (p === "win32") {
-			return execSync('powershell.exe -NoProfile -Command "Get-Clipboard"', {
-				encoding: "utf8",
-				timeout: 2000,
-			}).toString();
+			return (await readTextViaPowerShell()) ?? "";
 		}
 		if (process.env.TERMUX_VERSION) {
 			return execSync("termux-clipboard-get", { encoding: "utf8", timeout: 2000 }).toString();
 		}
+		if (isWsl()) {
+			const text = await readTextViaPowerShell();
+			if (text !== null) return text;
+			// Bridge failed — fall through to the wl-paste/xclip paths below.
+		}
 		const hasWaylandDisplay = Boolean(process.env.WAYLAND_DISPLAY);
 		const hasX11Display = Boolean(process.env.DISPLAY);
 		if (hasWaylandDisplay) {

package/src/utils/commit-message-generator.ts

@@ -6,8 +6,9 @@ import type { ThinkingLevel } from "@prometheus-ai/agent-core";
 import type { Api, Model } from "@prometheus-ai/ai";
 import { completeSimple } from "@prometheus-ai/ai";
 import { logger, prompt } from "@prometheus-ai/utils";
+
 import type { ModelRegistry } from "../config/model-registry";
-import { resolveModelRoleValue } from "../config/model-resolver";
+import { getModelMatchPreferences, resolveModelRoleValue } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 import commitSystemPrompt from "../prompts/system/commit-message-system.md" with { type: "text" };
@@ -50,7 +51,7 @@ function getSmolModelCandidates(
 		candidates.push({ model, thinkingLevel });
 	};
 
-	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
+	const matchPreferences = getModelMatchPreferences(settings);
 	const configuredSmol = resolveModelRoleValue(settings.getModelRole("smol"), availableModels, {
 		settings,
 		matchPreferences,
@@ -110,7 +111,11 @@ export async function generateCommitMessage(
 					systemPrompt: [COMMIT_SYSTEM_PROMPT],
 					messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
 				},
-				{ apiKey, maxTokens, reasoning: toReasoningEffort(candidate.thinkingLevel) },
+				{
+					apiKey: registry.resolver(candidate.model, sessionId),
+					maxTokens,
+					reasoning: toReasoningEffort(candidate.thinkingLevel),
+				},
 			);
 
 			if (response.stopReason === "error") {