@oh-my-pi/pi-coding-agent 14.4.3 → 14.4.4

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

@@ -348,6 +348,7 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
 		{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
 		{ value: "parallel", label: "Parallel", description: "Requires PARALLEL_API_KEY" },
+		{ value: "searxng", label: "SearXNG", description: "Self-hosted metasearch; set searxng.endpoint" },
 	],
 	"providers.image": [
 		{

package/src/modes/controllers/command-controller.ts

@@ -28,6 +28,7 @@ import { buildHotkeysMarkdown } from "../../modes/utils/hotkeys-markdown";
 import { buildToolsMarkdown } from "../../modes/utils/tools-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
+import type { NewSessionOptions } from "../../session/session-manager";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
@@ -573,7 +574,7 @@ export class CommandController {
 		this.ctx.showError("Usage: /memory <view|clear|reset|enqueue|rebuild>");
 	}
 
-	async handleClearCommand(): Promise<void> {
+	async #runNewSessionFlow(options?: NewSessionOptions, label: string = "New session started"): Promise<void> {
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
 			this.ctx.loadingAnimation = undefined;
@@ -586,7 +587,7 @@ export class CommandController {
 				await Bun.sleep(10);
 			}
 		}
-		await this.ctx.session.newSession();
+		if (!(await this.ctx.session.newSession(options))) return;
 		this.ctx.resetObserverRegistry();
 		setSessionTerminalTitle(
 			this.ctx.sessionManager.getSessionName(),
@@ -608,13 +609,23 @@ export class CommandController {
 		this.ctx.pendingTools.clear();
 
 		this.ctx.chatContainer.addChild(new Spacer(1));
-		this.ctx.chatContainer.addChild(
-			new Text(`${theme.fg("accent", `${theme.status.success} New session started`)}`, 1, 1),
-		);
+		this.ctx.chatContainer.addChild(new Text(`${theme.fg("accent", `${theme.status.success} ${label}`)}`, 1, 1));
 		await this.ctx.reloadTodos();
 		this.ctx.ui.requestRender();
 	}
 
+	async handleClearCommand(): Promise<void> {
+		await this.#runNewSessionFlow();
+	}
+
+	async handleDropCommand(): Promise<void> {
+		if (!this.ctx.sessionManager.getSessionFile()) {
+			this.ctx.showError("Nothing to drop (in-memory session)");
+			return;
+		}
+		await this.#runNewSessionFlow({ drop: true }, "Session dropped");
+	}
+
 	async handleForkCommand(): Promise<void> {
 		if (this.ctx.session.isStreaming) {
 			this.ctx.showWarning("Wait for the current response to finish or abort it before forking.");

package/src/modes/controllers/selector-controller.ts

@@ -1,14 +1,17 @@
+import * as os from "node:os";
+import * as path from "node:path";
 import { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { getOAuthProviders, type OAuthProvider } from "@oh-my-pi/pi-ai";
-import type { Component } from "@oh-my-pi/pi-tui";
+import type { Component, OverlayHandle } from "@oh-my-pi/pi-tui";
 import { Input, Loader, Spacer, Text } from "@oh-my-pi/pi-tui";
-import { getAgentDbPath, getProjectDir } from "@oh-my-pi/pi-utils";
+import { getAgentDbPath, getConfigDirName, getProjectDir } from "@oh-my-pi/pi-utils";
+import { invalidate as invalidateFsCache } from "../../capability/fs";
 import { getRoleInfo } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import { settings } from "../../config/settings";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
-import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
+import { clearClaudePluginRootsCache, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import {
 	getInstalledPluginsRegistryPath,
 	getMarketplacesCacheDir,
@@ -440,7 +443,13 @@ export class SelectorController {
 			projectInstalledRegistryPath: (await resolveActiveProjectRegistryPath(getProjectDir())) ?? undefined,
 			marketplacesCacheDir: getMarketplacesCacheDir(),
 			pluginsCacheDir: getPluginsCacheDir(),
-			clearPluginRootsCache: clearPluginRootsAndCaches,
+			clearPluginRootsCache: (extraPaths?: readonly string[]) => {
+				const home = os.homedir();
+				invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
+				invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+				for (const p of extraPaths ?? []) invalidateFsCache(p);
+				clearClaudePluginRootsCache();
+			},
 		});
 
 		const [marketplaces, installed] = await Promise.all([mgr.listMarketplaces(), mgr.listInstalledPlugins()]);
@@ -969,25 +978,29 @@ export class SelectorController {
 
 	showSessionObserver(registry: SessionObserverRegistry): void {
 		const observeKeys = this.ctx.keybindings.getKeys("app.session.observe");
+		let cleanup: (() => void) | undefined;
+		let overlayHandle: OverlayHandle | undefined;
 
-		this.showSelector(done => {
-			let cleanup: (() => void) | undefined;
+		const done = () => {
+			cleanup?.();
+			overlayHandle?.hide();
+			this.ctx.ui.requestRender();
+		};
 
-			const selector = new SessionObserverOverlayComponent(
-				registry,
-				() => {
-					cleanup?.();
-					done();
-				},
-				observeKeys,
-			);
+		const selector = new SessionObserverOverlayComponent(registry, done, observeKeys);
 
-			cleanup = registry.onChange(() => {
-				selector.refreshFromRegistry();
-				this.ctx.ui.requestRender();
-			});
+		cleanup = registry.onChange(() => {
+			selector.refreshFromRegistry();
+			this.ctx.ui.requestRender();
+		});
 
-			return { component: selector, focus: selector };
+		overlayHandle = this.ctx.ui.showOverlay(selector, {
+			anchor: "bottom-center",
+			width: "100%",
+			maxHeight: "100%",
+			margin: 0,
 		});
+		this.ctx.ui.setFocus(selector);
+		this.ctx.ui.requestRender();
 	}
 }

package/src/modes/interactive-mode.ts

@@ -1324,13 +1324,22 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#commandController.handleToolsCommand();
 	}
 
-	handleClearCommand(): Promise<void> {
+	#prepareSessionSwitch(): void {
 		this.#btwController.dispose();
 		this.#extensionUiController.clearExtensionTerminalInputListeners();
 		this.#planReviewContainer = undefined;
+	}
+
+	handleClearCommand(): Promise<void> {
+		this.#prepareSessionSwitch();
 		return this.#commandController.handleClearCommand();
 	}
 
+	handleDropCommand(): Promise<void> {
+		this.#prepareSessionSwitch();
+		return this.#commandController.handleDropCommand();
+	}
+
 	handleForkCommand(): Promise<void> {
 		this.#btwController.dispose();
 		return this.#commandController.handleForkCommand();

package/src/modes/types.ts

@@ -181,6 +181,7 @@ export interface InteractiveModeContext {
 	handleDumpCommand(): void;
 	handleDebugTranscriptCommand(): Promise<void>;
 	handleClearCommand(): Promise<void>;
+	handleDropCommand(): Promise<void>;
 	handleForkCommand(): Promise<void>;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
 	handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;

package/src/session/agent-session.ts

@@ -3373,7 +3373,15 @@ export class AgentSession {
 		this.#asyncJobManager?.cancelAll();
 		this.#closeAllProviderSessions("new session");
 		this.agent.reset();
-		await this.sessionManager.flush();
+		if (options?.drop && previousSessionFile) {
+			try {
+				await this.sessionManager.dropSession(previousSessionFile);
+			} catch (err) {
+				logger.error("Failed to delete session during /drop", { err });
+			}
+		} else {
+			await this.sessionManager.flush();
+		}
 		await this.sessionManager.newSession(options);
 		this.setTodoPhases([]);
 		this.agent.sessionId = this.sessionManager.getSessionId();

package/src/session/session-manager.ts

@@ -66,6 +66,8 @@ export interface SessionHeader {
 
 export interface NewSessionOptions {
 	parentSession?: string;
+	/** Skip flushing the current session and delete it instead of saving. */
+	drop?: boolean;
 }
 
 export interface SessionEntryBase {
@@ -1707,6 +1709,17 @@ export class SessionManager {
 		return this.#newSessionSync(options);
 	}
 
+	/** Delete a session file and its artifacts. Drains the persist writer first to avoid EPERM on Windows. ENOENT is treated as success. */
+	async dropSession(sessionPath: string): Promise<void> {
+		await this.#closePersistWriter();
+		try {
+			await this.storage.deleteSessionWithArtifacts(sessionPath);
+		} catch (err) {
+			if (isEnoent(err)) return;
+			throw err;
+		}
+	}
+
 	/**
 	 * Fork the current session, creating a new session file with the same entries.
 	 * Returns both the old and new session file paths for artifact copying.

package/src/session/session-storage.ts

@@ -32,6 +32,7 @@ export interface SessionStorage {
 	writeText(path: string, content: string): Promise<void>;
 	rename(path: string, nextPath: string): Promise<void>;
 	unlink(path: string): Promise<void>;
+	deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
 	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter;
 }
 
@@ -360,6 +361,9 @@ export class MemorySessionStorage implements SessionStorage {
 		this.#files.delete(path);
 		return Promise.resolve();
 	}
+	deleteSessionWithArtifacts(_sessionPath: string): Promise<void> {
+		return Promise.resolve();
+	}
 
 	openWriter(path: string, options?: { flags?: "a" | "w"; onError?: (err: Error) => void }): SessionStorageWriter {
 		return new MemorySessionStorageWriter(this, path, options);

package/src/slash-commands/builtin-registry.ts

@@ -512,6 +512,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			await runtime.ctx.handleClearCommand();
 		},
 	},
+	{
+		name: "drop",
+		description: "Delete the current session and start a new one",
+		handle: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleDropCommand();
+		},
+	},
 	{
 		name: "compact",
 		description: "Manually compact the session context",

package/src/web/search/index.ts

@@ -1,7 +1,7 @@
 /**
  * Unified Web Search Tool
  *
- * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, and Synthetic
+ * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, SearXNG, and Synthetic
  * providers with provider-specific parameters exposed conditionally.
  *
  */
@@ -202,7 +202,7 @@ export async function runSearchQuery(
 /**
  * Web search tool implementation.
  *
- * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Z.AI, and Synthetic providers with automatic fallback.
+ * Supports Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Z.AI, SearXNG, and Synthetic providers with automatic fallback.
  * Session is accepted for interface consistency but not used.
  */
 export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {

package/src/web/search/provider.ts

@@ -9,6 +9,7 @@ import { KagiProvider } from "./providers/kagi";
 import { KimiProvider } from "./providers/kimi";
 import { ParallelProvider } from "./providers/parallel";
 import { PerplexityProvider } from "./providers/perplexity";
+import { SearXNGProvider } from "./providers/searxng";
 import { SyntheticProvider } from "./providers/synthetic";
 import { TavilyProvider } from "./providers/tavily";
 import { ZaiProvider } from "./providers/zai";
@@ -31,6 +32,7 @@ const SEARCH_PROVIDERS: Record<SearchProviderId, SearchProvider> = {
 	parallel: new ParallelProvider(),
 	kagi: new KagiProvider(),
 	synthetic: new SyntheticProvider(),
+	searxng: new SearXNGProvider(),
 } as const;
 
 export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
@@ -47,6 +49,7 @@ export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
 	"parallel",
 	"kagi",
 	"synthetic",
+	"searxng",
 ];
 
 export function getSearchProvider(provider: SearchProviderId): SearchProvider {

package/src/web/search/providers/searxng.ts

@@ -0,0 +1,238 @@
+/**
+ * SearXNG Web Search Provider
+ *
+ * Calls a SearXNG instance's JSON search API and maps results into the unified
+ * SearchResponse shape used by the web search tool.
+ *
+ * SearXNG is a free, open-source metasearch engine that aggregates results from
+ * multiple sources without tracking users. It supports self-hosted instances
+ * and various authentication methods (bearer token, basic auth, or none).
+ *
+ * Configuration via settings:
+ *   searxng.endpoint  - Base URL of the SearXNG instance (e.g. https://searx.example.org)
+ *   searxng.token     - Optional bearer token for authentication
+ *   searxng.categories - Optional comma-separated categories filter
+ *   searxng.language  - Optional language code (e.g. en, zh-CN)
+ *
+ * Environment variable fallbacks:
+ *   SEARXNG_ENDPOINT  - Base URL of the SearXNG instance
+ *   SEARXNG_TOKEN     - Optional bearer token
+ *
+ * Reference: https://docs.searxng.org/dev/search_api.html
+ */
+
+import { settings } from "../../../config/settings";
+import type { SearchResponse, SearchSource } from "../../../web/search/types";
+import { SearchProviderError } from "../../../web/search/types";
+import { clampNumResults, dateToAgeSeconds } from "../utils";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
+
+const DEFAULT_NUM_RESULTS = 10;
+const MAX_NUM_RESULTS = 20;
+
+/** Map our recency filter to SearXNG time_range parameter.
+ *  SearXNG only supports day/month/year, so week maps to month. */
+const RECENCY_MAP: Record<"day" | "week" | "month" | "year", string> = {
+	day: "day",
+	week: "month",
+	month: "month",
+	year: "year",
+};
+
+/** SearXNG JSON API response types */
+interface SearXNGResult {
+	title?: string;
+	url?: string;
+	content?: string;
+	engine?: string;
+	publishedDate?: string;
+	/** SearXNG sometimes uses publishedDate, sometimes just date */
+	published_date?: string;
+	score?: number;
+}
+
+interface SearXNGResponse {
+	query?: string;
+	number_of_results?: number;
+	results?: SearXNGResult[];
+	suggestions?: string[];
+	corrections?: string[];
+	unresponsive_engines?: Array<[string, string]>;
+}
+
+/** Find SearXNG endpoint from settings or environment. */
+function findEndpoint(): string | null {
+	try {
+		const endpoint = settings.get("searxng.endpoint");
+		if (endpoint) return endpoint;
+	} catch {
+		// Settings not initialized yet
+	}
+	return process.env.SEARXNG_ENDPOINT ?? null;
+}
+
+/** Find SearXNG bearer token from settings or environment. */
+function findToken(): string | null {
+	try {
+		const token = settings.get("searxng.token");
+		if (token) return token;
+	} catch {
+		// Settings not initialized yet
+	}
+	return process.env.SEARXNG_TOKEN ?? null;
+}
+
+/** Build the search URL and headers for a SearXNG request */
+function buildRequest(
+	endpoint: string,
+	params: {
+		query: string;
+		num_results?: number;
+		recency?: "day" | "week" | "month" | "year";
+		categories?: string;
+		language?: string;
+		signal?: AbortSignal;
+	},
+	token: string | null,
+): { url: URL; headers: Record<string, string> } {
+	const base = endpoint.replace(/\/+$/, "");
+	const url = new URL(`${base}/search`);
+
+	url.searchParams.set("q", params.query);
+	url.searchParams.set("format", "json");
+
+	if (params.num_results) {
+		url.searchParams.set("pageno", "1");
+	}
+
+	if (params.recency) {
+		url.searchParams.set("time_range", RECENCY_MAP[params.recency]);
+	}
+
+	if (params.categories) {
+		url.searchParams.set("categories", params.categories);
+	}
+
+	if (params.language) {
+		url.searchParams.set("language", params.language);
+	}
+
+	const headers: Record<string, string> = {
+		Accept: "application/json",
+	};
+
+	if (token) {
+		headers.Authorization = `Bearer ${token}`;
+	}
+
+	return { url, headers };
+}
+
+async function callSearXNGSearch(
+	endpoint: string,
+	params: {
+		query: string;
+		num_results?: number;
+		recency?: "day" | "week" | "month" | "year";
+		categories?: string;
+		language?: string;
+		signal?: AbortSignal;
+	},
+	token: string | null,
+): Promise<SearXNGResponse> {
+	const { url, headers } = buildRequest(endpoint, params, token);
+
+	const response = await fetch(url, {
+		headers,
+		signal: params.signal,
+	});
+
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new SearchProviderError("searxng", `SearXNG API error (${response.status}): ${errorText}`, response.status);
+	}
+
+	return (await response.json()) as SearXNGResponse;
+}
+
+/** Execute SearXNG web search. */
+export async function searchSearXNG(params: {
+	query: string;
+	num_results?: number;
+	recency?: "day" | "week" | "month" | "year";
+	signal?: AbortSignal;
+}): Promise<SearchResponse> {
+	const numResults = clampNumResults(params.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
+
+	const endpoint = findEndpoint();
+	if (!endpoint) {
+		throw new Error(
+			"SearXNG endpoint not configured. Set searxng.endpoint in settings or SEARXNG_ENDPOINT in environment.",
+		);
+	}
+
+	const token = findToken();
+
+	let categories: string | undefined;
+	let language: string | undefined;
+	try {
+		categories = settings.get("searxng.categories") ?? undefined;
+		language = settings.get("searxng.language") ?? undefined;
+	} catch {
+		// Settings not initialized yet
+	}
+
+	const response = await callSearXNGSearch(
+		endpoint,
+		{
+			...params,
+			categories,
+			language,
+		},
+		token,
+	);
+
+	const sources: SearchSource[] = [];
+
+	for (const result of response.results ?? []) {
+		if (!result.url) continue;
+		const publishedDate = result.publishedDate ?? result.published_date;
+		sources.push({
+			title: result.title ?? result.url,
+			url: result.url,
+			snippet: result.content?.trim() || undefined,
+			publishedDate: publishedDate ?? undefined,
+			ageSeconds: dateToAgeSeconds(publishedDate),
+		});
+	}
+
+	return {
+		provider: "searxng",
+		sources: sources.slice(0, numResults),
+		relatedQuestions: response.suggestions?.length ? response.suggestions : undefined,
+	};
+}
+
+/** Search provider for SearXNG web search. */
+export class SearXNGProvider extends SearchProvider {
+	readonly id = "searxng";
+	readonly label = "SearXNG";
+
+	isAvailable() {
+		try {
+			return !!findEndpoint();
+		} catch {
+			return false;
+		}
+	}
+
+	search(params: SearchParams): Promise<SearchResponse> {
+		return searchSearXNG({
+			query: params.query,
+			num_results: params.numSearchResults ?? params.limit,
+			recency: params.recency,
+			signal: params.signal,
+		});
+	}
+}

package/src/web/search/types.ts

@@ -18,7 +18,8 @@ export type SearchProviderId =
 	| "tavily"
 	| "parallel"
 	| "kagi"
-	| "synthetic";
+	| "synthetic"
+	| "searxng";
 
 export function isSearchProviderId(value: string): value is SearchProviderId {
 	return [
@@ -35,6 +36,7 @@ export function isSearchProviderId(value: string): value is SearchProviderId {
 		"parallel",
 		"kagi",
 		"synthetic",
+		"searxng",
 	].includes(value);
 }