@prometheus-ai/agent 0.5.3 → 0.5.8

package/src/modes/components/reset-usage-selector.ts

@@ -0,0 +1,161 @@
+import { Container, matchesKey, ScrollView, Spacer, TruncatedText } from "@prometheus-ai/tui";
+import { theme } from "../../modes/theme/theme";
+import { matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../../modes/utils/keybinding-matchers";
+import type { ResetUsageAccount } from "../../slash-commands/helpers/reset-usage";
+import { DynamicBorder } from "./dynamic-border";
+
+const RESET_SELECTOR_MAX_VISIBLE = 10;
+
+/**
+ * Account picker for `/usage reset`. Lists Codex accounts with their saved
+ * rate-limit reset counts; selecting one redeems a reset. Because a reset is a
+ * scarce, irreversible credit, Enter requires a second press to confirm.
+ */
+export class ResetUsageSelectorComponent extends Container {
+	#listContainer: Container;
+	#accounts: ResetUsageAccount[];
+	#selectedIndex = 0;
+	#pendingIndex: number | null = null;
+	#statusMessage: string | undefined;
+	#onSelectCallback: (account: ResetUsageAccount) => void;
+	#onCancelCallback: () => void;
+
+	constructor(accounts: ResetUsageAccount[], onSelect: (account: ResetUsageAccount) => void, onCancel: () => void) {
+		super();
+		this.#accounts = accounts;
+		this.#onSelectCallback = onSelect;
+		this.#onCancelCallback = onCancel;
+		const firstRedeemable = accounts.findIndex(account => account.availableCount > 0);
+		this.#selectedIndex = firstRedeemable >= 0 ? firstRedeemable : 0;
+
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+		this.addChild(new TruncatedText(theme.bold("Spend a saved rate-limit reset:")));
+		this.addChild(new Spacer(1));
+		this.#listContainer = new Container();
+		this.addChild(this.#listContainer);
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+		this.#updateList();
+	}
+
+	#updateList(): void {
+		this.#listContainer.clear();
+
+		const total = this.#accounts.length;
+		const maxVisible = RESET_SELECTOR_MAX_VISIBLE;
+		const startIndex =
+			total <= maxVisible
+				? 0
+				: Math.max(0, Math.min(this.#selectedIndex - Math.floor(maxVisible / 2), total - maxVisible));
+		const endIndex = Math.min(startIndex + maxVisible, total);
+
+		const rows: string[] = [];
+		for (let i = startIndex; i < endIndex; i++) {
+			const account = this.#accounts[i];
+			if (!account) continue;
+			const isSelected = i === this.#selectedIndex;
+			const redeemable = account.availableCount > 0;
+			const countLabel = account.error
+				? account.error
+				: `${account.availableCount} saved reset${account.availableCount === 1 ? "" : "s"}`;
+			const countText = account.error
+				? theme.fg("error", countLabel)
+				: redeemable
+					? theme.fg("success", countLabel)
+					: theme.fg("dim", countLabel);
+			const activeTag = account.active ? theme.fg("muted", " (active)") : "";
+			if (isSelected) {
+				const name = redeemable ? theme.fg("accent", account.label) : theme.fg("dim", account.label);
+				rows.push(`${theme.fg("accent", `${theme.nav.cursor} `)}${name}${activeTag}  ${countText}`);
+			} else {
+				const name = redeemable ? `  ${account.label}` : theme.fg("dim", `  ${account.label}`);
+				rows.push(`${name}${activeTag}  ${countText}`);
+			}
+		}
+
+		if (rows.length > 0) {
+			const sv = new ScrollView(rows, {
+				height: rows.length,
+				scrollbar: "auto",
+				totalRows: total,
+				theme: { track: t => theme.fg("muted", t), thumb: t => theme.fg("accent", t) },
+			});
+			sv.setScrollOffset(startIndex);
+			this.#listContainer.addChild(sv);
+		}
+
+		if (total === 0) {
+			this.#listContainer.addChild(
+				new TruncatedText(theme.fg("muted", "  No Codex accounts with saved resets"), 0, 0),
+			);
+		}
+
+		const pending = this.#pendingIndex !== null ? this.#accounts[this.#pendingIndex] : undefined;
+		const hint = pending
+			? theme.fg("warning", `  Press Enter again to spend 1 reset for ${pending.label}, Esc to cancel`)
+			: theme.fg("muted", "  ↑/↓ select · ↵ spend a reset · Esc cancel");
+		this.#listContainer.addChild(new TruncatedText(hint, 0, 0));
+
+		if (this.#statusMessage) {
+			this.#listContainer.addChild(new Spacer(1));
+			this.#listContainer.addChild(new TruncatedText(theme.fg("warning", `  ${this.#statusMessage}`), 0, 0));
+		}
+	}
+
+	handleInput(keyData: string): void {
+		if (matchesSelectCancel(keyData)) {
+			if (this.#pendingIndex !== null) {
+				this.#pendingIndex = null;
+				this.#statusMessage = undefined;
+				this.#updateList();
+				return;
+			}
+			this.#onCancelCallback();
+			return;
+		}
+
+		if (matchesSelectUp(keyData)) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = this.#selectedIndex === 0 ? this.#accounts.length - 1 : this.#selectedIndex - 1;
+			}
+			this.#pendingIndex = null;
+			this.#statusMessage = undefined;
+			this.#updateList();
+		} else if (matchesSelectDown(keyData)) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = this.#selectedIndex === this.#accounts.length - 1 ? 0 : this.#selectedIndex + 1;
+			}
+			this.#pendingIndex = null;
+			this.#statusMessage = undefined;
+			this.#updateList();
+		} else if (matchesKey(keyData, "pageUp")) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = Math.max(0, this.#selectedIndex - RESET_SELECTOR_MAX_VISIBLE);
+			}
+			this.#pendingIndex = null;
+			this.#updateList();
+		} else if (matchesKey(keyData, "pageDown")) {
+			if (this.#accounts.length > 0) {
+				this.#selectedIndex = Math.min(this.#accounts.length - 1, this.#selectedIndex + RESET_SELECTOR_MAX_VISIBLE);
+			}
+			this.#pendingIndex = null;
+			this.#updateList();
+		} else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
+			const account = this.#accounts[this.#selectedIndex];
+			if (!account) return;
+			if (account.availableCount <= 0) {
+				this.#statusMessage = "That account has no saved resets to spend.";
+				this.#updateList();
+				return;
+			}
+			if (this.#pendingIndex === this.#selectedIndex) {
+				this.#onSelectCallback(account);
+				return;
+			}
+			this.#pendingIndex = this.#selectedIndex;
+			this.#statusMessage = undefined;
+			this.#updateList();
+		}
+	}
+}

package/src/modes/components/segment-track.ts

@@ -1,9 +1,9 @@
 /**
  * Shared renderer for a horizontal row of colored "segments" styled after the
- * status line: each segment shows in its own accent, the active one is filled
- * as a powerline chip (its accent as the background, a luminance-matched label,
- * flanked by triangle caps) and the rest are plain colored labels joined by a
- * thin separator.
+ * status line: each segment is colored by its track position from the theme's
+ * own palette, the active one is filled as a powerline chip (its color as the
+ * background, a luminance-matched label, flanked by triangle caps) and the
+ * rest are plain colored labels joined by a thin separator.
  *
  * Used by the plan-mode model-tier slider ({@link HookSelectorComponent}) and
  * the ctrl+p role-cycle status so both surfaces read identically.
@@ -12,13 +12,49 @@ import { type ThemeColor, theme } from "../theme/theme";
 
 export interface TrackSegment {
 	label: string;
-	/** Theme color for the segment; defaults to `accent`. */
-	color?: ThemeColor;
 }
 
 const FG_RESET = "\x1b[39m";
 const BG_RESET = "\x1b[49m";
 
+/** Vivid theme colors for position-based segment coloring, in preference
+ *  order. Themes alias many of these to the same value (titanium maps most of
+ *  the syntax set onto its accent), so {@link resolveSegmentPalette} dedupes
+ *  by resolved escape and hands position i the i-th distinct color. */
+const SEGMENT_COLOR_CANDIDATES: ThemeColor[] = [
+	"accent",
+	"success",
+	"warning",
+	"error",
+	"mdCode",
+	"mdLink",
+	"syntaxString",
+	"syntaxKeyword",
+	"syntaxFunction",
+	"syntaxNumber",
+	"syntaxOperator",
+	"syntaxVariable",
+];
+
+/**
+ * Resolve up to `count` theme colors that render distinctly under the active
+ * theme, in candidate preference order. May return fewer than `count` when the
+ * theme has fewer distinct hues (e.g. monochrome themes) — callers wrap with
+ * modulo. Never returns an empty array: `accent` always resolves.
+ */
+export function resolveSegmentPalette(count: number): ThemeColor[] {
+	const palette: ThemeColor[] = [];
+	const seen = new Set<string>();
+	for (const color of SEGMENT_COLOR_CANDIDATES) {
+		const ansi = theme.getFgAnsi(color);
+		if (seen.has(ansi)) continue;
+		seen.add(ansi);
+		palette.push(color);
+		if (palette.length >= count) break;
+	}
+	return palette;
+}
+
 /**
  * Render `segments` as a colored chip track with `activeIndex` filled. Returns
  * a single line of styled text with no surrounding caption or arrows — callers
@@ -30,6 +66,7 @@ export function renderSegmentTrack(segments: TrackSegment[], activeIndex: number
 	const capLeft = theme.sep.powerlineRight;
 	const capRight = theme.sep.powerlineLeft;
 	const thinSep = theme.fg("statusLineSep", theme.sep.powerlineThin);
+	const palette = resolveSegmentPalette(segments.length);
 
 	let track = "";
 	segments.forEach((segment, i) => {
@@ -38,7 +75,7 @@ export function renderSegmentTrack(segments: TrackSegment[], activeIndex: number
 			// caps already delimit the active segment, so pad around it instead.
 			track += i === activeIndex || i - 1 === activeIndex ? "  " : ` ${thinSep} `;
 		}
-		const color = segment.color ?? "accent";
+		const color = palette[i % palette.length];
 		const fg = theme.getFgAnsi(color);
 		if (i !== activeIndex) {
 			track += `${fg}${segment.label}${FG_RESET}`;

package/src/modes/components/session-selector.ts

@@ -1,7 +1,7 @@
 import {
 	type Component,
 	Container,
-	fuzzyFilter,
+	fuzzyMatch,
 	Input,
 	matchesKey,
 	padding,
@@ -15,7 +15,7 @@ import {
 import { formatBytes } from "@prometheus-ai/utils";
 import { theme } from "../../modes/theme/theme";
 import { matchesAppInterrupt, matchesSelectDown, matchesSelectUp } from "../../modes/utils/keybinding-matchers";
-import type { SessionInfo, SessionStatus } from "../../session/session-manager";
+import type { SessionInfo, SessionStatus } from "../../session/session-listing";
 import { shortenPath } from "../../tools/render-utils";
 import { DynamicBorder } from "./dynamic-border";
 import { HookSelectorComponent } from "./hook-selector";
@@ -46,43 +46,113 @@ function formatSessionStatus(status: SessionStatus | undefined): string | undefi
 /** Returns the IDs of sessions whose recorded prompts match a query, best first. */
 export type SessionHistoryMatcher = (query: string) => string[];
 
+function sessionSearchText(session: SessionInfo): string {
+	const parts = [
+		session.id,
+		session.title ?? "",
+		session.cwd ?? "",
+		session.firstMessage ?? "",
+		session.allMessagesText,
+		session.path,
+	];
+	return parts.filter(Boolean).join(" ");
+}
+
+function tokenizeSessionQuery(query: string): string[] {
+	const trimmed = query.trim().toLowerCase();
+	return trimmed ? trimmed.split(/\s+/) : [];
+}
+
+function compareSessionRecency(a: SessionInfo, b: SessionInfo): number {
+	return b.modified.getTime() - a.modified.getTime();
+}
+
+const MIN_PURE_FUZZY_TOKEN_SCORE = -20;
+
+/**
+ * Filter and rank session picker search results.
+ *
+ * Resume search narrows a recency-sorted list: once every query token appears
+ * as a literal substring, newer sessions should beat a slightly better fuzzy
+ * position match. Pure fuzzy/acronym matches still sort by fuzzy score after
+ * literal matches, but weak pure fuzzy tokens are dropped as noise.
+ */
+export function rankSessionSearchMatches(allSessions: SessionInfo[], query: string): SessionInfo[] {
+	const tokens = tokenizeSessionQuery(query);
+	if (tokens.length === 0) return allSessions;
+
+	const results: Array<{ session: SessionInfo; score: number; literal: boolean; index: number }> = [];
+	for (let index = 0; index < allSessions.length; index++) {
+		const session = allSessions[index]!;
+		const text = sessionSearchText(session);
+		const textLower = text.toLowerCase();
+		let score = 0;
+		let worstTokenScore = Number.NEGATIVE_INFINITY;
+		let literal = true;
+		let matches = true;
+
+		for (const token of tokens) {
+			const match = fuzzyMatch(token, textLower);
+			if (!match.matches) {
+				matches = false;
+				break;
+			}
+			score += match.score;
+			worstTokenScore = Math.max(worstTokenScore, match.score);
+			if (!textLower.includes(token)) literal = false;
+		}
+
+		if (matches && (literal || worstTokenScore < MIN_PURE_FUZZY_TOKEN_SCORE)) {
+			results.push({ session, score, literal, index });
+		}
+	}
+
+	results.sort((a, b) => {
+		if (a.literal !== b.literal) return a.literal ? -1 : 1;
+		if (a.literal) return compareSessionRecency(a.session, b.session) || a.index - b.index;
+		return a.score - b.score || compareSessionRecency(a.session, b.session) || a.index - b.index;
+	});
+
+	return results.map(result => result.session);
+}
+
 /**
- * Combine fuzzy session matches with prompt-history matches for ranking, using
- * both signals rather than replacing one with the other.
+ * Combine metadata matches with prompt-history matches for ranking, using both
+ * signals rather than replacing one with the other.
  *
- * - `fuzzy` is the ordered fuzzy-filter result over session metadata (best first).
+ * - `fuzzy` is the ordered metadata/session-text result.
  * - `historyIds` are session IDs whose recorded prompts matched the query,
  *   ordered by prompt-history rank (typically newest matching prompt first); duplicates are tolerated.
  *
- * Ranking: sessions matched by **both** signals lead (keeping fuzzy order), then
- * fuzzy-only matches, then history-only matches (by prompt-history order). A fuzzy match
- * is never dropped, and history matches not present in `allSessions` (e.g. deleted
- * or out-of-scope sessions) are ignored since they cannot be resumed from here.
+ * Ranking: prompt-history matches lead in history order, then remaining
+ * metadata matches keep their existing order. A metadata match is never dropped,
+ * and history matches not present in `allSessions` (e.g. deleted or out-of-scope
+ * sessions) are ignored since they cannot be resumed from here.
  */
 export function mergeSessionRanking(
 	allSessions: SessionInfo[],
 	fuzzy: SessionInfo[],
 	historyIds: string[],
 ): SessionInfo[] {
-	const historyRank = new Map<string, number>();
-	historyIds.forEach((id, index) => {
-		if (!historyRank.has(id)) historyRank.set(id, index);
-	});
-	if (historyRank.size === 0) return fuzzy;
-
-	const both: SessionInfo[] = [];
-	const fuzzyOnly: SessionInfo[] = [];
-	const fuzzyPaths = new Set<string>();
-	for (const session of fuzzy) {
-		fuzzyPaths.add(session.path);
-		(historyRank.has(session.id) ? both : fuzzyOnly).push(session);
+	if (historyIds.length === 0) return fuzzy;
+
+	const sessionsById = new Map<string, SessionInfo>();
+	for (const session of allSessions) {
+		if (!sessionsById.has(session.id)) sessionsById.set(session.id, session);
 	}
 
-	const historyOnly = allSessions
-		.filter(session => historyRank.has(session.id) && !fuzzyPaths.has(session.path))
-		.sort((a, b) => (historyRank.get(a.id) ?? 0) - (historyRank.get(b.id) ?? 0));
+	const historyMatches: SessionInfo[] = [];
+	const historyPaths = new Set<string>();
+	for (const id of historyIds) {
+		const session = sessionsById.get(id);
+		if (!session || historyPaths.has(session.path)) continue;
+		historyMatches.push(session);
+		historyPaths.add(session.path);
+	}
+	if (historyMatches.length === 0) return fuzzy;
 
-	return [...both, ...fuzzyOnly, ...historyOnly];
+	const metadataOnly = fuzzy.filter(session => !historyPaths.has(session.path));
+	return [...historyMatches, ...metadataOnly];
 }
 
 /**
@@ -156,17 +226,7 @@ class SessionList implements Component {
 	}
 
 	#filterSessions(query: string): void {
-		const fuzzy = fuzzyFilter(this.#allSessions, query, session => {
-			const parts = [
-				session.id,
-				session.title ?? "",
-				session.cwd ?? "",
-				session.firstMessage ?? "",
-				session.allMessagesText,
-				session.path,
-			];
-			return parts.filter(Boolean).join(" ");
-		});
+		const fuzzy = rankSessionSearchMatches(this.#allSessions, query);
 		this.#filteredSessions = this.#mergeHistoryMatches(query, fuzzy);
 		this.#selectedIndex = Math.min(this.#selectedIndex, Math.max(0, this.#filteredSessions.length - 1));
 	}
@@ -201,7 +261,7 @@ class SessionList implements Component {
 		// No cached state to invalidate currently
 	}
 
-	render(width: number): string[] {
+	render(width: number): readonly string[] {
 		const lines: string[] = [];
 
 		// Render search input

package/src/modes/components/settings-defs.ts

@@ -4,7 +4,8 @@
  * settings selector.
  *
  * To add a new setting to the UI: declare it in `settings-schema.ts`
- * with a `ui` block. If it needs a submenu, include `options: [...]`
+ * with a `ui` block carrying `tab` and `group` (the group must be listed
+ * in `TAB_GROUPS[tab]`). If it needs a submenu, include `options: [...]`
  * (or `options: "runtime"` for runtime-injected lists like themes).
  */
 
@@ -21,6 +22,7 @@ import {
 	type SettingPath,
 	type SettingTab,
 	type SubmenuOption,
+	TAB_GROUPS,
 } from "../../config/settings-schema";
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -34,6 +36,8 @@ interface BaseSettingDef {
 	label: string;
 	description: string;
 	tab: SettingTab;
+	/** Section within the tab; items are ordered by TAB_GROUPS[tab] and rendered under a heading row. */
+	group?: string;
 	/**
 	 * Optional visibility predicate. When supplied and returning false, the
 	 * setting is hidden from the UI. Applies to every variant — booleans,
@@ -79,9 +83,16 @@ const CONDITIONS: Record<string, () => boolean> = {
 			return false;
 		}
 	},
-	prometheusMemoryActive: () => {
+	mnemopiActive: () => {
 		try {
-			return Settings.instance.get("memory.backend") === "prometheus-memory";
+			return Settings.instance.get("memory.backend") === "mnemopi";
+		} catch {
+			return false;
+		}
+	},
+	autolearnActive: () => {
+		try {
+			return Settings.instance.get("autolearn.enabled") === true;
 		} catch {
 			return false;
 		}
@@ -111,7 +122,7 @@ function pathToSettingDef(path: SettingPath): SettingDef | null {
 
 	const schemaType = getType(path);
 	const condition = ui.condition ? CONDITIONS[ui.condition] : undefined;
-	const base = { path, label: ui.label, description: ui.description, tab: ui.tab, condition };
+	const base = { path, label: ui.label, description: ui.description, tab: ui.tab, group: ui.group, condition };
 
 	if (schemaType === "boolean") {
 		return { ...base, type: "boolean" };
@@ -170,9 +181,20 @@ export function getAllSettingDefs(): SettingDef[] {
 	return defs;
 }
 
-/** Get settings for a specific tab */
+/**
+ * Get settings for a specific tab, ordered by the tab's group layout
+ * (TAB_GROUPS). Ungrouped settings sort first; within a group, schema
+ * declaration order is preserved.
+ */
 export function getSettingsForTab(tab: SettingTab): SettingDef[] {
-	return getAllSettingDefs().filter(def => def.tab === tab);
+	const defs = getAllSettingDefs().filter(def => def.tab === tab);
+	const order = TAB_GROUPS[tab];
+	const rank = (def: SettingDef): number => {
+		if (!def.group) return -1;
+		const index = order.indexOf(def.group);
+		return index >= 0 ? index : order.length;
+	};
+	return defs.sort((a, b) => rank(a) - rank(b));
 }
 
 /** Get a setting definition by path */