pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/antigravity-auth/stream.ts

@@ -0,0 +1,302 @@
+import { randomUUID } from "node:crypto";
+import { calculateCost, createAssistantMessageEventStream, type AssistantMessage, type AssistantMessageEventStream, type Context, type SimpleStreamOptions, type ToolCall } from "@earendil-works/pi-ai";
+import { ALL_ACCOUNTS_EXHAUSTED_MARKER, API_ID, ENDPOINT_PROD, PROVIDER_ID, STREAM_ENDPOINTS } from "./constants";
+import { clampAccountIndex, decodeApiKey, getPiAuthPath, getStoredAccounts, readJsonFile } from "./auth-store";
+import { getAntigravityHeaders, getModelHeaderStyle } from "./headers";
+import { refreshNextFailoverCredential } from "./oauth";
+import { buildPayload, extraHeadersForPayload, partThoughtSignature } from "./payload";
+import { emitAntigravityStatus } from "./status";
+import type { AntigravityChunk, AntigravityModel, PiAuthData } from "./types";
+
+function baseUsage(): NonNullable<AssistantMessage["usage"]> {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+}
+
+function mapStopReason(reason?: string): "stop" | "length" | "error" {
+	switch (reason) {
+		case "STOP":
+			return "stop";
+		case "MAX_TOKENS":
+			return "length";
+		default:
+			return "error";
+	}
+}
+
+function isFailoverCandidate(status: number | undefined, body: string): boolean {
+	if (isLimitFailoverCandidate(status, body)) return true;
+	const lower = body.toLowerCase();
+	if (lower.includes("model_capacity_exhausted") || lower.includes("server busy") || lower.includes("overloaded") || lower.includes("capacity")) {
+		return true;
+	}
+	return [500, 502, 503, 504].includes(status ?? 0) && (lower.includes("unavailable") || lower.includes("try again") || lower.includes("busy"));
+}
+
+function isLimitFailoverCandidate(status: number | undefined, body: string): boolean {
+	if (status === 429) return true;
+	const lower = body.toLowerCase();
+	return lower.includes("quota_exhausted")
+		|| lower.includes("quota exhausted")
+		|| lower.includes("quota exceeded")
+		|| lower.includes("resource_exhausted")
+		|| lower.includes("resource exhausted")
+		|| lower.includes("rate limit")
+		|| lower.includes("rate_limit");
+}
+
+function shouldTryNextEndpoint(status: number | undefined, body: string): boolean {
+	if (isFailoverCandidate(status, body)) return false;
+	return [404, 500, 502, 503, 504].includes(status ?? 0);
+}
+
+async function sendAntigravityRequest(
+	payload: Record<string, unknown>,
+	apiKey: string,
+	requestHeaders: Record<string, string>,
+	model: AntigravityModel,
+	options?: SimpleStreamOptions,
+): Promise<{ response: Response; lastError: string }> {
+	let response: Response | undefined;
+	let lastError = "";
+	const headerStyle = getModelHeaderStyle(model);
+	const endpoints = headerStyle === "gemini-cli" ? [ENDPOINT_PROD] : STREAM_ENDPOINTS;
+	for (const endpoint of endpoints) {
+		response = await fetch(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+			method: "POST",
+			signal: options?.signal,
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				"Content-Type": "application/json",
+				Accept: "text/event-stream",
+				...getAntigravityHeaders(headerStyle),
+				...requestHeaders,
+				...(options?.headers ?? {}),
+			},
+			body: JSON.stringify(payload),
+		});
+		await options?.onResponse?.({ status: response.status, headers: Object.fromEntries(response.headers.entries()) }, model);
+		if (response.ok) break;
+		lastError = await response.text().catch(() => response?.statusText ?? "");
+		if (!shouldTryNextEndpoint(response.status, lastError)) break;
+	}
+	if (!response) throw new Error("Antigravity request failed: no response");
+	return { response, lastError };
+}
+
+function updateUsage(output: AssistantMessage, model: AntigravityModel, metadata: NonNullable<AntigravityChunk["response"]>["usageMetadata"]): void {
+	if (!metadata) return;
+	const cacheRead = metadata.cachedContentTokenCount ?? 0;
+	output.usage = {
+		input: Math.max(0, (metadata.promptTokenCount ?? 0) - cacheRead),
+		output: (metadata.candidatesTokenCount ?? 0) + (metadata.thoughtsTokenCount ?? 0),
+		cacheRead,
+		cacheWrite: 0,
+		totalTokens: metadata.totalTokenCount ?? 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+	calculateCost(model, output.usage);
+}
+
+export function streamAntigravity(model: AntigravityModel, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+	const stream = createAssistantMessageEventStream();
+	(async () => {
+		const output: AssistantMessage = {
+			role: "assistant",
+			content: [],
+			api: API_ID,
+			provider: model.provider,
+			model: model.id,
+			usage: baseUsage(),
+			stopReason: "stop",
+			timestamp: Date.now(),
+		};
+
+		let openTextIndex: number | undefined;
+		let openThinkingIndex: number | undefined;
+		const closeOpenText = () => {
+			if (openTextIndex === undefined) return;
+			const block = output.content[openTextIndex];
+			if (block?.type === "text") stream.push({ type: "text_end", contentIndex: openTextIndex, content: block.text, partial: output });
+			openTextIndex = undefined;
+		};
+		const closeOpenThinking = () => {
+			if (openThinkingIndex === undefined) return;
+			const block = output.content[openThinkingIndex];
+			if (block?.type === "thinking") stream.push({ type: "thinking_end", contentIndex: openThinkingIndex, content: block.thinking, partial: output });
+			openThinkingIndex = undefined;
+		};
+
+		try {
+			const attemptedAccountIndices = new Set<number>();
+			const auth = await readJsonFile<PiAuthData>(getPiAuthPath(), {});
+			const storedCredential = auth[PROVIDER_ID];
+			const apiKey = storedCredential?.type === "oauth" && storedCredential.access && (storedCredential.expires ?? 0) > Date.now()
+				? storedCredential.access
+				: options?.apiKey;
+			if (!apiKey) throw new Error("Not authenticated with Antigravity. Run /login antigravity first.");
+			const decodedApiKey = decodeApiKey(apiKey);
+			const authAccounts = getStoredAccounts(auth[PROVIDER_ID]);
+			if (authAccounts.length > 0) attemptedAccountIndices.add(clampAccountIndex(auth[PROVIDER_ID]?.activeIndex, authAccounts.length));
+
+			let payload = buildPayload(model, context, options);
+			if (decodedApiKey.projectId) payload.project = decodedApiKey.projectId;
+			const replacedPayload = await options?.onPayload?.(payload, model);
+			if (replacedPayload !== undefined) payload = replacedPayload as Record<string, unknown>;
+
+			stream.push({ type: "start", partial: output });
+			const requestHeaders = extraHeadersForPayload(payload);
+			let requestApiKey = decodedApiKey.access;
+			let response: Response | undefined;
+			let lastError = "";
+			let allAccountsExhausted = false;
+			while (true) {
+				const result = await sendAntigravityRequest(payload, requestApiKey, requestHeaders, model, options);
+				response = result.response;
+				lastError = result.lastError;
+				if (response.ok) break;
+				if (!isFailoverCandidate(response.status, lastError) || options?.signal?.aborted) break;
+				const nextCredential = await refreshNextFailoverCredential(attemptedAccountIndices);
+				if (!nextCredential) {
+					allAccountsExhausted = isLimitFailoverCandidate(response.status, lastError);
+					break;
+				}
+				const decodedNext = decodeApiKey(nextCredential.apiKey);
+				requestApiKey = decodedNext.access;
+				payload = { ...payload, project: decodedNext.projectId || nextCredential.projectId };
+				emitAntigravityStatus({
+					kind: "switch",
+					email: nextCredential.email,
+					accountIndex: nextCredential.accountIndex,
+					accountCount: nextCredential.accountCount,
+					projectId: decodedNext.projectId || nextCredential.projectId,
+					status: response.status,
+				});
+			}
+			if (!response?.ok) {
+				const status = response?.status ?? "no response";
+				if (allAccountsExhausted) {
+					throw new Error(`${ALL_ACCOUNTS_EXHAUSTED_MARKER} model=${model.id} status=${status}: all configured Antigravity accounts are exhausted for this model: ${lastError}`);
+				}
+				throw new Error(`Antigravity request failed (${status}): ${lastError}`);
+			}
+			if (!response.body) throw new Error("Antigravity response did not include a stream body");
+
+			for await (const chunk of readSse(response.body, options?.signal)) {
+				if (chunk.error) throw new Error(chunk.error.message ?? JSON.stringify(chunk.error));
+				const inner = chunk.response;
+				if (!inner) continue;
+				output.responseId ||= inner.responseId;
+				output.responseModel ||= inner.modelVersion;
+				updateUsage(output, model, inner.usageMetadata);
+				const candidate = inner.candidates?.[0];
+				const parts = candidate?.content?.parts ?? [];
+				for (const part of parts) {
+					const thoughtSignature = partThoughtSignature(part);
+					if (typeof part.text === "string") {
+						if (part.thought === true) {
+							closeOpenText();
+							if (openThinkingIndex === undefined) {
+								output.content.push({ type: "thinking", thinking: "", thinkingSignature: thoughtSignature });
+								openThinkingIndex = output.content.length - 1;
+								stream.push({ type: "thinking_start", contentIndex: openThinkingIndex, partial: output });
+							}
+							const block = output.content[openThinkingIndex];
+							if (block?.type === "thinking") {
+								block.thinking += part.text;
+								block.thinkingSignature ||= thoughtSignature;
+								stream.push({ type: "thinking_delta", contentIndex: openThinkingIndex, delta: part.text, partial: output });
+							}
+						} else {
+							closeOpenThinking();
+							if (openTextIndex === undefined) {
+								output.content.push({ type: "text", text: "", textSignature: thoughtSignature });
+								openTextIndex = output.content.length - 1;
+								stream.push({ type: "text_start", contentIndex: openTextIndex, partial: output });
+							}
+							const block = output.content[openTextIndex];
+							if (block?.type === "text") {
+								block.text += part.text;
+								block.textSignature ||= thoughtSignature;
+								stream.push({ type: "text_delta", contentIndex: openTextIndex, delta: part.text, partial: output });
+							}
+						}
+					}
+					if (part.functionCall) {
+						closeOpenText();
+						closeOpenThinking();
+						const toolCall: ToolCall = {
+							type: "toolCall",
+							id: part.functionCall.id || `${part.functionCall.name ?? "tool"}_${randomUUID()}`,
+							name: part.functionCall.name ?? "",
+							arguments: part.functionCall.args ?? {},
+							...(thoughtSignature ? { thoughtSignature } : {}),
+						};
+						output.content.push(toolCall);
+						const contentIndex = output.content.length - 1;
+						stream.push({ type: "toolcall_start", contentIndex, partial: output });
+						stream.push({ type: "toolcall_delta", contentIndex, delta: JSON.stringify(toolCall.arguments), partial: output });
+						stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
+					}
+				}
+				if (candidate?.finishReason) output.stopReason = mapStopReason(candidate.finishReason);
+				if (output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
+			}
+			closeOpenText();
+			closeOpenThinking();
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "error" || output.stopReason === "aborted") throw new Error("Antigravity stopped with an error finish reason");
+			stream.push({ type: "done", reason: output.stopReason, message: output });
+			stream.end();
+		} catch (error) {
+			closeOpenText();
+			closeOpenThinking();
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : String(error);
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+	return stream;
+}
+
+async function* readSse(body: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<AntigravityChunk> {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			if (signal?.aborted) throw new Error("Request was aborted");
+			const { value, done } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let boundary = buffer.match(/\r?\n\r?\n/);
+			while (boundary?.index !== undefined) {
+				const raw = buffer.slice(0, boundary.index);
+				buffer = buffer.slice(boundary.index + boundary[0].length);
+				const data = raw
+					.split(/\r?\n/)
+					.filter((line) => line.startsWith("data:"))
+					.map((line) => line.slice(5).trim())
+					.join("\n");
+				if (!data || data === "[DONE]") continue;
+				yield JSON.parse(data) as AntigravityChunk;
+				boundary = buffer.match(/\r?\n\r?\n/);
+			}
+		}
+		buffer += decoder.decode();
+		for (const line of buffer.split(/\r?\n/)) {
+			if (!line.startsWith("data:")) continue;
+			const data = line.slice(5).trim();
+			if (data && data !== "[DONE]") yield JSON.parse(data) as AntigravityChunk;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}

package/external/pi-tools-suite/src/antigravity-auth/types.ts

@@ -0,0 +1,113 @@
+import type { Model, OAuthCredentials, OAuthLoginCallbacks } from "@earendil-works/pi-ai";
+
+export type HeaderStyle = "antigravity" | "gemini-cli";
+export type AntigravityModel = Model<"antigravity-unified-gateway"> & { antigravityProjectId?: string; antigravityHeaderStyle?: HeaderStyle };
+
+export type AntigravityPart = {
+	text?: string;
+	thought?: boolean;
+	thoughtSignature?: string;
+	thought_signature?: string;
+	inlineData?: { mimeType: string; data: string };
+	functionCall?: { id?: string; name?: string; args?: Record<string, unknown> };
+	functionResponse?: { id?: string; name?: string; response?: Record<string, unknown> };
+};
+
+export type AntigravityContent = {
+	role: "user" | "model";
+	parts: AntigravityPart[];
+};
+
+export type AntigravityChunk = {
+	response?: {
+		candidates?: Array<{
+			content?: { role?: string; parts?: AntigravityPart[] };
+			finishReason?: string;
+		}>;
+		usageMetadata?: {
+			promptTokenCount?: number;
+			candidatesTokenCount?: number;
+			cachedContentTokenCount?: number;
+			thoughtsTokenCount?: number;
+			totalTokenCount?: number;
+		};
+		modelVersion?: string;
+		responseId?: string;
+	};
+	error?: { code?: number; message?: string; status?: string };
+};
+
+export type OpencodeAntigravityAccount = {
+	email?: string;
+	refreshToken?: string;
+	projectId?: string;
+	managedProjectId?: string;
+	enabled?: boolean;
+};
+
+export type OpencodeAntigravityStorage = {
+	version?: number;
+	accounts?: OpencodeAntigravityAccount[];
+	activeIndex?: number;
+};
+
+export type PiAuthCredential = {
+	type?: string;
+	refresh?: string;
+	access?: string;
+	expires?: number;
+	email?: string;
+	accounts?: OpencodeAntigravityAccount[];
+	activeIndex?: number;
+	[key: string]: unknown;
+};
+
+export type PiAuthData = Record<string, PiAuthCredential>;
+
+export type RefreshedAntigravityAccount = {
+	account: OpencodeAntigravityAccount;
+	credentials: OAuthCredentials & PiAuthCredential;
+	projectId: string;
+};
+
+export type AntigravityFailoverCredential = {
+	apiKey: string;
+	projectId: string;
+	email?: string;
+	accountIndex: number;
+	accountCount: number;
+};
+
+export type AntigravityStatusDetails = {
+	kind: "status" | "switch";
+	email?: string;
+	accountIndex?: number;
+	accountCount?: number;
+	projectId?: string;
+	status?: number;
+	expires?: number;
+};
+
+export type AntigravityLoginCallbacks = Pick<OAuthLoginCallbacks, "onAuth" | "onPrompt">;
+
+export type OpencodeAntigravityImportResult = {
+	imported: boolean;
+	reason?: string;
+	sourcePath: string;
+	authPath: string;
+	email?: string;
+	accountIndex?: number;
+	accountCount?: number;
+	overwroteExisting?: boolean;
+};
+
+export type AntigravityAddAccountResult = {
+	added: boolean;
+	updatedExisting?: boolean;
+	activated: boolean;
+	authPath: string;
+	email?: string;
+	accountIndex: number;
+	accountCount: number;
+	projectId?: string;
+};

package/external/pi-tools-suite/src/ast-grep/index.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerAstGrepTool } from "./tool";
+
+export default function astGrepExtension(pi: ExtensionAPI) {
+	registerAstGrepTool(pi);
+}

package/external/pi-tools-suite/src/ast-grep/render.ts

@@ -0,0 +1,70 @@
+import { Text } from "@earendil-works/pi-tui";
+import type { AstGrepDetails, AstGrepParamsType } from "./types";
+import { shellQuoteForDisplay } from "./utils";
+
+type RenderTheme = {
+	fg(name: string, text: string): string;
+	bold(text: string): string;
+};
+
+type AstGrepRenderResult = {
+	content: unknown[];
+	details?: unknown;
+};
+
+type RenderResultOptions = {
+	expanded?: boolean;
+	isPartial?: boolean;
+};
+
+function renderAstGrepCallWithName(args: Partial<AstGrepParamsType>, theme: RenderTheme, toolName: string) {
+	let text = theme.fg("toolTitle", theme.bold(`${toolName} `));
+	text += theme.fg("accent", args.command === "scan" ? "scan" : JSON.stringify(args.pattern ?? ""));
+	if (args.lang) text += theme.fg("muted", ` --lang ${args.lang}`);
+	if (args.updateAll) text += theme.fg("warning", " update-all");
+	else if (args.rewrite) text += theme.fg("warning", " rewrite-preview");
+	const paths = Array.isArray(args.paths) ? args.paths : [];
+	if (paths.length > 0) text += theme.fg("dim", ` in ${paths.join(", ")}`);
+	return new Text(text, 0, 0);
+}
+
+export function renderAstGrepCall(args: Partial<AstGrepParamsType>, theme: RenderTheme) {
+	return renderAstGrepCallWithName(args, theme, "ast_grep");
+}
+
+export function renderAstApplyCall(args: Partial<AstGrepParamsType>, theme: RenderTheme) {
+	return renderAstGrepCallWithName({ ...args, updateAll: true }, theme, "ast_apply");
+}
+
+export function renderAstGrepResult(
+	result: AstGrepRenderResult,
+	{ expanded, isPartial }: RenderResultOptions,
+	theme: RenderTheme,
+) {
+	const details = result.details as AstGrepDetails | undefined;
+	if (isPartial) return new Text(theme.fg("warning", "Searching AST..."), 0, 0);
+	if (!details) return new Text(theme.fg("dim", "ast-grep finished"), 0, 0);
+
+	let text = details.matchCount === 0
+		? theme.fg("dim", "No matches")
+		: theme.fg("success", `${details.matchCount} match${details.matchCount === 1 ? "" : "es"}`);
+	if (details.mutated) text += theme.fg("warning", " (applied)");
+	if (details.changedFiles?.length) {
+		text += theme.fg("dim", ` ${details.changedFiles.length} file${details.changedFiles.length === 1 ? "" : "s"}`);
+	}
+	if (details.rewritePreview) text += theme.fg("warning", " (rewrite preview)");
+	if (details.truncation?.truncated) text += theme.fg("warning", " (truncated)");
+	if (details.fullOutputPath) text += theme.fg("dim", ` full: ${details.fullOutputPath}`);
+
+	if (expanded) {
+		text += `\n${theme.fg("dim", shellQuoteForDisplay(details.command))}`;
+		const content = result.content[0] as { type?: unknown; text?: unknown } | undefined;
+		if (content?.type === "text" && typeof content.text === "string" && content.text.trim()) {
+			for (const line of content.text.split("\n").slice(0, 30)) {
+				text += `\n${theme.fg("dim", line)}`;
+			}
+		}
+	}
+
+	return new Text(text, 0, 0);
+}

package/external/pi-tools-suite/src/ast-grep/schema.ts

@@ -0,0 +1,109 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+
+const AstGrepParamProperties = {
+	command: Type.Optional(
+		StringEnum(["run", "scan"] as const, {
+			description: "ast-grep subcommand. run searches/rewrites by pattern; scan uses sgconfig/rule YAML. Default: run.",
+		}),
+	),
+	pattern: Type.Optional(
+		Type.String({
+			description: "AST pattern to match for command=run, e.g. 'console.log($A)'",
+		}),
+	),
+	paths: Type.Optional(
+		Type.Array(Type.String(), {
+			description: "Files/directories to search. Defaults to ['.'].",
+		}),
+	),
+	lang: Type.Optional(
+		Type.String({
+			description: "Language of the pattern, e.g. ts, tsx, js, python, rust, go.",
+		}),
+	),
+	rewrite: Type.Optional(
+		Type.String({
+			description:
+				"Optional rewrite template/fix. ast_grep previews rewrites only; use ast_apply to apply changes.",
+		}),
+	),
+	selector: Type.Optional(
+		Type.String({
+			description: "Optional AST node kind selector to extract the sub-node of the pattern to match.",
+		}),
+	),
+	strictness: Type.Optional(
+		StringEnum(["cst", "smart", "ast", "relaxed", "signature", "template"] as const, {
+			description: "Pattern strictness. ast-grep default is smart.",
+		}),
+	),
+	debugQuery: Type.Optional(
+		StringEnum(["pattern", "ast", "cst", "sexp"] as const, {
+			description: "Print query pattern's tree-sitter AST. Requires lang be set explicitly.",
+		}),
+	),
+	config: Type.Optional(Type.String({ description: "Path to ast-grep root config, default is sgconfig.yml." })),
+	globs: Type.Optional(
+		Type.Array(Type.String(), {
+			description: "Include/exclude globs. Repeatable ast-grep --globs values; use !pattern to exclude.",
+		}),
+	),
+	threads: Type.Optional(Type.Number({ description: "Approximate number of threads to use. 0 lets ast-grep choose." })),
+	inspect: Type.Optional(
+		StringEnum(["nothing", "summary", "entity"] as const, {
+			description: "Inspect information for file/rule discovery and scanning.",
+		}),
+	),
+	maxResults: Type.Optional(Type.Number({ description: "For command=scan, show at most N results and stop once the limit is reached." })),
+	context: Type.Optional(Type.Number({ description: "Show N context lines around each match." })),
+	before: Type.Optional(Type.Number({ description: "Show N lines before each match." })),
+	after: Type.Optional(Type.Number({ description: "Show N lines after each match." })),
+	filesWithMatches: Type.Optional(
+		Type.Boolean({ description: "Only print paths with at least one match. Conflicts with rewrite and json." }),
+	),
+	json: Type.Optional(Type.Boolean({ description: "Return ast-grep matches as JSON." })),
+	jsonStyle: Type.Optional(
+		StringEnum(["pretty", "stream", "compact"] as const, {
+			description: "JSON output style. Default: pretty.",
+		}),
+	),
+	follow: Type.Optional(Type.Boolean({ description: "Follow symbolic links while traversing directories." })),
+	noIgnore: Type.Optional(
+		Type.Array(StringEnum(["hidden", "dot", "exclude", "global", "parent", "vcs"] as const), {
+			description: "Ignore-file suppression modes passed as repeated --no-ignore values.",
+		}),
+	),
+	rule: Type.Optional(Type.String({ description: "For command=scan, scan with a single rule file." })),
+	inlineRules: Type.Optional(
+		Type.String({ description: "For command=scan, rule YAML text. Separate multiple rules with --- . Conflicts with rule." }),
+	),
+	format: Type.Optional(
+		StringEnum(["github", "sarif"] as const, {
+			description: "For command=scan, output warning/error messages in a machine-readable format.",
+		}),
+	),
+	reportStyle: Type.Optional(
+		StringEnum(["rich", "medium", "short"] as const, {
+			description: "For command=scan, diagnostic report style. Default: rich.",
+		}),
+	),
+	includeMetadata: Type.Optional(Type.Boolean({ description: "For command=scan with json=true, include rule metadata." })),
+	filter: Type.Optional(Type.String({ description: "For command=scan, regex for rule ids to run. Conflicts with rule." })),
+	error: Type.Optional(Type.Array(Type.String(), { description: "For command=scan, set specified rule ids to error. Use [''] for bare --error." })),
+	warning: Type.Optional(Type.Array(Type.String(), { description: "For command=scan, set specified rule ids to warning. Use [''] for bare --warning." })),
+	info: Type.Optional(Type.Array(Type.String(), { description: "For command=scan, set specified rule ids to info. Use [''] for bare --info." })),
+	hint: Type.Optional(Type.Array(Type.String(), { description: "For command=scan, set specified rule ids to hint. Use [''] for bare --hint." })),
+	off: Type.Optional(Type.Array(Type.String(), { description: "For command=scan, turn off specified rule ids. Use [''] for bare --off." })),
+};
+
+export const AstGrepParams = Type.Object(AstGrepParamProperties);
+
+export const AstApplyParams = Type.Object({
+	...AstGrepParamProperties,
+	rewrite: Type.Optional(
+		Type.String({
+			description: "Rewrite template/fix for command=run. ast_apply applies changes with ast-grep --update-all.",
+		}),
+	),
+});