@oh-my-pi/pi-coding-agent 14.1.2 → 14.2.1

package/src/discovery/claude-plugins.ts

@@ -28,6 +28,58 @@ const PROVIDER_ID = "claude-plugins";
 const DISPLAY_NAME = "Claude Code Marketplace";
 const PRIORITY = 70; // Below claude.ts (80) so user .claude/ overrides win
 
+interface ClaudePluginManifest {
+	skills?: string;
+	"slash-commands"?: string;
+}
+
+interface ResolvedPluginDir {
+	dir: string;
+	warning?: string;
+}
+
+async function readPluginManifest(root: ClaudePluginRoot): Promise<ClaudePluginManifest | null> {
+	const manifestPath = path.join(root.path, ".claude-plugin", "plugin.json");
+	const raw = await readFile(manifestPath);
+	if (raw === null) return null;
+
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		return parsed as ClaudePluginManifest;
+	} catch {
+		return null;
+	}
+}
+
+function isWithinPluginRoot(rootPath: string, targetPath: string): boolean {
+	const relative = path.relative(rootPath, targetPath);
+	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function resolvePluginDir(
+	root: ClaudePluginRoot,
+	manifestKey: keyof ClaudePluginManifest,
+	fallback: string,
+): Promise<ResolvedPluginDir> {
+	const manifest = await readPluginManifest(root);
+	const fallbackDir = path.join(root.path, fallback);
+	const configured = manifest?.[manifestKey];
+	if (typeof configured !== "string" || !configured.trim()) {
+		return { dir: fallbackDir };
+	}
+
+	const resolved = path.resolve(root.path, configured.trim());
+	if (isWithinPluginRoot(root.path, resolved)) {
+		return { dir: resolved };
+	}
+
+	return {
+		dir: fallbackDir,
+		warning: `[claude-plugins] Ignoring ${String(manifestKey)} path outside plugin root for ${root.id}: ${configured}`,
+	};
+}
+
 // =============================================================================
 // Skills
 // =============================================================================
@@ -41,17 +93,18 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const skillsDir = path.join(root.path, "skills");
+			const { dir: skillsDir, warning } = await resolvePluginDir(root, "skills", "skills");
 			const result = await scanSkillsFromDir(ctx, {
 				dir: skillsDir,
 				providerId: PROVIDER_ID,
 				level: root.scope,
 			});
-			return { root, result };
+			return { root, result, warning };
 		}),
 	);
 
-	for (const { root, result } of results) {
+	for (const { root, result, warning } of results) {
+		if (warning) warnings.push(warning);
 		for (const skill of result.items) {
 			if (root.plugin) skill.name = `${root.plugin}:${skill.name}`;
 			items.push(skill);
@@ -75,8 +128,8 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 	const results = await Promise.all(
 		roots.map(async root => {
-			const commandsDir = path.join(root.path, "commands");
-			return loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
+			const { dir: commandsDir, warning } = await resolvePluginDir(root, "slash-commands", "commands");
+			const result = await loadFilesFromDir<SlashCommand>(ctx, commandsDir, PROVIDER_ID, root.scope, {
 				extensions: ["md"],
 				transform: (name, content, filePath, source) => {
 					const cmdName = name.replace(/\.md$/, "");
@@ -89,10 +142,12 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 					};
 				},
 			});
+			return { result, warning };
 		}),
 	);
 
-	for (const result of results) {
+	for (const { result, warning } of results) {
+		if (warning) warnings.push(warning);
 		items.push(...result.items);
 		if (result.warnings) warnings.push(...result.warnings);
 	}

package/src/discovery/codex.ts

@@ -30,9 +30,9 @@ import { toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
 import {
+	buildExtensionModuleItems,
 	createSourceMeta,
 	discoverExtensionModulePaths,
-	getExtensionNameFromPath,
 	loadFilesFromDir,
 	SOURCE_PATHS,
 	scanSkillsFromDir,
@@ -251,20 +251,7 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 		discoverExtensionModulePaths(ctx, projectExtensionsDir),
 	]);
 
-	const items: ExtensionModule[] = [
-		...userPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "user" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
-		})),
-		...projectPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "project" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
-		})),
-	];
+	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
 
 	return { items, warnings };
 }

package/src/discovery/gemini.ts

@@ -27,11 +27,11 @@ import { type Settings, settingsCapability } from "../capability/settings";
 import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
 import type { LoadContext, LoadResult } from "../capability/types";
 import {
+	buildExtensionModuleItems,
 	calculateDepth,
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	expandEnvVarsDeep,
-	getExtensionNameFromPath,
 	getProjectPath,
 	getUserPath,
 } from "./helpers";
@@ -238,20 +238,7 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 		projectExtensionsDir ? discoverExtensionModulePaths(ctx, projectExtensionsDir) : Promise.resolve([]),
 	]);
 
-	const items: ExtensionModule[] = [
-		...userPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "user" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
-		})),
-		...projectPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "project" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
-		})),
-	];
+	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
 
 	return { items, warnings: [] };
 }

package/src/discovery/helpers.ts

@@ -4,7 +4,8 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { CONFIG_DIR_NAME, getConfigDirName, getProjectDir, parseFrontmatter, tryParseJson } from "@oh-my-pi/pi-utils";
-import { readDirEntries, readFile } from "../capability/fs";
+import type { ExtensionModule } from "../capability/extension-module";
+import { invalidate as invalidateFsCache, readDirEntries, readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
@@ -581,6 +582,31 @@ export function getExtensionNameFromPath(extensionPath: string): string {
 	return base;
 }
 
+/**
+ * Build ExtensionModule items from discovered user/project paths.
+ * Shared across providers that expose extension modules via user + project dirs.
+ */
+export function buildExtensionModuleItems(
+	providerId: string,
+	userPaths: string[],
+	projectPaths: string[],
+): ExtensionModule[] {
+	return [
+		...userPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "user" as const,
+			_source: createSourceMeta(providerId, extPath, "user"),
+		})),
+		...projectPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "project" as const,
+			_source: createSourceMeta(providerId, extPath, "project"),
+		})),
+	];
+}
+
 // =============================================================================
 // Claude Code Plugin Cache Helpers
 // =============================================================================
@@ -896,6 +922,19 @@ export function clearClaudePluginRootsCache(): void {
 	}
 }
 
+/**
+ * Invalidate fs caches for installed-plugin registry files and reset the
+ * in-memory plugin roots cache. Used by MarketplaceManager clients after
+ * installing/uninstalling/enabling/disabling plugins.
+ */
+export function clearPluginRootsAndCaches(extraPaths?: readonly string[]): void {
+	const home = os.homedir();
+	invalidateFsCache(path.join(home, ".claude", "plugins", "installed_plugins.json"));
+	invalidateFsCache(path.join(home, getConfigDirName(), "plugins", "installed_plugins.json"));
+	for (const p of extraPaths ?? []) invalidateFsCache(p);
+	clearClaudePluginRootsCache();
+}
+
 // ── Preloaded plugin roots (for sync consumers like LSP config) ─────────────
 // Populated at startup by preloadPluginRoots(). Read synchronously by
 // getPreloadedPluginRoots(). Safe degradation: empty array if not warmed.

package/src/discovery/opencode.ts

@@ -28,10 +28,10 @@ import { type SlashCommand, slashCommandCapability } from "../capability/slash-c
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
 import {
+	buildExtensionModuleItems,
 	createSourceMeta,
 	discoverExtensionModulePaths,
 	expandEnvVarsDeep,
-	getExtensionNameFromPath,
 	getProjectPath,
 	getUserPath,
 	loadFilesFromDir,
@@ -227,20 +227,7 @@ async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<Extens
 		projectPluginsDir ? discoverExtensionModulePaths(ctx, projectPluginsDir) : Promise.resolve([]),
 	]);
 
-	const items: ExtensionModule[] = [
-		...userPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "user" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
-		})),
-		...projectPaths.map(extPath => ({
-			name: getExtensionNameFromPath(extPath),
-			path: extPath,
-			level: "project" as const,
-			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
-		})),
-	];
+	const items = buildExtensionModuleItems(PROVIDER_ID, userPaths, projectPaths);
 
 	return { items, warnings: [] };
 }

package/src/edit/apply-patch/index.ts

@@ -0,0 +1,87 @@
+/**
+ * Multi-file orchestrator for the Codex `apply_patch` envelope.
+ *
+ * Decoupled from tool-registration: takes raw patch text + options, parses
+ * it, and applies each hunk via the existing single-file `applyPatch` in
+ * `../modes/patch.ts`. A future OpenAI freeform/grammar tool variant can
+ * call this directly with the raw grammar output.
+ *
+ * Per spec §6.1, hunks are applied in order and NOT atomically — if hunk
+ * N fails, hunks `0..N-1` are already on disk. We surface that by
+ * returning the per-file results alongside the error when it happens.
+ */
+
+import { ApplyPatchError } from "../diff";
+import { type ApplyPatchOptions, type ApplyPatchResult, applyPatch, type PatchInput } from "../modes/patch";
+import { parseApplyPatch } from "./parser";
+
+export * from "./parser";
+
+export interface ApplyCodexPatchResult {
+	/** Single-file apply results in the order they were attempted. */
+	results: ApplyPatchResult[];
+	/** Affected file paths grouped by operation, for the §9.1 summary. */
+	affected: {
+		added: string[];
+		modified: string[];
+		deleted: string[];
+	};
+}
+
+/**
+ * Apply a full Codex `*** Begin Patch` envelope.
+ *
+ * Note: renames are reported under `modified` with the original path (spec
+ * §9.1), not as a delete + add.
+ */
+export async function applyCodexPatch(patchText: string, options: ApplyPatchOptions): Promise<ApplyCodexPatchResult> {
+	const hunks = parseApplyPatch(patchText);
+
+	if (hunks.length === 0) {
+		throw new ApplyPatchError("No files were modified.");
+	}
+
+	const results: ApplyPatchResult[] = [];
+	const affected = {
+		added: [] as string[],
+		modified: [] as string[],
+		deleted: [] as string[],
+	};
+
+	for (const hunk of hunks) {
+		const result = await applyPatch(hunk, options);
+		results.push(result);
+		recordAffected(affected, hunk, result);
+	}
+
+	return { results, affected };
+}
+
+function recordAffected(
+	affected: ApplyCodexPatchResult["affected"],
+	hunk: PatchInput,
+	_result: ApplyPatchResult,
+): void {
+	switch (hunk.op) {
+		case "create":
+			affected.added.push(hunk.path);
+			break;
+		case "delete":
+			affected.deleted.push(hunk.path);
+			break;
+		case "update":
+			affected.modified.push(hunk.path);
+			break;
+	}
+}
+
+/**
+ * Format the A/M/D summary described in spec §9.1.
+ */
+export function formatApplyCodexPatchSummary(affected: ApplyCodexPatchResult["affected"]): string {
+	const lines = ["Success. Updated the following files:"];
+	for (const p of affected.added) lines.push(`A ${p}`);
+	for (const p of affected.modified) lines.push(`M ${p}`);
+	for (const p of affected.deleted) lines.push(`D ${p}`);
+	return lines.join("\n");
+}

package/src/edit/apply-patch/parser.ts

@@ -0,0 +1,174 @@
+/**
+ * Parser for the Codex `apply_patch` envelope format.
+ *
+ *     *** Begin Patch
+ *     *** Add File: <path>
+ *     +<line>
+ *     *** Delete File: <path>
+ *     *** Update File: <path>
+ *     *** Move to: <newpath>
+ *     @@ <optional context>
+ *     -old
+ *     +new
+ *      context
+ *     *** End of File
+ *     *** End Patch
+ *
+ * Input is the full envelope text (optionally heredoc-wrapped). Output is a
+ * list of `PatchInput` records, each ready to hand to the existing
+ * single-file `applyPatch()` in `../modes/patch.ts`.
+ *
+ * Per spec §4.3 Lenient mode: a `<<EOF` / `<<'EOF'` / `<<"EOF"` heredoc
+ * wrapper around the whole envelope is stripped before parsing.
+ */
+
+import { ParseError } from "../diff";
+import type { PatchInput } from "../modes/patch";
+
+const BEGIN_PATCH_MARKER = "*** Begin Patch";
+const END_PATCH_MARKER = "*** End Patch";
+const ADD_FILE_MARKER = "*** Add File: ";
+const DELETE_FILE_MARKER = "*** Delete File: ";
+const UPDATE_FILE_MARKER = "*** Update File: ";
+const MOVE_TO_MARKER = "*** Move to: ";
+
+interface ParseApplyPatchOptions {
+	streaming?: boolean;
+}
+
+/**
+ * Parse a Codex `*** Begin Patch` envelope into a list of single-file
+ * patch inputs.
+ */
+export function parseApplyPatch(patchText: string): PatchInput[] {
+	return parseApplyPatchWithOptions(patchText, {});
+}
+
+/**
+ * Best-effort parser for in-progress TUI previews. It tolerates missing
+ * envelope markers and incomplete trailing hunks; do not use it to apply edits.
+ */
+export function parseApplyPatchStreaming(patchText: string): PatchInput[] {
+	return parseApplyPatchWithOptions(patchText, { streaming: true });
+}
+
+function parseApplyPatchWithOptions(patchText: string, options: ParseApplyPatchOptions): PatchInput[] {
+	const streaming = options.streaming === true;
+	let lines = patchText.trim().split("\n");
+
+	// Lenient heredoc strip: <<EOF / <<'EOF' / <<"EOF" ... EOF
+	if (lines.length >= 2) {
+		const first = lines[0];
+		const last = lines[lines.length - 1].trim();
+		const validOpeners = new Set(["<<EOF", "<<'EOF'", '<<"EOF"']);
+		if (validOpeners.has(first) && last === "EOF") {
+			lines = lines.slice(1, lines.length - 1);
+		}
+	}
+
+	if (lines.length === 0 || lines[0].trim() !== BEGIN_PATCH_MARKER) {
+		if (streaming) return [];
+		throw new ParseError("The first line of the patch must be '*** Begin Patch'");
+	}
+	const hasEndMarker = lines[lines.length - 1].trim() === END_PATCH_MARKER;
+	if (!hasEndMarker && !streaming) {
+		throw new ParseError("The last line of the patch must be '*** End Patch'");
+	}
+
+	const hunks: PatchInput[] = [];
+	let remaining = hasEndMarker ? lines.slice(1, lines.length - 1) : lines.slice(1);
+	// Line numbers are 1-based and include the `*** Begin Patch` line (= 1).
+	let lineNumber = 2;
+
+	while (remaining.length > 0) {
+		// Blank separator lines between hunks are ignored (spec §3.3).
+		if (remaining[0].trim() === "") {
+			remaining = remaining.slice(1);
+			lineNumber++;
+			continue;
+		}
+
+		const firstLine = remaining[0].trim();
+
+		if (firstLine.startsWith(ADD_FILE_MARKER)) {
+			const path = firstLine.slice(ADD_FILE_MARKER.length);
+			let contents = "";
+			let consumed = 1;
+
+			for (let i = 1; i < remaining.length; i++) {
+				const line = remaining[i];
+				if (line.startsWith("+")) {
+					contents += `${line.slice(1)}\n`;
+					consumed++;
+				} else {
+					break;
+				}
+			}
+
+			hunks.push({ path, op: "create", diff: contents });
+			remaining = remaining.slice(consumed);
+			lineNumber += consumed;
+			continue;
+		}
+
+		if (firstLine.startsWith(DELETE_FILE_MARKER)) {
+			const path = firstLine.slice(DELETE_FILE_MARKER.length);
+			hunks.push({ path, op: "delete" });
+			remaining = remaining.slice(1);
+			lineNumber++;
+			continue;
+		}
+
+		if (firstLine.startsWith(UPDATE_FILE_MARKER)) {
+			const path = firstLine.slice(UPDATE_FILE_MARKER.length);
+			remaining = remaining.slice(1);
+			lineNumber++;
+
+			let movePath: string | undefined;
+			if (remaining.length > 0 && remaining[0].startsWith(MOVE_TO_MARKER)) {
+				movePath = remaining[0].slice(MOVE_TO_MARKER.length);
+				remaining = remaining.slice(1);
+				lineNumber++;
+			}
+
+			// The body runs until the next file-op marker or end of input.
+			// `*** End of File` is a chunk-terminator and stays inside the body —
+			// the downstream unified-diff parser handles it.
+			const diffLines: string[] = [];
+			while (remaining.length > 0) {
+				const line = remaining[0];
+				if (
+					line.startsWith("*** Add File:") ||
+					line.startsWith("*** Delete File:") ||
+					line.startsWith("*** Update File:")
+				) {
+					break;
+				}
+				diffLines.push(line);
+				remaining = remaining.slice(1);
+				lineNumber++;
+			}
+
+			if (diffLines.length === 0) {
+				if (streaming) {
+					hunks.push({ path, op: "update", rename: movePath, diff: "" });
+					continue;
+				}
+				throw new ParseError(`Update file hunk for path '${path}' is empty`, lineNumber);
+			}
+
+			hunks.push({ path, op: "update", rename: movePath, diff: diffLines.join("\n") });
+			continue;
+		}
+
+		if (streaming) {
+			break;
+		}
+		throw new ParseError(
+			`'${firstLine}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`,
+			lineNumber,
+		);
+	}
+
+	return hunks;
+}

package/src/edit/diff.ts

@@ -4,11 +4,11 @@
  * Provides diff string generation and the replace-mode edit logic
  * used when not in patch mode.
  */
-import { isEnoent } from "@oh-my-pi/pi-utils";
 import * as Diff from "diff";
 import { resolveToCwd } from "../tools/path-utils";
 import { DEFAULT_FUZZY_THRESHOLD, EditMatchError, findMatch } from "./modes/replace";
 import { adjustIndentation, normalizeToLF, stripBom } from "./normalize";
+import { readEditFileText } from "./read-file";
 
 export interface DiffResult {
 	diff: string;
@@ -275,17 +275,6 @@ function formatOccurrenceMatchError(
 	return `Found ${occurrences} occurrences${pathSuffix}${moreMsg}:\n\n${previews}\n\nAdd more context lines to disambiguate.`;
 }
 
-async function readFileTextForDiff(path: string, absolutePath: string): Promise<string> {
-	try {
-		return await Bun.file(absolutePath).text();
-	} catch (error) {
-		if (isEnoent(error)) {
-			throw new Error(`File not found: ${path}`);
-		}
-		throw error;
-	}
-}
-
 export function normalizeDiff(diff: string): string {
 	let lines = diff.split("\n");
 
@@ -761,12 +750,12 @@ export async function computeEditDiff(
 	if (oldText.length === 0) {
 		return { error: "oldText must not be empty." };
 	}
-	const absolutePath = resolveToCwd(path, cwd);
 
 	try {
+		const absolutePath = resolveToCwd(path, cwd);
 		let rawContent: string;
 		try {
-			rawContent = await readFileTextForDiff(path, absolutePath);
+			rawContent = await readEditFileText(absolutePath, path);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			return { error: message || `Unable to read ${path}` };