@howaboua/pi-codex-conversion 1.0.0

package/src/shell/parse.ts

@@ -0,0 +1,297 @@
+import type { ShellAction } from "./types.ts";
+import { isAbsoluteLike, joinPaths, shortDisplayPath } from "./tokenize.ts";
+
+export function parseShellPart(tokens: string[], cwd?: string): ShellAction | null {
+	if (tokens.length === 0) return null;
+
+	if (tokens[0] === "cd") {
+		return null;
+	}
+
+	const parsed = parseMainTokens(tokens);
+	if (parsed === null) return null;
+	if (parsed.kind === "run") return parsed;
+
+	if (parsed.kind === "read" && cwd && !isAbsoluteLike(parsed.path)) {
+		return {
+			...parsed,
+			path: joinPaths(cwd, parsed.path),
+		};
+	}
+	return parsed;
+}
+
+export function nextCwd(currentCwd: string | undefined, tokens: string[]): string | undefined {
+	if (tokens[0] !== "cd") return currentCwd;
+	const target = cdTarget(tokens.slice(1));
+	if (!target) return currentCwd;
+	return currentCwd ? joinPaths(currentCwd, target) : target;
+}
+
+function parseMainTokens(tokens: string[]): ShellAction | null {
+	const [head, ...tail] = tokens;
+	if (!head) return null;
+
+	if (head === "echo" || head === "true") {
+		return null;
+	}
+
+	if (head === "ls" || head === "eza" || head === "exa" || head === "tree" || head === "du") {
+		const flagsWithValues =
+			head === "tree"
+				? ["-L", "-P", "-I", "--charset", "--filelimit", "--sort"]
+				: head === "du"
+					? ["-d", "--max-depth", "-B", "--block-size", "--exclude", "--time-style"]
+					: head === "ls"
+						? ["-I", "--ignore", "-w", "--block-size", "--format", "--time-style", "--color"]
+						: ["-I", "--ignore-glob", "--color", "--sort", "--time-style", "--time"];
+		const path = firstNonFlagOperand(tail, flagsWithValues);
+		return { kind: "list", command: tokens.join(" "), path: path ? shortDisplayPath(path) : undefined };
+	}
+
+	if (head === "rg" || head === "rga" || head === "ripgrep-all") {
+		const hasFilesFlag = tail.includes("--files");
+		const candidates = skipFlagValues(tail, [
+			"-g",
+			"--glob",
+			"--iglob",
+			"-t",
+			"--type",
+			"--type-add",
+			"--type-not",
+			"-m",
+			"--max-count",
+			"-A",
+			"-B",
+			"-C",
+			"--context",
+			"--max-depth",
+		]);
+		const nonFlags = candidates.filter((token) => !token.startsWith("-"));
+		if (hasFilesFlag) {
+			const path = nonFlags[0];
+			return { kind: "list", command: tokens.join(" "), path: path ? shortDisplayPath(path) : undefined };
+		}
+		return {
+			kind: "search",
+			command: tokens.join(" "),
+			query: nonFlags[0],
+			path: nonFlags[1] ? shortDisplayPath(nonFlags[1]) : undefined,
+		};
+	}
+
+	if (head === "git" && tail[0] === "grep") {
+		return parseGrepLike(tokens.join(" "), tail.slice(1));
+	}
+
+	if (head === "git" && tail[0] === "ls-files") {
+		const path = firstNonFlagOperand(tail.slice(1), ["--exclude", "--exclude-from", "--pathspec-from-file"]);
+		return { kind: "list", command: tokens.join(" "), path: path ? shortDisplayPath(path) : undefined };
+	}
+
+	if (head === "fd") {
+		const nonFlags = skipFlagValues(tail, ["-g", "--glob", "-e", "--extension", "-E", "--exclude"]).filter(
+			(token) => !token.startsWith("-"),
+		);
+		if (nonFlags.length === 0) {
+			return { kind: "list", command: tokens.join(" ") };
+		}
+		if (nonFlags.length === 1) {
+			return { kind: "list", command: tokens.join(" "), path: shortDisplayPath(nonFlags[0]) };
+		}
+		return {
+			kind: "search",
+			command: tokens.join(" "),
+			query: nonFlags[0],
+			path: shortDisplayPath(nonFlags[1]),
+		};
+	}
+
+	if (head === "find") {
+		const path = tail.find((token) => !token.startsWith("-"));
+		const nameIndex = tail.findIndex((token) => token === "-name" || token === "-iname");
+		const query = nameIndex !== -1 ? tail[nameIndex + 1] : undefined;
+		if (query) {
+			return {
+				kind: "search",
+				command: tokens.join(" "),
+				query,
+				path: path ? shortDisplayPath(path) : undefined,
+			};
+		}
+		return { kind: "list", command: tokens.join(" "), path: path ? shortDisplayPath(path) : undefined };
+	}
+
+	if (head === "grep" || head === "egrep" || head === "fgrep" || head === "ag" || head === "ack" || head === "pt") {
+		return parseGrepLike(tokens.join(" "), tail);
+	}
+
+	if (head === "cat" || head === "bat" || head === "batcat" || head === "less" || head === "more") {
+		const path = singleNonFlagOperand(tail, [
+			"--theme",
+			"--language",
+			"--style",
+			"--terminal-width",
+			"--tabs",
+			"--line-range",
+			"--map-syntax",
+			"-p",
+			"-P",
+			"-x",
+			"-y",
+			"-z",
+			"-j",
+			"--pattern",
+			"--prompt",
+			"--shift",
+			"--jump-target",
+		]);
+		return path ? readAction(tokens.join(" "), path) : { kind: "run", command: tokens.join(" ") };
+	}
+
+	if (head === "head") {
+		const path = readPathFromHeadTail(tail, "head");
+		return path ? readAction(tokens.join(" "), path) : null;
+	}
+
+	if (head === "tail") {
+		const path = readPathFromHeadTail(tail, "tail");
+		return path ? readAction(tokens.join(" "), path) : null;
+	}
+
+	if (head === "nl") {
+		const candidates = skipFlagValues(tail, ["-s", "-w", "-v", "-i", "-b"]);
+		const path = candidates.find((token) => !token.startsWith("-"));
+		return path ? readAction(tokens.join(" "), path) : null;
+	}
+
+	if (head === "sed") {
+		const path = sedReadPath(tail);
+		return path ? readAction(tokens.join(" "), path) : null;
+	}
+
+	return { kind: "run", command: tokens.join(" ") };
+}
+
+function parseGrepLike(command: string, tail: string[]): ShellAction {
+	const candidates = skipFlagValues(tail, [
+		"-e",
+		"-f",
+		"-g",
+		"-G",
+		"--glob",
+		"--include",
+		"--exclude",
+		"--exclude-dir",
+		"--exclude-from",
+		"--ignore-dir",
+	]);
+	const nonFlags = candidates.filter((token) => !token.startsWith("-"));
+	return {
+		kind: "search",
+		command,
+		query: nonFlags[0],
+		path: nonFlags[1] ? shortDisplayPath(nonFlags[1]) : undefined,
+	};
+}
+
+function readAction(command: string, path: string): ShellAction {
+	return {
+		kind: "read",
+		command,
+		name: shortDisplayPath(path),
+		path,
+	};
+}
+
+function readPathFromHeadTail(args: string[], tool: "head" | "tail"): string | undefined {
+	if (args.length === 1 && !args[0].startsWith("-")) {
+		return args[0];
+	}
+
+	const tokens = [...args];
+	let index = 0;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		if (!token) break;
+		if (!token.startsWith("-")) {
+			return token;
+		}
+		if ((token === "-n" || token === "-c") && index + 1 < tokens.length) {
+			index += 2;
+			continue;
+		}
+		if ((tool === "head" || tool === "tail") && /^-[nc].+/.test(token)) {
+			index += 1;
+			continue;
+		}
+		index += 1;
+	}
+
+	return undefined;
+}
+
+function sedReadPath(args: string[]): string | undefined {
+	if (!args.includes("-n")) return undefined;
+
+	let hasRangeScript = false;
+	for (let index = 0; index < args.length; index++) {
+		const token = args[index];
+		if ((token === "-e" || token === "--expression") && isValidSedRange(args[index + 1])) {
+			hasRangeScript = true;
+		}
+		if (!token.startsWith("-") && isValidSedRange(token)) {
+			hasRangeScript = true;
+		}
+	}
+	if (!hasRangeScript) return undefined;
+
+	const candidates = skipFlagValues(args, ["-e", "-f", "--expression", "--file"]);
+	const nonFlags = candidates.filter((token) => !token.startsWith("-"));
+	if (nonFlags.length === 0) return undefined;
+	if (isValidSedRange(nonFlags[0])) {
+		return nonFlags[1];
+	}
+	return nonFlags[0];
+}
+
+function isValidSedRange(value: string | undefined): boolean {
+	if (!value || !value.endsWith("p")) return false;
+	const core = value.slice(0, -1);
+	const parts = core.split(",");
+	return parts.length >= 1 && parts.length <= 2 && parts.every((part) => part.length > 0 && /^\d+$/.test(part));
+}
+
+function firstNonFlagOperand(args: string[], flagsWithValues: string[]): string | undefined {
+	return skipFlagValues(args, flagsWithValues).find((token) => !token.startsWith("-"));
+}
+
+function singleNonFlagOperand(args: string[], flagsWithValues: string[]): string | undefined {
+	const nonFlags = skipFlagValues(args, flagsWithValues).filter((token) => !token.startsWith("-"));
+	return nonFlags.length === 1 ? nonFlags[0] : undefined;
+}
+
+function skipFlagValues(args: string[], flagsWithValues: string[]): string[] {
+	const out: string[] = [];
+	for (let index = 0; index < args.length; index++) {
+		const token = args[index];
+		out.push(token);
+		if (flagsWithValues.includes(token) && index + 1 < args.length) {
+			index += 1;
+		}
+	}
+	return out;
+}
+
+function cdTarget(args: string[]): string | undefined {
+	for (let index = 0; index < args.length; index++) {
+		const token = args[index];
+		if (token === "--") {
+			continue;
+		}
+		if (!token.startsWith("-")) {
+			return token;
+		}
+	}
+	return undefined;
+}

package/src/shell/summary.ts

@@ -0,0 +1,62 @@
+import { parseShellPart, nextCwd } from "./parse.ts";
+import { splitOnConnectors, normalizeTokens, shellSplit } from "./tokenize.ts";
+import type { CommandSummary, ShellAction } from "./types.ts";
+
+export type { CommandSummary, ShellAction } from "./types.ts";
+
+// The adapter only masks commands when every parsed segment still looks like
+// repository exploration. The moment we see an actual side-effectful run, we
+// fall back to raw command rendering so the UI does not hide meaningful work.
+export function summarizeShellCommand(command: string): CommandSummary {
+	const normalized = normalizeTokens(shellSplit(command));
+	const parts = splitOnConnectors(normalized);
+	const fallback = runSummary(command);
+
+	if (parts.length === 0) {
+		return fallback;
+	}
+
+	const actions: ShellAction[] = [];
+	let cwd: string | undefined;
+
+	for (const part of parts) {
+		if (part.length === 0) continue;
+
+		cwd = nextCwd(cwd, part);
+		const parsed = parseShellPart(part, cwd);
+		if (parsed === null) continue;
+		if (parsed.kind === "run") {
+			return fallback;
+		}
+		actions.push(parsed);
+	}
+
+	const deduped = dedupeActions(actions);
+	if (deduped.length === 0) {
+		return fallback;
+	}
+
+	return {
+		maskAsExplored: deduped.every((action) => action.kind !== "run"),
+		actions: deduped,
+	};
+}
+
+function runSummary(command: string): CommandSummary {
+	return {
+		maskAsExplored: false,
+		actions: [{ kind: "run", command: command.trim() || command }],
+	};
+}
+
+function dedupeActions(actions: ShellAction[]): ShellAction[] {
+	const deduped: ShellAction[] = [];
+	for (const action of actions) {
+		const previous = deduped[deduped.length - 1];
+		if (previous && JSON.stringify(previous) === JSON.stringify(action)) {
+			continue;
+		}
+		deduped.push(action);
+	}
+	return deduped;
+}

package/src/shell/tokenize.ts

@@ -0,0 +1,125 @@
+// Shell tokenization is intentionally lightweight: it only needs enough fidelity
+// to classify obvious read/list/search commands for compact Codex-style rendering.
+export function shellSplit(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let quote: "'" | '"' | undefined;
+	let escaping = false;
+
+	const pushCurrent = () => {
+		if (current.length > 0) {
+			tokens.push(current);
+			current = "";
+		}
+	};
+
+	for (let index = 0; index < input.length; index++) {
+		const char = input[index];
+		const next = input[index + 1];
+
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+
+		if (char === "\\" && quote !== "'") {
+			escaping = true;
+			continue;
+		}
+
+		if (quote) {
+			if (char === quote) {
+				quote = undefined;
+			} else {
+				current += char;
+			}
+			continue;
+		}
+
+		if (char === "'" || char === '"') {
+			quote = char;
+			continue;
+		}
+
+		if (char === "&" && next === "&") {
+			pushCurrent();
+			tokens.push("&&");
+			index += 1;
+			continue;
+		}
+		if (char === "|" && next === "|") {
+			pushCurrent();
+			tokens.push("||");
+			index += 1;
+			continue;
+		}
+		if (char === "|" || char === ";") {
+			pushCurrent();
+			tokens.push(char);
+			continue;
+		}
+
+		if (/\s/.test(char)) {
+			pushCurrent();
+			continue;
+		}
+
+		current += char;
+	}
+
+	pushCurrent();
+	return tokens;
+}
+
+export function normalizeTokens(tokens: string[]): string[] {
+	if (tokens.length >= 3 && (tokens[0] === "yes" || tokens[0] === "y" || tokens[0] === "no" || tokens[0] === "n") && tokens[1] === "|") {
+		return normalizeTokens(tokens.slice(2));
+	}
+	if (
+		tokens.length === 3 &&
+		(tokens[0] === "bash" || tokens[0] === "zsh" || tokens[0].endsWith("/bash") || tokens[0].endsWith("/zsh")) &&
+		(tokens[1] === "-c" || tokens[1] === "-lc")
+	) {
+		return normalizeTokens(shellSplit(tokens[2]));
+	}
+	return tokens;
+}
+
+export function splitOnConnectors(tokens: string[]): string[][] {
+	const parts: string[][] = [];
+	let current: string[] = [];
+	for (const token of tokens) {
+		if (token === "&&" || token === "||" || token === "|" || token === ";") {
+			if (current.length > 0) {
+				parts.push(current);
+				current = [];
+			}
+			continue;
+		}
+		current.push(token);
+	}
+	if (current.length > 0) {
+		parts.push(current);
+	}
+	return parts;
+}
+
+export function shortDisplayPath(path: string): string {
+	const normalized = path.replace(/\\/g, "/").replace(/\/$/, "");
+	const parts = normalized
+		.split("/")
+		.filter((part) => part.length > 0 && part !== "." && part !== "src" && part !== "dist" && part !== "build" && part !== "node_modules");
+	return parts[parts.length - 1] ?? normalized;
+}
+
+export function joinPaths(base: string, extra: string): string {
+	if (isAbsoluteLike(extra)) return extra;
+	const left = base.replace(/\\/g, "/").replace(/\/$/, "");
+	const right = extra.replace(/\\/g, "/").replace(/^\.\//, "");
+	return `${left}/${right}`;
+}
+
+export function isAbsoluteLike(path: string): boolean {
+	return path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("\\\\");
+}

package/src/shell/types.ts

@@ -0,0 +1,10 @@
+export type ShellAction =
+	| { kind: "read"; command: string; name: string; path: string }
+	| { kind: "list"; command: string; path?: string }
+	| { kind: "search"; command: string; query?: string; path?: string }
+	| { kind: "run"; command: string };
+
+export interface CommandSummary {
+	maskAsExplored: boolean;
+	actions: ShellAction[];
+}

package/src/tools/apply-patch-tool.ts

@@ -0,0 +1,84 @@
+import { Type } from "@sinclair/typebox";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { executePatch } from "../patch/core.ts";
+import type { ExecutePatchResult } from "../patch/types.ts";
+
+const APPLY_PATCH_PARAMETERS = Type.Object({
+	input: Type.String({
+		description: "Full patch text. Use *** Begin Patch / *** End Patch with Add/Update/Delete File sections.",
+	}),
+});
+
+function parseApplyPatchParams(params: unknown): { patchText: string } {
+	if (!params || typeof params !== "object" || !("input" in params) || typeof params.input !== "string") {
+		throw new Error("apply_patch requires a string 'input' parameter");
+	}
+	return { patchText: params.input };
+}
+
+function isExecutePatchResult(details: unknown): details is ExecutePatchResult {
+	return typeof details === "object" && details !== null;
+}
+
+export type { ExecutePatchResult } from "../patch/types.ts";
+
+export function registerApplyPatchTool(pi: ExtensionAPI): void {
+	pi.registerTool({
+		name: "apply_patch",
+		label: "apply_patch",
+		description: "Use `apply_patch` to edit files. Send the full patch in `input`.",
+		promptSnippet: "Edit files with a patch.",
+		promptGuidelines: ["Prefer apply_patch for focused textual edits instead of rewriting whole files."],
+		parameters: APPLY_PATCH_PARAMETERS,
+		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+			if (signal?.aborted) {
+				throw new Error("apply_patch aborted");
+			}
+
+			const typedParams = parseApplyPatchParams(params);
+			const result = executePatch({ cwd: ctx.cwd, patchText: typedParams.patchText });
+			const summary = [
+				"Applied patch successfully.",
+				`Changed files: ${result.changedFiles.length}`,
+				`Created files: ${result.createdFiles.length}`,
+				`Deleted files: ${result.deletedFiles.length}`,
+				`Moved files: ${result.movedFiles.length}`,
+				`Fuzz: ${result.fuzz}`,
+			].join("\n");
+
+			return {
+				content: [{ type: "text", text: summary }],
+				details: result,
+			};
+		},
+		renderCall(_args, theme) {
+			return new Text(`${theme.fg("toolTitle", theme.bold("apply_patch"))} ${theme.fg("muted", "patch")}`, 0, 0);
+		},
+		renderResult(result, { isPartial, expanded }, theme) {
+			if (isPartial) {
+				return new Text(theme.fg("warning", "Applying patch..."), 0, 0);
+			}
+
+			const details = isExecutePatchResult(result.details) ? result.details : undefined;
+			if (!details) {
+				return new Text(theme.fg("success", "Patch applied"), 0, 0);
+			}
+
+			let text = theme.fg("success", "Patch applied");
+			text += theme.fg(
+				"dim",
+				` (${details.changedFiles.length} changed, ${details.createdFiles.length} created, ${details.deletedFiles.length} deleted)`,
+			);
+			if (expanded) {
+				for (const file of details.changedFiles) {
+					text += `\n${theme.fg("dim", file)}`;
+				}
+				for (const move of details.movedFiles) {
+					text += `\n${theme.fg("accent", move)}`;
+				}
+			}
+			return new Text(text, 0, 0);
+		},
+	});
+}

package/src/tools/codex-rendering.ts

@@ -0,0 +1,95 @@
+import { summarizeShellCommand, type ShellAction } from "../shell/summary.ts";
+import type { ExecCommandStatus } from "./exec-command-state.ts";
+
+export interface RenderTheme {
+	fg(role: string, text: string): string;
+	bold(text: string): string;
+}
+
+export function renderExecCommandCall(command: string, state: ExecCommandStatus, theme: RenderTheme): string {
+	const summary = summarizeShellCommand(command);
+	return summary.maskAsExplored ? renderExplorationText(summary.actions, state, theme) : renderCommandText(command, state, theme);
+}
+
+export function renderWriteStdinCall(
+	sessionId: number | string,
+	input: string | undefined,
+	command: string | undefined,
+	theme: RenderTheme,
+): string {
+	const interacted = typeof input === "string" && input.length > 0;
+	const marker = interacted ? "↳ " : "• ";
+	const title = interacted ? "Interacted with background terminal" : "Waited for background terminal";
+	let text = `${theme.fg("dim", marker)}${theme.bold(title)}`;
+	const commandPreview = formatCommandPreview(command);
+	if (commandPreview) {
+		text += `${theme.fg("dim", " · ")}${theme.fg("muted", commandPreview)}`;
+	}
+	// Keep the session fallback only when we do not have a stable command display.
+	if (!commandPreview) {
+		text += `${theme.fg("dim", " ")}${theme.fg("muted", `#${sessionId}`)}`;
+	}
+	return text;
+}
+
+function renderExplorationText(actions: ShellAction[], state: ExecCommandStatus, theme: RenderTheme): string {
+	const header = state === "running" ? "Exploring" : "Explored";
+	let text = `${theme.fg("dim", "•")} ${theme.bold(header)}`;
+
+	for (const [index, line] of coalesceReads(actions).map(formatActionLine).entries()) {
+		const prefix = index === 0 ? "  └ " : "    ";
+		text += `\n${theme.fg("dim", prefix)}${theme.fg("accent", line.title)} ${theme.fg("muted", line.body)}`;
+	}
+
+	return text;
+}
+
+function renderCommandText(command: string, state: ExecCommandStatus, theme: RenderTheme): string {
+	const verb = state === "running" ? "Running" : "Ran";
+	let text = `${theme.fg("dim", "•")} ${theme.bold(verb)}`;
+	text += `\n${theme.fg("dim", "  └ ")}${theme.fg("accent", shortenCommand(command))}`;
+	return text;
+}
+
+function shortenCommand(command: string, max = 100): string {
+	const trimmed = command.trim();
+	if (trimmed.length <= max) return trimmed;
+	return `${trimmed.slice(0, max - 3)}...`;
+}
+
+function formatCommandPreview(command: string | undefined): string | undefined {
+	if (!command) return undefined;
+	const singleLine = command.replace(/\s+/g, " ").trim();
+	if (singleLine.length === 0) return undefined;
+	return shortenCommand(singleLine, 80);
+}
+
+function formatActionLine(action: ShellAction): { title: string; body: string } {
+	if (action.kind === "read") {
+		return { title: "Read", body: action.name };
+	}
+	if (action.kind === "list") {
+		return { title: "List", body: action.path ?? action.command };
+	}
+	if (action.kind === "search") {
+		if (action.query && action.path) {
+			return { title: "Search", body: `${action.query} in ${action.path}` };
+		}
+		if (action.query) {
+			return { title: "Search", body: action.query };
+		}
+		return { title: "Search", body: action.command };
+	}
+	return { title: "Run", body: action.command };
+}
+
+function coalesceReads(actions: ShellAction[]): ShellAction[] {
+	if (!actions.every((action) => action.kind !== "run")) return actions;
+	const reads = actions.filter((action): action is Extract<ShellAction, { kind: "read" }> => action.kind === "read");
+	if (reads.length !== actions.length) {
+		return actions;
+	}
+
+	const names = [...new Set(reads.map((action) => action.name))];
+	return [{ kind: "read", command: reads.map((action) => action.command).join(" && "), name: names.join(", "), path: reads[0].path }];
+}