@bacnh85/pi-plan 0.1.5 → 0.1.7

package/README.md

@@ -58,6 +58,23 @@ pi --plan
 
 Agents should ask blocking, user-answerable planning questions with `ask_plan_question` before finalizing a plan. Final plans may still list non-blocking uncertainties or implementation-time checks, but should not leave consequential user decisions unresolved.
 
+## Plan-mode bash allowlist
+
+Plan mode allows only a narrow read-only subset of shell commands. Examples include:
+
+```bash
+git status --short
+git diff
+git show HEAD -- package.json
+git log --oneline -5
+git branch --show-current
+git rev-parse --show-toplevel
+npm view <package> --json
+npm info <package> version
+```
+
+`npm view` and `npm info` are allowed only for npm registry metadata lookup. They may contact the network and disclose the queried package name, but pi-plan does not allow npm install/update/publish/run/exec/auth/config style commands in plan mode.
+
 ## Reasoning levels
 
 pi-plan remembers two reasoning levels:

package/index.ts

@@ -30,9 +30,9 @@ interface PlanState {
 }
 
 interface PlanPreferences {
-	version: 1;
-	planThinking: ThinkingLevel;
-	normalThinking: ThinkingLevel;
+	version: 2;
+	defaults: { planThinking: ThinkingLevel; normalThinking: ThinkingLevel };
+	perModel: Record<string, { planThinking: ThinkingLevel; normalThinking: ThinkingLevel }>;
 }
 
 interface WritePlanParams {
@@ -128,14 +128,35 @@ function hasOpenQuestionWarning(content: string): boolean {
 	return /(^|\n)#{1,6}\s+.*open questions?.*\n[\s\S]*\?/i.test(content);
 }
 
+function modelKey(model: { provider?: string; id?: string } | undefined): string | undefined {
+	if (!model?.provider || !model?.id) return undefined;
+	return `${model.provider}/${model.id}`;
+}
+
+function getEffectiveThinking(prefs: PlanPreferences, model: { provider?: string; id?: string } | undefined): { plan: ThinkingLevel; normal: ThinkingLevel } {
+	const key = modelKey(model);
+	const stored = key ? prefs.perModel[key] : undefined;
+	return {
+		plan: stored?.planThinking ?? prefs.defaults.planThinking,
+		normal: stored?.normalThinking ?? prefs.defaults.normalThinking,
+	};
+}
+
 async function loadPreferences(): Promise<PlanPreferences | undefined> {
 	try {
 		const raw = await readFile(PREFERENCES_FILE, "utf8");
-		const parsed = JSON.parse(raw) as Partial<PlanPreferences>;
-		const savedPlanThinking = parsed.planThinking;
-		const savedNormalThinking = parsed.normalThinking;
-		if (parsed.version !== 1 || !savedPlanThinking || !savedNormalThinking || !isThinkingLevel(savedPlanThinking) || !isThinkingLevel(savedNormalThinking)) return undefined;
-		return { version: 1, planThinking: savedPlanThinking, normalThinking: savedNormalThinking };
+		const parsed = JSON.parse(raw) as Record<string, any>;
+		if (parsed.version === 2 && isThinkingLevel(parsed.defaults?.planThinking) && isThinkingLevel(parsed.defaults?.normalThinking) && typeof parsed.perModel === "object" && parsed.perModel !== null) {
+			return { version: 2, defaults: parsed.defaults, perModel: parsed.perModel } as PlanPreferences;
+		}
+		if (parsed.version === 1 && isThinkingLevel(parsed.planThinking) && isThinkingLevel(parsed.normalThinking)) {
+			return {
+				version: 2,
+				defaults: { planThinking: parsed.planThinking as ThinkingLevel, normalThinking: parsed.normalThinking as ThinkingLevel },
+				perModel: {},
+			};
+		}
+		return undefined;
 	} catch {
 		return undefined;
 	}
@@ -152,11 +173,60 @@ function isDestructiveBash(command: string): boolean {
 	return DESTRUCTIVE_BASH_PATTERNS.some((pattern) => pattern.test(command));
 }
 
-function isReadOnlyBash(command: string): boolean {
+function tokenizeSimpleCommand(command: string): string[] | undefined {
 	const trimmed = command.trim();
-	if (!trimmed) return true;
-	if (/[;&|`$(){}]/.test(trimmed) || /\b(python|python3|node|ruby|perl|php|sh|bash|zsh|fish)\b/i.test(trimmed)) return false;
-	return /^(git\s+(status|branch|rev-parse|diff|show|log|ls-files)\b|(?:rg|grep|find|fd|ls|pwd|cat|head|tail|sed|awk|wc|sort|uniq|cut)\b)/i.test(trimmed);
+	if (!trimmed) return [];
+	if (/[;&|`$(){}<>]/.test(trimmed) || /\b(python|python3|node|ruby|perl|php|sh|bash|zsh|fish)\b/i.test(trimmed)) return undefined;
+	if (/['"]/.test(trimmed)) return undefined;
+	return trimmed.split(/\s+/).filter(Boolean);
+}
+
+function hasOptionValue(tokens: string[], index: number): boolean {
+	return index + 1 < tokens.length && !tokens[index + 1].startsWith("-");
+}
+
+function isAllowedNpmMetadataCommand(tokens: string[]): boolean {
+	if (tokens[0] !== "npm" || !["view", "info"].includes(tokens[1])) return false;
+	let hasSpec = false;
+	for (let index = 2; index < tokens.length; index += 1) {
+		const token = tokens[index];
+		if (["--registry", "--tag"].includes(token)) {
+			if (!hasOptionValue(tokens, index)) return false;
+			index += 1;
+			continue;
+		}
+		if (token.startsWith("--registry=") || token.startsWith("--tag=") || token === "--json" || token === "--parseable" || token === "--silent") continue;
+		if (token.startsWith("-")) return false;
+		hasSpec = true;
+	}
+	return hasSpec;
+}
+
+function isAllowedGitCommand(tokens: string[]): boolean {
+	if (tokens[0] !== "git" || !tokens[1]) return false;
+	const subcommand = tokens[1];
+	const args = tokens.slice(2);
+	if (["add", "commit", "push", "pull", "merge", "rebase", "reset", "checkout", "switch", "restore", "stash", "cherry-pick", "revert", "tag", "init", "clone", "fetch", "remote", "config", "worktree"].includes(subcommand)) return false;
+
+	if (subcommand === "status") return args.every((arg) => ["--short", "-s", "--porcelain", "--porcelain=v1", "--porcelain=v2", "--branch", "-b", "--ignored", "--ignored=matching", "--ignored=traditional", "--ignored=no", "--untracked-files", "--untracked-files=no", "--untracked-files=normal", "--untracked-files=all", "-uno", "-unormal", "-uall"].includes(arg));
+	if (subcommand === "diff") return !args.some((arg) => arg === "--output" || arg.startsWith("--output=") || arg === "--ext-diff" || arg === "--textconv");
+	if (["show", "log", "rev-parse", "ls-files"].includes(subcommand)) return true;
+	if (subcommand === "branch") {
+		const mutating = new Set(["-d", "-D", "-m", "-M", "-c", "-C", "--delete", "--move", "--copy", "--set-upstream-to", "--track", "--unset-upstream", "--edit-description"]);
+		return !args.some((arg) => mutating.has(arg) || arg.startsWith("--set-upstream-to=") || arg === "-u");
+	}
+	return false;
+}
+
+export function isReadOnlyBash(command: string): boolean {
+	const tokens = tokenizeSimpleCommand(command);
+	if (!tokens) return false;
+	if (tokens.length === 0) return true;
+	const normalized = tokens[0] === "rtk" ? tokens.slice(1) : tokens;
+	if (normalized.length === 0) return false;
+	if (isAllowedGitCommand(normalized)) return true;
+	if (isAllowedNpmMetadataCommand(normalized)) return true;
+	return /^(rg|grep|find|fd|ls|pwd|cat|head|tail|sed|awk|wc|sort|uniq|cut)$/.test(normalized[0]);
 }
 
 export default function piPlanExtension(pi: ExtensionAPI): void {
@@ -199,8 +269,11 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		} satisfies PlanState);
 	}
 
+	let preferences: PlanPreferences | undefined;
+
 	function persistPreferences(): void {
-		void savePreferences({ version: 1, planThinking, normalThinking }).catch(() => undefined);
+		if (!preferences) return;
+		void savePreferences(preferences).catch(() => undefined);
 	}
 
 	function enablePlanTools(): void {
@@ -230,6 +303,10 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 			if (normalThinking === level) return;
 			normalThinking = level;
 		}
+		const key = modelKey(ctx.model);
+		if (key && preferences) {
+			preferences.perModel[key] = { planThinking, normalThinking };
+		}
 		setStatus(ctx);
 		persistState();
 		persistPreferences();
@@ -452,26 +529,29 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
-		const preferences = await loadPreferences();
+		preferences = await loadPreferences();
+		if (!preferences) {
+			preferences = { version: 2, defaults: { planThinking, normalThinking }, perModel: {} };
+		}
+		const effective = getEffectiveThinking(preferences, ctx.model);
+		planThinking = effective.plan;
+		normalThinking = effective.normal;
+
 		const entries = ctx.sessionManager.getEntries();
 		const saved = entries
 			.filter((entry: { type: string; customType?: string }) => entry.type === "custom" && entry.customType === "pi-plan")
 			.pop() as { data?: PlanState } | undefined;
-		if (preferences) {
-			planThinking = preferences.planThinking;
-			normalThinking = preferences.normalThinking;
-		}
 		if (saved?.data) {
 			planModeEnabled = saved.data.enabled ?? planModeEnabled;
 			executionMode = saved.data.executing ?? executionMode;
-			if (!preferences && isThinkingLevel(saved.data.planThinking)) planThinking = saved.data.planThinking;
-			if (!preferences && isThinkingLevel(saved.data.normalThinking)) normalThinking = saved.data.normalThinking;
+			if (isThinkingLevel(saved.data.planThinking)) planThinking = saved.data.planThinking;
+			if (isThinkingLevel(saved.data.normalThinking)) normalThinking = saved.data.normalThinking;
 			toolsBeforePlan = saved.data.toolsBeforePlan ?? toolsBeforePlan;
 			lastPlanPath = saved.data.lastPlanPath ?? lastPlanPath;
 			lastPlanTitle = saved.data.lastPlanTitle ?? lastPlanTitle;
 			lastPlanStatus = saved.data.lastPlanStatus ?? lastPlanStatus;
 		}
-		if (!preferences) persistPreferences();
+		persistPreferences();
 		if (pi.getFlag("plan") === true) planModeEnabled = true;
 		if (planModeEnabled) {
 			enablePlanTools();
@@ -483,6 +563,25 @@ export default function piPlanExtension(pi: ExtensionAPI): void {
 		clearPlanWidget(ctx);
 	});
 
+	pi.on("model_select", async (event, ctx) => {
+		if (executionMode) return;
+		if (!preferences) return;
+		const effective = getEffectiveThinking(preferences, event.model);
+		if (planModeEnabled) {
+			if (planThinking !== effective.plan) {
+				planThinking = effective.plan;
+				applyThinking(planThinking);
+			}
+		} else {
+			if (normalThinking !== effective.normal) {
+				normalThinking = effective.normal;
+				applyThinking(normalThinking);
+			}
+		}
+		setStatus(ctx);
+		persistState();
+	});
+
 	pi.on("thinking_level_select", async (event, ctx) => {
 		if (applyingStoredThinking) return;
 		if (!isThinkingLevel(event.level)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-plan",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Pi extension that adds a plan mode with workspace markdown plans and thinking-level presets.",
   "license": "MIT",
   "publishConfig": {