@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/tools/github-cache.ts

@@ -93,10 +93,11 @@ export function openDb(): Database | null {
 		const dbPath = getGithubCacheDbPath();
 		ensureParentDir(dbPath);
 		const db = new Database(dbPath);
+		// Install the busy handler BEFORE any lock-taking statement. See #2421.
+		db.run("PRAGMA busy_timeout = 5000");
 		db.run(`
 			PRAGMA journal_mode=WAL;
 			PRAGMA synchronous=NORMAL;
-			PRAGMA busy_timeout=5000;
 		`);
 		// Migrate any pre-existing table whose key/check constraint predates
 		// the current schema. The cache is regenerable, so we drop rows rather
@@ -174,6 +175,21 @@ function hashCacheIdentity(parts: string[]): string {
 	return Bun.hash(parts.map(part => `${part.length}:${part}`).join("|")).toString(36);
 }
 
+/**
+ * Memo for {@link resolveGithubCacheAuthKey}. Recomputed only when the token
+ * env vars or the hosts.yml path/mtime change, so the per-lookup cost on the
+ * cache hot path is four env reads plus one `stat` instead of a full file
+ * read + hash.
+ */
+interface AuthKeyMemoEntry {
+	envSig: string;
+	hostsPath: string;
+	hostsMtimeMs: number;
+	value: string | undefined;
+}
+const AUTH_KEY_TOKEN_ENV_VARS = ["GH_TOKEN", "GITHUB_TOKEN", "GH_ENTERPRISE_TOKEN", "GITHUB_ENTERPRISE_TOKEN"];
+const authKeyMemo = new Map<string, AuthKeyMemoEntry>();
+
 /**
  * Best-effort local fingerprint for the active GitHub CLI credentials.
  *
@@ -185,16 +201,32 @@ function hashCacheIdentity(parts: string[]): string {
  * credential source is visible, callers should pass `null` to bypass caching.
  */
 export function resolveGithubCacheAuthKey(host: string = process.env.GH_HOST || "github.com"): string | undefined {
+	const hostsPath = path.join(getGhConfigDir(), "hosts.yml");
+	let envSig = "";
+	for (const name of AUTH_KEY_TOKEN_ENV_VARS) {
+		const value = process.env[name];
+		if (value) envSig += `${name}=${value.length}:${value}\0`;
+	}
+	let hostsMtimeMs = -1;
+	try {
+		hostsMtimeMs = fs.statSync(hostsPath, { throwIfNoEntry: false })?.mtimeMs ?? -1;
+	} catch (err) {
+		logger.debug("github cache: failed to stat gh hosts config for cache identity", { err: String(err) });
+	}
+	const memo = authKeyMemo.get(host);
+	if (memo && memo.envSig === envSig && memo.hostsPath === hostsPath && memo.hostsMtimeMs === hostsMtimeMs) {
+		return memo.value;
+	}
+
 	const parts: string[] = [`host:${host}`];
 	let hasCredentialMaterial = false;
-	for (const name of ["GH_TOKEN", "GITHUB_TOKEN", "GH_ENTERPRISE_TOKEN", "GITHUB_ENTERPRISE_TOKEN"]) {
+	for (const name of AUTH_KEY_TOKEN_ENV_VARS) {
 		const value = process.env[name];
 		if (!value) continue;
 		hasCredentialMaterial = true;
 		parts.push(`${name}:${value}`);
 	}
 	try {
-		const hostsPath = path.join(getGhConfigDir(), "hosts.yml");
 		const hosts = fs.readFileSync(hostsPath, "utf8");
 		hasCredentialMaterial = true;
 		parts.push(`hosts:${hosts}`);
@@ -203,8 +235,9 @@ export function resolveGithubCacheAuthKey(host: string = process.env.GH_HOST ||
 			logger.debug("github cache: failed to read gh hosts config for cache identity", { err: String(err) });
 		}
 	}
-	if (!hasCredentialMaterial) return undefined;
-	return `${host}:${hashCacheIdentity(parts)}`;
+	const value = hasCredentialMaterial ? `${host}:${hashCacheIdentity(parts)}` : undefined;
+	authKeyMemo.set(host, { envSig, hostsPath, hostsMtimeMs, value });
+	return value;
 }
 
 function normalizeRepo(repo: string): string {
@@ -316,6 +349,31 @@ export function invalidate(
 	}
 }
 
+/**
+ * Drop every cached row for a given issue/PR number, regardless of repo,
+ * auth key, include_comments flag, or row kind ({@link CacheKind}). Best-effort:
+ * swallows DB failures the same way {@link invalidate} does.
+ *
+ * Used by the bash-side detector that reacts to `gh issue close` / `gh pr merge`
+ * style mutations. Repo + auth-key narrowing is intentionally skipped because
+ * the bash command often does not name the repo (defaults to cwd's `gh`
+ * config) and resolving the *current* repo from `cwd` for every bash call would
+ * be far more expensive than a write-amplified DELETE.
+ */
+export function invalidateAllForNumber(number: number, repo?: string): void {
+	const db = openDb();
+	if (!db) return;
+	try {
+		if (repo === undefined) {
+			db.prepare("DELETE FROM github_view_cache WHERE number = ?").run(number);
+		} else {
+			db.prepare("DELETE FROM github_view_cache WHERE number = ? AND repo = ?").run(number, normalizeRepo(repo));
+		}
+	} catch (err) {
+		logger.debug("github cache: invalidateAllForNumber failed", { err: String(err) });
+	}
+}
+
 /** Drop every cached row. Test helper. */
 export function clearAll(): void {
 	const db = openDb();
@@ -327,6 +385,26 @@ export function clearAll(): void {
 	}
 }
 
+/**
+ * Drop every cached row for a repo, or all rows when the repo is unknown.
+ * Fallback for current-branch `gh pr merge`/`gh pr close`-style mutations
+ * where the bash command names no PR number or URL, so the target row cannot
+ * be identified. Over-invalidation is deliberate (see module header).
+ */
+export function invalidateAllForRepo(repo?: string): void {
+	const db = openDb();
+	if (!db) return;
+	try {
+		if (repo === undefined) {
+			db.prepare("DELETE FROM github_view_cache").run();
+		} else {
+			db.prepare("DELETE FROM github_view_cache WHERE repo = ?").run(normalizeRepo(repo));
+		}
+	} catch (err) {
+		logger.debug("github cache: invalidateAllForRepo failed", { err: String(err) });
+	}
+}
+
 /**
  * Test/maintenance helper. Closes and forgets the cached connection so the
  * next access reopens against (possibly) a different DB path.
@@ -342,6 +420,7 @@ export function resetForTests(): void {
 	cachedDb = null;
 	openAttempted = false;
 	lastSweepAt = 0;
+	authKeyMemo.clear();
 }
 
 // ────────────────────────────────────────────────────────────────────────────
@@ -442,6 +521,12 @@ function storeResult<T>(
 	});
 }
 
+/**
+ * In-flight background refreshes keyed by row identity. N concurrent stale
+ * reads of the same row must spawn one `gh` subprocess, not N identical ones.
+ */
+const inflightRefreshes = new Set<string>();
+
 function scheduleBackgroundRefresh<T>(
 	authKey: string,
 	repo: string,
@@ -450,9 +535,11 @@ function scheduleBackgroundRefresh<T>(
 	includeComments: boolean,
 	fetchFresh: () => Promise<FreshResult<T>>,
 ): void {
+	const key = `${authKey}|${normalizeRepo(repo)}|${kind}|${number}|${includeComments ? 1 : 0}`;
+	if (inflightRefreshes.has(key)) return;
+	inflightRefreshes.add(key);
 	queueMicrotask(() => {
-		const promise = fetchFresh();
-		promise
+		fetchFresh()
 			.then(fresh => {
 				storeResult(authKey, repo, kind, number, includeComments, fresh, Date.now());
 			})
@@ -463,6 +550,9 @@ function scheduleBackgroundRefresh<T>(
 					kind,
 					number,
 				});
+			})
+			.finally(() => {
+				inflightRefreshes.delete(key);
 			});
 	});
 }

package/src/tools/grouped-file-output.ts

@@ -1,15 +1,15 @@
 import path from "node:path";
 
-const URL_LIKE_PATH_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+import { buildPathTree, isUrlLikePath, type PathTreeInput, walkPathTree } from "@prometheus-ai/utils";
 
-function isUrlLikePath(filePath: string): boolean {
-	return URL_LIKE_PATH_RE.test(filePath);
-}
+// =============================================================================
+// Grouped file output (grep / ast-grep / ast-edit / lsp diagnostics)
+// =============================================================================
 
 /**
  * One file's contribution to a grouped file output. The header itself is generated
- * by `formatGroupedFiles` (single `#` for root files, `##` for files inside a dir);
- * use `headerSuffix` to tack on extras like ` (1 replacement)`.
+ * by `formatGroupedFiles` (one `#` per nesting level); use `headerSuffix` to tack
+ * on extras like ` (1 replacement)`.
  */
 export interface GroupedFileSection {
 	/** Optional suffix appended to the file header. */
@@ -28,76 +28,183 @@ export interface GroupedFilesOutput {
 }
 
 /**
- * Render a list of files as directory-grouped sections shared by grep, ast-grep,
- * ast-edit, and the LSP diagnostic formatter.
+ * Render a list of files as a multi-level, prefix-folded directory tree shared by
+ * grep, ast-grep, ast-edit, and the LSP diagnostic formatter.
  *
- * Layout:
- *   # dir/
- *   ## file.ts
+ * Layout (one `#` per level; the shared prefix folds into the top header):
+ *   # packages/pkg/src/
+ *   ## root.ts
  *   …body…
- *
- *   # otherdir/
- *   ## other.ts
+ *   ## nested/
+ *   ### child.ts
  *   …body…
  *
- * Files in the project root (directory `.`) become single-`#` headers without a
- * `## file` line, matching the existing convention.
+ * Files in the (folded) project root become single-`#` headers with no parent
+ * directory line. A blank line precedes every directory header and every
+ * root-level file so the renderers can split the output into collapsible groups.
  */
 export function formatGroupedFiles(
 	files: string[],
 	renderFile: (filePath: string) => GroupedFileSection,
 ): GroupedFilesOutput {
-	const filesByDirectory = new Map<string, string[]>();
+	const sections = new Map<string, GroupedFileSection>();
+	const inputs: PathTreeInput[] = [];
 	for (const filePath of files) {
-		const directory = isUrlLikePath(filePath) ? "." : path.dirname(filePath).replace(/\\/g, "/");
-		if (!filesByDirectory.has(directory)) {
-			filesByDirectory.set(directory, []);
-		}
-		filesByDirectory.get(directory)!.push(filePath);
+		if (sections.has(filePath)) continue;
+		const section = renderFile(filePath);
+		if (section.skip) continue;
+		sections.set(filePath, section);
+		inputs.push({ path: filePath, isDir: false, key: filePath });
 	}
 
+	const tree = buildPathTree(inputs);
 	const model: string[] = [];
 	const display: string[] = [];
+	let emitted = false;
 
-	const pushSeparatorIfNeeded = () => {
-		if (model.length > 0) {
+	for (const event of walkPathTree(tree)) {
+		const hashes = "#".repeat(event.depth + 1);
+		const needsSeparator = emitted && (event.depth === 0 || event.kind === "dir");
+		if (needsSeparator) {
 			model.push("");
 			display.push("");
 		}
+		emitted = true;
+		if (event.kind === "dir") {
+			const header = `${hashes} ${event.name}/`;
+			model.push(header);
+			display.push(header);
+			continue;
+		}
+		const section = sections.get(event.key)!;
+		const header = `${hashes} ${event.name}${section.headerSuffix ?? ""}`;
+		model.push(header, ...section.modelLines);
+		display.push(header, ...(section.displayLines ?? section.modelLines));
+	}
+
+	return { model, display };
+}
+
+// =============================================================================
+// Parsing grouped output back into per-line context (TUI renderers)
+// =============================================================================
+
+const GROUPED_HEADER_RE = /^(#+)\s+(.*)$/;
+const HEADER_SUFFIX_RE = /\s+\([^)]*\)\s*$/;
+const HEADER_HASH_TAG_RE = /#[0-9a-f]+$/i;
+
+/** Per-line classification of grouped output, used by renderers for hyperlinks. */
+export interface GroupedLineContext {
+	/** Directory header, file header, or any non-header body/content line. */
+	kind: "dir" | "file" | "content";
+	/** Number of leading `#` for headers; 0 for content lines. */
+	depth: number;
+	/** Resolved absolute path of the dir/file a header points at (when resolvable). */
+	headerPath?: string;
+	/** For content lines, the absolute path of the owning file (line hyperlinks). */
+	filePath?: string;
+	/** Header is an internal/url-like target the caller resolves itself. */
+	isUrl?: boolean;
+}
+
+function resolveGroupedPath(parent: string | undefined, name: string): string | undefined {
+	if (parent === undefined) return undefined;
+	if (name === "" || name === ".") return parent;
+	// `path.resolve` keeps an absolute `name` intact (out-of-cwd results) while
+	// joining a relative folded chain (`packages/pkg/src`) onto the parent.
+	return path.resolve(parent, name);
+}
+
+/**
+ * Walk grouped output lines, tracking a directory stack keyed by header depth, so
+ * each header and body line can be linked back to its absolute filesystem path.
+ * Reconstruction is stack-based (not per-blank-group) so nested directory headers
+ * resolve correctly across the whole output.
+ *
+ * `headerBase` is the directory the displayed (folded) header paths are relative
+ * to — for grep/ast tools that is the session cwd, since display paths are
+ * formatted relative to cwd regardless of the (sub)directory the search was
+ * scoped to. `fileScope` is the initial owning file for body lines that appear
+ * before any header (single-file scopes have no `#` headers); it defaults to
+ * `headerBase` and should be passed the scoped file's absolute path.
+ */
+export function classifyGroupedLines(
+	lines: readonly string[],
+	headerBase: string | undefined,
+	fileScope: string | undefined = headerBase,
+): GroupedLineContext[] {
+	const result: GroupedLineContext[] = [];
+	const dirAtDepth = new Map<number, string>();
+	// Body lines before any header (single-file scopes) link to the scoped file.
+	let currentFile = fileScope;
+
+	const clearDeeper = (depth: number) => {
+		for (const key of dirAtDepth.keys()) {
+			if (key >= depth) dirAtDepth.delete(key);
+		}
 	};
 
-	for (const [directory, dirFiles] of filesByDirectory) {
-		if (directory === ".") {
-			for (const filePath of dirFiles) {
-				const section = renderFile(filePath);
-				if (section.skip) continue;
-				pushSeparatorIfNeeded();
-				const headerName = isUrlLikePath(filePath) ? filePath : path.basename(filePath);
-				const header = `# ${headerName}${section.headerSuffix ?? ""}`;
-				model.push(header, ...section.modelLines);
-				display.push(header, ...(section.displayLines ?? section.modelLines));
-			}
+	for (const line of lines) {
+		const match = GROUPED_HEADER_RE.exec(line);
+		if (!match) {
+			result.push({ kind: "content", depth: 0, filePath: currentFile });
 			continue;
 		}
-
-		const sections: Array<{ filePath: string; section: GroupedFileSection }> = [];
-		for (const filePath of dirFiles) {
-			const section = renderFile(filePath);
-			if (section.skip) continue;
-			sections.push({ filePath, section });
+		const depth = match[1]!.length;
+		const rest = match[2]!.trimEnd();
+		if (isUrlLikePath(rest)) {
+			clearDeeper(depth);
+			currentFile = undefined;
+			result.push({ kind: "file", depth, isUrl: true });
+			continue;
 		}
-		if (sections.length === 0) continue;
-
-		pushSeparatorIfNeeded();
-		const dirHeader = `# ${directory}/`;
-		model.push(dirHeader);
-		display.push(dirHeader);
-		for (const { filePath, section } of sections) {
-			const fileHeader = `## ${path.basename(filePath)}${section.headerSuffix ?? ""}`;
-			model.push(fileHeader, ...section.modelLines);
-			display.push(fileHeader, ...(section.displayLines ?? section.modelLines));
+		const parent = depth > 1 ? dirAtDepth.get(depth - 1) : headerBase;
+		if (rest.endsWith("/")) {
+			const name = rest.slice(0, -1).replace(HEADER_SUFFIX_RE, "");
+			const abs = resolveGroupedPath(parent, name);
+			clearDeeper(depth);
+			if (abs !== undefined) dirAtDepth.set(depth, abs);
+			currentFile = undefined;
+			result.push({ kind: "dir", depth, headerPath: abs });
+			continue;
 		}
+		const name = rest.replace(HEADER_SUFFIX_RE, "").replace(HEADER_HASH_TAG_RE, "");
+		const abs = name ? resolveGroupedPath(parent, name) : undefined;
+		currentFile = abs;
+		result.push({ kind: "file", depth, headerPath: abs });
 	}
 
-	return { model, display };
+	return result;
+}
+
+/**
+ * Split line indices into blank-line-separated groups, mirroring
+ * `splitGroupsByBlankLine`: when any blank line is present, break on runs of
+ * blanks; otherwise return a single group of the non-empty lines. Returning
+ * indices lets callers slice parallel arrays (raw lines, styled lines, contexts).
+ */
+export function groupLineIndicesByBlank(rawLines: readonly string[]): number[][] {
+	const hasSeparators = rawLines.some(line => line.trim().length === 0);
+	const groups: number[][] = [];
+	if (hasSeparators) {
+		let current: number[] = [];
+		for (let i = 0; i < rawLines.length; i++) {
+			if (rawLines[i]!.trim().length === 0) {
+				if (current.length > 0) {
+					groups.push(current);
+					current = [];
+				}
+				continue;
+			}
+			current.push(i);
+		}
+		if (current.length > 0) groups.push(current);
+	} else {
+		const current: number[] = [];
+		for (let i = 0; i < rawLines.length; i++) {
+			if (rawLines[i]!.trim().length > 0) current.push(i);
+		}
+		if (current.length > 0) groups.push(current);
+	}
+	return groups;
 }