@simon_he/pi 0.2.9 → 0.2.11

package/dist/index.cjs

@@ -39,19 +39,21 @@ picocolors = __toESM(picocolors);
 let node_readline = require("node:readline");
 node_readline = __toESM(node_readline);
 let node_console = require("node:console");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
 let node_os = require("node:os");
 node_os = __toESM(node_os);
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
 let node_module = require("node:module");
 let node_url = require("node:url");
 
 //#region package.json
-var version = "0.2.9";
+var version = "0.2.11";
 
 //#endregion
 //#region src/tty.ts
-const isZh$6 = node_process.default.env.PI_Lang === "zh";
+const isZh$7 = node_process.default.env.PI_Lang === "zh";
 function isInteractive() {
 	return Boolean(node_process.default.stdin.isTTY && node_process.default.stdout.isTTY);
 }
@@ -233,7 +235,7 @@ async function runSelect(options, config) {
 	if (anchor) {
 		const prompt = "> ";
 		const header = `? ${config.placeholder}`;
-		const hintLine = `${config.mode === "multiple" ? isZh$6 ? "↑/↓ 选择，空格标记，Tab 补全，/ 搜索，回车确认，Esc 取消" : "Use ↑/↓ to move, Space to toggle, Tab to complete, / to search, Enter to confirm, Esc to cancel" : isZh$6 ? "↑/↓ 选择，Tab 补全，/ 搜索，回车确认，Esc 取消" : "Use ↑/↓ to move, Tab to complete, / to search, Enter to confirm, Esc to cancel"} (1/${options.length})`;
+		const hintLine = `${config.mode === "multiple" ? isZh$7 ? "↑/↓ 选择，空格标记，Tab 补全，/ 搜索，回车确认，Esc 取消" : "Use ↑/↓ to move, Space to toggle, Tab to complete, / to search, Enter to confirm, Esc to cancel" : isZh$7 ? "↑/↓ 选择，Tab 补全，/ 搜索，回车确认，Esc 取消" : "Use ↑/↓ to move, Tab to complete, / to search, Enter to confirm, Esc to cancel"} (1/${options.length})`;
 		const headerRows = rowCount(header, columns);
 		const inputRows = rowCount(`${prompt}`, columns);
 		const hintRows = rowCount(hintLine, columns);
@@ -271,10 +273,10 @@ async function runSelect(options, config) {
 		const hintLine = (() => {
 			const position = ` (${Math.min(cursor + 1, filtered.length)}/${filtered.length})`;
 			if (config.mode === "multiple") {
-				if (isZh$6) return picocolors.default.dim("↑/↓ 选择，") + picocolors.default.bold(picocolors.default.cyan("空格")) + picocolors.default.dim(" 标记，Tab 补全，/ 搜索，回车确认，Esc 取消") + picocolors.default.dim(position);
+				if (isZh$7) return picocolors.default.dim("↑/↓ 选择，") + picocolors.default.bold(picocolors.default.cyan("空格")) + picocolors.default.dim(" 标记，Tab 补全，/ 搜索，回车确认，Esc 取消") + picocolors.default.dim(position);
 				return picocolors.default.dim("Use ↑/↓ to move, ") + picocolors.default.bold(picocolors.default.cyan("Space")) + picocolors.default.dim(" to toggle, Tab to complete, / to search, Enter to confirm, Esc to cancel") + picocolors.default.dim(position);
 			}
-			const hint = isZh$6 ? "↑/↓ 选择，Tab 补全，/ 搜索，回车确认，Esc 取消" : "Use ↑/↓ to move, Tab to complete, / to search, Enter to confirm, Esc to cancel";
+			const hint = isZh$7 ? "↑/↓ 选择，Tab 补全，/ 搜索，回车确认，Esc 取消" : "Use ↑/↓ to move, Tab to complete, / to search, Enter to confirm, Esc to cancel";
 			return picocolors.default.dim(`${hint}${position}`);
 		})();
 		const headerRows = rowCount(header, columns);
@@ -288,7 +290,7 @@ async function runSelect(options, config) {
 		const maxVisibleRaw = needsScroll ? Math.max(minVisibleTarget, optionAreaRows - ellipsisReserve) : filtered.length;
 		const maxVisible = Math.max(1, Math.min(maxVisibleRaw, optionAreaRows, filtered.length));
 		const lines = [header, inputLine];
-		if (filtered.length === 0) lines.push(picocolors.default.dim(isZh$6 ? "没有匹配项" : "No matches"));
+		if (filtered.length === 0) lines.push(picocolors.default.dim(isZh$7 ? "没有匹配项" : "No matches"));
 		else {
 			const window = getVisibleWindow(filtered.length, cursor, maxVisible);
 			const visible = filtered.slice(window.start, window.end);
@@ -489,11 +491,11 @@ function renderBox(lines, options = {}) {
 
 //#endregion
 //#region src/help.ts
-const isZh$5 = node_process.default.env.PI_Lang === "zh";
+const isZh$6 = node_process.default.env.PI_Lang === "zh";
 async function help(argv) {
 	const arg = argv[0];
 	if (arg === "-v" || arg === "--version") {
-		const message = isZh$5 ? [
+		const message = isZh$6 ? [
 			`pi 版本: ${version}`,
 			"请为我的努力点一个行 🌟",
 			"谢谢 🤟"
@@ -515,6 +517,13 @@ async function help(argv) {
 		console.log(renderBox([
 			"PI Commands:",
 			"~ pi: install package",
+			"~ pi --choose-tool: choose package manager for this workspace",
+			"~ pi --choose-tool bun: choose the tool directly",
+			"~ pi --forget-tool: clear saved package manager choice",
+			"~ pi --show-tool: show current workspace package manager",
+			"~ pi --show-tool --json: show current tool as JSON",
+			"~ pi --list-tools: list detected package-manager candidates",
+			"~ pi --list-tools --json: list candidates as JSON",
 			"~ pix: npx package",
 			"~ pui: uninstall package",
 			"~ prun: run package script",
@@ -524,10 +533,24 @@ async function help(argv) {
 			"~ pa: agent alias",
 			"~ pu: package upgrade",
 			"~ pci: package clean install",
-			"~ pil: package latest install"
+			"~ pci --choose-tool: re-pick tool before clean install",
+			"~ pci --choose-tool bun: choose the tool directly",
+			"~ pci --forget-tool: clear saved tool before clean install",
+			"~ pci --show-tool: show current tool before clean install",
+			"~ pci --show-tool --json: show current tool as JSON",
+			"~ pci --list-tools: list detected candidates",
+			"~ pci --list-tools --json: list candidates as JSON",
+			"~ pil: package latest install",
+			"~ pil --choose-tool: re-pick tool before latest install",
+			"~ pil --choose-tool bun: choose the tool directly",
+			"~ pil --forget-tool: clear saved tool before latest install",
+			"~ pil --show-tool: show current tool before latest install",
+			"~ pil --show-tool --json: show current tool as JSON",
+			"~ pil --list-tools: list detected candidates",
+			"~ pil --list-tools --json: list candidates as JSON"
 		], {
 			align: "left",
-			width: 50,
+			width: 76,
 			marginX: 2,
 			marginY: 1,
 			paddingX: 1,
@@ -557,9 +580,27 @@ async function detectNode() {
 
 //#endregion
 //#region src/pkgManager.ts
+const resolvedToolCache = /* @__PURE__ */ new Map();
+const toolIndicatorMap = {
+	pnpm: ["pnpm-workspace.yaml", "pnpm-lock.yaml"],
+	yarn: ["yarn.lock", ".yarnrc.yml"],
+	bun: ["bun.lock", "bun.lockb"],
+	npm: ["package-lock.json", "npm-shrinkwrap.json"]
+};
+const isZh$5 = node_process.default.env.PI_Lang === "zh";
+const supportedPkgTools$1 = Object.keys(toolIndicatorMap);
+function isEnabled(value) {
+	if (!value) return false;
+	const normalized = value.toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes";
+}
 function normalizeDir$1(dir) {
 	return node_path.default.resolve(dir);
 }
+function isSameOrInsideDir(base, target) {
+	const relative = node_path.default.relative(base, target);
+	return relative === "" || !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+}
 function findUpSync$1(startDir, predicate) {
 	let current = normalizeDir$1(startDir);
 	while (true) {
@@ -569,24 +610,332 @@ function findUpSync$1(startDir, predicate) {
 		current = parent;
 	}
 }
-function inferToolFromRepoLayout(cwd) {
-	if (findUpSync$1(cwd, (dir) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, "pnpm-workspace.yaml")) || (0, lazy_js_utils.isFile)(node_path.default.join(dir, "pnpm-lock.yaml")))) return "pnpm";
-	if (findUpSync$1(cwd, (dir) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, "yarn.lock")) || (0, lazy_js_utils.isFile)(node_path.default.join(dir, ".yarnrc.yml")))) return "yarn";
-	if (findUpSync$1(cwd, (dir) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, "bun.lockb")))) return "bun";
-	return null;
-}
-async function resolvePkgTool() {
-	let detected = await (0, lazy_js_utils_node.getPkgTool)() || "npm";
-	if (detected === "npm") {
-		const inferred = inferToolFromRepoLayout(node_process.default.cwd());
-		if (inferred) detected = inferred;
+function findToolCandidate(cwd, tool) {
+	const indicators = toolIndicatorMap[tool];
+	if (!indicators?.length) return null;
+	const root = findUpSync$1(cwd, (dir) => indicators.some((indicator) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, indicator))));
+	if (!root) return null;
+	const foundIndicators = indicators.filter((indicator) => (0, lazy_js_utils.isFile)(node_path.default.join(root, indicator)));
+	return {
+		tool,
+		root,
+		indicators: foundIndicators.length ? foundIndicators : indicators.slice(0, 1)
+	};
+}
+function getToolCandidates(cwd) {
+	return Object.keys(toolIndicatorMap).map((tool) => findToolCandidate(cwd, tool)).filter(Boolean);
+}
+function getPreferenceWorkspaceKey(cwd, candidates) {
+	const roots = [...new Set(candidates.map((candidate) => normalizeDir$1(candidate.root)))];
+	if (roots.length === 1) return roots[0];
+	return normalizeDir$1(cwd);
+}
+function findStoredWorkspaceKey(cwd, preferences) {
+	return Object.keys(preferences.workspaces).filter((workspaceKey) => isSameOrInsideDir(workspaceKey, cwd)).sort((a, b) => b.length - a.length)[0] || null;
+}
+function resolveWorkspaceKey(cwd, candidates, preferences) {
+	if (candidates.length > 0) return getPreferenceWorkspaceKey(cwd, candidates);
+	return findStoredWorkspaceKey(cwd, preferences) || normalizeDir$1(cwd);
+}
+function getConfigHome() {
+	const home = node_process.default.env.HOME || node_os.default.homedir();
+	if (node_process.default.platform === "win32") return node_process.default.env.APPDATA || node_path.default.join(home, "AppData", "Roaming");
+	return node_process.default.env.XDG_CONFIG_HOME || node_path.default.join(home, ".config");
+}
+function getWorkspaceToolPreferencePath() {
+	return node_path.default.join(getConfigHome(), "pi", "workspace-tools.json");
+}
+async function readWorkspaceToolPreferences() {
+	const configPath = getWorkspaceToolPreferencePath();
+	try {
+		const raw = await node_fs_promises.default.readFile(configPath, "utf8");
+		const parsed = JSON.parse(raw);
+		return {
+			version: 1,
+			workspaces: parsed.workspaces && typeof parsed.workspaces === "object" ? parsed.workspaces : {}
+		};
+	} catch {
+		return {
+			version: 1,
+			workspaces: {}
+		};
 	}
-	const fallback = node_process.default.env.PI_DEFAULT;
+}
+async function writeWorkspaceToolPreference(workspaceKey, tool) {
+	const configPath = getWorkspaceToolPreferencePath();
+	const data = await readWorkspaceToolPreferences();
+	data.workspaces[workspaceKey] = tool;
+	await node_fs_promises.default.mkdir(node_path.default.dirname(configPath), { recursive: true });
+	await node_fs_promises.default.writeFile(configPath, JSON.stringify(data, null, 2), "utf8");
+	resolvedToolCache.clear();
+}
+async function deleteWorkspaceToolPreference(workspaceKey) {
+	const configPath = getWorkspaceToolPreferencePath();
+	const data = await readWorkspaceToolPreferences();
+	if (!(workspaceKey in data.workspaces)) return;
+	delete data.workspaces[workspaceKey];
+	await node_fs_promises.default.mkdir(node_path.default.dirname(configPath), { recursive: true });
+	await node_fs_promises.default.writeFile(configPath, JSON.stringify(data, null, 2), "utf8");
+	resolvedToolCache.clear();
+}
+async function forgetPkgToolPreference() {
+	const workspaceKey = findStoredWorkspaceKey(normalizeDir$1(node_process.default.cwd()), await readWorkspaceToolPreferences());
+	if (!workspaceKey) return false;
+	await deleteWorkspaceToolPreference(workspaceKey);
+	return true;
+}
+function getSupportedPkgToolNames() {
+	return supportedPkgTools$1.slice();
+}
+function getPreferredToolFromEnv(candidates) {
+	const preferred = node_process.default.env.PI_DEFAULT;
+	if (!preferred) return null;
+	return candidates.some((candidate) => candidate.tool === preferred) ? preferred : null;
+}
+function getExplicitPreferredTool(value) {
+	if (!value) return null;
+	return supportedPkgTools$1.includes(value) ? value : null;
+}
+function validateExplicitPreferredTool(preferredTool, candidates) {
+	if (candidates.length === 0) return true;
+	return candidates.some((candidate) => candidate.tool === preferredTool);
+}
+function logInvalidPreferredTool(preferredTool, candidates) {
+	const names = candidates.map((candidate) => candidate.tool).join(", ");
+	console.log(picocolors.default.red(isZh$5 ? `当前 workspace 可选的包管理器是: ${names}，不能直接指定 ${preferredTool}。` : `This workspace supports: ${names}. ${preferredTool} cannot be selected directly here.`));
+}
+function getDetectedToolFallback(detected, candidates) {
+	if (candidates.some((candidate) => candidate.tool === detected)) return detected;
+	return candidates[0]?.tool || detected;
+}
+function formatCandidateLabel(candidate, cwd) {
+	const indicators = candidate.indicators.join(", ");
+	const relativeRoot = node_path.default.relative(cwd, candidate.root) || ".";
+	if (relativeRoot === ".") return `${candidate.tool}: ${indicators}`;
+	return `${candidate.tool}: ${indicators} (${relativeRoot})`;
+}
+function toCandidateInfo(candidates) {
+	return candidates.map((candidate) => ({
+		tool: candidate.tool,
+		indicators: candidate.indicators,
+		root: candidate.root
+	}));
+}
+async function selectToolCandidate(candidates, cwd) {
+	if (!isInteractive()) return { status: "unavailable" };
+	const options = candidates.map((candidate) => formatCandidateLabel(candidate, cwd));
+	const labelToTool = new Map(candidates.map((candidate) => [formatCandidateLabel(candidate, cwd), candidate.tool]));
+	const choice = await ttySelect(options, isZh$5 ? "🤔检测到多个包管理环境，请选择当前 workspace 使用的安装方式" : "Multiple package managers were detected, choose one for this workspace.");
+	if (!choice) return { status: "cancelled" };
+	const tool = labelToTool.get(choice);
+	if (!tool) return { status: "cancelled" };
 	return {
+		status: "selected",
+		tool
+	};
+}
+function logAmbiguousToolFallback(candidates, tool) {
+	const names = candidates.map((candidate) => candidate.tool).join(", ");
+	console.log(picocolors.default.yellow(isZh$5 ? `检测到多个包管理环境(${names})，当前不是交互式终端，临时使用 ${tool}。可在交互式终端运行一次 pi 以保存当前 workspace 的选择。` : `Detected multiple package managers (${names}). Using ${tool} for now because no interactive TTY is available. Run pi once in an interactive shell to save this workspace preference.`));
+}
+function getSourceLabel(source) {
+	switch (source) {
+		case "saved-preference": return isZh$5 ? "已保存的 workspace 选择" : "saved workspace choice";
+		case "fresh-selection": return isZh$5 ? "本次重新选择并保存" : "picked now and saved";
+		case "single-candidate": return isZh$5 ? "当前只检测到一种包管理器标记" : "single detected package-manager indicator";
+		case "env-default": return isZh$5 ? "PI_DEFAULT 兜底" : "PI_DEFAULT fallback";
+		case "detected-tool": return isZh$5 ? "环境自动检测结果" : "environment auto-detection";
+		case "non-interactive-fallback": return isZh$5 ? "非交互终端下的临时兜底" : "non-interactive fallback";
+	}
+}
+function logWorkspaceToolSelected(tool, forceChoose) {
+	console.log(picocolors.default.green(forceChoose ? isZh$5 ? `当前 workspace 已切换为使用 ${tool}，并保存了这个选择。` : `This workspace now uses ${tool}, and the choice has been saved.` : isZh$5 ? `已为当前 workspace 记住 ${tool} 作为包管理器。` : `Saved ${tool} as the package manager for this workspace.`));
+}
+function logWorkspaceToolResolved(tool) {
+	console.log(picocolors.default.green(isZh$5 ? `当前 workspace 使用 ${tool} 作为包管理器。` : `This workspace uses ${tool} as the package manager.`));
+}
+function logStaleWorkspaceToolRemoved(tool) {
+	console.log(picocolors.default.yellow(isZh$5 ? `检测到之前保存的 ${tool} 已不再适用于当前 workspace，已自动清除旧记录。` : `The saved ${tool} choice no longer matches this workspace and was removed automatically.`));
+}
+async function preparePkgToolContext(forgetPreference = false) {
+	const cwd = normalizeDir$1(node_process.default.cwd());
+	const originalDetected = await (0, lazy_js_utils_node.getPkgTool)() || "npm";
+	const candidates = getToolCandidates(cwd);
+	const preferences = await readWorkspaceToolPreferences();
+	const workspaceKey = resolveWorkspaceKey(cwd, candidates, preferences);
+	let detected = originalDetected;
+	if (forgetPreference) await deleteWorkspaceToolPreference(workspaceKey);
+	if (forgetPreference) delete preferences.workspaces[workspaceKey];
+	let rememberedTool = preferences.workspaces[workspaceKey];
+	if (rememberedTool && !candidates.some((candidate) => candidate.tool === rememberedTool)) {
+		await deleteWorkspaceToolPreference(workspaceKey);
+		delete preferences.workspaces[workspaceKey];
+		logStaleWorkspaceToolRemoved(rememberedTool);
+		rememberedTool = void 0;
+	}
+	if (detected === "npm" && candidates.length === 1) detected = candidates[0].tool;
+	return {
+		detected,
+		candidates,
+		rememberedTool
+	};
+}
+async function getPkgToolStatus() {
+	const { detected, candidates, rememberedTool } = await preparePkgToolContext();
+	const candidateInfo = toCandidateInfo(candidates);
+	if (rememberedTool) return {
+		status: "resolved",
+		detected,
+		tool: rememberedTool,
+		source: "saved-preference",
+		candidates: candidateInfo
+	};
+	if (candidates.length <= 1) {
+		const fallback = node_process.default.env.PI_DEFAULT;
+		return {
+			status: "resolved",
+			detected,
+			tool: detected === "npm" && fallback ? fallback : detected,
+			source: detected === "npm" && fallback ? "env-default" : candidates.length === 1 ? "single-candidate" : "detected-tool",
+			candidates: candidateInfo
+		};
+	}
+	const envPreferredTool = getPreferredToolFromEnv(candidates);
+	if (envPreferredTool) return {
+		status: "resolved",
+		detected,
+		tool: envPreferredTool,
+		source: "env-default",
+		candidates: candidateInfo
+	};
+	if (!isInteractive()) return {
+		status: "resolved",
+		detected,
+		tool: getDetectedToolFallback(detected, candidates),
+		source: "non-interactive-fallback",
+		candidates: candidateInfo
+	};
+	return {
+		status: "needs-selection",
 		detected,
-		tool: detected === "npm" && fallback ? fallback : detected
+		candidates: candidateInfo
 	};
 }
+function printPkgToolStatus(status, options = {}) {
+	if (options.json) {
+		console.log(JSON.stringify({
+			...status,
+			sourceLabel: status.status === "resolved" ? getSourceLabel(status.source) : void 0
+		}, null, 2));
+		return;
+	}
+	if (status.status === "resolved") {
+		const candidateNames = status.candidates.map((candidate) => candidate.tool).join(", ");
+		console.log(picocolors.default.green(isZh$5 ? `当前 workspace 使用 ${status.tool} 作为包管理器。` : `This workspace uses ${status.tool} as the package manager.`));
+		console.log(picocolors.default.cyan(`${isZh$5 ? "来源" : "Source"}: ${getSourceLabel(status.source)}`));
+		if (candidateNames) console.log(picocolors.default.dim(`${isZh$5 ? "候选项" : "Candidates"}: ${candidateNames}`));
+		return;
+	}
+	const candidateNames = status.candidates.map((candidate) => candidate.tool).join(", ");
+	console.log(picocolors.default.yellow(isZh$5 ? "当前 workspace 还没有固定包管理器选择。" : "This workspace does not have a locked package-manager choice yet."));
+	console.log(picocolors.default.cyan(`${isZh$5 ? "原因" : "Reason"}: ${isZh$5 ? "检测到了多个包管理器标记，且当前没有保存的选择。" : "Multiple package-manager indicators were found and no saved choice exists yet."}`));
+	console.log(picocolors.default.dim(`${isZh$5 ? "候选项" : "Candidates"}: ${candidateNames}`));
+	console.log(picocolors.default.dim(isZh$5 ? "可执行 `pi --choose-tool` 来保存当前 workspace 的选择。" : "Run `pi --choose-tool` to save a choice for this workspace."));
+}
+function printPkgToolCandidates(status, options = {}) {
+	if (options.json) {
+		console.log(JSON.stringify({
+			...status,
+			sourceLabel: status.status === "resolved" ? getSourceLabel(status.source) : void 0
+		}, null, 2));
+		return;
+	}
+	if (status.status === "resolved") {
+		console.log(picocolors.default.green(isZh$5 ? `当前 workspace 使用 ${status.tool} 作为包管理器。` : `This workspace uses ${status.tool} as the package manager.`));
+		console.log(picocolors.default.cyan(`${isZh$5 ? "来源" : "Source"}: ${getSourceLabel(status.source)}`));
+	} else console.log(picocolors.default.yellow(isZh$5 ? "当前 workspace 还没有固定包管理器选择。" : "This workspace does not have a locked package-manager choice yet."));
+	if (status.candidates.length === 0) {
+		console.log(picocolors.default.dim(isZh$5 ? "当前 workspace 没有检测到明确的 lockfile / workspace 候选。" : "No explicit lockfile or workspace candidates were detected in this workspace."));
+		return;
+	}
+	console.log(picocolors.default.bold(isZh$5 ? "候选工具:" : "Candidate tools:"));
+	for (const candidate of status.candidates) {
+		const indicators = candidate.indicators.join(", ");
+		console.log(`- ${candidate.tool}`);
+		console.log(picocolors.default.dim(`  ${isZh$5 ? "root" : "root"}: ${candidate.root}`));
+		console.log(picocolors.default.dim(`  ${isZh$5 ? "indicators" : "indicators"}: ${indicators}`));
+	}
+}
+async function resolvePkgTool(options = {}) {
+	const cwd = normalizeDir$1(node_process.default.cwd());
+	const forceChoose = options.forceChoose || isEnabled(node_process.default.env.PI_FORCE_PICK_TOOL);
+	const forgetPreference = options.forgetPreference || isEnabled(node_process.default.env.PI_FORGET_PICK_TOOL);
+	const preferredTool = getExplicitPreferredTool(options.preferredTool || node_process.default.env.PI_PREFERRED_TOOL);
+	const shouldBypassCache = forceChoose || forgetPreference || Boolean(preferredTool);
+	const cached = resolvedToolCache.get(cwd);
+	if (!shouldBypassCache && cached) return cached;
+	const pending = (async () => {
+		const { detected, candidates, rememberedTool } = await preparePkgToolContext(forgetPreference);
+		if (preferredTool) {
+			if (!validateExplicitPreferredTool(preferredTool, candidates)) {
+				logInvalidPreferredTool(preferredTool, candidates);
+				node_process.default.exit(1);
+			}
+			await writeWorkspaceToolPreference(resolveWorkspaceKey(normalizeDir$1(node_process.default.cwd()), candidates, await readWorkspaceToolPreferences()), preferredTool);
+			logWorkspaceToolSelected(preferredTool, true);
+			return {
+				detected,
+				tool: preferredTool,
+				source: "fresh-selection"
+			};
+		}
+		if (!forceChoose && rememberedTool) return {
+			detected,
+			tool: rememberedTool,
+			source: "saved-preference"
+		};
+		if (candidates.length <= 1) {
+			const fallback = node_process.default.env.PI_DEFAULT;
+			const tool = detected === "npm" && fallback ? fallback : detected;
+			if (forceChoose) logWorkspaceToolResolved(tool);
+			return {
+				detected,
+				tool,
+				source: detected === "npm" && fallback ? "env-default" : candidates.length === 1 ? "single-candidate" : "detected-tool"
+			};
+		}
+		const envPreferredTool = getPreferredToolFromEnv(candidates);
+		if (!forceChoose && envPreferredTool) return {
+			detected,
+			tool: envPreferredTool,
+			source: "env-default"
+		};
+		const cwdForSelection = normalizeDir$1(node_process.default.cwd());
+		const selection = await selectToolCandidate(candidates, cwd);
+		if (selection.status === "selected") {
+			await writeWorkspaceToolPreference(resolveWorkspaceKey(cwdForSelection, candidates, await readWorkspaceToolPreferences()), selection.tool);
+			logWorkspaceToolSelected(selection.tool, forceChoose);
+			return {
+				detected,
+				tool: selection.tool,
+				source: "fresh-selection"
+			};
+		}
+		if (selection.status === "cancelled") {
+			console.log(picocolors.default.dim(isZh$5 ? "已取消" : "Cancelled"));
+			node_process.default.exit(0);
+		}
+		const tool = getDetectedToolFallback(detected, candidates);
+		logAmbiguousToolFallback(candidates, tool);
+		return {
+			detected,
+			tool,
+			source: "non-interactive-fallback"
+		};
+	})();
+	resolvedToolCache.set(cwd, pending);
+	return pending;
+}
 function getInstallCommand(tool, hasParams) {
 	const action = hasParams ? "add" : "install";
 	switch (tool) {
@@ -644,12 +993,7 @@ async function findUpAsync(startDir, predicate) {
 async function getParams(params) {
 	const cwd = node_process.default.cwd();
 	try {
-		let tool = await (0, lazy_js_utils_node.getPkgTool)() || "npm";
-		if (tool === "npm") {
-			if (findUpSync(cwd, (dir) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, "pnpm-workspace.yaml")) || (0, lazy_js_utils.isFile)(node_path.default.join(dir, "pnpm-lock.yaml")))) tool = "pnpm";
-			else if (findUpSync(cwd, (dir) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, "yarn.lock")) || (0, lazy_js_utils.isFile)(node_path.default.join(dir, ".yarnrc.yml")))) tool = "yarn";
-			else if (findUpSync(cwd, (dir) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, "bun.lockb")))) tool = "bun";
-		}
+		const { tool } = await resolvePkgTool();
 		switch (tool) {
 			case "pnpm": {
 				const pnpmWorkspaceRoot = findUpSync(cwd, (dir) => (0, lazy_js_utils.isFile)(node_path.default.join(dir, "pnpm-workspace.yaml")));
@@ -886,9 +1230,9 @@ async function pi(params, pkg, executor = "pi") {
 	];
 	let loading_status;
 	const { PI_DEFAULT, PI_MaxSockets: sockets } = node_process.default.env;
-	const { detected, tool } = await resolvePkgTool();
+	const { tool } = await resolvePkgTool();
 	const maxSockets = sockets || 4;
-	if (detected === "npm" && !PI_DEFAULT) stdio = "inherit";
+	if (tool === "npm" && !PI_DEFAULT) stdio = "inherit";
 	else loading_status = await loading(text, isSilent);
 	executor = getInstallCommand(tool, Boolean(params));
 	const newParams = isLatest ? "" : await getParams(params);
@@ -956,16 +1300,419 @@ function getCcommand() {
 }
 
 //#endregion
-//#region src/pfind.ts
+//#region src/prun.ts
+async function prun(params) {
+	ensurePrunAutoInit();
+	const hadNoHistoryEnv = node_process.default.env.CCOMMAND_NO_HISTORY != null || node_process.default.env.NO_HISTORY != null;
+	const initialNoHistory = node_process.default.env.CCOMMAND_NO_HISTORY ?? node_process.default.env.NO_HISTORY;
+	const prevNoHistory = node_process.default.env.CCOMMAND_NO_HISTORY;
+	if (!(hadNoHistoryEnv && isNoHistory$1(initialNoHistory))) delete node_process.default.env.CCOMMAND_NO_HISTORY;
+	else node_process.default.env.CCOMMAND_NO_HISTORY = "1";
+	const { ccommand } = getCcommand();
+	try {
+		await ccommand(params);
+	} finally {
+		if (prevNoHistory == null) delete node_process.default.env.CCOMMAND_NO_HISTORY;
+		else node_process.default.env.CCOMMAND_NO_HISTORY = prevNoHistory;
+	}
+}
+const isZh$2 = node_process.default.env.PI_Lang === "zh";
+const safeShellValue = /^[\w./:@%+=,-]+$/;
 function isNoHistory$1(value) {
 	if (!value) return false;
 	const normalized = value.toLowerCase();
 	return normalized === "1" || normalized === "true" || normalized === "yes";
 }
+function shellQuote(value) {
+	if (value === "") return "''";
+	if (safeShellValue.test(value)) return value;
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function powerShellQuote(value) {
+	if (value === "") return "''";
+	return `'${value.replace(/'/g, "''")}'`;
+}
+function splitCommand(value) {
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let hasValue = false;
+	const pushCurrent = () => {
+		if (!hasValue) return;
+		parts.push(current);
+		current = "";
+		hasValue = false;
+	};
+	for (let i = 0; i < value.length; i++) {
+		const char = value[i];
+		if (quote) {
+			if (char === quote) {
+				quote = null;
+				hasValue = true;
+				continue;
+			}
+			if (quote === "\"" && char === "\\") {
+				const next = value[i + 1];
+				if (next) {
+					current += next;
+					hasValue = true;
+					i++;
+					continue;
+				}
+			}
+			current += char;
+			hasValue = true;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			hasValue = true;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			pushCurrent();
+			while (i + 1 < value.length && /\s/.test(value[i + 1])) i++;
+			continue;
+		}
+		if (char === "\\") {
+			const next = value[i + 1];
+			if (next) {
+				current += next;
+				hasValue = true;
+				i++;
+				continue;
+			}
+		}
+		current += char;
+		hasValue = true;
+	}
+	pushCurrent();
+	return parts;
+}
+function normalizeShellName(value) {
+	const shell = (value || "").toLowerCase().replace(/\.exe$/, "");
+	if (shell === "powershell") return "powershell";
+	if (shell === "pwsh") return "pwsh";
+	if (shell === "fish" || shell === "zsh" || shell === "bash") return shell;
+	return shell;
+}
+function detectShell() {
+	const envShell = normalizeShellName(node_path.default.basename(node_process.default.env.SHELL || ""));
+	if (node_process.default.env.FISH_VERSION) return "fish";
+	if (node_process.default.env.ZSH_VERSION) return "zsh";
+	if (node_process.default.env.BASH_VERSION) return "bash";
+	if (node_process.default.env.POWERSHELL_DISTRIBUTION_CHANNEL) return "pwsh";
+	if (envShell) return envShell;
+	if (node_process.default.platform === "win32") return "powershell";
+	return "zsh";
+}
+function getPowerShellProfilePath(shell, home) {
+	if (node_process.default.platform === "win32") {
+		const documentsHome = node_process.default.env.USERPROFILE || home;
+		const profileDir = shell === "pwsh" ? "PowerShell" : "WindowsPowerShell";
+		return node_path.default.join(documentsHome, "Documents", profileDir, "Microsoft.PowerShell_profile.ps1");
+	}
+	const configHome = node_process.default.env.XDG_CONFIG_HOME || node_path.default.join(home, ".config");
+	return node_path.default.join(configHome, "powershell", "Microsoft.PowerShell_profile.ps1");
+}
+function ensurePrunAutoInit() {
+	if (!shouldAutoInit()) return;
+	const shell = detectShell();
+	const home = node_process.default.env.HOME || node_os.default.homedir();
+	let rcFile = "";
+	let initLine = "";
+	if (shell === "zsh") {
+		const zdotdir = node_process.default.env.ZDOTDIR || home;
+		rcFile = node_path.default.join(zdotdir, ".zshrc");
+		initLine = "eval \"$(prun --init zsh)\"";
+	} else if (shell === "bash") {
+		rcFile = node_path.default.join(home, ".bashrc");
+		initLine = "eval \"$(prun --init bash)\"";
+	} else if (shell === "fish") {
+		const configHome = node_process.default.env.XDG_CONFIG_HOME || node_path.default.join(home, ".config");
+		rcFile = node_path.default.join(configHome, "fish", "config.fish");
+		initLine = "prun --init fish | source";
+	} else if (shell === "powershell" || shell === "pwsh") {
+		rcFile = getPowerShellProfilePath(shell, home);
+		initLine = `prun --init ${shell} | Out-String | Invoke-Expression`;
+	} else return;
+	try {
+		const dir = node_path.default.dirname(rcFile);
+		if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
+		const content = node_fs.default.existsSync(rcFile) ? node_fs.default.readFileSync(rcFile, "utf8") : "";
+		if (!/prun\s+--init/.test(content)) {
+			const prefix = content.length && !content.endsWith("\n") ? "\n" : "";
+			node_fs.default.appendFileSync(rcFile, `${prefix}${initLine}\n`, "utf8");
+		}
+	} catch {}
+}
+function shouldAutoInit() {
+	const auto = node_process.default.env.PI_AUTO_INIT || node_process.default.env.PRUN_AUTO_INIT;
+	if (auto != null) return isNoHistory$1(auto);
+	if (isNoHistory$1(node_process.default.env.PI_NO_AUTO_INIT || node_process.default.env.PRUN_NO_AUTO_INIT)) return false;
+	if (node_process.default.env.CI) return false;
+	if (!node_process.default.stdout.isTTY || !node_process.default.stdin.isTTY) return false;
+	return true;
+}
+function printPrunInit(args = []) {
+	const shellArg = normalizeShellName(args[0]);
+	const binArg = args[1] || node_process.default.env.PRUN_BIN || "prun";
+	const bin = shellQuote(binArg);
+	const shell = shellArg || detectShell() || "zsh";
+	const historyHintExpr = "${CCOMMAND_HISTORY_HINT:-${XDG_CACHE_HOME:-$HOME/.cache}/ccommand/last-history}";
+	let script = "";
+	if (shell === "zsh") script = [
+		"prun() {",
+		`  local bin=${bin}`,
+		"  local -a cmd",
+		"  cmd=(${=bin})",
+		"  command \"${cmd[@]}\" \"$@\"",
+		"}",
+		"__prun_sync_history() {",
+		"  local history_disable=${CCOMMAND_NO_HISTORY:-${NO_HISTORY:-\"\"}}",
+		"  local history_disable_lower=${history_disable:l}",
+		"  if [[ $history_disable_lower == \"1\" || $history_disable_lower == \"true\" || $history_disable_lower == \"yes\" ]]; then",
+		"    return",
+		"  fi",
+		`  local history_hint=${historyHintExpr}`,
+		"  if [[ ! -f $history_hint ]]; then",
+		"    return",
+		"  fi",
+		"  local line",
+		"  line=$(<\"$history_hint\")",
+		"  local hint_ts=${line%%$'\\t'*}",
+		"  local hint_cmd=${line#*$'\\t'}",
+		"  if [[ -z $hint_ts || $hint_ts == $line ]]; then",
+		"    hint_cmd=$line",
+		"    hint_ts=\"\"",
+		"  fi",
+		"  if [[ -n $hint_ts && $hint_ts == ${__PRUN_HISTORY_HINT_TS:-\"\"} ]]; then",
+		"    return",
+		"  fi",
+		"  __PRUN_HISTORY_HINT_TS=$hint_ts",
+		"  fc -R",
+		"  if [[ $hint_cmd != pfind* && $hint_cmd != prun* ]]; then",
+		"    return",
+		"  fi",
+		"  local last_line",
+		"  last_line=$(fc -l -1 2>/dev/null)",
+		"  local last_cmd",
+		"  last_cmd=$(printf \"%s\" \"$last_line\" | sed -E \"s/^[[:space:]]*[0-9]+[[:space:]]*//\")",
+		"  if [[ $last_cmd == \"$hint_cmd\" ]]; then",
+		"    return",
+		"  fi",
+		"  if [[ $last_cmd == prun || $last_cmd == prun\\ * ]]; then",
+		"    local last_num",
+		"    last_num=$(printf \"%s\" \"$last_line\" | sed -E \"s/^[[:space:]]*([0-9]+).*/\\1/\")",
+		"    if [[ -n $last_num ]]; then",
+		"      history -d $last_num 2>/dev/null",
+		"    fi",
+		"  fi",
+		"  print -s -- \"$hint_cmd\"",
+		"}",
+		"",
+		"if ! typeset -f __prun_precmd >/dev/null; then",
+		"  __prun_precmd() { __prun_sync_history }",
+		"  autoload -Uz add-zsh-hook",
+		"  add-zsh-hook precmd __prun_precmd",
+		"fi"
+	].join("\n");
+	else if (shell === "bash") script = [
+		"prun() {",
+		`  local bin=${bin}`,
+		"  local -a cmd",
+		"  read -r -a cmd <<< \"$bin\"",
+		"  command \"${cmd[@]}\" \"$@\"",
+		"}",
+		"__prun_sync_history() {",
+		"  local history_disable=${CCOMMAND_NO_HISTORY:-${NO_HISTORY:-\"\"}}",
+		"  local history_disable_lower",
+		"  history_disable_lower=$(printf '%s' \"$history_disable\" | tr '[:upper:]' '[:lower:]')",
+		"  if [[ $history_disable_lower == \"1\" || $history_disable_lower == \"true\" || $history_disable_lower == \"yes\" ]]; then",
+		"    return",
+		"  fi",
+		`  local history_hint=${historyHintExpr}`,
+		"  if [[ ! -f $history_hint ]]; then",
+		"    return",
+		"  fi",
+		"  local line",
+		"  line=$(<\"$history_hint\")",
+		"  local hint_ts=\"${line%%$'\\t'*}\"",
+		"  local hint_cmd=\"${line#*$'\\t'}\"",
+		"  if [[ -z $hint_ts || $hint_ts == \"$line\" ]]; then",
+		"    hint_cmd=\"$line\"",
+		"    hint_ts=\"\"",
+		"  fi",
+		"  if [[ -n $hint_ts && $hint_ts == \"${__PRUN_HISTORY_HINT_TS:-}\" ]]; then",
+		"    return",
+		"  fi",
+		"  __PRUN_HISTORY_HINT_TS=$hint_ts",
+		"  if [[ $hint_cmd != pfind* && $hint_cmd != prun* ]]; then",
+		"    return",
+		"  fi",
+		"  history -n",
+		"  local last_line",
+		"  last_line=$(history 1)",
+		"  local last_cmd",
+		"  last_cmd=$(printf \"%s\" \"$last_line\" | sed -E \"s/^[[:space:]]*[0-9]+[[:space:]]*//\")",
+		"  if [[ $last_cmd == \"$hint_cmd\" ]]; then",
+		"    return",
+		"  fi",
+		"  if [[ $last_cmd == prun || $last_cmd == prun\\ * ]]; then",
+		"    local last_num",
+		"    last_num=$(printf \"%s\" \"$last_line\" | sed -E \"s/^[[:space:]]*([0-9]+).*/\\1/\")",
+		"    if [[ -n $last_num ]]; then",
+		"      history -d \"$last_num\" 2>/dev/null",
+		"    fi",
+		"  fi",
+		"  history -s -- \"$hint_cmd\"",
+		"}",
+		"",
+		"if [[ -z \"${__PRUN_PROMPT_INSTALLED:-}\" ]]; then",
+		"  __PRUN_PROMPT_INSTALLED=1",
+		"  if [[ -n \"${PROMPT_COMMAND:-}\" ]]; then",
+		"    PROMPT_COMMAND=\"__prun_sync_history;${PROMPT_COMMAND}\"",
+		"  else",
+		"    PROMPT_COMMAND=\"__prun_sync_history\"",
+		"  fi",
+		"fi"
+	].join("\n");
+	else if (shell === "fish") script = [
+		"function prun",
+		`  set -l bin ${bin}`,
+		"  set -l cmd (string split -- \" \" $bin)",
+		"  command $cmd $argv",
+		"  set -l history_disable $CCOMMAND_NO_HISTORY",
+		"  if test -z \"$history_disable\"",
+		"    set history_disable $NO_HISTORY",
+		"  end",
+		"  set history_disable (string lower -- (string trim -- \"$history_disable\"))",
+		"  if test \"$history_disable\" != \"1\" -a \"$history_disable\" != \"true\" -a \"$history_disable\" != \"yes\"",
+		"    history --merge",
+		"    set -l history_hint $CCOMMAND_HISTORY_HINT",
+		"    if test -z \"$history_hint\"",
+		"      set -l cache_home $XDG_CACHE_HOME",
+		"      if test -z \"$cache_home\"",
+		"        set cache_home \"$HOME/.cache\"",
+		"      end",
+		"      set history_hint \"$cache_home/ccommand/last-history\"",
+		"    end",
+		"    if test -f \"$history_hint\"",
+		"      set -l last_cmd (string trim -- (cat \"$history_hint\"))",
+		"      set -l last_cmd (string replace -r \"^[0-9]+\\t\" \"\" -- \"$last_cmd\")",
+		"      if string match -q \"pfind*\" -- \"$last_cmd\"; or string match -q \"prun*\" -- \"$last_cmd\"",
+		"        set -l last_hist (history --max=1)",
+		"        if test \"$last_hist\" != \"$last_cmd\"",
+		"          history add -- \"$last_cmd\"",
+		"        end",
+		"      end",
+		"    end",
+		"  end",
+		"end"
+	].join("\n");
+	else if (shell === "powershell" || shell === "pwsh") script = [
+		`$script:__prun_bin = @(${splitCommand(binArg).map(powerShellQuote).join(", ") || powerShellQuote("prun")})`,
+		"",
+		"function global:prun {",
+		"  param([Parameter(ValueFromRemainingArguments = $true)] [string[]] $CliArgs)",
+		"  $command = $script:__prun_bin[0]",
+		"  if ($command -ieq \"prun\") {",
+		"    $resolved = Get-Command -Name $command -CommandType Application,ExternalScript -ErrorAction SilentlyContinue | Select-Object -First 1",
+		"    if ($null -ne $resolved) {",
+		"      if ($resolved.Path) { $command = $resolved.Path }",
+		"      elseif ($resolved.Definition) { $command = $resolved.Definition }",
+		"      elseif ($resolved.Source) { $command = $resolved.Source }",
+		"    }",
+		"  }",
+		"  $extra = @()",
+		"  if ($script:__prun_bin.Count -gt 1) {",
+		"    $extra = $script:__prun_bin[1..($script:__prun_bin.Count - 1)]",
+		"  }",
+		"  & $command @extra @CliArgs",
+		"}",
+		"",
+		"function global:__prun_sync_history {",
+		"  $historyDisable = $env:CCOMMAND_NO_HISTORY",
+		"  if ([string]::IsNullOrWhiteSpace($historyDisable)) {",
+		"    $historyDisable = $env:NO_HISTORY",
+		"  }",
+		"  $historyDisable = \"$historyDisable\".Trim().ToLowerInvariant()",
+		"  if ($historyDisable -eq \"1\" -or $historyDisable -eq \"true\" -or $historyDisable -eq \"yes\") {",
+		"    return",
+		"  }",
+		"  $historyHint = $env:CCOMMAND_HISTORY_HINT",
+		"  if ([string]::IsNullOrWhiteSpace($historyHint)) {",
+		"    $cacheHome = $env:XDG_CACHE_HOME",
+		"    if ([string]::IsNullOrWhiteSpace($cacheHome)) {",
+		"      $cacheHome = Join-Path $HOME \".cache\"",
+		"    }",
+		"    $historyHint = Join-Path (Join-Path $cacheHome \"ccommand\") \"last-history\"",
+		"  }",
+		"  if (-not (Test-Path -LiteralPath $historyHint)) {",
+		"    return",
+		"  }",
+		"  $line = (Get-Content -LiteralPath $historyHint -Raw -ErrorAction SilentlyContinue)",
+		"  if ([string]::IsNullOrWhiteSpace($line)) {",
+		"    return",
+		"  }",
+		"  $line = $line.Trim()",
+		"  $hintTs = \"\"",
+		"  $hintCmd = $line",
+		"  $parts = $line -split \"`t\", 2",
+		"  if ($parts.Count -eq 2 -and $parts[0] -match \"^\\d+$\") {",
+		"    $hintTs = $parts[0]",
+		"    $hintCmd = $parts[1]",
+		"  }",
+		"  if (-not $hintCmd.StartsWith(\"prun\") -and -not $hintCmd.StartsWith(\"pfind\")) {",
+		"    return",
+		"  }",
+		"  if ($hintTs -and $script:__PRUN_HISTORY_HINT_TS -eq $hintTs) {",
+		"    return",
+		"  }",
+		"  $script:__PRUN_HISTORY_HINT_TS = $hintTs",
+		"  $psReadLineType = \"Microsoft.PowerShell.PSConsoleReadLine\" -as [type]",
+		"  if ($null -eq $psReadLineType) {",
+		"    return",
+		"  }",
+		"  $psReadLineType::AddToHistory($hintCmd)",
+		"}",
+		"",
+		"if (-not $script:__PRUN_PROMPT_INSTALLED) {",
+		"  $script:__PRUN_PROMPT_INSTALLED = $true",
+		"  if (-not $script:__prun_original_prompt) {",
+		"    if (Test-Path Function:\\prompt) {",
+		"      $script:__prun_original_prompt = $function:prompt",
+		"    }",
+		"  }",
+		"  function global:prompt {",
+		"    __prun_sync_history",
+		"    if ($script:__prun_original_prompt) {",
+		"      & $script:__prun_original_prompt",
+		"      return",
+		"    }",
+		"    \"PS $($executionContext.SessionState.Path.CurrentLocation)> \"",
+		"  }",
+		"}"
+	].join("\n");
+	else {
+		console.log(picocolors.default.red(isZh$2 ? `不支持的 shell: ${shell}` : `Unsupported shell: ${shell}`));
+		return;
+	}
+	console.log(script);
+}
+
+//#endregion
+//#region src/pfind.ts
+function isNoHistory(value) {
+	if (!value) return false;
+	const normalized = value.toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes";
+}
 async function pfind(params) {
+	ensurePrunAutoInit();
 	const hadNoHistoryEnv = node_process.default.env.CCOMMAND_NO_HISTORY != null || node_process.default.env.NO_HISTORY != null;
 	const initialNoHistory = node_process.default.env.CCOMMAND_NO_HISTORY ?? node_process.default.env.NO_HISTORY;
-	const shouldWriteHistory = !(hadNoHistoryEnv && isNoHistory$1(initialNoHistory));
+	const shouldWriteHistory = !(hadNoHistoryEnv && isNoHistory(initialNoHistory));
 	const prevNoHistory = node_process.default.env.CCOMMAND_NO_HISTORY;
 	if (shouldWriteHistory) delete node_process.default.env.CCOMMAND_NO_HISTORY;
 	else node_process.default.env.CCOMMAND_NO_HISTORY = "1";
@@ -1087,117 +1834,6 @@ async function pix(params) {
 	}
 }
 
-//#endregion
-//#region src/prun.ts
-async function prun(params) {
-	ensurePrunAutoInit();
-	const hadNoHistoryEnv = node_process.default.env.CCOMMAND_NO_HISTORY != null || node_process.default.env.NO_HISTORY != null;
-	const initialNoHistory = node_process.default.env.CCOMMAND_NO_HISTORY ?? node_process.default.env.NO_HISTORY;
-	const prevNoHistory = node_process.default.env.CCOMMAND_NO_HISTORY;
-	if (!(hadNoHistoryEnv && isNoHistory(initialNoHistory))) delete node_process.default.env.CCOMMAND_NO_HISTORY;
-	else node_process.default.env.CCOMMAND_NO_HISTORY = "1";
-	const { ccommand } = getCcommand();
-	try {
-		await ccommand(params);
-	} finally {
-		if (prevNoHistory == null) delete node_process.default.env.CCOMMAND_NO_HISTORY;
-		else node_process.default.env.CCOMMAND_NO_HISTORY = prevNoHistory;
-	}
-}
-const isZh$2 = node_process.default.env.PI_Lang === "zh";
-const safeShellValue = /^[\w./:@%+=,-]+$/;
-function isNoHistory(value) {
-	if (!value) return false;
-	const normalized = value.toLowerCase();
-	return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-function shellQuote(value) {
-	if (value === "") return "''";
-	if (safeShellValue.test(value)) return value;
-	return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function detectShell() {
-	const envShell = node_process.default.env.SHELL || "";
-	if (node_process.default.env.FISH_VERSION) return "fish";
-	if (node_process.default.env.ZSH_VERSION) return "zsh";
-	if (node_process.default.env.BASH_VERSION) return "bash";
-	return envShell.split("/").pop() || "zsh";
-}
-function ensurePrunAutoInit() {
-	if (!shouldAutoInit()) return;
-	const shell = detectShell();
-	const home = node_process.default.env.HOME || node_os.default.homedir();
-	let rcFile = "";
-	let initLine = "";
-	if (shell === "zsh") {
-		const zdotdir = node_process.default.env.ZDOTDIR || home;
-		rcFile = node_path.default.join(zdotdir, ".zshrc");
-		initLine = "eval \"$(prun --init zsh)\"";
-	} else if (shell === "bash") {
-		rcFile = node_path.default.join(home, ".bashrc");
-		initLine = "eval \"$(prun --init bash)\"";
-	} else if (shell === "fish") {
-		const configHome = node_process.default.env.XDG_CONFIG_HOME || node_path.default.join(home, ".config");
-		rcFile = node_path.default.join(configHome, "fish", "config.fish");
-		initLine = "prun --init fish | source";
-	} else return;
-	try {
-		const dir = node_path.default.dirname(rcFile);
-		if (!node_fs.default.existsSync(dir)) node_fs.default.mkdirSync(dir, { recursive: true });
-		const content = node_fs.default.existsSync(rcFile) ? node_fs.default.readFileSync(rcFile, "utf8") : "";
-		if (!/prun\s+--init/.test(content)) {
-			const prefix = content.length && !content.endsWith("\n") ? "\n" : "";
-			node_fs.default.appendFileSync(rcFile, `${prefix}${initLine}\n`, "utf8");
-		}
-	} catch {}
-}
-function shouldAutoInit() {
-	const auto = node_process.default.env.PI_AUTO_INIT || node_process.default.env.PRUN_AUTO_INIT;
-	if (auto != null) return isNoHistory(auto);
-	if (isNoHistory(node_process.default.env.PI_NO_AUTO_INIT || node_process.default.env.PRUN_NO_AUTO_INIT)) return false;
-	if (node_process.default.env.CI) return false;
-	if (!node_process.default.stdout.isTTY || !node_process.default.stdin.isTTY) return false;
-	return true;
-}
-function printPrunInit(args = []) {
-	const shellArg = args[0];
-	const binArg = args[1];
-	const bin = shellQuote(binArg || node_process.default.env.PRUN_BIN || "prun");
-	const shell = shellArg || detectShell() || "zsh";
-	let script = "";
-	if (shell === "zsh") script = [
-		"prun() {",
-		`  local bin=${bin}`,
-		"  local -a cmd",
-		"  cmd=(${=bin})",
-		"  command \"${cmd[@]}\" \"$@\"",
-		"  fc -R",
-		"}"
-	].join("\n");
-	else if (shell === "bash") script = [
-		"prun() {",
-		`  local bin=${bin}`,
-		"  local -a cmd",
-		"  read -r -a cmd <<< \"$bin\"",
-		"  command \"${cmd[@]}\" \"$@\"",
-		"  history -n",
-		"}"
-	].join("\n");
-	else if (shell === "fish") script = [
-		"function prun",
-		`  set -l bin ${bin}`,
-		"  set -l cmd (string split -- \" \" $bin)",
-		"  command $cmd $argv",
-		"  history --merge",
-		"end"
-	].join("\n");
-	else {
-		console.log(picocolors.default.red(isZh$2 ? `不支持的 shell: ${shell}` : `Unsupported shell: ${shell}`));
-		return;
-	}
-	console.log(script);
-}
-
 //#endregion
 //#region src/pu.ts
 function pu() {
@@ -1268,6 +1904,72 @@ const runMap = {
 	"pio.mjs": pio
 };
 const isZh = node_process.default.env.PI_Lang === "zh";
+const pkgToolFlagCommands = new Set([
+	"pi",
+	"pi.mjs",
+	"pil",
+	"pil.mjs",
+	"pci",
+	"pci.mjs"
+]);
+const supportedPkgTools = new Set(getSupportedPkgToolNames());
+function parsePkgToolFlags(argv) {
+	const hasInspectFlag = argv.includes("--show-tool") || argv.includes("--list-tools");
+	let chooseTool = false;
+	let forgetTool = false;
+	let listTools = false;
+	let showTool = false;
+	let showToolJson = false;
+	let preferredTool = "";
+	let invalidPreferredTool = "";
+	const normalizedArgv = [];
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--forget-tool") {
+			forgetTool = true;
+			continue;
+		}
+		if (arg === "--show-tool") {
+			showTool = true;
+			continue;
+		}
+		if (arg === "--list-tools") {
+			listTools = true;
+			continue;
+		}
+		if (arg === "--json" && hasInspectFlag) {
+			showToolJson = true;
+			continue;
+		}
+		if (arg === "--choose-tool") {
+			chooseTool = true;
+			const next = argv[i + 1];
+			if (next && supportedPkgTools.has(next)) {
+				preferredTool = next;
+				i++;
+			}
+			continue;
+		}
+		if (arg.startsWith("--choose-tool=")) {
+			chooseTool = true;
+			const value = arg.slice(14);
+			if (supportedPkgTools.has(value)) preferredTool = value;
+			else invalidPreferredTool = value;
+			continue;
+		}
+		normalizedArgv.push(arg);
+	}
+	return {
+		chooseTool,
+		forgetTool,
+		invalidPreferredTool,
+		listTools,
+		normalizedArgv,
+		preferredTool,
+		showTool,
+		showToolJson
+	};
+}
 async function setup() {
 	const cmd = node_process.default.argv[1];
 	let exec = "";
@@ -1284,8 +1986,56 @@ async function setup() {
 		printPrunInit(argv.slice(1));
 		return;
 	}
-	let params = (0, lazy_js_utils.spaceFormat)(argv.join(" ")).trim();
-	if (!await (0, lazy_js_utils_node.hasPkg)(rootPath)) {
+	const supportsPkgToolFlags = pkgToolFlagCommands.has(exec);
+	const { chooseTool, forgetTool, invalidPreferredTool, listTools, normalizedArgv, preferredTool, showTool, showToolJson } = supportsPkgToolFlags ? parsePkgToolFlags(argv) : {
+		chooseTool: false,
+		forgetTool: false,
+		invalidPreferredTool: "",
+		listTools: false,
+		normalizedArgv: argv,
+		preferredTool: "",
+		showTool: false,
+		showToolJson: false
+	};
+	if (invalidPreferredTool) {
+		console.log(picocolors.default.red(isZh ? `不支持直接指定 ${invalidPreferredTool}，可选值为: ${getSupportedPkgToolNames().join(", ")}` : `Unsupported tool "${invalidPreferredTool}". Valid values: ${getSupportedPkgToolNames().join(", ")}`));
+		return;
+	}
+	if (chooseTool) node_process.default.env.PI_FORCE_PICK_TOOL = "1";
+	else delete node_process.default.env.PI_FORCE_PICK_TOOL;
+	if (forgetTool) node_process.default.env.PI_FORGET_PICK_TOOL = "1";
+	else delete node_process.default.env.PI_FORGET_PICK_TOOL;
+	if (preferredTool) node_process.default.env.PI_PREFERRED_TOOL = preferredTool;
+	else delete node_process.default.env.PI_PREFERRED_TOOL;
+	let params = (0, lazy_js_utils.spaceFormat)(normalizedArgv.join(" ")).trim();
+	const hasPackage = await (0, lazy_js_utils_node.hasPkg)(rootPath);
+	if (supportsPkgToolFlags && (chooseTool || forgetTool || showTool || listTools)) {
+		if (!hasPackage) {
+			console.log(picocolors.default.yellow(isZh ? "当前命令仅在 Node 项目的包管理场景下可用。" : "This option is only available for package-manager selection in Node projects."));
+			return;
+		}
+		if (showTool || listTools) {
+			if (forgetTool && !chooseTool) {
+				const removed = await forgetPkgToolPreference();
+				console.log(removed ? picocolors.default.green(isZh ? "已清除当前 workspace 保存的包管理器选择。" : "Cleared the saved package-manager choice for this workspace.") : picocolors.default.yellow(isZh ? "当前 workspace 没有保存的包管理器选择。" : "No saved package-manager choice was found for this workspace."));
+			}
+			if (chooseTool) await resolvePkgTool();
+			const status = await getPkgToolStatus();
+			if (listTools) printPkgToolCandidates(status, { json: showToolJson });
+			else printPkgToolStatus(status, { json: showToolJson });
+			return;
+		}
+		if (normalizedArgv.length === 0) {
+			if (forgetTool && !chooseTool) {
+				const removed = await forgetPkgToolPreference();
+				console.log(removed ? picocolors.default.green(isZh ? "已清除当前 workspace 保存的包管理器选择。" : "Cleared the saved package-manager choice for this workspace.") : picocolors.default.yellow(isZh ? "当前 workspace 没有保存的包管理器选择。" : "No saved package-manager choice was found for this workspace."));
+				return;
+			}
+			await resolvePkgTool();
+			return;
+		}
+	}
+	if (!hasPackage) {
 		if (await (0, lazy_js_utils_node.isGo)(rootPath)) {
 			if (exec === "pi") {
 				const loading_status = await loading(`${isZh ? "正在为您安装" : "Installing"} ${params} ...\n`);
@@ -1337,7 +2087,7 @@ async function setup() {
 		else console.log(picocolors.default.yellow(isZh ? "命令不存在, 请执行 pi -h 查看帮助" : "The command does not exist, please execute pi -h to view the help"));
 		return;
 	}
-	const pkg = argv.filter((v) => !v.startsWith("-")).join(" ");
+	const pkg = normalizedArgv.filter((v) => !v.startsWith("-")).join(" ");
 	await handler(params, pkg);
 }
 if (!node_process.default.env.PI_TEST) setup().catch((error) => {