@howaboua/pi-codex-conversion 1.0.0

package/src/patch/parser.ts

@@ -0,0 +1,422 @@
+import { normalizePatchPath } from "./paths.ts";
+import { DiffError, type Chunk, type ParseMode, type ParsedPatchAction, type ParserState, type PatchAction } from "./types.ts";
+
+function parserIsDone({ state, prefixes }: { state: ParserState; prefixes?: string[] }): boolean {
+	if (state.index >= state.lines.length) {
+		return true;
+	}
+	if (prefixes && prefixes.some((prefix) => state.lines[state.index].startsWith(prefix))) {
+		return true;
+	}
+	return false;
+}
+
+function parserStartsWith({ state, prefix }: { state: ParserState; prefix: string }): boolean {
+	if (state.index >= state.lines.length) {
+		throw new DiffError(`Index: ${state.index} >= ${state.lines.length}`);
+	}
+	return state.lines[state.index].startsWith(prefix);
+}
+
+function parserReadStr({
+	state,
+	prefix,
+	returnEverything,
+}: {
+	state: ParserState;
+	prefix?: string;
+	returnEverything?: boolean;
+}): string {
+	if (state.index >= state.lines.length) {
+		throw new DiffError(`Index: ${state.index} >= ${state.lines.length}`);
+	}
+
+	const expectedPrefix = prefix ?? "";
+	if (state.lines[state.index].startsWith(expectedPrefix)) {
+		const text = returnEverything ? state.lines[state.index] : state.lines[state.index].slice(expectedPrefix.length);
+		state.index += 1;
+		return text;
+	}
+	return "";
+}
+
+function splitFileLines(text: string): string[] {
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") {
+		lines.pop();
+	}
+	return lines;
+}
+
+function linesEqual({ left, right }: { left: string[]; right: string[] }): boolean {
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) {
+		if (left[index] !== right[index]) return false;
+	}
+	return true;
+}
+
+function findContextCore({ lines, context, start }: { lines: string[]; context: string[]; start: number }): {
+	newIndex: number;
+	fuzz: number;
+} {
+	if (context.length === 0) {
+		return { newIndex: start, fuzz: 0 };
+	}
+
+	for (let index = start; index < lines.length; index++) {
+		if (linesEqual({ left: lines.slice(index, index + context.length), right: context })) {
+			return { newIndex: index, fuzz: 0 };
+		}
+	}
+
+	for (let index = start; index < lines.length; index++) {
+		const left = lines.slice(index, index + context.length).map((line) => line.trimEnd());
+		const right = context.map((line) => line.trimEnd());
+		if (linesEqual({ left, right })) {
+			return { newIndex: index, fuzz: 1 };
+		}
+	}
+
+	for (let index = start; index < lines.length; index++) {
+		const left = lines.slice(index, index + context.length).map((line) => line.trim());
+		const right = context.map((line) => line.trim());
+		if (linesEqual({ left, right })) {
+			return { newIndex: index, fuzz: 100 };
+		}
+	}
+
+	return { newIndex: -1, fuzz: 0 };
+}
+
+function findContext({
+	lines,
+	context,
+	start,
+	eof,
+}: {
+	lines: string[];
+	context: string[];
+	start: number;
+	eof: boolean;
+}): { newIndex: number; fuzz: number } {
+	if (eof) {
+		const nearEnd = Math.max(lines.length - context.length, 0);
+		const preferred = findContextCore({ lines, context, start: nearEnd });
+		if (preferred.newIndex !== -1) {
+			return preferred;
+		}
+		const fallback = findContextCore({ lines, context, start });
+		return { newIndex: fallback.newIndex, fuzz: fallback.fuzz + 10000 };
+	}
+	return findContextCore({ lines, context, start });
+}
+
+function peekNextSection({ lines, index }: { lines: string[]; index: number }): {
+	nextChunkContext: string[];
+	chunks: Chunk[];
+	endPatchIndex: number;
+	eof: boolean;
+} {
+	const old: string[] = [];
+	let delLines: string[] = [];
+	let insLines: string[] = [];
+	const chunks: Chunk[] = [];
+	let mode: ParseMode = "keep";
+	const origIndex = index;
+
+	while (index < lines.length) {
+		const rawLine = lines[index];
+		if (
+			rawLine.startsWith("@@") ||
+			rawLine.startsWith("*** End Patch") ||
+			rawLine.startsWith("*** Update File:") ||
+			rawLine.startsWith("*** Delete File:") ||
+			rawLine.startsWith("*** Add File:") ||
+			rawLine.startsWith("*** End of File")
+		) {
+			break;
+		}
+
+		if (rawLine === "***") {
+			break;
+		}
+		if (rawLine.startsWith("***")) {
+			throw new DiffError(`Invalid Line: ${rawLine}`);
+		}
+
+		index += 1;
+		const lastMode: ParseMode = mode;
+		let line = rawLine;
+		if (line === "") {
+			line = " ";
+		}
+
+		if (line[0] === "+") {
+			mode = "add";
+		} else if (line[0] === "-") {
+			mode = "delete";
+		} else if (line[0] === " ") {
+			mode = "keep";
+		} else {
+			throw new DiffError(`Invalid Line: ${line}`);
+		}
+
+		const value = line.slice(1);
+		if (mode === "keep" && lastMode !== mode) {
+			if (insLines.length > 0 || delLines.length > 0) {
+				chunks.push({
+					origIndex: old.length - delLines.length,
+					delLines,
+					insLines,
+				});
+			}
+			delLines = [];
+			insLines = [];
+		}
+
+		if (mode === "delete") {
+			delLines.push(value);
+			old.push(value);
+		} else if (mode === "add") {
+			insLines.push(value);
+		} else {
+			old.push(value);
+		}
+	}
+
+	if (insLines.length > 0 || delLines.length > 0) {
+		chunks.push({
+			origIndex: old.length - delLines.length,
+			delLines,
+			insLines,
+		});
+	}
+
+	if (index < lines.length && lines[index] === "*** End of File") {
+		return {
+			nextChunkContext: old,
+			chunks,
+			endPatchIndex: index + 1,
+			eof: true,
+		};
+	}
+
+	if (index === origIndex) {
+		throw new DiffError(`Nothing in this section - index=${index} ${lines[index] ?? ""}`);
+	}
+
+	return {
+		nextChunkContext: old,
+		chunks,
+		endPatchIndex: index,
+		eof: false,
+	};
+}
+
+function parseAddFile({ state }: { state: ParserState }): PatchAction {
+	const lines: string[] = [];
+	while (
+		!parserIsDone({
+			state,
+			prefixes: ["*** End Patch", "*** Update File:", "*** Delete File:", "*** Add File:"],
+		})
+	) {
+		const value = parserReadStr({ state, prefix: "" });
+		if (!value.startsWith("+")) {
+			throw new DiffError(`Invalid Add File Line: ${value}`);
+		}
+		lines.push(value.slice(1));
+	}
+
+	return {
+		type: "add",
+		newFile: lines.length === 0 ? "" : `${lines.join("\n")}\n`,
+		chunks: [],
+	};
+}
+
+export function parseUpdateFile({ state, text, path }: { state: ParserState; text: string; path: string }): PatchAction {
+	const action: PatchAction = {
+		type: "update",
+		chunks: [],
+	};
+
+	const lines = splitFileLines(text);
+	let index = 0;
+
+	while (
+		!parserIsDone({
+			state,
+			prefixes: ["*** End Patch", "*** Update File:", "*** Delete File:", "*** Add File:", "*** End of File"],
+		})
+	) {
+		const defStr = parserReadStr({ state, prefix: "@@ " });
+		let sectionStr = "";
+		if (!defStr && state.index < state.lines.length && state.lines[state.index] === "@@") {
+			sectionStr = state.lines[state.index];
+			state.index += 1;
+		}
+
+		if (!(defStr || sectionStr || index === 0)) {
+			throw new DiffError(`Invalid Line:\n${state.lines[state.index]}`);
+		}
+
+		if (defStr.trim().length > 0) {
+			let found = false;
+
+			const exactAlreadySeen = lines.slice(0, index).some((line) => line === defStr);
+			if (!exactAlreadySeen) {
+				for (let lineIndex = index; lineIndex < lines.length; lineIndex++) {
+					if (lines[lineIndex] === defStr) {
+						index = lineIndex + 1;
+						found = true;
+						break;
+					}
+				}
+			}
+
+			if (!found) {
+				const trimAlreadySeen = lines.slice(0, index).some((line) => line.trim() === defStr.trim());
+				if (!trimAlreadySeen) {
+					for (let lineIndex = index; lineIndex < lines.length; lineIndex++) {
+						if (lines[lineIndex].trim() === defStr.trim()) {
+							index = lineIndex + 1;
+							state.fuzz += 1;
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		const { nextChunkContext, chunks, endPatchIndex, eof } = peekNextSection({ lines: state.lines, index: state.index });
+		const nextChunkText = nextChunkContext.join("\n");
+		const { newIndex, fuzz } = findContext({
+			lines,
+			context: nextChunkContext,
+			start: index,
+			eof,
+		});
+
+		if (newIndex === -1) {
+			throw new DiffError(`Failed to find expected lines in ${path}:\n${nextChunkText}`);
+		}
+
+		state.fuzz += fuzz;
+
+		for (const chunk of chunks) {
+			action.chunks.push({
+				origIndex: chunk.origIndex + newIndex,
+				delLines: chunk.delLines,
+				insLines: chunk.insLines,
+			});
+		}
+
+		index = newIndex + nextChunkContext.length;
+		state.index = endPatchIndex;
+	}
+
+	return action;
+}
+
+const VALID_HUNK_HEADERS = [
+	"'*** Add File: {path}'",
+	"'*** Delete File: {path}'",
+	"'*** Update File: {path}'",
+].join(", ");
+
+export function parsePatchActions({ text }: { text: string }): ParsedPatchAction[] {
+	const lines = text.trim().split("\n");
+	if (lines.length < 2 || !lines[0].startsWith("*** Begin Patch") || lines[lines.length - 1] !== "*** End Patch") {
+		throw new DiffError("Invalid patch text");
+	}
+
+	const actions: ParsedPatchAction[] = [];
+	const seenPaths = new Set<string>();
+	let index = 1;
+
+	while (index < lines.length - 1) {
+		const line = lines[index];
+		const lineNumber = index + 1;
+
+		if (line.startsWith("*** Update File: ")) {
+			const updatePath = normalizePatchPath({ path: line.slice("*** Update File: ".length) });
+			if (seenPaths.has(updatePath)) {
+				throw new DiffError(`Update File Error: Duplicate Path: ${updatePath}`);
+			}
+			seenPaths.add(updatePath);
+			index += 1;
+			let movePath: string | undefined;
+			if (index < lines.length - 1 && lines[index].startsWith("*** Move to: ")) {
+				movePath = normalizePatchPath({ path: lines[index].slice("*** Move to: ".length) });
+				index += 1;
+			}
+			const bodyStart = index;
+			while (
+				index < lines.length - 1 &&
+				!lines[index].startsWith("*** Update File: ") &&
+				!lines[index].startsWith("*** Delete File: ") &&
+				!lines[index].startsWith("*** Add File: ")
+			) {
+				index += 1;
+			}
+			const bodyLines = lines.slice(bodyStart, index);
+			if (bodyLines.length === 0) {
+				throw new DiffError(`Invalid patch hunk on line ${lineNumber}: Update file hunk for path '${updatePath}' is empty`);
+			}
+			actions.push({
+				type: "update",
+				path: updatePath,
+				movePath,
+				lines: bodyLines,
+			});
+			continue;
+		}
+
+		if (line.startsWith("*** Delete File: ")) {
+			const deletePath = normalizePatchPath({ path: line.slice("*** Delete File: ".length) });
+			if (seenPaths.has(deletePath)) {
+				throw new DiffError(`Delete File Error: Duplicate Path: ${deletePath}`);
+			}
+			seenPaths.add(deletePath);
+			actions.push({
+				type: "delete",
+				path: deletePath,
+			});
+			index += 1;
+			continue;
+		}
+
+		if (line.startsWith("*** Add File: ")) {
+			const addPath = normalizePatchPath({ path: line.slice("*** Add File: ".length) });
+			if (seenPaths.has(addPath)) {
+				throw new DiffError(`Add File Error: Duplicate Path: ${addPath}`);
+			}
+			seenPaths.add(addPath);
+			const state: ParserState = {
+				lines,
+				index: index + 1,
+				fuzz: 0,
+			};
+			const action = parseAddFile({ state });
+			actions.push({
+				type: "add",
+				path: addPath,
+				newFile: action.newFile,
+			});
+			index = state.index;
+			continue;
+		}
+
+		throw new DiffError(
+			`Invalid patch hunk on line ${lineNumber}: '${line}' is not a valid hunk header. Valid hunk headers: ${VALID_HUNK_HEADERS}`,
+		);
+	}
+
+	if (actions.length === 0) {
+		throw new DiffError("No files were modified.");
+	}
+
+	return actions;
+}

package/src/patch/paths.ts

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { DiffError } from "./types.ts";
+
+export function normalizePatchPath({ path }: { path: string }): string {
+	const trimmed = path.trim();
+	const withoutAt = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+	return withoutAt.replace(/^['"]|['"]$/g, "");
+}
+
+// Patch paths are intentionally confined to ctx.cwd so the adapter cannot write
+// outside the active workspace even if the incoming patch text is malicious.
+export function resolvePatchPath({ cwd, patchPath }: { cwd: string; patchPath: string }): string {
+	const normalized = normalizePatchPath({ path: patchPath });
+	if (!normalized) {
+		throw new DiffError("Patch path cannot be empty");
+	}
+	if (isAbsolute(normalized)) {
+		throw new DiffError("We do not support absolute paths.");
+	}
+
+	const absolutePath = resolve(cwd, normalized);
+	const rel = relative(cwd, absolutePath);
+	if (rel.startsWith("..") || isAbsolute(rel)) {
+		throw new DiffError(`Path escapes working directory: ${normalized}`);
+	}
+	return absolutePath;
+}
+
+export function openFileAtPath({ cwd, path }: { cwd: string; path: string }): string {
+	const absolutePath = resolvePatchPath({ cwd, patchPath: path });
+	if (!existsSync(absolutePath)) {
+		throw new DiffError(`File not found: ${path}`);
+	}
+	return readFileSync(absolutePath, "utf8");
+}
+
+export function writeFileAtPath({ cwd, path, content }: { cwd: string; path: string; content: string }): { created: boolean } {
+	const absolutePath = resolvePatchPath({ cwd, patchPath: path });
+	const created = !existsSync(absolutePath);
+	mkdirSync(dirname(absolutePath), { recursive: true });
+	writeFileSync(absolutePath, content, "utf8");
+	return { created };
+}
+
+export function removeFileAtPath({ cwd, path }: { cwd: string; path: string }): void {
+	const absolutePath = resolvePatchPath({ cwd, patchPath: path });
+	if (!existsSync(absolutePath)) {
+		throw new DiffError(`File not found: ${path}`);
+	}
+	unlinkSync(absolutePath);
+}
+
+export function pathExists({ cwd, path }: { cwd: string; path: string }): boolean {
+	return existsSync(resolvePatchPath({ cwd, patchPath: path }));
+}

package/src/patch/types.ts

@@ -0,0 +1,44 @@
+export type ActionType = "add" | "delete" | "update";
+export type ParseMode = "keep" | "add" | "delete";
+
+export interface Chunk {
+	origIndex: number;
+	delLines: string[];
+	insLines: string[];
+}
+
+export interface PatchAction {
+	type: ActionType;
+	newFile?: string;
+	chunks: Chunk[];
+	movePath?: string;
+}
+
+export interface ParsedPatchAction {
+	type: ActionType;
+	path: string;
+	newFile?: string;
+	lines?: string[];
+	movePath?: string;
+}
+
+export interface ParserState {
+	lines: string[];
+	index: number;
+	fuzz: number;
+}
+
+export interface ExecutePatchResult {
+	changedFiles: string[];
+	createdFiles: string[];
+	deletedFiles: string[];
+	movedFiles: string[];
+	fuzz: number;
+}
+
+export class DiffError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "DiffError";
+	}
+}

package/src/prompt/build-system-prompt.ts

@@ -0,0 +1,111 @@
+export interface PromptSkill {
+	name: string;
+	description: string;
+	filePath: string;
+}
+
+const PI_INTRO =
+	"You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
+const CODEX_INTRO =
+	"You are Codex running inside pi, a coding agent harness. Work directly in the user's workspace and finish the task end-to-end when feasible.";
+
+const CODEX_GUIDELINES = [
+	"Use `parallel` only when tool calls are independent and can safely run at the same time.",
+	"Use `write_stdin` when an exec session returns `session_id`, and continue until `exit_code` is present.",
+	"Do not request `tty` unless interactive terminal behavior is required.",
+];
+
+function rewriteIntro(prompt: string): string {
+	if (!prompt.startsWith(PI_INTRO)) {
+		return prompt;
+	}
+	return `${CODEX_INTRO}${prompt.slice(PI_INTRO.length)}`;
+}
+
+function insertBeforeTrailingContext(prompt: string, section: string): string {
+	const currentDateIndex = prompt.lastIndexOf("\nCurrent date:");
+	if (currentDateIndex !== -1) {
+		return `${prompt.slice(0, currentDateIndex)}\n\n${section}${prompt.slice(currentDateIndex)}`;
+	}
+	return `${prompt}\n\n${section}`;
+}
+
+function decodeXml(text: string): string {
+	return text
+		.replace(/'/g, "'")
+		.replace(/"/g, '"')
+		.replace(/>/g, ">")
+		.replace(/&lt;/g, "<")
+		.replace(/&amp;/g, "&");
+}
+
+export function extractPiPromptSkills(prompt: string): PromptSkill[] {
+	const skillsBlockMatch = prompt.match(/<available_skills>\n([\s\S]*?)\n<\/available_skills>/);
+	if (!skillsBlockMatch) {
+		return [];
+	}
+
+	const skillMatches = skillsBlockMatch[1].matchAll(
+		/<skill>\n\s*<name>([\s\S]*?)<\/name>\n\s*<description>([\s\S]*?)<\/description>\n\s*<location>([\s\S]*?)<\/location>\n\s*<\/skill>/g,
+	);
+
+	return Array.from(skillMatches, (match) => ({
+		name: decodeXml(match[1].trim()),
+		description: decodeXml(match[2].trim()),
+		filePath: decodeXml(match[3].trim()),
+	}));
+}
+
+function injectSkills(prompt: string, skills: PromptSkill[]): string {
+	if (skills.length === 0 || /\n## Skills\b/.test(prompt) || /<skills_instructions>/.test(prompt)) {
+		return prompt;
+	}
+
+	const lines = [
+		"<skills_instructions>",
+		"## Skills",
+		"A skill is a set of local instructions in a `SKILL.md` file.",
+		"### Available skills",
+	];
+
+	for (const skill of skills) {
+		lines.push(`- ${skill.name}: ${skill.description} (file: ${skill.filePath})`);
+	}
+
+	lines.push("### How to use skills");
+	lines.push("- Use a skill when the user names it (`$SkillName` or plain text) or when the request clearly matches its description.");
+	lines.push("- Use the minimal required set of skills. If multiple apply, use them together and state the order briefly.");
+	lines.push("- For each selected skill, open its `SKILL.md`, resolve relative paths from the skill directory first, load only the files you need, and prefer existing scripts/assets/templates over recreating them.");
+	lines.push("### Fallback");
+	lines.push("- If a skill is missing or its path cannot be read, say so briefly and continue with the best fallback approach.");
+	lines.push("</skills_instructions>");
+
+	return insertBeforeTrailingContext(prompt, lines.join("\n"));
+}
+
+function injectGuidelines(prompt: string): string {
+	const match = prompt.match(/(^Guidelines:\n)([\s\S]*?)(\n\n(?:Pi documentation:|# Project Context|# Skills|Current date:))/m);
+	if (!match || match.index === undefined) {
+		const fallbackSection = `Codex mode guidelines:\n${CODEX_GUIDELINES.map((line) => `- ${line}`).join("\n")}`;
+		return insertBeforeTrailingContext(prompt, fallbackSection);
+	}
+
+	const [, header, body, suffix] = match;
+	const existingLines = body
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.startsWith("- "));
+	const existing = new Set(existingLines.map((line) => line.slice(2)));
+	const additions = CODEX_GUIDELINES.filter((line) => !existing.has(line)).map((line) => `- ${line}`);
+	if (additions.length === 0) {
+		return prompt;
+	}
+
+	const normalizedBody = body.trimEnd();
+	const replacement = `${header}${normalizedBody}\n${additions.join("\n")}${suffix}`;
+	return `${prompt.slice(0, match.index)}${replacement}${prompt.slice(match.index + match[0].length)}`;
+}
+
+export function buildCodexSystemPrompt(basePrompt: string, options: { skills?: PromptSkill[] } = {}): string {
+	return injectSkills(injectGuidelines(rewriteIntro(basePrompt)), options.skills ?? []);
+}