@oh-my-pi/pi-coding-agent 15.7.6 → 15.8.2

package/src/utils/jj.ts

@@ -0,0 +1,225 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { $which } from "@oh-my-pi/pi-utils";
+import { LRUCache } from "lru-cache/raw";
+
+// ════════════════════════════════════════════════════════════════════════════
+// Types
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Result from a completed `jj` subprocess invocation. */
+export interface JjCommandResult {
+	/** Process exit code reported by `jj`. */
+	exitCode: number;
+	/** Captured standard output as UTF-8 text. */
+	stdout: string;
+	/** Captured standard error as UTF-8 text. */
+	stderr: string;
+}
+
+/** Resolved Jujutsu workspace metadata. */
+export interface JjRepository {
+	/** Root directory containing the `.jj` workspace metadata. */
+	repoRoot: string;
+	/** Path to the workspace store directory used to verify a real JJ checkout. */
+	storeDir: string;
+}
+
+/** Options for `jj diff` invocations. */
+export interface DiffOptions {
+	/** Optional file paths to restrict the diff with `-- <files>`. */
+	readonly files?: readonly string[];
+	/** Return only changed file names instead of Git-format diff text. */
+	readonly nameOnly?: boolean;
+	/** Optional abort signal passed to the spawned `jj` process. */
+	readonly signal?: AbortSignal;
+}
+
+interface CommandOptions {
+	readonly signal?: AbortSignal;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Error
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Error thrown when a checked `jj` command exits non-zero. */
+export class JjCommandError extends Error {
+	/** Arguments passed after the common `jj --no-pager --color=never` prefix. */
+	readonly args: readonly string[];
+	/** Captured command result that caused the failure. */
+	readonly result: JjCommandResult;
+
+	/** Create an error for a failed checked `jj` command. */
+	constructor(args: readonly string[], result: JjCommandResult) {
+		super(formatCommandFailure(args, result));
+		this.name = "JjCommandError";
+		this.args = [...args];
+		this.result = result;
+	}
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Internal: Core execution
+// ════════════════════════════════════════════════════════════════════════════
+
+function ensureAvailable(): void {
+	if (!$which("jj")) {
+		throw new Error("jj is not installed.");
+	}
+}
+
+function formatCommandFailure(
+	args: readonly string[],
+	result: Pick<JjCommandResult, "exitCode" | "stdout" | "stderr">,
+): string {
+	const stderr = result.stderr.trim();
+	if (stderr) return stderr;
+	const stdout = result.stdout.trim();
+	if (stdout) return stdout;
+	return `jj ${args.join(" ")} failed with exit code ${result.exitCode}`;
+}
+
+async function jj(cwd: string, args: readonly string[], options: CommandOptions = {}): Promise<JjCommandResult> {
+	const child = Bun.spawn(["jj", "--no-pager", "--color=never", ...args], {
+		cwd,
+		signal: options.signal,
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+		windowsHide: true,
+	});
+
+	if (!child.stdout || !child.stderr) {
+		throw new Error("Failed to capture jj command output.");
+	}
+
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(child.stdout).text(),
+		new Response(child.stderr).text(),
+		child.exited,
+	]);
+
+	return { exitCode: exitCode ?? 0, stdout, stderr };
+}
+
+async function runChecked(
+	cwd: string,
+	args: readonly string[],
+	options: CommandOptions = {},
+): Promise<JjCommandResult> {
+	ensureAvailable();
+	const result = await jj(cwd, args, options);
+	if (result.exitCode !== 0) {
+		throw new JjCommandError(args, result);
+	}
+	return result;
+}
+
+async function runText(cwd: string, args: readonly string[], options: CommandOptions = {}): Promise<string> {
+	return (await runChecked(cwd, args, options)).stdout;
+}
+
+function splitLines(text: string): string[] {
+	return text
+		.split("\n")
+		.map(line => line.trim())
+		.filter(Boolean);
+}
+
+function buildDiffArgs(options: DiffOptions): string[] {
+	const args = ["diff"];
+	args.push(options.nameOnly ? "--name-only" : "--git");
+	if (options.files?.length) args.push("--", ...options.files);
+	return args;
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// Internal: Repository resolution
+// ════════════════════════════════════════════════════════════════════════════
+
+interface WorkspaceRootCacheEntry {
+	readonly root?: string;
+}
+
+const WORKSPACE_ROOT_CACHE_MAX_ENTRIES = 256;
+const workspaceRootCache = new LRUCache<string, WorkspaceRootCacheEntry>({ max: WORKSPACE_ROOT_CACHE_MAX_ENTRIES });
+
+async function hasJjWorkspaceMetadata(dir: string): Promise<boolean> {
+	try {
+		return (await fs.stat(path.join(dir, ".jj", "repo", "store"))).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function parentOf(dir: string): string | undefined {
+	const parent = path.dirname(dir);
+	return parent === dir ? undefined : parent;
+}
+
+async function findWorkspaceRoot(cwd: string): Promise<string | undefined> {
+	const key = path.resolve(cwd);
+	if (workspaceRootCache.has(key)) return workspaceRootCache.get(key)?.root;
+
+	for (let dir: string | undefined = key; dir; dir = parentOf(dir)) {
+		if (await hasJjWorkspaceMetadata(dir)) {
+			workspaceRootCache.set(key, { root: dir });
+			return dir;
+		}
+	}
+
+	workspaceRootCache.set(key, {});
+	return undefined;
+}
+
+function repositoryFromRoot(root: string): JjRepository {
+	return {
+		repoRoot: root,
+		storeDir: path.join(root, ".jj", "repo", "store"),
+	};
+}
+
+// ════════════════════════════════════════════════════════════════════════════
+// API: diff
+// ════════════════════════════════════════════════════════════════════════════
+
+/** Run `jj diff --git` for the current workspace commit and return the raw Git-format diff text. */
+export const diff = Object.assign(
+	async function diff(cwd: string, options: DiffOptions = {}): Promise<string> {
+		return runText(cwd, buildDiffArgs(options), { signal: options.signal });
+	},
+	{
+		/** List changed file paths. */
+		async changedFiles(cwd: string, options: Pick<DiffOptions, "files" | "signal"> = {}): Promise<string[]> {
+			return splitLines(await diff(cwd, { ...options, nameOnly: true }));
+		},
+	},
+);
+
+// ════════════════════════════════════════════════════════════════════════════
+// API: repo
+// ════════════════════════════════════════════════════════════════════════════
+
+export const repo = {
+	/** Clear cached workspace roots. Intended for tests that mutate JJ metadata under an existing path. */
+	clearRootCache(): void {
+		workspaceRootCache.clear();
+	},
+
+	/** Resolve the current Jujutsu workspace root, or `null` when `cwd` is not in a JJ repository. */
+	async root(cwd: string): Promise<string | null> {
+		return (await findWorkspaceRoot(cwd)) ?? null;
+	},
+
+	/** Full Jujutsu workspace metadata. */
+	async resolve(cwd: string): Promise<JjRepository | null> {
+		const root = await repo.root(cwd);
+		return root ? repositoryFromRoot(root) : null;
+	},
+
+	/** Check whether `cwd` is inside a Jujutsu repository. */
+	async is(cwd: string): Promise<boolean> {
+		return (await repo.root(cwd)) !== null;
+	},
+};

package/src/utils/open.ts

@@ -1,3 +1,36 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as url from "node:url";
+import * as piUtils from "@oh-my-pi/pi-utils";
+
+const URL_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z\d+.-]*:/;
+
+function getExistingWslLocalPath(urlOrPath: string): string | undefined {
+	if (
+		process.platform !== "linux" ||
+		!(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) ||
+		!piUtils.$which("wslview")
+	) {
+		return undefined;
+	}
+
+	try {
+		const localPath = urlOrPath.startsWith("file://")
+			? url.fileURLToPath(urlOrPath)
+			: URL_SCHEME_PATTERN.test(urlOrPath)
+				? undefined
+				: path.resolve(urlOrPath);
+		if (!localPath || !fs.existsSync(localPath)) return undefined;
+
+		const result = Bun.spawnSync(["wslpath", "-w", localPath], { stdout: "pipe", stderr: "ignore" });
+		if (result.exitCode !== 0) return undefined;
+
+		return result.stdout.toString().trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /** Open a URL or file path in the default browser/application. Best-effort, never throws. */
 export function openPath(urlOrPath: string): void {
 	let cmd: string[];
@@ -8,9 +41,11 @@ export function openPath(urlOrPath: string): void {
 		case "win32":
 			cmd = ["rundll32", "url.dll,FileProtocolHandler", urlOrPath];
 			break;
-		default:
-			cmd = ["xdg-open", urlOrPath];
+		default: {
+			const wslPath = getExistingWslLocalPath(urlOrPath);
+			cmd = wslPath ? ["wslview", wslPath] : ["xdg-open", urlOrPath];
 			break;
+		}
 	}
 	try {
 		Bun.spawn(cmd, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });

package/src/web/kagi.ts

@@ -1,42 +1,92 @@
+/**
+ * Kagi API Client
+ *
+ * Implements the Kagi V1 Search API (POST /api/v1/search), the public-preview
+ * successor to the sunset V0 endpoint. Authentication is resolved exclusively
+ * through the shared {@link AuthStorage} broker (Bearer token), and responses
+ * are categorized result buckets rather than the legacy flat object array.
+ */
 import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import { withHardTimeout } from "./search/providers/utils";
 
-const KAGI_SEARCH_URL = "https://kagi.com/api/v0/search";
+const KAGI_SEARCH_URL = "https://kagi.com/api/v1/search";
 
-interface KagiSearchResultObject {
-	t: 0;
+// ---------------------------------------------------------------------------
+// Request / Response Types
+// ---------------------------------------------------------------------------
+
+/** V1 search request body. */
+export interface KagiSearchRequest {
+	query: string;
+	/** Workflow mode: "search" | "research". */
+	workflow?: string;
+	/** Number of results (1-100). */
+	limit?: number;
+	/** Lens identifier (e.g. "news", "reddit"). */
+	lens?: string;
+	/** Time-based filters as ISO date strings (YYYY-MM-DD). */
+	filters?: {
+		after?: string;
+		before?: string;
+	};
+}
+
+/** Individual V1 result item. */
+export interface KagiSearchResultItem {
 	url: string;
 	title: string;
 	snippet?: string;
-	published?: string;
+	/** ISO timestamp or relative string ("2h ago"). */
+	time?: string;
+	/** Thumbnail image. */
+	image?: { url: string; height?: number; width?: number };
+	/** Extra metadata key-value pairs. */
+	props?: Record<string, unknown>;
 }
 
-interface KagiRelatedSearchesObject {
-	t: 1;
-	list: string[];
+/** V1 categorizes results into named buckets; only consumed buckets are typed. */
+export interface KagiSearchData {
+	search?: KagiSearchResultItem[];
+	video?: KagiSearchResultItem[];
+	news?: KagiSearchResultItem[];
+	infobox?: KagiSearchResultItem[];
+	adjacent_question?: KagiSearchResultItem[];
+	related_search?: KagiSearchResultItem[];
+	direct_answer?: KagiSearchResultItem[];
 }
 
-type KagiSearchObject = KagiSearchResultObject | KagiRelatedSearchesObject;
-
-interface KagiErrorEntry {
+/** V1 error entry. */
+export interface KagiErrorEntry {
 	code?: number;
+	url?: string;
+	message?: string;
 	msg?: string;
+	location?: string;
 }
 
-interface KagiSearchResponse {
-	meta: {
-		id: string;
+/** V1 success response. */
+export interface KagiSearchResponse {
+	meta?: {
+		trace?: string;
+		id?: string;
+		ms?: number;
 	};
-	data: KagiSearchObject[];
+	data?: KagiSearchData;
 	error?: KagiErrorEntry[];
 }
 
-interface KagiErrorResponse {
+/** V1 error response. */
+export interface KagiErrorResponse {
+	meta?: Record<string, unknown>;
 	error?: string | KagiErrorEntry[];
 	message?: string;
 	detail?: string;
 }
 
+// ---------------------------------------------------------------------------
+// Error Handling
+// ---------------------------------------------------------------------------
+
 export class KagiApiError extends Error {
 	readonly statusCode?: number;
 
@@ -64,9 +114,11 @@ function extractKagiErrorMessage(payload: unknown): string | null {
 	if (Array.isArray(record.error)) {
 		for (const entry of record.error) {
 			if (!entry || typeof entry !== "object") continue;
-			const message = (entry as Record<string, unknown>).msg;
-			if (typeof message === "string" && message.trim().length > 0) {
-				return message.trim();
+			const e = entry as Record<string, unknown>;
+			for (const value of [e.message, e.msg]) {
+				if (typeof value === "string" && value.trim().length > 0) {
+					return value.trim();
+				}
 			}
 		}
 	}
@@ -82,21 +134,26 @@ function createKagiApiError(statusCode: number, detail?: string): KagiApiError {
 }
 
 function parseKagiErrorResponse(statusCode: number, responseText: string): KagiApiError {
-	const trimmedResponseText = responseText.trim();
-	if (trimmedResponseText.length === 0) {
+	const trimmed = responseText.trim();
+	if (trimmed.length === 0) {
 		return createKagiApiError(statusCode);
 	}
 
 	try {
-		const payload = JSON.parse(trimmedResponseText) as KagiErrorResponse;
-		return createKagiApiError(statusCode, extractKagiErrorMessage(payload) ?? trimmedResponseText);
+		const payload = JSON.parse(trimmed) as KagiErrorResponse;
+		return createKagiApiError(statusCode, extractKagiErrorMessage(payload) ?? trimmed);
 	} catch {
-		return createKagiApiError(statusCode, trimmedResponseText);
+		return createKagiApiError(statusCode, trimmed);
 	}
 }
 
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
 export interface KagiSearchOptions {
 	limit?: number;
+	recency?: "day" | "week" | "month" | "year";
 	sessionId?: string;
 	signal?: AbortSignal;
 }
@@ -112,6 +169,7 @@ export interface KagiSearchResult {
 	requestId: string;
 	sources: KagiSearchSource[];
 	relatedQuestions: string[];
+	answer?: string;
 }
 
 export async function findKagiApiKey(
@@ -122,11 +180,65 @@ export async function findKagiApiKey(
 	return (await authStorage.getApiKey("kagi", sessionId, { signal })) ?? null;
 }
 
-function getAuthHeaders(apiKey: string): Record<string, string> {
-	return {
-		Authorization: `Bot ${apiKey}`,
-		Accept: "application/json",
+/**
+ * Compute a YYYY-MM-DD date string `recency` units before now, in UTC.
+ * UTC keeps the recency window deterministic regardless of host timezone and
+ * matches Kagi's date-formatted `filters.after`. Date setters handle month
+ * drift (Mar 31 −1mo → Feb 28/29) and leap years correctly.
+ */
+function recencyToDate(recency: "day" | "week" | "month" | "year"): string {
+	const d = new Date();
+	switch (recency) {
+		case "day":
+			d.setUTCDate(d.getUTCDate() - 1);
+			break;
+		case "week":
+			d.setUTCDate(d.getUTCDate() - 7);
+			break;
+		case "month":
+			d.setUTCMonth(d.getUTCMonth() - 1);
+			break;
+		case "year":
+			d.setUTCFullYear(d.getUTCFullYear() - 1);
+			break;
+	}
+	const yyyy = d.getUTCFullYear();
+	const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+	const dd = String(d.getUTCDate()).padStart(2, "0");
+	return `${yyyy}-${mm}-${dd}`;
+}
+
+function buildRequestBody(query: string, options: KagiSearchOptions): KagiSearchRequest {
+	const req: KagiSearchRequest = {
+		query,
+		workflow: "search",
+		limit: options.limit,
 	};
+
+	if (options.recency) {
+		req.filters = { after: recencyToDate(options.recency) };
+	}
+
+	return req;
+}
+
+/** Push every item in a result bucket as a source, with an optional title tag. */
+function collectSources(sources: KagiSearchSource[], items: KagiSearchResultItem[] | undefined, tag?: string): void {
+	if (!items) return;
+	for (const item of items) {
+		sources.push({
+			title: tag ? `${tag} ${item.title}` : item.title,
+			url: item.url,
+			snippet: item.snippet,
+			publishedDate: item.time,
+		});
+	}
+}
+
+/** Pull a related/adjacent question from an item's props or fall back to title. */
+function questionOf(item: KagiSearchResultItem): string | undefined {
+	const q = item.props?.question ?? item.props?.query ?? item.title;
+	return typeof q === "string" && q.length > 0 ? q : undefined;
 }
 
 export async function searchWithKagi(
@@ -139,45 +251,52 @@ export async function searchWithKagi(
 		throw new KagiApiError("Kagi credentials not found. Set KAGI_API_KEY or login with 'omp /login kagi'.");
 	}
 
-	const requestUrl = new URL(KAGI_SEARCH_URL);
-	requestUrl.searchParams.set("q", query);
-	if (options.limit !== undefined) {
-		requestUrl.searchParams.set("limit", String(options.limit));
-	}
-
-	const response = await fetch(requestUrl, {
-		headers: getAuthHeaders(apiKey),
+	const response = await fetch(KAGI_SEARCH_URL, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${apiKey}`,
+			"Content-Type": "application/json",
+			Accept: "application/json",
+		},
+		body: JSON.stringify(buildRequestBody(query, options)),
 		signal: withHardTimeout(options.signal),
 	});
+
 	if (!response.ok) {
 		throw parseKagiErrorResponse(response.status, await response.text());
 	}
 
 	const payload = (await response.json()) as KagiSearchResponse;
 	if (payload.error && payload.error.length > 0) {
-		const firstError = payload.error[0];
-		throw createKagiApiError(firstError.code ?? response.status, extractKagiErrorMessage(payload) ?? undefined);
+		const first = payload.error[0];
+		throw createKagiApiError(first.code ?? response.status, extractKagiErrorMessage(payload) ?? first.message);
 	}
 
+	const data = payload.data;
 	const sources: KagiSearchSource[] = [];
 	const relatedQuestions: string[] = [];
 
-	for (const item of payload.data) {
-		if (item.t === 0) {
-			sources.push({
-				title: item.title,
-				url: item.url,
-				snippet: item.snippet,
-				publishedDate: item.published ?? undefined,
-			});
-		} else if (item.t === 1) {
-			relatedQuestions.push(...item.list);
-		}
+	collectSources(sources, data?.search);
+	collectSources(sources, data?.video, "[Video]");
+	collectSources(sources, data?.news, "[News]");
+	collectSources(sources, data?.infobox, "[Info]");
+
+	for (const item of data?.adjacent_question ?? []) {
+		const q = questionOf(item);
+		if (q) relatedQuestions.push(q);
+	}
+	for (const item of data?.related_search ?? []) {
+		const q = questionOf(item);
+		if (q) relatedQuestions.push(q);
 	}
 
+	const directAnswer = data?.direct_answer?.[0];
+	const answer = directAnswer ? (directAnswer.snippet ?? directAnswer.title) : undefined;
+
 	return {
-		requestId: payload.meta.id,
+		requestId: payload.meta?.trace ?? payload.meta?.id ?? "",
 		sources,
 		relatedQuestions,
+		answer,
 	};
 }

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

@@ -255,7 +255,7 @@ export async function searchAnthropic(
 		const apiKey = await params.authStorage.getApiKey("anthropic", params.sessionId, {
 			signal: params.signal,
 		});
-		if (apiKey) auth = buildAnthropicAuthConfig(apiKey);
+		if (apiKey) auth = buildAnthropicAuthConfig(apiKey, searchBaseUrl);
 	}
 
 	if (!auth) {