pi-prompt-template-model 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,13 +1,52 @@
 # Changelog
 
-## [Unreleased]
+## [0.4.0] - 2026-03-13
+
+### Added
+
+- Inline `<if-model is="...">...</if-model>` blocks with optional `<else>` branches inside prompt bodies.
+- Provider wildcard matching in conditionals with syntax like `anthropic/*`.
+- Conditional rendering now happens after model fallback resolution for both single prompt commands and `/chain-prompts`.
+- Prompt argument substitution now mirrors pi core more closely, including `${@:N}` and `${@:N:L}` slice syntax. See README for full placeholder reference.
+
+### Fixed
+
+- Model fallback now preserves the currently active model whenever it matches any listed fallback candidate, including ambiguous bare model IDs that would otherwise resolve through provider preference, instead of switching to an earlier candidate unnecessarily.
+- Prompt templates that collide with reserved slash commands, including built-ins like `/model` and the extension’s own `/chain-prompts`, are now skipped with a warning instead of being silently shadowed.
+- Prompt discovery is now deterministic in a locale-independent way, and duplicate model-enabled prompt names within the same source layer are skipped with a warning instead of silently depending on traversal order.
+- Invalid `model` frontmatter declarations are now rejected during prompt loading with diagnostics instead of failing later at execution time.
+- Literal tags like `<elsewhere>` and `</if-modeling>` no longer get misparsed as malformed conditional directives.
+- Non-interactive notifications now go to stderr so print-mode stdout stays clean.
+- Bare model IDs with multiple providers can now still resolve through OAuth-backed auth checks even when fast availability checks alone are inconclusive.
+- Optional string frontmatter fields are now trimmed so quoted values like `thinking: " high "` and `skill: " tmux "` behave as expected.
+- Existing prompt commands now refresh prompt files before execution, so edits made during a session take effect on the next run instead of waiting for a new session.
+- Skill-loaded custom messages now fail safe if their details payload is missing instead of crashing the renderer.
+- Frontmatter `model` specs and inline conditional `is` specs now reject internal whitespace like `anthropic /model` or `anthropic /*` instead of silently registering values that can never match.
+- Recursive prompt discovery now detects already-visited directories and skips symlink loops instead of risking infinite recursion or duplicate traversal.
+- Bare model IDs now honor provider priority across all auth-capable candidates, including OAuth-backed providers, instead of incorrectly favoring a lower-priority provider just because it appeared in the fast-available set.
+- Prompt loading now rejects non-object YAML frontmatter roots, like lists, with a diagnostic instead of silently treating them as missing `model` fields.
+- `/chain-prompts` now only restores model and thinking when they actually changed, avoiding redundant state writes and noisy restore notifications on no-op chains.
+- `/chain-prompts` now tracks thinking changes caused by model switches even when a step does not set `thinking`, so final restoration stays correct when the runtime clamps or resets thinking during a model change.
+- `/chain-prompts` now rejects empty or quote-only step segments explicitly instead of treating them as blank template names.
+- Single-command auto-restore now also skips no-op thinking restores and notifications when the runtime is already back on the original thinking level.
+- Removed unnecessary exports: `modelSpecMatches` from model-selection.ts and `VALID_THINKING_LEVELS` from prompt-loader.ts are now internal implementation details.
+- `/chain-prompts` now correctly ignores ` -- ` and `->` inside quoted per-step arguments instead of misinterpreting them as separators.
+- `</else>` is now explicitly rejected with a helpful error message explaining that `<else>` is a separator, not a container.
+- Fast-path optimization now correctly includes `</else>` check so standalone invalid tags are caught.
+- Empty prompt abort in single-command mode now notifies as "error" instead of "warning" for consistency with chain mode.
+
+## [0.3.1] - 2026-02-08
+
+### Fixed
+
+- Prompts map now initialized at extension load instead of waiting for `session_start`. Commands invoked before the first session event no longer fail with stale empty state.
 
 ## [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`
+- **Chain command**: `/chain-prompts` 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-prompts 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

package/README.md

@@ -131,6 +131,72 @@ Here the extension tries Haiku on Anthropic first, then Haiku on OpenRouter, the
 
 When all candidates fail, a single error notification lists everything that was tried.
 
+## Inline Model Conditionals
+
+Prompt bodies can embed model-specific instructions directly in the markdown:
+
+```markdown
+---
+description: Cross-model code review
+model: claude-haiku-4-5, claude-sonnet-4-20250514
+---
+Summarize the change first.
+
+<if-model is="claude-haiku-4-5">
+Keep the answer brief and cost-conscious.
+<else>
+Do a deeper pass and call out subtle risks.
+</if-model>
+```
+
+Conditionals are evaluated against the model that actually runs the command after fallback resolution. That means the same template can render differently depending on which candidate was selected.
+
+Supported matches inside `is="..."`:
+
+- Exact `provider/model-id`
+- Exact bare `model-id`
+- Provider wildcard like `anthropic/*`
+- Comma-separated lists combining any of the above
+
+Examples:
+
+```markdown
+<if-model is="anthropic/claude-sonnet-4-20250514">...</if-model>
+<if-model is="claude-sonnet-4-20250514">...</if-model>
+<if-model is="anthropic/*">...</if-model>
+<if-model is="openai/gpt-5.2, anthropic/*">...</if-model>
+```
+
+`<else>` is the fallback branch for the current `<if-model>` block. Nested blocks are supported.
+
+Conditionals are a raw text preprocessing step, not markdown-aware syntax. If you want to show the directive literally inside a prompt, escape it in the source text, for example with `&lt;if-model is="anthropic/*"&gt;`.
+
+## Argument Substitution
+
+Prompt bodies support argument placeholders that expand to command arguments:
+
+| Placeholder | Description |
+|-------------|-------------|
+| `$1`, `$2`, ... | Positional argument (1-indexed) |
+| `$@` | All arguments joined with spaces |
+| `$ARGUMENTS` | Same as `$@` |
+| `${@:N}` | All arguments from position N onward |
+| `${@:N:L}` | L arguments starting from position N |
+
+Example:
+
+```markdown
+---
+model: claude-sonnet-4-20250514
+---
+Analyze $1 focusing on $2. Additional context: ${@:3}
+```
+
+Running `/analyze src/main.ts performance edge cases error handling` expands to:
+- `$1` → `src/main.ts`
+- `$2` → `performance`
+- `${@:3}` → `edge cases error handling`
+
 ## Skill Resolution
 
 The `skill` field matches the skill's directory name:
@@ -158,7 +224,7 @@ Organize prompts in subdirectories for namespacing:
     └── hook.md                 → /hook (user:frontend)
 ```
 
-The subdirectory shows in autocomplete as the source label. Note: command names are based on filename only, so avoid duplicate filenames across subdirectories (e.g., `quick.md` and `frontend/quick.md` would collide).
+The subdirectory shows in autocomplete as the source label. Command names are based on filename only. If duplicates exist within the same source layer, the first one found after lexical sorting wins and later duplicates are skipped with a warning. Reserved command names like `model`, `reload`, and `chain-prompts` are also skipped with a warning.
 
 ## Examples
 
@@ -240,10 +306,10 @@ 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.
+The `/chain-prompts` command runs multiple templates sequentially. Each step switches to its own model, renders any inline model conditionals against that step’s resolved model, injects its own skill, and the conversation context carries forward between steps.
 
 ```
-/chain analyze-code -> fix-plan -> summarize -- src/main.ts
+/chain-prompts 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 `$@`.
@@ -251,7 +317,7 @@ This runs `analyze-code` first, then `fix-plan` (which sees the analysis in conv
 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
+/chain-prompts 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).
@@ -259,7 +325,7 @@ Here `analyze-code` gets `$@ = "look at error handling"`, `fix-plan` gets `$@ =
 You can mix both:
 
 ```
-/chain analyze-code "error handling" -> fix-plan -> summarize -- src/main.ts
+/chain-prompts 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"`).
@@ -290,7 +356,6 @@ The model switches, skill injects, agent responds, and output prints to stdout.
 
 ## Limitations
 
-- Templates discovered at startup. Restart pi after adding/modifying.
+- Prompt files are reloaded on session start and whenever an extension-owned prompt command runs. If you add a brand-new prompt file while already inside a session, run another extension-owned command such as `/chain-prompts`, start a new session, or reload pi so the new slash command is registered.
 - 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/args.ts

@@ -0,0 +1,59 @@
+export function parseCommandArgs(argsString: string): string[] {
+	const args: string[] = [];
+	let current = "";
+	let inQuote: string | null = null;
+
+	for (let i = 0; i < argsString.length; i++) {
+		const char = argsString[i];
+
+		if (inQuote) {
+			if (char === inQuote) {
+				inQuote = null;
+			} else {
+				current += char;
+			}
+		} else if (char === '"' || char === "'") {
+			inQuote = char;
+		} else if (char === " " || char === "\t") {
+			if (current) {
+				args.push(current);
+				current = "";
+			}
+		} else {
+			current += char;
+		}
+	}
+
+	if (current) {
+		args.push(current);
+	}
+
+	return args;
+}
+
+export function substituteArgs(content: string, args: string[]): string {
+	let result = content;
+
+	result = result.replace(/\$(\d+)/g, (_, num) => {
+		const index = parseInt(num, 10) - 1;
+		return args[index] ?? "";
+	});
+
+	result = result.replace(/\$\{@:(\d+)(?::(\d+))?\}/g, (_, startStr, lengthStr) => {
+		let start = parseInt(startStr, 10) - 1;
+		if (start < 0) start = 0;
+
+		if (lengthStr) {
+			const length = parseInt(lengthStr, 10);
+			return args.slice(start, start + length).join(" ");
+		}
+
+		return args.slice(start).join(" ");
+	});
+
+	const allArgs = args.join(" ");
+	result = result.replace(/\$ARGUMENTS/g, allArgs);
+	result = result.replace(/\$@/g, allArgs);
+
+	return result;
+}