@oh-my-pi/pi-coding-agent 16.3.6 → 16.3.7

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -17,9 +17,18 @@ import * as path from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { TSchema } from "@oh-my-pi/pi-ai";
 import { Text } from "@oh-my-pi/pi-tui";
-import { parseFrontmatter as parseOmpFrontmatter } from "@oh-my-pi/pi-utils";
+import { getAgentDir, getProjectDir, parseFrontmatter as parseOmpFrontmatter } from "@oh-my-pi/pi-utils";
+import type { PromptTemplate } from "../config/prompt-templates";
 import { type SettingPath, Settings } from "../config/settings";
 import { EditTool } from "../edit";
+import type { CreateAgentSessionOptions, CreateAgentSessionResult, LoadExtensionsResult } from "../sdk";
+import {
+	discoverContextFiles,
+	discoverPromptTemplates,
+	discoverSessionExtensionPaths,
+	discoverSkills,
+	createAgentSession as ompCreateAgentSession,
+} from "../sdk";
 import {
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
@@ -34,7 +43,12 @@ import { GrepTool } from "../tools/grep";
 import { ReadTool } from "../tools/read";
 import { formatBytes } from "../tools/render-utils";
 import { WriteTool } from "../tools/write";
-import type { ToolDefinition } from "./extensions/types";
+import { EventBus } from "../utils/event-bus";
+import { loadExtensionFromFactory, loadExtensions } from "./extensions";
+import { ExtensionRuntime } from "./extensions/loader";
+import type { ExtensionFactory, ToolDefinition } from "./extensions/types";
+import type { Skill } from "./skills";
+import { loadSkillsFromDir } from "./skills";
 import { Type } from "./typebox";
 
 const TOOL_DEFINITION_MARKER = "__isToolDefinition";
@@ -641,6 +655,544 @@ export const SettingsManager = {
 	},
 } as const;
 
+/**
+ * Resource-loader compatibility layer for legacy pi extensions.
+ *
+ * Upstream `@earendil-works/pi-coding-agent` centralizes extension / skill /
+ * prompt / theme / AGENTS.md discovery inside a `DefaultResourceLoader`
+ * instance that the caller constructs, `reload()`s, and hands to
+ * `createAgentSession({ resourceLoader })`. Every published version of
+ * pi-schedule-prompt (≥0.2.0) and other pi extensions that spawn subagents
+ * import the class at module scope; a missing export takes the whole
+ * extension down at parse time (issue #4567).
+ *
+ * OMP does the same discovery inline inside `createAgentSession()`, so this
+ * shim intentionally does NOT re-implement pi's ResourceLoader plumbing.
+ * Instead the loader captures the caller's intent (`no*` flags, `*Override`
+ * callbacks, `additional*Paths`, `extensionFactories`, `settingsManager`,
+ * `eventBus`) plus the discovery results, and the sibling `createAgentSession`
+ * override below translates them into OMP's native session options
+ * (`disableExtensionDiscovery`, `preloadedExtensionPaths`, `extensions`,
+ * `skills`, `promptTemplates`, `contextFiles`, `settings`, `eventBus`,
+ * `systemPrompt`) before delegating to `../sdk`.
+ *
+ * The pi surface it emulates is the intersection actually used by real
+ * extensions in the wild — themes are silently dropped (OMP has no
+ * session-level themes surface); `extendResources`, `loadProjectTrustExtensions`,
+ * and provider-trust hooks are omitted.
+ */
+
+export type ResourceDiagnostic = {
+	type: "error" | "warning" | "info";
+	message: string;
+	path?: string;
+};
+
+export interface AgentsFile {
+	path: string;
+	content: string;
+}
+
+/** Marker interface preserved for pi extensions that type against upstream. */
+export interface Theme {
+	name: string;
+}
+
+export interface DefaultResourceLoaderOptions {
+	cwd?: string;
+	agentDir?: string;
+	settingsManager?: Settings | Promise<Settings>;
+	eventBus?: EventBus;
+	additionalExtensionPaths?: string[];
+	additionalSkillPaths?: string[];
+	additionalPromptTemplatePaths?: string[];
+	additionalThemePaths?: string[];
+	extensionFactories?: ExtensionFactory[];
+	noExtensions?: boolean;
+	noSkills?: boolean;
+	noPromptTemplates?: boolean;
+	noThemes?: boolean;
+	noContextFiles?: boolean;
+	systemPrompt?: string;
+	appendSystemPrompt?: string | string[];
+	extensionsOverride?: (base: LoadExtensionsResult) => LoadExtensionsResult;
+	skillsOverride?: (base: { skills: Skill[]; diagnostics: ResourceDiagnostic[] }) => {
+		skills: Skill[];
+		diagnostics: ResourceDiagnostic[];
+	};
+	promptsOverride?: (base: { prompts: PromptTemplate[]; diagnostics: ResourceDiagnostic[] }) => {
+		prompts: PromptTemplate[];
+		diagnostics: ResourceDiagnostic[];
+	};
+	themesOverride?: (base: { themes: Theme[]; diagnostics: ResourceDiagnostic[] }) => {
+		themes: Theme[];
+		diagnostics: ResourceDiagnostic[];
+	};
+	agentsFilesOverride?: (base: { agentsFiles: AgentsFile[] }) => { agentsFiles: AgentsFile[] };
+	systemPromptOverride?: (base: string | undefined) => string | undefined;
+	appendSystemPromptOverride?: (base: string[]) => string[];
+}
+
+/**
+ * The subset of {@link DefaultResourceLoader} state consumed by the
+ * {@link createAgentSession} adapter. Kept as an explicit interface so tests
+ * (and any future third-party ResourceLoader passed to `createAgentSession`)
+ * only need to satisfy the read surface — not the reload lifecycle.
+ */
+export interface ResourceLoader {
+	getExtensions(): LoadExtensionsResult;
+	getSkills(): { skills: Skill[]; diagnostics: ResourceDiagnostic[] };
+	getPrompts(): { prompts: PromptTemplate[]; diagnostics: ResourceDiagnostic[] };
+	getThemes(): { themes: Theme[]; diagnostics: ResourceDiagnostic[] };
+	getAgentsFiles(): { agentsFiles: AgentsFile[] };
+	getSystemPrompt(): string | undefined;
+	getAppendSystemPrompt(): string[];
+	reload(): Promise<void>;
+	/** @internal — used by the shim's createAgentSession to detect its own loaders. */
+	readonly __ompLegacyPiLoader?: true;
+}
+
+/**
+ * Loader-owned inputs that {@link createAgentSession} needs regardless of
+ * whether the caller provided extra options. `cwd`/`agentDir` fall back to
+ * `getProjectDir()`/`getAgentDir()` at construction time so subsequent
+ * `reload()` and `createAgentSession()` calls read the same directories the
+ * caller thought they were configuring.
+ */
+interface ResolvedLoaderState {
+	cwd: string;
+	agentDir: string;
+	settingsPromise?: Promise<Settings>;
+	eventBus: EventBus;
+	extensionFactories: ExtensionFactory[];
+	noExtensions: boolean;
+	additionalExtensionPaths: string[];
+	additionalSkillPaths: string[];
+	additionalPromptTemplatePaths: string[];
+}
+
+interface AdditionalSkillLoadResult {
+	skills: Skill[];
+	diagnostics: ResourceDiagnostic[];
+}
+
+interface AdditionalPromptLoadResult {
+	prompts: PromptTemplate[];
+	diagnostics: ResourceDiagnostic[];
+}
+
+export class DefaultResourceLoader implements ResourceLoader {
+	readonly __ompLegacyPiLoader = true as const;
+	#state: ResolvedLoaderState;
+	#options: DefaultResourceLoaderOptions;
+	#extensionsResult: LoadExtensionsResult = { extensions: [], errors: [], runtime: new ExtensionRuntime() };
+	#skills: Skill[] = [];
+	#skillDiagnostics: ResourceDiagnostic[] = [];
+	#prompts: PromptTemplate[] = [];
+	#promptDiagnostics: ResourceDiagnostic[] = [];
+	#themes: Theme[] = [];
+	#themeDiagnostics: ResourceDiagnostic[] = [];
+	#agentsFiles: AgentsFile[] = [];
+	#systemPrompt: string | undefined;
+	#appendSystemPrompt: string[] = [];
+	#loaded = false;
+
+	constructor(options: DefaultResourceLoaderOptions = {}) {
+		this.#options = options;
+		const cwd = options.cwd ?? getProjectDir();
+		const agentDir = options.agentDir ?? getAgentDir();
+		this.#state = {
+			cwd,
+			agentDir,
+			settingsPromise: options.settingsManager ? Promise.resolve(options.settingsManager) : undefined,
+			eventBus: options.eventBus ?? new EventBus(),
+			extensionFactories: options.extensionFactories ?? [],
+			noExtensions: options.noExtensions ?? false,
+			additionalExtensionPaths: options.additionalExtensionPaths ?? [],
+			additionalSkillPaths: options.additionalSkillPaths ?? [],
+			additionalPromptTemplatePaths: options.additionalPromptTemplatePaths ?? [],
+		};
+	}
+
+	getExtensions(): LoadExtensionsResult {
+		return this.#extensionsResult;
+	}
+
+	getSkills(): { skills: Skill[]; diagnostics: ResourceDiagnostic[] } {
+		return { skills: this.#skills, diagnostics: this.#skillDiagnostics };
+	}
+
+	getPrompts(): { prompts: PromptTemplate[]; diagnostics: ResourceDiagnostic[] } {
+		return { prompts: this.#prompts, diagnostics: this.#promptDiagnostics };
+	}
+
+	getThemes(): { themes: Theme[]; diagnostics: ResourceDiagnostic[] } {
+		return { themes: this.#themes, diagnostics: this.#themeDiagnostics };
+	}
+
+	getAgentsFiles(): { agentsFiles: AgentsFile[] } {
+		return { agentsFiles: this.#agentsFiles };
+	}
+
+	getSystemPrompt(): string | undefined {
+		return this.#systemPrompt;
+	}
+
+	getAppendSystemPrompt(): string[] {
+		return this.#appendSystemPrompt;
+	}
+
+	/**
+	 * Discovery snapshot used to seed the session. Emulates upstream pi's
+	 * `reload()` lifecycle: run every enabled discovery arm against the
+	 * resolved cwd/agentDir, then thread each result through the caller's
+	 * `*Override` callback. Discovery arms guarded by an `no*` flag start from
+	 * an empty base — callers that flipped the flag off still get the override
+	 * hook, so overrides can inject synthetic entries without triggering a
+	 * filesystem scan they explicitly opted out of.
+	 */
+	async reload(): Promise<void> {
+		const { cwd, agentDir } = this.#state;
+		const options = this.#options;
+
+		let settingsPromise = this.#state.settingsPromise;
+		if (!settingsPromise) {
+			settingsPromise = Settings.init({ cwd, agentDir });
+			this.#state.settingsPromise = settingsPromise;
+		}
+		const settings = await settingsPromise;
+
+		const [extensionsResult, skillsBase, additionalSkills, prompts, additionalPrompts, agentsFiles] =
+			await Promise.all([
+				this.#loadExtensions(settings),
+				options.noSkills
+					? Promise.resolve({ skills: [], warnings: [] })
+					: discoverSkills(cwd, agentDir, {
+							...settings.getGroup("skills"),
+							disabledExtensions: settings.get("disabledExtensions") ?? [],
+						}),
+				this.#loadAdditionalSkills(),
+				options.noPromptTemplates ? Promise.resolve([]) : discoverPromptTemplates(cwd, agentDir),
+				this.#loadAdditionalPromptTemplates(),
+				options.noContextFiles ? Promise.resolve([]) : discoverContextFiles(cwd, agentDir),
+			]);
+
+		this.#extensionsResult = options.extensionsOverride
+			? options.extensionsOverride(extensionsResult)
+			: extensionsResult;
+
+		const skillsBaseResult = {
+			skills: [...skillsBase.skills, ...additionalSkills.skills],
+			diagnostics: [
+				...skillsBase.warnings.map(w => ({
+					type: "warning" as const,
+					message: w.message,
+					path: w.skillPath,
+				})),
+				...additionalSkills.diagnostics,
+			],
+		};
+		const skillsFinal = options.skillsOverride ? options.skillsOverride(skillsBaseResult) : skillsBaseResult;
+		this.#skills = skillsFinal.skills;
+		this.#skillDiagnostics = skillsFinal.diagnostics;
+
+		const promptsBase = {
+			prompts: [...prompts, ...additionalPrompts.prompts],
+			diagnostics: additionalPrompts.diagnostics,
+		};
+		const promptsFinal = options.promptsOverride ? options.promptsOverride(promptsBase) : promptsBase;
+		this.#prompts = promptsFinal.prompts;
+		this.#promptDiagnostics = promptsFinal.diagnostics;
+
+		const themesBase = { themes: [] as Theme[], diagnostics: [] as ResourceDiagnostic[] };
+		const themesFinal = options.themesOverride ? options.themesOverride(themesBase) : themesBase;
+		this.#themes = themesFinal.themes;
+		this.#themeDiagnostics = themesFinal.diagnostics;
+
+		const agentsFilesBase = { agentsFiles };
+		const agentsFilesFinal = options.agentsFilesOverride
+			? options.agentsFilesOverride(agentsFilesBase)
+			: agentsFilesBase;
+		this.#agentsFiles = agentsFilesFinal.agentsFiles;
+
+		const baseSystemPrompt = options.systemPrompt;
+		this.#systemPrompt = options.systemPromptOverride
+			? options.systemPromptOverride(baseSystemPrompt)
+			: baseSystemPrompt;
+
+		const appendSource = options.appendSystemPrompt;
+		const baseAppend =
+			typeof appendSource === "string" ? [appendSource] : Array.isArray(appendSource) ? appendSource : [];
+		this.#appendSystemPrompt = options.appendSystemPromptOverride
+			? options.appendSystemPromptOverride(baseAppend)
+			: baseAppend;
+
+		this.#loaded = true;
+	}
+
+	async #loadExtensions(settings: Settings): Promise<LoadExtensionsResult> {
+		const { cwd, noExtensions, additionalExtensionPaths, extensionFactories, eventBus } = this.#state;
+
+		if (noExtensions && additionalExtensionPaths.length === 0 && extensionFactories.length === 0) {
+			return { extensions: [], errors: [], runtime: new ExtensionRuntime() };
+		}
+
+		const paths = await discoverSessionExtensionPaths(
+			{
+				disableExtensionDiscovery: noExtensions,
+				additionalExtensionPaths,
+			},
+			cwd,
+			settings,
+		);
+
+		const result = await loadExtensions(paths, cwd, eventBus);
+		for (let i = 0; i < extensionFactories.length; i++) {
+			const loaded = await loadExtensionFromFactory(
+				extensionFactories[i],
+				cwd,
+				eventBus,
+				result.runtime,
+				`<inline-loader-${i}>`,
+			);
+			result.extensions.push(loaded);
+		}
+		return result;
+	}
+
+	async #loadAdditionalSkills(): Promise<AdditionalSkillLoadResult> {
+		const skills: Skill[] = [];
+		const diagnostics: ResourceDiagnostic[] = [];
+
+		for (const resourcePath of this.#state.additionalSkillPaths) {
+			const resolvedPath = path.isAbsolute(resourcePath)
+				? resourcePath
+				: path.resolve(this.#state.cwd, resourcePath);
+			const skillDir =
+				path.basename(resolvedPath).toLowerCase() === "skill.md" ? path.dirname(resolvedPath) : resolvedPath;
+			try {
+				const result = await loadSkillsFromDir({
+					dir: skillDir,
+					source: "legacy-resource-loader",
+				});
+				skills.push(...result.skills);
+				diagnostics.push(
+					...result.warnings.map(w => ({
+						type: "warning" as const,
+						message: w.message,
+						path: w.skillPath,
+					})),
+				);
+			} catch (err) {
+				diagnostics.push({
+					type: "warning",
+					message: `Failed to load additional skill path: ${err instanceof Error ? err.message : String(err)}`,
+					path: resolvedPath,
+				});
+			}
+		}
+
+		return { skills, diagnostics };
+	}
+
+	async #loadAdditionalPromptTemplates(): Promise<AdditionalPromptLoadResult> {
+		const prompts: PromptTemplate[] = [];
+		const diagnostics: ResourceDiagnostic[] = [];
+
+		for (const resourcePath of this.#state.additionalPromptTemplatePaths) {
+			const resolvedPath = path.isAbsolute(resourcePath)
+				? resourcePath
+				: path.resolve(this.#state.cwd, resourcePath);
+			const files: string[] = [];
+			try {
+				const stat = await fs.stat(resolvedPath);
+				if (stat.isDirectory()) {
+					const glob = new Bun.Glob("**/*.md");
+					for await (const entry of glob.scan({ cwd: resolvedPath, absolute: false, onlyFiles: true })) {
+						files.push(path.join(resolvedPath, entry));
+					}
+					files.sort();
+				} else if (resolvedPath.toLowerCase().endsWith(".md")) {
+					files.push(resolvedPath);
+				} else {
+					diagnostics.push({
+						type: "warning",
+						message: "Additional prompt template path is neither a directory nor a Markdown file",
+						path: resolvedPath,
+					});
+				}
+			} catch (err) {
+				diagnostics.push({
+					type: "warning",
+					message: `Failed to inspect additional prompt template path: ${err instanceof Error ? err.message : String(err)}`,
+					path: resolvedPath,
+				});
+				continue;
+			}
+
+			for (const filePath of files) {
+				try {
+					const raw = await Bun.file(filePath).text();
+					const { frontmatter, body } = parseFrontmatter(raw);
+					const rawDescription = frontmatter.description;
+					let description = typeof rawDescription === "string" ? rawDescription : "";
+					if (!description) {
+						const firstLine = body.split("\n").find(line => line.trim());
+						if (firstLine) {
+							description = firstLine.slice(0, 60);
+							if (firstLine.length > 60) {
+								description += "...";
+							}
+						}
+					}
+
+					const source = "(legacy-resource-loader)";
+					prompts.push({
+						name: path.basename(filePath, path.extname(filePath)),
+						description: description ? `${description} ${source}` : source,
+						content: body,
+						source,
+					});
+				} catch (err) {
+					diagnostics.push({
+						type: "warning",
+						message: `Failed to load additional prompt template: ${err instanceof Error ? err.message : String(err)}`,
+						path: filePath,
+					});
+				}
+			}
+		}
+
+		return { prompts, diagnostics };
+	}
+
+	/** Test seam: whether `reload()` has completed at least once. */
+	get loaded(): boolean {
+		return this.#loaded;
+	}
+
+	/** @internal — used by the shim's createAgentSession to translate options. */
+	__getResolverState(): {
+		cwd: string;
+		agentDir: string;
+		settingsPromise?: Promise<Settings>;
+		eventBus: EventBus;
+		extensionsResult: LoadExtensionsResult;
+		skills: Skill[];
+		prompts: PromptTemplate[];
+		agentsFiles: AgentsFile[];
+		systemPrompt: string | undefined;
+		appendSystemPrompt: string[];
+		extensionFactories: ExtensionFactory[];
+	} {
+		return {
+			cwd: this.#state.cwd,
+			agentDir: this.#state.agentDir,
+			settingsPromise: this.#state.settingsPromise,
+			eventBus: this.#state.eventBus,
+			extensionsResult: this.#extensionsResult,
+			skills: this.#skills,
+			prompts: this.#prompts,
+			agentsFiles: this.#agentsFiles,
+			systemPrompt: this.#systemPrompt,
+			appendSystemPrompt: this.#appendSystemPrompt,
+			extensionFactories: this.#state.extensionFactories,
+		};
+	}
+}
+
+/**
+ * Legacy pi extensions call `createAgentSession({ resourceLoader })`. OMP's
+ * native option surface has no such field — extension / skill / prompt /
+ * context-file discovery are configured directly on the session options — so
+ * an untranslated call would silently ignore the loader (including its
+ * `noExtensions`/`noSkills` opt-outs), re-run OMP's own discovery, and
+ * happily re-load the calling extension into the subagent. That's exactly
+ * the recursion the caller passed the loader to prevent.
+ *
+ * Translate the loader's captured state into OMP's option fields, then
+ * delegate to the underlying SDK. Explicit fields on `options` override the
+ * loader (matches upstream pi semantics — a caller can partially override a
+ * shared loader).
+ *
+ * `resourceLoader` is not part of {@link CreateAgentSessionOptions}, so it's
+ * accepted through a widened alias and stripped before the underlying call.
+ */
+export type LegacyPiCreateAgentSessionOptions = CreateAgentSessionOptions & {
+	resourceLoader?: ResourceLoader;
+};
+
+export async function createAgentSession(
+	options: LegacyPiCreateAgentSessionOptions = {},
+): Promise<CreateAgentSessionResult> {
+	const loader = options.resourceLoader;
+	if (!loader) {
+		return ompCreateAgentSession(options);
+	}
+
+	if (loader instanceof DefaultResourceLoader && !loader.loaded) {
+		await loader.reload();
+	}
+
+	const state =
+		loader instanceof DefaultResourceLoader
+			? loader.__getResolverState()
+			: {
+					cwd: options.cwd ?? getProjectDir(),
+					agentDir: options.agentDir ?? getAgentDir(),
+					settingsPromise: undefined,
+					eventBus: undefined,
+					extensionsResult: loader.getExtensions(),
+					skills: loader.getSkills().skills,
+					prompts: loader.getPrompts().prompts,
+					agentsFiles: loader.getAgentsFiles().agentsFiles,
+					systemPrompt: loader.getSystemPrompt(),
+					appendSystemPrompt: loader.getAppendSystemPrompt(),
+					extensionFactories: [] as ExtensionFactory[],
+				};
+
+	const { resourceLoader: _, ...rest } = options;
+	const forwarded: CreateAgentSessionOptions = {
+		...rest,
+		cwd: rest.cwd ?? state.cwd,
+		agentDir: rest.agentDir ?? state.agentDir,
+	};
+
+	if (rest.eventBus === undefined && state.eventBus !== undefined) {
+		forwarded.eventBus = state.eventBus;
+	}
+	if (rest.settings === undefined && rest.settingsManager === undefined && state.settingsPromise !== undefined) {
+		forwarded.settingsManager = state.settingsPromise;
+	}
+
+	// Route the loader's already-loaded extension result through the SDK's
+	// `preloadedExtensions` seam. Skipping this branch would let
+	// `createAgentSession` re-run its own discovery and undo the caller's
+	// `noExtensions: true`.
+	if (rest.preloadedExtensions === undefined && rest.preloadedExtensionPaths === undefined) {
+		forwarded.preloadedExtensions = state.extensionsResult;
+	}
+
+	if (rest.skills === undefined) {
+		forwarded.skills = state.skills;
+	}
+	if (rest.promptTemplates === undefined) {
+		forwarded.promptTemplates = state.prompts;
+	}
+	if (rest.contextFiles === undefined) {
+		forwarded.contextFiles = state.agentsFiles;
+	}
+
+	if (rest.systemPrompt === undefined && state.systemPrompt !== undefined) {
+		forwarded.systemPrompt = state.systemPrompt;
+	}
+	if (rest.appendSystemPrompt === undefined && state.appendSystemPrompt.length > 0) {
+		forwarded.appendSystemPrompt = state.appendSystemPrompt.join("\n\n");
+	}
+
+	return ompCreateAgentSession(forwarded);
+}
+
 export * from "../index";
 export { formatBytes as formatSize } from "../tools/render-utils";
 export { Type } from "./typebox";