pi-ui-extend 0.1.1

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

@@ -0,0 +1,345 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	truncateHead,
+	withFileMutationQueue,
+} from "@earendil-works/pi-coding-agent";
+import { astGrepToolDescriptions } from "../tool-descriptions";
+import { renderAstApplyCall, renderAstGrepCall, renderAstGrepResult } from "./render";
+import { AstApplyParams, AstGrepParams } from "./schema";
+import type { AstGrepDetails, AstGrepParamsType } from "./types";
+import { cleanPath, countLikelyMatches, normalizeNonNegativeInteger } from "./utils";
+
+type NormalizedAstGrepParams = {
+	mode: "run" | "scan";
+	paths: string[];
+	context?: number;
+	before?: number;
+	after?: number;
+	threads?: number;
+	maxResults?: number;
+};
+
+function pushJsonArg(args: string[], params: AstGrepParamsType) {
+	if (params.json) args.push(`--json=${params.jsonStyle ?? "pretty"}`);
+}
+
+function pushSeverityArgs(args: string[], flag: "error" | "warning" | "info" | "hint" | "off", ids?: string[]) {
+	for (const id of ids ?? []) {
+		args.push(id ? `--${flag}=${id}` : `--${flag}`);
+	}
+}
+
+function validateParams(params: AstGrepParamsType, options: { allowUpdateAll: boolean } = { allowUpdateAll: false }): NormalizedAstGrepParams {
+	const mode = params.command ?? "run";
+
+	if (params.updateAll && !options.allowUpdateAll) {
+		throw new Error("ast_grep is read-only; use ast_apply to apply rewrites/fixes");
+	}
+
+	if (params.filesWithMatches && params.json) {
+		throw new Error("filesWithMatches conflicts with json");
+	}
+	if (params.filesWithMatches && params.rewrite) {
+		throw new Error("filesWithMatches conflicts with rewrite");
+	}
+	if (params.filesWithMatches && params.updateAll) {
+		throw new Error("filesWithMatches conflicts with updateAll");
+	}
+	if (params.updateAll && params.json) {
+		throw new Error("updateAll conflicts with json: ast-grep does not apply rewrites while emitting JSON");
+	}
+	if (params.context !== undefined && (params.before !== undefined || params.after !== undefined)) {
+		throw new Error("context conflicts with before/after; choose one style");
+	}
+	if (params.debugQuery && !params.lang) {
+		throw new Error("debugQuery requires lang");
+	}
+
+	if (mode === "run") {
+		if (!params.pattern?.trim()) throw new Error("pattern is required when command=run");
+		if (params.updateAll && !params.rewrite) throw new Error("updateAll requires rewrite when command=run");
+		if (
+			params.rule || params.inlineRules || params.format || params.reportStyle || params.includeMetadata ||
+			params.filter || params.maxResults !== undefined || params.error || params.warning || params.info || params.hint ||
+			params.off
+		) {
+			throw new Error("scan-only options require command=scan");
+		}
+	} else {
+		if (params.pattern || params.rewrite || params.selector || params.strictness || params.debugQuery || params.lang) {
+			throw new Error("pattern/rewrite/lang/selector/strictness/debugQuery are run-only options; use command=run");
+		}
+		if (params.rule && params.inlineRules) throw new Error("rule conflicts with inlineRules");
+		if (params.rule && params.filter) throw new Error("rule conflicts with filter");
+		if (params.includeMetadata && !params.json) throw new Error("includeMetadata requires json");
+	}
+
+	return {
+		mode,
+		paths: (params.paths && params.paths.length > 0 ? params.paths : ["."]).map(cleanPath),
+		context: normalizeNonNegativeInteger(params.context, "context"),
+		before: normalizeNonNegativeInteger(params.before, "before"),
+		after: normalizeNonNegativeInteger(params.after, "after"),
+		threads: normalizeNonNegativeInteger(params.threads, "threads"),
+		maxResults: normalizeNonNegativeInteger(params.maxResults, "maxResults"),
+	};
+}
+
+function appendSharedArgs(args: string[], params: AstGrepParamsType, normalized: NormalizedAstGrepParams) {
+	if (params.config) args.push("--config", cleanPath(params.config));
+	if (params.updateAll) args.push("--update-all");
+	if (params.filesWithMatches) args.push("--files-with-matches");
+	pushJsonArg(args, params);
+	if (params.follow) args.push("--follow");
+	if (normalized.threads !== undefined) args.push("--threads", String(normalized.threads));
+	if (params.inspect) args.push("--inspect", params.inspect);
+	if (normalized.context !== undefined) args.push("--context", String(normalized.context));
+	if (normalized.before !== undefined) args.push("--before", String(normalized.before));
+	if (normalized.after !== undefined) args.push("--after", String(normalized.after));
+	for (const glob of params.globs ?? []) args.push("--globs", glob);
+	for (const mode of params.noIgnore ?? []) args.push("--no-ignore", mode);
+}
+
+function buildAstGrepArgs(params: AstGrepParamsType, normalized: NormalizedAstGrepParams): string[] {
+	if (normalized.mode === "run") {
+		const args = ["run", "--pattern", params.pattern!, "--color", "never", "--heading", "never"];
+		if (params.lang) args.push("--lang", params.lang);
+		if (params.selector) args.push("--selector", params.selector);
+		if (params.strictness) args.push("--strictness", params.strictness);
+		if (params.debugQuery) args.push(`--debug-query=${params.debugQuery}`);
+		if (params.rewrite) args.push("--rewrite", params.rewrite);
+		appendSharedArgs(args, params, normalized);
+		args.push(...normalized.paths);
+		return args;
+	}
+
+	const args = ["scan", "--color", "never"];
+	if (params.rule) args.push("--rule", cleanPath(params.rule));
+	if (params.inlineRules) args.push("--inline-rules", params.inlineRules);
+	if (params.format) args.push("--format", params.format);
+	if (params.reportStyle) args.push("--report-style", params.reportStyle);
+	if (params.includeMetadata) args.push("--include-metadata");
+	if (params.filter) args.push("--filter", params.filter);
+	pushSeverityArgs(args, "error", params.error);
+	pushSeverityArgs(args, "warning", params.warning);
+	pushSeverityArgs(args, "info", params.info);
+	pushSeverityArgs(args, "hint", params.hint);
+	pushSeverityArgs(args, "off", params.off);
+	appendSharedArgs(args, params, normalized);
+	if (normalized.maxResults !== undefined) args.push("--max-results", String(normalized.maxResults));
+	args.push(...normalized.paths);
+	return args;
+}
+
+function mutationQueuePath(cwd: string, paths: string[]) {
+	return resolve(cwd, paths.length === 1 ? paths[0] : ".");
+}
+
+function buildPreviewArgsForChangedFiles(params: AstGrepParamsType, normalized: NormalizedAstGrepParams): string[] {
+	const previewParams: AstGrepParamsType = {
+		...params,
+		updateAll: false,
+		json: true,
+		jsonStyle: "stream",
+		format: undefined,
+		reportStyle: undefined,
+		includeMetadata: undefined,
+	};
+	return buildAstGrepArgs(previewParams, normalized);
+}
+
+function collectFilesFromJsonStream(output: string): string[] {
+	const files = new Set<string>();
+	for (const line of output.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const record = JSON.parse(trimmed) as { file?: unknown; replacement?: unknown };
+			if (typeof record.file === "string" && record.file.trim() && "replacement" in record) files.add(record.file);
+		} catch {
+			// Ignore malformed non-JSON lines. The real ast-grep invocation below will
+			// still surface errors; this preflight is only for LSP changedFiles metadata.
+		}
+	}
+	return [...files];
+}
+
+async function collectChangedFiles(
+	pi: ExtensionAPI,
+	params: AstGrepParamsType,
+	normalized: NormalizedAstGrepParams,
+	cwd: string,
+	signal: AbortSignal | undefined,
+): Promise<string[]> {
+	const previewArgs = buildPreviewArgsForChangedFiles(params, normalized);
+	const result = await pi.exec("ast-grep", previewArgs, { cwd, signal, timeout: 120_000 });
+	const combined = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? "\n" : "");
+	if ((result.code ?? 0) > 1) {
+		throw new Error(`ast-grep changed-file preflight failed with exit code ${result.code}: ${combined.trim() || "no output"}`);
+	}
+	return collectFilesFromJsonStream(result.stdout);
+}
+
+function prepareAstGrepArguments(args: unknown): AstGrepParamsType {
+	if (!args || typeof args !== "object") return args as AstGrepParamsType;
+	const input = args as AstGrepParamsType & { path?: string; paths?: string[] | string };
+	if (typeof input.paths === "string") {
+		return { ...input, paths: [input.paths] };
+	}
+	if (typeof input.path === "string" && input.paths === undefined) {
+		const { path, ...rest } = input;
+		return { ...rest, paths: [path] };
+	}
+	return args as AstGrepParamsType;
+}
+
+async function executeAstGrep(
+	pi: ExtensionAPI,
+	params: AstGrepParamsType,
+	signal: AbortSignal | undefined,
+	ctx: { cwd: string },
+	options: { allowUpdateAll: boolean } = { allowUpdateAll: false },
+) {
+	const normalized = validateParams(params, options);
+	const args = buildAstGrepArgs(params, normalized);
+	const mutated = Boolean(params.updateAll);
+	const rewritePreview = Boolean(params.rewrite && !params.updateAll);
+	let changedFiles: string[] | undefined;
+
+	const runAstGrep = async () => {
+		if (mutated) changedFiles = await collectChangedFiles(pi, params, normalized, ctx.cwd, signal);
+		return pi.exec("ast-grep", args, { cwd: ctx.cwd, signal, timeout: 120_000 });
+	};
+	const result = mutated
+		? await withFileMutationQueue(mutationQueuePath(ctx.cwd, normalized.paths), runAstGrep)
+		: await runAstGrep();
+	const combined = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? "\n" : "");
+
+	if (signal?.aborted || result.killed) {
+		return {
+			content: [{ type: "text" as const, text: "ast-grep cancelled" }],
+			details: {
+				command: ["ast-grep", ...args],
+				mode: normalized.mode,
+				cwd: ctx.cwd,
+				pattern: params.pattern,
+				paths: normalized.paths,
+				lang: params.lang,
+				rewritePreview,
+				mutated,
+				changedFiles,
+				matchCount: 0,
+				exitCode: result.code ?? -1,
+				stderr: result.stderr || undefined,
+			} satisfies AstGrepDetails,
+		};
+	}
+
+	if ((result.code ?? 0) !== 0 && !combined.trim()) {
+		return {
+			content: [{ type: "text" as const, text: "No matches found" }],
+			details: {
+				command: ["ast-grep", ...args],
+				mode: normalized.mode,
+				cwd: ctx.cwd,
+				pattern: params.pattern,
+				paths: normalized.paths,
+				lang: params.lang,
+				rewritePreview,
+				mutated,
+				changedFiles,
+				matchCount: 0,
+				exitCode: result.code ?? 1,
+			} satisfies AstGrepDetails,
+		};
+	}
+
+	if ((result.code ?? 0) > 1) {
+		throw new Error(`ast-grep failed with exit code ${result.code}: ${combined.trim() || "no output"}`);
+	}
+
+	const matchCount = countLikelyMatches(combined, params);
+	const truncation = truncateHead(combined || "No matches found", {
+		maxLines: DEFAULT_MAX_LINES,
+		maxBytes: DEFAULT_MAX_BYTES,
+	});
+
+	let resultText = truncation.content;
+	const details: AstGrepDetails = {
+		command: ["ast-grep", ...args],
+		mode: normalized.mode,
+		cwd: ctx.cwd,
+		pattern: params.pattern,
+		paths: normalized.paths,
+		lang: params.lang,
+		rewritePreview,
+		mutated,
+		changedFiles,
+		matchCount,
+		exitCode: result.code ?? 0,
+		stderr: result.stderr || undefined,
+	};
+
+	if (truncation.truncated) {
+		const tempDir = await mkdtemp(join(tmpdir(), "pi-ast-grep-"));
+		const tempFile = join(tempDir, "output.txt");
+		await withFileMutationQueue(tempFile, async () => {
+			await writeFile(tempFile, combined, "utf8");
+		});
+
+		details.truncation = truncation;
+		details.fullOutputPath = tempFile;
+
+		resultText += `\n\n[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`;
+		resultText += ` (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}).`;
+		resultText += ` Full output saved to: ${tempFile}]`;
+	}
+
+	if (mutated) {
+		const changedCount = changedFiles?.length ?? 0;
+		resultText += `\n\n[Changes were applied with ast-grep --update-all${changedCount ? ` to ${changedCount} file${changedCount === 1 ? "" : "s"}` : ""}.]`;
+	} else if (rewritePreview) {
+		resultText += "\n\n[Rewrite preview only: no files were modified.]";
+	}
+
+	return {
+		content: [{ type: "text" as const, text: resultText }],
+		details,
+	};
+}
+
+export function registerAstGrepTool(pi: ExtensionAPI) {
+	const toolDescriptions = astGrepToolDescriptions(DEFAULT_MAX_LINES, formatSize(DEFAULT_MAX_BYTES));
+
+	pi.registerTool({
+		...toolDescriptions.astGrep,
+		parameters: AstGrepParams,
+		prepareArguments: prepareAstGrepArguments,
+
+		async execute(_toolCallId, params: AstGrepParamsType, signal, _onUpdate, ctx) {
+			return executeAstGrep(pi, params, signal, ctx);
+		},
+
+		renderCall: renderAstGrepCall,
+		renderResult: renderAstGrepResult,
+	});
+
+	pi.registerTool({
+		...toolDescriptions.astApply,
+		parameters: AstApplyParams,
+		prepareArguments: prepareAstGrepArguments,
+
+		async execute(_toolCallId, params: AstGrepParamsType, signal, _onUpdate, ctx) {
+			return executeAstGrep(pi, { ...params, updateAll: true }, signal, ctx, { allowUpdateAll: true });
+		},
+
+		renderCall: renderAstApplyCall,
+		renderResult: renderAstGrepResult,
+	});
+}

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

@@ -0,0 +1,55 @@
+import type { TruncationResult } from "@earendil-works/pi-coding-agent";
+
+export type AstGrepParamsType = {
+	command?: "run" | "scan";
+	pattern?: string;
+	paths?: string[];
+	path?: string;
+	lang?: string;
+	rewrite?: string;
+	updateAll?: boolean;
+	selector?: string;
+	strictness?: "cst" | "smart" | "ast" | "relaxed" | "signature" | "template";
+	debugQuery?: "pattern" | "ast" | "cst" | "sexp";
+	config?: string;
+	globs?: string[];
+	threads?: number;
+	inspect?: "nothing" | "summary" | "entity";
+	maxResults?: number;
+	context?: number;
+	before?: number;
+	after?: number;
+	filesWithMatches?: boolean;
+	json?: boolean;
+	jsonStyle?: "pretty" | "stream" | "compact";
+	follow?: boolean;
+	noIgnore?: Array<"hidden" | "dot" | "exclude" | "global" | "parent" | "vcs">;
+	rule?: string;
+	inlineRules?: string;
+	format?: "github" | "sarif";
+	reportStyle?: "rich" | "medium" | "short";
+	includeMetadata?: boolean;
+	filter?: string;
+	error?: string[];
+	warning?: string[];
+	info?: string[];
+	hint?: string[];
+	off?: string[];
+};
+
+export interface AstGrepDetails {
+	command: string[];
+	mode: "run" | "scan";
+	cwd: string;
+	pattern?: string;
+	paths: string[];
+	lang?: string;
+	rewritePreview: boolean;
+	mutated: boolean;
+	changedFiles?: string[];
+	matchCount: number;
+	exitCode: number;
+	stderr?: string;
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}

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

@@ -0,0 +1,65 @@
+import type { AstGrepParamsType } from "./types";
+
+export function cleanPath(path: string): string {
+	return path.trim();
+}
+
+export function normalizeNonNegativeInteger(value: unknown, name: string): number | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || !Number.isInteger(value)) {
+		throw new Error(`${name} must be a non-negative integer`);
+	}
+	return value;
+}
+
+export function countLikelyMatches(output: string, params: AstGrepParamsType): number {
+	const trimmed = output.trim();
+	if (!trimmed) return 0;
+
+	if (params.json) {
+		try {
+			const parsed = JSON.parse(trimmed);
+			return Array.isArray(parsed) ? parsed.length : 0;
+		} catch {
+			const jsonLineCount = trimmed.split("\n").filter((line) => {
+				try {
+					JSON.parse(line);
+					return true;
+				} catch {
+					return false;
+				}
+			}).length;
+			if (jsonLineCount > 0) return jsonLineCount;
+			// Fall through if ast-grep changed its JSON shape or output was truncated.
+		}
+	}
+
+	if (params.updateAll) {
+		const applied = trimmed.match(/Applied\s+(\d+)\s+changes?/i);
+		if (applied) return Number(applied[1]);
+	}
+
+	if (params.rewrite) {
+		return trimmed
+			.split("\n")
+			.filter((line) => line.includes("│-") || line.match(/^\s*[-+]\d+\s*│[+-]/)).length;
+	}
+
+	if (params.command === "scan") {
+		return trimmed
+			.split("\n")
+			.filter((line) => /(?:^|:\d+:\d+:\s+)(?:error|warning|info|hint)\[[^\]]+\]:/i.test(line.trim()))
+			.length;
+	}
+
+	return trimmed.split("\n").filter((line) => line.trim()).length;
+}
+
+export function shellQuoteForDisplay(args: string[]): string {
+	return args
+		.map((arg) => {
+			if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(arg)) return arg;
+			return `'${arg.replace(/'/g, `'"'"'`)}'`;
+		})
+		.join(" ");
+}