pi-prompt-template-model 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-02-08
+
+### Added
+
+- **Chain command**: `/chain` orchestrates multiple prompt templates sequentially, each with its own model, skill, and thinking level. Conversation context flows between steps naturally.
+- Per-step args override shared args: `/chain analyze "error handling" -> fix-plan "focus on perf" -> summarize -- src/main.ts`
+- Mid-chain failure rolls back to the original model and thinking level
+- Step progress notifications show which step is running
+- State isolation: chain uses local variables, never interferes with single-command restore behavior
+
+## [0.2.1] - 2026-01-31
+
+### Fixed
+
+- Thinking level now correctly restored after commands that switch model without a `thinking` field. Previously, running a prompt template that only specified `model` would reset thinking to "off" instead of restoring the original level (e.g., "high").
+
 ## [0.2.0] - 2025-01-31
 
 ### Added

package/README.md

@@ -238,6 +238,34 @@ restore: false
 Switched to Haiku. How can I help?
 ```
 
+## Chaining Templates
+
+The `/chain` command runs multiple templates sequentially. Each step switches to its own model, injects its own skill, and the conversation context carries forward between steps.
+
+```
+/chain analyze-code -> fix-plan -> summarize -- src/main.ts
+```
+
+This runs `analyze-code` first, then `fix-plan` (which sees the analysis in conversation context), then `summarize`. The `-- src/main.ts` provides shared args substituted into every template's `$@`.
+
+Each step can also receive its own args, overriding the shared args for that step:
+
+```
+/chain analyze-code "look at error handling" -> fix-plan "focus on perf" -> summarize
+```
+
+Here `analyze-code` gets `$@ = "look at error handling"`, `fix-plan` gets `$@ = "focus on perf"`, and `summarize` has no per-step args so it falls back to the shared args (empty in this case, but conversation context from prior steps is usually enough).
+
+You can mix both:
+
+```
+/chain analyze-code "error handling" -> fix-plan -> summarize -- src/main.ts
+```
+
+Step 1 uses its per-step args (`"error handling"`), steps 2 and 3 fall back to the shared args (`"src/main.ts"`).
+
+The chain captures your current model and thinking level before starting, and restores them when the chain finishes (or if any step fails mid-chain). Individual template `restore` settings are ignored during chain execution.
+
 ## Autocomplete Display
 
 Commands show model, thinking level, and skill in the description:
@@ -264,3 +292,5 @@ The model switches, skill injects, agent responds, and output prints to stdout.
 
 - Templates discovered at startup. Restart pi after adding/modifying.
 - Model restore state is in-memory. Closing pi mid-response loses restore state.
+- Only templates with a `model` field can be chained. Templates without `model` are handled by pi core and invisible to this extension.
+- Per-step args containing a literal `->` will be misinterpreted as a step separator. Use shared `--` args or a template file instead.

package/index.ts

@@ -376,6 +376,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 	let previousModel: Model<any> | undefined;
 	let previousThinking: ThinkingLevel | undefined;
 	let pendingSkill: { name: string; cwd: string } | undefined;
+	let chainActive = false;
 	
 	// Register custom message renderer for skill-loaded messages
 	pi.registerMessageRenderer<SkillLoadedDetails>("skill-loaded", renderSkillLoaded);
@@ -493,6 +494,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 	// Restore model and thinking level after the agent finishes responding
 	pi.on("agent_end", async (_event, ctx) => {
+		if (chainActive) return;
 		const restoredParts: string[] = [];
 
 		if (previousModel) {
@@ -549,8 +551,9 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					return;
 				}
 
-				// Capture current model before any switching (needed for restore)
+				// Capture current state before any switching (needed for restore)
 				const savedModel = ctx.model;
+				const savedThinking = pi.getThinkingLevel();
 
 				// Resolve and switch to the first available model from the list
 				const result = await resolveAndSwitch(currentPrompt.models, ctx);
@@ -558,17 +561,15 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 				if (!result.alreadyActive && currentPrompt.restore) {
 					previousModel = savedModel;
+					previousThinking = savedThinking;
 				}
 
 				// Set thinking level if specified
 				if (currentPrompt.thinking) {
-					const currentThinking = pi.getThinkingLevel();
-					if (currentThinking !== currentPrompt.thinking) {
-						if (currentPrompt.restore) {
-							previousThinking = currentThinking;
-						}
-						pi.setThinkingLevel(currentPrompt.thinking);
+					if (currentPrompt.restore && previousThinking === undefined && currentPrompt.thinking !== savedThinking) {
+						previousThinking = savedThinking;
 					}
+					pi.setThinkingLevel(currentPrompt.thinking);
 				}
 
 				// Set pending skill for before_agent_start handler
@@ -592,4 +593,104 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			},
 		});
 	}
+
+	pi.registerCommand("chain", {
+		description: "Chain prompt templates sequentially [template -> template -> ...]",
+		handler: async (args, ctx) => {
+			let templatesPart = args;
+			let argsPart = "";
+			const argsSeparator = args.indexOf(" -- ");
+			if (argsSeparator !== -1) {
+				templatesPart = args.slice(0, argsSeparator);
+				argsPart = args.slice(argsSeparator + 4);
+			}
+
+			const steps = templatesPart
+				.split("->")
+				.map(s => s.trim())
+				.filter(Boolean)
+				.map(segment => {
+					const tokens = parseCommandArgs(segment);
+					return { name: tokens[0], args: tokens.slice(1) };
+				});
+
+			if (steps.length === 0) {
+				ctx.ui.notify("No templates specified", "error");
+				return;
+			}
+
+			const missingTemplates = steps.filter(s => !prompts.has(s.name));
+			if (missingTemplates.length > 0) {
+				ctx.ui.notify(`Templates not found: ${missingTemplates.map(s => s.name).join(", ")}`, "error");
+				return;
+			}
+
+			const templates = steps.map(s => ({ ...prompts.get(s.name)!, stepArgs: s.args }));
+			const originalModel = ctx.model;
+			const originalThinking = pi.getThinkingLevel();
+			const parsedArgs = parseCommandArgs(argsPart);
+
+			try {
+				chainActive = true;
+
+				for (const [index, tmpl] of templates.entries()) {
+					const stepNumber = index + 1;
+					const modelLabel = tmpl.models
+						.map(m => m.split("/").pop() || m)
+						.join("|");
+					const skillLabel = tmpl.skill ? ` +${tmpl.skill}` : "";
+					const thinkingLabel = tmpl.thinking ? ` ${tmpl.thinking}` : "";
+					ctx.ui.notify(
+						`Step ${stepNumber}/${templates.length}: ${tmpl.name} [${modelLabel}${thinkingLabel}${skillLabel}]`,
+						"info"
+					);
+
+					const result = await resolveAndSwitch(tmpl.models, ctx);
+					if (!result) {
+						ctx.ui.notify(`Step ${stepNumber}/${templates.length} failed: ${tmpl.name}`, "error");
+						if (originalModel) {
+							await pi.setModel(originalModel);
+						}
+						if (originalThinking !== undefined) {
+							pi.setThinkingLevel(originalThinking);
+						}
+						return;
+					}
+
+					if (tmpl.thinking) {
+						pi.setThinkingLevel(tmpl.thinking);
+					}
+
+					pendingSkill = undefined;
+					if (tmpl.skill) {
+						pendingSkill = { name: tmpl.skill, cwd: ctx.cwd };
+					}
+
+					const effectiveArgs = tmpl.stepArgs.length > 0 ? tmpl.stepArgs : parsedArgs;
+					const expandedContent = substituteArgs(tmpl.content, effectiveArgs);
+					pi.sendUserMessage(expandedContent);
+
+					while (ctx.isIdle()) {
+						await new Promise(resolve => setTimeout(resolve, 10));
+					}
+					await ctx.waitForIdle();
+				}
+
+				const restoredParts: string[] = [];
+				if (originalModel) {
+					restoredParts.push(originalModel.id);
+					await pi.setModel(originalModel);
+				}
+				if (originalThinking !== undefined) {
+					restoredParts.push(`thinking:${originalThinking}`);
+					pi.setThinkingLevel(originalThinking);
+				}
+				if (restoredParts.length > 0) {
+					ctx.ui.notify(`Restored to ${restoredParts.join(", ")}`, "info");
+				}
+			} finally {
+				chainActive = false;
+			}
+		},
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-prompt-template-model",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Prompt template model selector extension for pi coding agent",
   "author": "Nico Bailon",
   "license": "MIT",