Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/pipi/resources.ts

Raw
import { homedir } from "node:os";
import { isAbsolute, resolve } from "node:path";
import {
	DefaultPackageManager,
	type ExtensionToolContext,
	getAgentDir,
	parseArgs,
	SettingsManager,
} from "@earendil-works/pi-coding-agent";
import type { Config } from "./config.ts";
import type { Inheritance } from "./runtime.ts";

/** Resolve file identities without executing extensions; keep Pi's resource filters authoritative. */
export async function childResources(
	ctx: ExtensionToolContext,
	cwd: string,
	inherited: Inheritance,
	config: Config,
): Promise<{
	settingsManager: SettingsManager;
	cli: ReturnType<typeof parseArgs>;
	extensions: string[];
	skills: string[];
	prompts: string[];
}> {
	const agentDir = getAgentDir();
	const cli = parseArgs(process.argv.slice(2));
	const parentSettings = SettingsManager.create(ctx.cwd, agentDir, {
		projectTrusted: ctx.isProjectTrusted(),
	});
	const targetSettings =
		cwd === ctx.cwd
			? parentSettings
			: SettingsManager.create(cwd, agentDir, { projectTrusted: false });
	const resolveResources = (
		settingsManager: SettingsManager,
		directory: string,
	) =>
		new DefaultPackageManager({
			cwd: directory,
			agentDir,
			settingsManager,
			builtinExtensions: ["codemode", "tool-search", "mcp"],
		}).resolve(async () => "skip");
	const parent = await resolveResources(parentSettings, ctx.cwd);
	const target =
		cwd === ctx.cwd ? parent : await resolveResources(targetSettings, cwd);
	const anchor = (value: string, base: string): string => {
		const prefix = /^[+!-]/u.test(value) ? value.slice(0, 1) : "";
		const path = prefix ? value.slice(1) : value;
		if (isAbsolute(path) || /^(?:builtin:|npm:|git:|https?:|ssh:)/u.test(path))
			return value;
		return (
			prefix +
			resolve(
				base,
				path.startsWith("~/") ? resolve(homedir(), path.slice(2)) : path,
			)
		);
	};
	const selections = {} as Record<
		"extensions" | "skills" | "prompts",
		string[]
	>;
	for (const kind of ["extensions", "skills", "prompts"] as const) {
		const disabled =
			kind === "extensions"
				? (config.noExtensions ?? cli.noExtensions)
				: kind === "skills"
					? (config.noSkills ?? cli.noSkills)
					: (config.noPromptTemplates ?? cli.noPromptTemplates);
		const paths = new Map<string, boolean>();
		for (const item of [...parent[kind], ...target[kind]])
			paths.set(item.path, !disabled && item.enabled);
		const cliPaths =
			kind === "extensions"
				? cli.extensions
				: kind === "skills"
					? cli.skills
					: cli.promptTemplates;
		selections[kind] = [
			...[...paths].map(([path, enabled]) => (enabled ? path : `-${path}`)),
			...(kind === "extensions" && !disabled ? inherited.extensions : []),
			...(cliPaths ?? []).map((path) => anchor(path, process.cwd())),
			...(config[kind] ?? []).map((path) => anchor(path, ctx.cwd)),
		];
	}
	// In-memory overrides never write user/project settings; native loader resolves +/-/! patterns.
	const settingsManager = SettingsManager.inMemory(
		{ ...targetSettings.getSettings(), packages: [], ...selections },
		{ projectTrusted: cwd === ctx.cwd && ctx.isProjectTrusted() },
	);
	const selected = await resolveResources(settingsManager, cwd);
	return {
		settingsManager,
		cli,
		extensions: [
			...selected.extensions
				.filter((item) => item.enabled)
				.map((item) => item.path),
			...[...(cli.extensions ?? []), ...(config.extensions ?? [])].filter(
				(path) => /^(?:npm:|git:|https?:|ssh:)/u.test(path),
			),
		],
		skills: selected.skills
			.filter((item) => item.enabled)
			.map((item) => item.path),
		prompts: selected.prompts
			.filter((item) => item.enabled)
			.map((item) => item.path),
	};
}