@simon_he/pi 0.2.10 → 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.10";
+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,
-		tool: detected === "npm" && fallback ? fallback : 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,
+		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);
@@ -1560,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 = "";
@@ -1576,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`);
@@ -1629,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) => {