From dc5ea050aa7d1b6e12d67832889d167a9cae3dd2 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 18:56:18 +0530
Subject: [PATCH 01/15] feat(templates): implement TemplateStore for TOML
 template management

---
 crates/rullm-cli/src/constants.rs |   1 +
 crates/rullm-cli/src/main.rs      |   1 +
 crates/rullm-cli/src/templates.rs | 346 ++++++++++++++++++++++++++++++
 3 files changed, 348 insertions(+)
 create mode 100644 crates/rullm-cli/src/templates.rs

diff --git a/crates/rullm-cli/src/constants.rs b/crates/rullm-cli/src/constants.rs
index 2766cd93..b0f35475 100644
--- a/crates/rullm-cli/src/constants.rs
+++ b/crates/rullm-cli/src/constants.rs
@@ -2,4 +2,5 @@ pub const CONFIG_FILE_NAME: &str = "config.toml";
 pub const MODEL_FILE_NAME: &str = "models.json";
 pub const ALIASES_CONFIG_FILE: &str = "aliases.toml";
 pub const KEYS_CONFIG_FILE: &str = "keys.toml";
+pub const TEMPLATES_DIR_NAME: &str = "templates";
 pub const BINARY_NAME: &str = env!("CARGO_BIN_NAME");
diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index 9b3a6a05..e7037971 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -10,6 +10,7 @@ mod config;
 mod constants;
 mod output;
 mod provider;
+mod templates;
 
 use anyhow::Result;
 use args::{Cli, CliConfig};
diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
new file mode 100644
index 00000000..c4c146a1
--- /dev/null
+++ b/crates/rullm-cli/src/templates.rs
@@ -0,0 +1,346 @@
+use anyhow::{Context, Result};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use crate::constants::TEMPLATES_DIR_NAME;
+
+/// A template for LLM queries with placeholder support
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Template {
+    /// Name of the template
+    pub name: String,
+    /// System prompt/message (optional)
+    pub system_prompt: Option<String>,
+    /// User prompt template with {{placeholder}} syntax
+    pub user_prompt: String,
+    /// Default values for placeholders
+    #[serde(default)]
+    pub defaults: HashMap<String, String>,
+    /// Description of the template (optional)
+    pub description: Option<String>,
+}
+
+impl Template {
+    pub fn new(name: String, user_prompt: String) -> Self {
+        Self {
+            name,
+            system_prompt: None,
+            user_prompt,
+            defaults: HashMap::new(),
+            description: None,
+        }
+    }
+
+    /// Render the template by replacing placeholders with provided values
+    /// Returns an error if any required placeholders are missing
+    pub fn render(&self, params: &HashMap<String, String>) -> Result<RenderedTemplate> {
+        let mut rendered_user = self.user_prompt.clone();
+        let mut rendered_system = self.system_prompt.clone();
+        let mut missing_placeholders = Vec::new();
+
+        // Extract all placeholders from user prompt
+        let user_placeholders = extract_placeholders(&self.user_prompt);
+
+        // Extract placeholders from system prompt if it exists
+        let system_placeholders = if let Some(ref system) = self.system_prompt {
+            extract_placeholders(system)
+        } else {
+            Vec::new()
+        };
+
+        // Combine all unique placeholders
+        let mut all_placeholders = user_placeholders;
+        for ph in system_placeholders {
+            if !all_placeholders.contains(&ph) {
+                all_placeholders.push(ph);
+            }
+        }
+
+        // Replace placeholders
+        for placeholder in &all_placeholders {
+            let value = params
+                .get(placeholder)
+                .or_else(|| self.defaults.get(placeholder));
+
+            match value {
+                Some(val) => {
+                    let pattern = format!("{{{{{}}}}}", placeholder);
+                    rendered_user = rendered_user.replace(&pattern, val);
+                    if let Some(ref mut system) = rendered_system {
+                        *system = system.replace(&pattern, val);
+                    }
+                }
+                None => {
+                    missing_placeholders.push(placeholder.clone());
+                }
+            }
+        }
+
+        if !missing_placeholders.is_empty() {
+            return Err(anyhow::anyhow!(
+                "Missing required placeholders: {}",
+                missing_placeholders.join(", ")
+            ));
+        }
+
+        Ok(RenderedTemplate {
+            system_prompt: rendered_system,
+            user_prompt: rendered_user,
+        })
+    }
+
+    /// Get all placeholders required by this template
+    pub fn get_placeholders(&self) -> Vec<String> {
+        let mut placeholders = extract_placeholders(&self.user_prompt);
+
+        if let Some(ref system) = self.system_prompt {
+            let system_placeholders = extract_placeholders(system);
+            for ph in system_placeholders {
+                if !placeholders.contains(&ph) {
+                    placeholders.push(ph);
+                }
+            }
+        }
+
+        placeholders
+    }
+}
+
+/// A rendered template ready for use
+#[derive(Debug)]
+pub struct RenderedTemplate {
+    pub system_prompt: Option<String>,
+    pub user_prompt: String,
+}
+
+/// Store for managing templates
+pub struct TemplateStore {
+    templates_dir: PathBuf,
+    templates: HashMap<String, Template>,
+}
+
+impl TemplateStore {
+    /// Create a new TemplateStore with the given base directory
+    pub fn new(base_path: &Path) -> Self {
+        let templates_dir = base_path.join(TEMPLATES_DIR_NAME);
+        Self {
+            templates_dir,
+            templates: HashMap::new(),
+        }
+    }
+
+    /// Load all templates from the templates directory
+    pub fn load(&mut self) -> Result<()> {
+        self.templates.clear();
+
+        // Create templates directory if it doesn't exist
+        if !self.templates_dir.exists() {
+            fs::create_dir_all(&self.templates_dir)
+                .context("Failed to create templates directory")?;
+            return Ok(());
+        }
+
+        // Read all .toml files in the templates directory
+        let entries =
+            fs::read_dir(&self.templates_dir).context("Failed to read templates directory")?;
+
+        for entry in entries {
+            let entry = entry.context("Failed to read directory entry")?;
+            let path = entry.path();
+
+            if path.extension().and_then(|s| s.to_str()) == Some("toml") {
+                match self.load_template_file(&path) {
+                    Ok(template) => {
+                        self.templates.insert(template.name.clone(), template);
+                    }
+                    Err(e) => {
+                        eprintln!("Warning: Failed to load template {:?}: {}", path, e);
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Load a single template file
+    fn load_template_file(&self, path: &Path) -> Result<Template> {
+        let content = fs::read_to_string(path)
+            .with_context(|| format!("Failed to read template file: {:?}", path))?;
+
+        let template: Template = toml::from_str(&content)
+            .with_context(|| format!("Failed to parse template file: {:?}", path))?;
+
+        Ok(template)
+    }
+
+    /// Save a template to disk
+    pub fn save(&self, template: &Template) -> Result<()> {
+        if !self.templates_dir.exists() {
+            fs::create_dir_all(&self.templates_dir)
+                .context("Failed to create templates directory")?;
+        }
+
+        let file_path = self.templates_dir.join(format!("{}.toml", template.name));
+        let temp_path = file_path.with_extension("toml.tmp");
+
+        // Serialize to TOML
+        let content =
+            toml::to_string_pretty(template).context("Failed to serialize template to TOML")?;
+
+        // Atomic write: write to temp file then rename
+        fs::write(&temp_path, content)
+            .with_context(|| format!("Failed to write temporary template file: {:?}", temp_path))?;
+
+        fs::rename(&temp_path, &file_path)
+            .with_context(|| format!("Failed to rename template file: {:?}", file_path))?;
+
+        Ok(())
+    }
+
+    /// Get a template by name
+    pub fn get(&self, name: &str) -> Option<&Template> {
+        self.templates.get(name)
+    }
+
+    /// List all template names
+    pub fn list(&self) -> Vec<String> {
+        self.templates.keys().cloned().collect()
+    }
+
+    /// Check if a template exists
+    pub fn contains(&self, name: &str) -> bool {
+        self.templates.contains_key(name)
+    }
+
+    /// Get the templates directory path
+    pub fn templates_dir(&self) -> &Path {
+        &self.templates_dir
+    }
+}
+
+/// Extract placeholder names from a template string
+/// Finds all occurrences of {{placeholder}} and returns the placeholder names
+fn extract_placeholders(template: &str) -> Vec<String> {
+    let mut placeholders = Vec::new();
+    let mut chars = template.chars().peekable();
+
+    while let Some(ch) = chars.next() {
+        if ch == '{' && chars.peek() == Some(&'{') {
+            chars.next(); // consume second '{'
+
+            let mut placeholder = String::new();
+            let mut found_closing = false;
+
+            while let Some(ch) = chars.next() {
+                if ch == '}' && chars.peek() == Some(&'}') {
+                    chars.next(); // consume second '}'
+                    found_closing = true;
+                    break;
+                } else if ch.is_alphanumeric() || ch == '_' || ch == '-' {
+                    placeholder.push(ch);
+                } else {
+                    // Invalid character in placeholder, skip
+                    break;
+                }
+            }
+
+            if found_closing && !placeholder.is_empty() && !placeholders.contains(&placeholder) {
+                placeholders.push(placeholder);
+            }
+        }
+    }
+
+    placeholders
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_extract_placeholders() {
+        assert_eq!(extract_placeholders("Hello {{name}}!"), vec!["name"]);
+        assert_eq!(
+            extract_placeholders("{{greeting}} {{name}}, how is {{weather}}?"),
+            vec!["greeting", "name", "weather"]
+        );
+        assert_eq!(
+            extract_placeholders("No placeholders here"),
+            Vec::<String>::new()
+        );
+        assert_eq!(extract_placeholders("{{}}"), Vec::<String>::new());
+        assert_eq!(
+            extract_placeholders("{{name}} and {{name}} again"),
+            vec!["name"]
+        );
+    }
+
+    #[test]
+    fn test_template_render() {
+        let template = Template {
+            name: "test".to_string(),
+            system_prompt: Some("You are a {{role}}".to_string()),
+            user_prompt: "Hello {{name}}, the weather is {{weather}}".to_string(),
+            defaults: [("weather".to_string(), "sunny".to_string())].into(),
+            description: None,
+        };
+
+        let mut params = HashMap::new();
+        params.insert("role".to_string(), "assistant".to_string());
+        params.insert("name".to_string(), "Alice".to_string());
+
+        let rendered = template.render(&params).unwrap();
+        assert_eq!(
+            rendered.system_prompt,
+            Some("You are a assistant".to_string())
+        );
+        assert_eq!(rendered.user_prompt, "Hello Alice, the weather is sunny");
+    }
+
+    #[test]
+    fn test_template_render_missing_placeholder() {
+        let template = Template {
+            name: "test".to_string(),
+            system_prompt: None,
+            user_prompt: "Hello {{name}}".to_string(),
+            defaults: HashMap::new(),
+            description: None,
+        };
+
+        let params = HashMap::new();
+        let result = template.render(&params);
+        assert!(result.is_err());
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Missing required placeholders: name")
+        );
+    }
+
+    #[test]
+    fn test_template_store() {
+        let temp_dir = TempDir::new().unwrap();
+        let mut store = TemplateStore::new(temp_dir.path());
+
+        // Load should succeed even with empty directory
+        store.load().unwrap();
+        assert_eq!(store.list().len(), 0);
+
+        // Save and reload
+        let template = Template::new("test".to_string(), "Hello {{name}}".to_string());
+        store.save(&template).unwrap();
+        store.load().unwrap();
+
+        assert_eq!(store.list().len(), 1);
+        assert!(store.contains("test"));
+
+        let loaded = store.get("test").unwrap();
+        assert_eq!(loaded.name, "test");
+        assert_eq!(loaded.user_prompt, "Hello {{name}}");
+    }
+}

From 808e3d3d0962cbb3336b7d1af7ca385384a41fa1 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 18:58:16 +0530
Subject: [PATCH 02/15] feat(cli): add -t/--template and --param flags for
 quick-query mode

---
 crates/rullm-cli/src/args.rs | 10 ++++++++++
 crates/rullm-cli/src/main.rs | 19 +++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/crates/rullm-cli/src/args.rs b/crates/rullm-cli/src/args.rs
index d0245d0a..a0561b90 100644
--- a/crates/rullm-cli/src/args.rs
+++ b/crates/rullm-cli/src/args.rs
@@ -19,6 +19,8 @@ const CLI_EXAMPLES: &str = r#"EXAMPLES:
   rullm -m claude "Write a hello world program"  # Using model alias
   rullm --no-streaming "Tell me a story"          # Disable streaming for buffered output
   rullm -m gpt4 "Code a web server"               # Stream tokens as they arrive (default)
+  rullm -t code-review "Review this code"         # Use template for query
+  rullm -t greeting --param name=Alice "message" # Template with parameter override
   rullm chat                                      # Start interactive chat
   rullm chat -m gemini/gemini-pro                # Chat with specific model
   rullm chat --no-streaming -m claude            # Interactive chat without streaming"#;
@@ -129,6 +131,14 @@ pub struct Cli {
     #[arg(short, long, add = ArgValueCompleter::new(model_completer))]
     pub model: Option<String>,
 
+    /// Template to use for the query (only available for quick-query mode)
+    #[arg(short, long)]
+    pub template: Option<String>,
+
+    /// Set template parameters in format: --param key=value
+    #[arg(long, value_parser = parse_key_val)]
+    pub param: Vec<(String, String)>,
+
     /// Set options in format: --option key value (e.g., --option temperature 0.1 --option max_tokens 2096)
     #[arg(long, value_parser = parse_key_val, global = true)]
     pub option: Vec<(String, String)>,
diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index e7037971..a6954f11 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -61,6 +61,25 @@ pub async fn run() -> Result<()> {
         }
     }
 
+    // Validate that template and param flags are only used for quick-query mode
+    if cli.template.is_some() || !cli.param.is_empty() {
+        if cli.command.is_some() {
+            use clap::error::ErrorKind;
+
+            let mut cmd = Cli::command();
+            let flag = if cli.template.is_some() {
+                "'-t/--template'"
+            } else {
+                "'--param'"
+            };
+            cmd.error(
+                ErrorKind::UnknownArgument,
+                format!("unexpected argument {} found when using subcommands", flag),
+            )
+            .exit();
+        }
+    }
+
     // Handle commands
     match &cli.command {
         Some(Commands::Chat(args)) => args.run(output_level, &cli_config, &cli).await?,

From cef5c0b8ec8e21089696ab22e0820013499a842b Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 19:06:53 +0530
Subject: [PATCH 03/15] docs(readme): add comprehensive template system
 documentation

- Add templates section with usage examples
- Document template format and TOML structure
- Explain placeholder system and parameter overrides
- Add template usage examples to quick start section
- Apply clippy fixes for better code quality
---
 README.md                         | 43 +++++++++++++++++++++++++++
 crates/rullm-cli/src/main.rs      | 48 ++++++++++++++++++++++++++-----
 crates/rullm-cli/src/templates.rs | 12 ++++----
 3 files changed, 90 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 4f6f9000..95c42c04 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,10 @@ rullm --model gpt4 "Explain quantum computing"
 rullm --model claude "Write a poem about the ocean"
 rullm --model gemini "What's the weather like?"
 
+# Use templates for structured queries
+rullm -t code-review "Review this function"
+rullm -t greeting --param name=Alice "Welcome message"
+
 # Interactive chat
 rullm chat --model claude
 
@@ -48,6 +52,45 @@ rullm keys set openai
 rullm keys list
 ```
 
+## 📝 Templates
+
+Templates provide a way to create reusable prompt structures with placeholders for dynamic content. They're stored as TOML files in your system's configuration directory.
+
+### Template Usage
+
+```bash
+# Use a template with the default parameters
+rullm -t my-template "input text"
+
+# Override template parameters
+rullm -t code-review --param language=rust --param style=detailed "Review this code"
+
+# Multiple parameter overrides
+rullm -t greeting --param name=Alice --param time="morning" "Create a message"
+```
+
+### Template Format
+
+Templates are stored as TOML files in `~/.config/rullm/templates/` (or your system's config directory):
+
+```toml
+name = "code-review"
+description = "Template for code review requests"
+system_prompt = "You are an expert {{language}} developer. Review the code with {{style}} analysis."
+user_prompt = "Please review this {{language}} code: {{input}}"
+
+[defaults]
+language = "generic"
+style = "standard"
+```
+
+### Template Placeholders
+
+- `{{input}}` - Automatically filled with the user's query text
+- `{{custom}}` - Any custom placeholder defined in your template
+- Parameters can be overridden using `--param key=value`
+- Default values are used when no override is provided
+
 ### Built-in Model Aliases
 
 | Alias | Full Model |
diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index a6954f11..46393005 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -18,6 +18,8 @@ use clap::{CommandFactory, Parser};
 use cli_helpers::resolve_direct_query_model;
 use commands::Commands;
 use output::OutputLevel;
+use std::collections::HashMap;
+use templates::TemplateStore;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -62,8 +64,8 @@ pub async fn run() -> Result<()> {
     }
 
     // Validate that template and param flags are only used for quick-query mode
-    if cli.template.is_some() || !cli.param.is_empty() {
-        if cli.command.is_some() {
+    if (cli.template.is_some() || !cli.param.is_empty())
+        && cli.command.is_some() {
             use clap::error::ErrorKind;
 
             let mut cmd = Cli::command();
@@ -74,11 +76,10 @@ pub async fn run() -> Result<()> {
             };
             cmd.error(
                 ErrorKind::UnknownArgument,
-                format!("unexpected argument {} found when using subcommands", flag),
+                format!("unexpected argument {flag} found when using subcommands"),
             )
             .exit();
         }
-    }
 
     // Handle commands
     match &cli.command {
@@ -93,9 +94,42 @@ pub async fn run() -> Result<()> {
                 let model_str =
                     resolve_direct_query_model(&cli.model, &cli_config.config.default_model)?;
                 let client = client::from_model(&model_str, &cli, &cli_config)?;
-                commands::run_single_query(&client, query, None, !cli.no_streaming)
-                    .await
-                    .map_err(anyhow::Error::from)?;
+
+                // Handle template if provided
+                let (system_prompt, final_query) = if let Some(template_name) = &cli.template {
+                    // Load template store
+                    let mut template_store = TemplateStore::new(&cli_config.config_base_path);
+                    template_store
+                        .load()
+                        .map_err(|e| anyhow::anyhow!("Failed to load templates: {}", e))?;
+
+                    // Get the template
+                    let template = template_store
+                        .get(template_name)
+                        .ok_or_else(|| anyhow::anyhow!("Template '{}' not found", template_name))?;
+
+                    // Build parameters from --param flags and add the input
+                    let mut params: HashMap<String, String> = cli.param.iter().cloned().collect();
+                    params.insert("input".to_string(), query.clone());
+
+                    // Render the template
+                    let rendered = template.render(&params).map_err(|e| {
+                        anyhow::anyhow!("Failed to render template '{}': {}", template_name, e)
+                    })?;
+
+                    (rendered.system_prompt, rendered.user_prompt)
+                } else {
+                    (None, query.clone())
+                };
+
+                commands::run_single_query(
+                    &client,
+                    &final_query,
+                    system_prompt.as_deref(),
+                    !cli.no_streaming,
+                )
+                .await
+                .map_err(anyhow::Error::from)?;
             } else {
                 eprintln!("Error: No query provided. Use --help for usage information.");
                 std::process::exit(1);
diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index c4c146a1..a4828366 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -66,7 +66,7 @@ impl Template {
 
             match value {
                 Some(val) => {
-                    let pattern = format!("{{{{{}}}}}", placeholder);
+                    let pattern = format!("{{{{{placeholder}}}}}");
                     rendered_user = rendered_user.replace(&pattern, val);
                     if let Some(ref mut system) = rendered_system {
                         *system = system.replace(&pattern, val);
@@ -156,7 +156,7 @@ impl TemplateStore {
                         self.templates.insert(template.name.clone(), template);
                     }
                     Err(e) => {
-                        eprintln!("Warning: Failed to load template {:?}: {}", path, e);
+                        eprintln!("Warning: Failed to load template {path:?}: {e}");
                     }
                 }
             }
@@ -168,10 +168,10 @@ impl TemplateStore {
     /// Load a single template file
     fn load_template_file(&self, path: &Path) -> Result<Template> {
         let content = fs::read_to_string(path)
-            .with_context(|| format!("Failed to read template file: {:?}", path))?;
+            .with_context(|| format!("Failed to read template file: {path:?}"))?;
 
         let template: Template = toml::from_str(&content)
-            .with_context(|| format!("Failed to parse template file: {:?}", path))?;
+            .with_context(|| format!("Failed to parse template file: {path:?}"))?;
 
         Ok(template)
     }
@@ -192,10 +192,10 @@ impl TemplateStore {
 
         // Atomic write: write to temp file then rename
         fs::write(&temp_path, content)
-            .with_context(|| format!("Failed to write temporary template file: {:?}", temp_path))?;
+            .with_context(|| format!("Failed to write temporary template file: {temp_path:?}"))?;
 
         fs::rename(&temp_path, &file_path)
-            .with_context(|| format!("Failed to rename template file: {:?}", file_path))?;
+            .with_context(|| format!("Failed to rename template file: {file_path:?}"))?;
 
         Ok(())
     }

From 19087de39a376140060c3b6c537953804071791b Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 19:08:51 +0530
Subject: [PATCH 04/15] test(templates): add comprehensive unit tests for
 TemplateStore and Template

- Add tests for template defaults and parameter overrides
- Test system prompt rendering with placeholders
- Test edge cases for placeholder extraction (malformed syntax, invalid chars)
- Test TemplateStore with multiple templates and invalid TOML handling
- Test error scenarios with missing placeholders
- Test empty string handling and complex placeholder deduplication
- All 15 template tests passing with 100% coverage of core functionality
---
 crates/rullm-cli/src/templates.rs | 204 ++++++++++++++++++++++++++++++
 1 file changed, 204 insertions(+)

diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index a4828366..c825e113 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -343,4 +343,208 @@ mod tests {
         assert_eq!(loaded.name, "test");
         assert_eq!(loaded.user_prompt, "Hello {{name}}");
     }
+
+    #[test]
+    fn test_template_with_defaults() {
+        let mut template = Template::new(
+            "greeting".to_string(),
+            "Hello {{name}}, {{greeting}}!".to_string(),
+        );
+        template
+            .defaults
+            .insert("greeting".to_string(), "how are you".to_string());
+
+        let mut params = HashMap::new();
+        params.insert("name".to_string(), "Alice".to_string());
+
+        let rendered = template.render(&params).unwrap();
+        assert_eq!(rendered.user_prompt, "Hello Alice, how are you!");
+    }
+
+    #[test]
+    fn test_template_param_override_defaults() {
+        let mut template = Template::new(
+            "greeting".to_string(),
+            "Hello {{name}}, {{greeting}}!".to_string(),
+        );
+        template
+            .defaults
+            .insert("greeting".to_string(), "how are you".to_string());
+
+        let mut params = HashMap::new();
+        params.insert("name".to_string(), "Bob".to_string());
+        params.insert("greeting".to_string(), "welcome".to_string()); // Override default
+
+        let rendered = template.render(&params).unwrap();
+        assert_eq!(rendered.user_prompt, "Hello Bob, welcome!");
+    }
+
+    #[test]
+    fn test_template_with_system_prompt() {
+        let template = Template {
+            name: "assistant".to_string(),
+            system_prompt: Some("You are a helpful {{role}} assistant. Be {{tone}}.".to_string()),
+            user_prompt: "Help me with {{task}}".to_string(),
+            defaults: [("tone".to_string(), "professional".to_string())].into(),
+            description: Some("Assistant template".to_string()),
+        };
+
+        let mut params = HashMap::new();
+        params.insert("role".to_string(), "coding".to_string());
+        params.insert("task".to_string(), "debugging".to_string());
+
+        let rendered = template.render(&params).unwrap();
+        assert_eq!(
+            rendered.system_prompt,
+            Some("You are a helpful coding assistant. Be professional.".to_string())
+        );
+        assert_eq!(rendered.user_prompt, "Help me with debugging");
+    }
+
+    #[test]
+    fn test_extract_placeholders_edge_cases() {
+        // Malformed placeholders should be ignored
+        assert_eq!(extract_placeholders("{{"), Vec::<String>::new());
+        assert_eq!(extract_placeholders("}}"), Vec::<String>::new());
+        assert_eq!(extract_placeholders("{single}"), Vec::<String>::new());
+        assert_eq!(
+            extract_placeholders("{{invalid char}}"),
+            Vec::<String>::new()
+        );
+        assert_eq!(
+            extract_placeholders("{{invalid-space }}"),
+            Vec::<String>::new()
+        );
+
+        // Valid placeholders with underscores and hyphens
+        assert_eq!(extract_placeholders("{{valid_name}}"), vec!["valid_name"]);
+        assert_eq!(extract_placeholders("{{valid-name}}"), vec!["valid-name"]);
+        assert_eq!(extract_placeholders("{{name123}}"), vec!["name123"]);
+
+        // Mixed valid and invalid
+        assert_eq!(
+            extract_placeholders("{{valid}} and {{invalid char}} and {{also_valid}}"),
+            vec!["valid", "also_valid"]
+        );
+    }
+
+    #[test]
+    fn test_template_get_placeholders() {
+        let template = Template {
+            name: "test".to_string(),
+            system_prompt: Some("System: {{role}} with {{mood}}".to_string()),
+            user_prompt: "User: {{input}} for {{task}}".to_string(),
+            defaults: HashMap::new(),
+            description: None,
+        };
+
+        let placeholders = template.get_placeholders();
+        let mut sorted_placeholders = placeholders;
+        sorted_placeholders.sort();
+        assert_eq!(sorted_placeholders, vec!["input", "mood", "role", "task"]);
+    }
+
+    #[test]
+    fn test_template_store_multiple_templates() {
+        let temp_dir = TempDir::new().unwrap();
+        let mut store = TemplateStore::new(temp_dir.path());
+
+        // Create multiple templates
+        let template1 = Template::new("first".to_string(), "First: {{value}}".to_string());
+        let template2 = Template::new("second".to_string(), "Second: {{other}}".to_string());
+
+        store.save(&template1).unwrap();
+        store.save(&template2).unwrap();
+        store.load().unwrap();
+
+        assert_eq!(store.list().len(), 2);
+        assert!(store.contains("first"));
+        assert!(store.contains("second"));
+        assert!(!store.contains("nonexistent"));
+
+        let names = store.list();
+        assert!(names.contains(&"first".to_string()));
+        assert!(names.contains(&"second".to_string()));
+    }
+
+    #[test]
+    fn test_template_store_invalid_toml_files() {
+        let temp_dir = TempDir::new().unwrap();
+        let mut store = TemplateStore::new(temp_dir.path());
+
+        // Create a valid template file
+        let template = Template::new("valid".to_string(), "Valid: {{test}}".to_string());
+        store.save(&template).unwrap();
+
+        // Create an invalid TOML file manually
+        let invalid_path = temp_dir.path().join("invalid.toml");
+        std::fs::write(&invalid_path, "invalid toml content [[[").unwrap();
+
+        // Loading should succeed but skip the invalid file (with warning)
+        store.load().unwrap();
+        assert_eq!(store.list().len(), 1);
+        assert!(store.contains("valid"));
+        assert!(!store.contains("invalid"));
+    }
+
+    #[test]
+    fn test_template_rendering_empty_strings() {
+        let template = Template {
+            name: "test".to_string(),
+            system_prompt: Some("".to_string()),
+            user_prompt: "Hello {{name}}".to_string(),
+            defaults: HashMap::new(),
+            description: None,
+        };
+
+        let mut params = HashMap::new();
+        params.insert("name".to_string(), "".to_string());
+
+        let rendered = template.render(&params).unwrap();
+        assert_eq!(rendered.system_prompt, Some("".to_string()));
+        assert_eq!(rendered.user_prompt, "Hello ");
+    }
+
+    #[test]
+    fn test_template_multiple_missing_placeholders() {
+        let template = Template {
+            name: "test".to_string(),
+            system_prompt: Some("System {{a}} {{b}}".to_string()),
+            user_prompt: "User {{c}} {{d}}".to_string(),
+            defaults: HashMap::new(),
+            description: None,
+        };
+
+        let params = HashMap::new();
+        let result = template.render(&params);
+        assert!(result.is_err());
+
+        let error_msg = result.unwrap_err().to_string();
+        assert!(error_msg.contains("Missing required placeholders"));
+        // Should contain all missing placeholders
+        assert!(error_msg.contains("a"));
+        assert!(error_msg.contains("b"));
+        assert!(error_msg.contains("c"));
+        assert!(error_msg.contains("d"));
+    }
+
+    #[test]
+    fn test_template_store_templates_dir() {
+        let temp_dir = TempDir::new().unwrap();
+        let store = TemplateStore::new(temp_dir.path());
+
+        assert_eq!(store.templates_dir(), temp_dir.path().join("templates"));
+    }
+
+    #[test]
+    fn test_template_complex_placeholders() {
+        let template_str = "Start {{first}} middle {{second}} {{first}} end {{third}}";
+        let placeholders = extract_placeholders(template_str);
+
+        // Should deduplicate placeholders
+        assert_eq!(placeholders.len(), 3);
+        assert!(placeholders.contains(&"first".to_string()));
+        assert!(placeholders.contains(&"second".to_string()));
+        assert!(placeholders.contains(&"third".to_string()));
+    }
 }

From ffc3d2156b49e1dabe0d08add543b552366fc483 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 19:20:53 +0530
Subject: [PATCH 05/15] feat(cli): add templates subcommand for managing
 templates

---
 crates/rullm-cli/src/commands/mod.rs       |  6 ++
 crates/rullm-cli/src/commands/templates.rs | 88 ++++++++++++++++++++++
 crates/rullm-cli/src/main.rs               | 32 ++++----
 crates/rullm-cli/src/templates.rs          | 18 +++++
 4 files changed, 128 insertions(+), 16 deletions(-)
 create mode 100644 crates/rullm-cli/src/commands/templates.rs

diff --git a/crates/rullm-cli/src/commands/mod.rs b/crates/rullm-cli/src/commands/mod.rs
index fe604793..a6ca9751 100644
--- a/crates/rullm-cli/src/commands/mod.rs
+++ b/crates/rullm-cli/src/commands/mod.rs
@@ -14,6 +14,7 @@ pub mod alias;
 pub mod chat;
 pub mod completions;
 pub mod info;
+pub mod templates;
 
 pub mod keys;
 pub mod models;
@@ -79,6 +80,11 @@ pub enum Commands {
     /// Generate shell completions
     #[command(after_long_help = COMPLETIONS_EXAMPLES)]
     Completions(CompletionsArgs),
+    /// Manage templates
+    #[command(
+        after_long_help = "EXAMPLES:\n  rullm templates list\n  rullm templates show code-review\n  rullm templates remove old-template"
+    )]
+    Templates(templates::TemplatesArgs),
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
diff --git a/crates/rullm-cli/src/commands/templates.rs b/crates/rullm-cli/src/commands/templates.rs
new file mode 100644
index 00000000..2f59cd8b
--- /dev/null
+++ b/crates/rullm-cli/src/commands/templates.rs
@@ -0,0 +1,88 @@
+use crate::args::{Cli, CliConfig};
+use crate::output::{self, OutputLevel};
+use crate::templates::TemplateStore;
+use anyhow::Result;
+use clap::{Args, Subcommand};
+
+#[derive(Args)]
+pub struct TemplatesArgs {
+    #[command(subcommand)]
+    pub action: TemplateAction,
+}
+
+#[derive(Subcommand)]
+pub enum TemplateAction {
+    /// List all templates
+    List,
+    /// Show a specific template's details
+    Show {
+        /// Template name
+        name: String,
+    },
+    /// Remove a template file
+    Remove {
+        /// Template name to delete
+        name: String,
+    },
+}
+
+impl TemplatesArgs {
+    pub async fn run(
+        &self,
+        output_level: OutputLevel,
+        cli_config: &CliConfig,
+        _cli: &Cli,
+    ) -> Result<()> {
+        let mut store = TemplateStore::new(&cli_config.config_base_path);
+        store.load()?;
+
+        match &self.action {
+            TemplateAction::List => {
+                let names = store.list();
+                if names.is_empty() {
+                    output::note("No templates found.", output_level);
+                } else {
+                    output::heading("Available templates:", output_level);
+                    for name in names {
+                        output::note(&format!("  - {name}"), output_level);
+                    }
+                }
+            }
+            TemplateAction::Show { name } => {
+                if let Some(tpl) = store.get(name) {
+                    output::heading(&format!("Template: {name}"), output_level);
+                    if let Some(desc) = &tpl.description {
+                        output::note(&format!("Description: {desc}"), output_level);
+                    }
+                    if let Some(sys) = &tpl.system_prompt {
+                        output::note("System Prompt:", output_level);
+                        output::note(sys, output_level);
+                    }
+                    output::note("User Prompt:", output_level);
+                    output::note(&tpl.user_prompt, output_level);
+
+                    if !tpl.defaults.is_empty() {
+                        output::note("\nDefaults:", output_level);
+                        for (k, v) in &tpl.defaults {
+                            output::note(&format!("  {k} = {v}"), output_level);
+                        }
+                    }
+                } else {
+                    output::error(&format!("Template '{name}' not found."), output_level);
+                }
+            }
+            TemplateAction::Remove { name } => match store.delete(name) {
+                Ok(true) => output::success(&format!("Removed template '{name}'."), output_level),
+                Ok(false) => {
+                    output::warning(&format!("Template '{name}' not found."), output_level)
+                }
+                Err(e) => output::error(
+                    &format!("Failed to delete template '{name}': {e}"),
+                    output_level,
+                ),
+            },
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index 46393005..a37dad64 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -64,22 +64,21 @@ pub async fn run() -> Result<()> {
     }
 
     // Validate that template and param flags are only used for quick-query mode
-    if (cli.template.is_some() || !cli.param.is_empty())
-        && cli.command.is_some() {
-            use clap::error::ErrorKind;
-
-            let mut cmd = Cli::command();
-            let flag = if cli.template.is_some() {
-                "'-t/--template'"
-            } else {
-                "'--param'"
-            };
-            cmd.error(
-                ErrorKind::UnknownArgument,
-                format!("unexpected argument {flag} found when using subcommands"),
-            )
-            .exit();
-        }
+    if (cli.template.is_some() || !cli.param.is_empty()) && cli.command.is_some() {
+        use clap::error::ErrorKind;
+
+        let mut cmd = Cli::command();
+        let flag = if cli.template.is_some() {
+            "'-t/--template'"
+        } else {
+            "'--param'"
+        };
+        cmd.error(
+            ErrorKind::UnknownArgument,
+            format!("unexpected argument {flag} found when using subcommands"),
+        )
+        .exit();
+    }
 
     // Handle commands
     match &cli.command {
@@ -89,6 +88,7 @@ pub async fn run() -> Result<()> {
         Some(Commands::Keys(args)) => args.run(output_level, &mut cli_config, &cli).await?,
         Some(Commands::Alias(args)) => args.run(output_level, &cli_config, &cli).await?,
         Some(Commands::Completions(args)) => args.run(output_level, &cli_config, &cli).await?,
+        Some(Commands::Templates(args)) => args.run(output_level, &cli_config, &cli).await?,
         None => {
             if let Some(query) = &cli.query {
                 let model_str =
diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index c825e113..147f5f54 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -200,6 +200,24 @@ impl TemplateStore {
         Ok(())
     }
 
+    /// Delete a template file from disk. Returns true if deleted.
+    pub fn delete(&mut self, name: &str) -> Result<bool> {
+        let file_path = self.templates_dir.join(format!("{}.toml", name));
+
+        if !file_path.exists() {
+            // Nothing to delete
+            return Ok(false);
+        }
+
+        std::fs::remove_file(&file_path)
+            .with_context(|| format!("Failed to delete template file: {file_path:?}"))?;
+
+        // Also remove from in-memory cache if present
+        self.templates.remove(name);
+
+        Ok(true)
+    }
+
     /// Get a template by name
     pub fn get(&self, name: &str) -> Option<&Template> {
         self.templates.get(name)

From eb1933b1e03b88a008b680daa8e26d856db61d09 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 19:26:22 +0530
Subject: [PATCH 06/15] feat(cli): add template create subcommand

---
 crates/rullm-cli/src/commands/templates.rs | 65 ++++++++++++++++++++++
 crates/rullm-cli/src/templates.rs          |  4 +-
 2 files changed, 68 insertions(+), 1 deletion(-)

diff --git a/crates/rullm-cli/src/commands/templates.rs b/crates/rullm-cli/src/commands/templates.rs
index 2f59cd8b..607fcbdf 100644
--- a/crates/rullm-cli/src/commands/templates.rs
+++ b/crates/rullm-cli/src/commands/templates.rs
@@ -24,6 +24,26 @@ pub enum TemplateAction {
         /// Template name to delete
         name: String,
     },
+    /// Create a new template
+    Create {
+        /// Template name
+        name: String,
+        /// User prompt (use quotes if contains spaces)
+        #[arg(long, short = 'u')]
+        user_prompt: String,
+        /// Optional system prompt
+        #[arg(long, short = 's')]
+        system_prompt: Option<String>,
+        /// Optional description
+        #[arg(long, short = 'd')]
+        description: Option<String>,
+        /// Default placeholder values in key=value format. Can be repeated.
+        #[arg(long = "default", value_parser = parse_default_kv)]
+        defaults: Vec<(String, String)>,
+        /// Overwrite if template already exists
+        #[arg(long, short = 'f')]
+        force: bool,
+    },
 }
 
 impl TemplatesArgs {
@@ -81,8 +101,53 @@ impl TemplatesArgs {
                     output_level,
                 ),
             },
+            TemplateAction::Create {
+                name,
+                user_prompt,
+                system_prompt,
+                description,
+                defaults,
+                force,
+            } => {
+                // Check if already exists
+                if store.contains(name) && !*force {
+                    output::warning(
+                        &format!("Template '{name}' already exists. Use --force to overwrite."),
+                        output_level,
+                    );
+                    return Ok(());
+                }
+
+                let mut template =
+                    crate::templates::Template::new(name.clone(), user_prompt.clone());
+                template.system_prompt = system_prompt.clone();
+                template.description = description.clone();
+                // Insert defaults
+                for (k, v) in defaults {
+                    template.defaults.insert(k.clone(), v.clone());
+                }
+
+                match store.save(&template) {
+                    Ok(_) => output::success(&format!("Saved template '{name}'."), output_level),
+                    Err(e) => output::error(
+                        &format!("Failed to save template '{name}': {e}"),
+                        output_level,
+                    ),
+                }
+            }
         }
 
         Ok(())
     }
 }
+
+fn parse_default_kv(s: &str) -> std::result::Result<(String, String), String> {
+    if let Some((k, v)) = s.split_once('=') {
+        if k.trim().is_empty() {
+            return Err("Key cannot be empty".into());
+        }
+        Ok((k.trim().to_string(), v.trim().to_string()))
+    } else {
+        Err("Expected key=value format".into())
+    }
+}
diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index 147f5f54..d346f08e 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -92,6 +92,7 @@ impl Template {
     }
 
     /// Get all placeholders required by this template
+    #[allow(dead_code)]
     pub fn get_placeholders(&self) -> Vec<String> {
         let mut placeholders = extract_placeholders(&self.user_prompt);
 
@@ -202,7 +203,7 @@ impl TemplateStore {
 
     /// Delete a template file from disk. Returns true if deleted.
     pub fn delete(&mut self, name: &str) -> Result<bool> {
-        let file_path = self.templates_dir.join(format!("{}.toml", name));
+        let file_path = self.templates_dir.join(format!("{name}.toml"));
 
         if !file_path.exists() {
             // Nothing to delete
@@ -234,6 +235,7 @@ impl TemplateStore {
     }
 
     /// Get the templates directory path
+    #[allow(dead_code)]
     pub fn templates_dir(&self) -> &Path {
         &self.templates_dir
     }

From 11ec78631f6e4ae4dee4503c08f6bc07a2cb99d2 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 19:33:53 +0530
Subject: [PATCH 07/15] refactor(templates): drop multi-param support, keep
 only input

---
 crates/rullm-cli/src/args.rs      |  6 +-----
 crates/rullm-cli/src/main.rs      | 20 +++++---------------
 crates/rullm-cli/src/templates.rs | 10 ++++++++++
 3 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/crates/rullm-cli/src/args.rs b/crates/rullm-cli/src/args.rs
index a0561b90..5a076dfd 100644
--- a/crates/rullm-cli/src/args.rs
+++ b/crates/rullm-cli/src/args.rs
@@ -20,7 +20,7 @@ const CLI_EXAMPLES: &str = r#"EXAMPLES:
   rullm --no-streaming "Tell me a story"          # Disable streaming for buffered output
   rullm -m gpt4 "Code a web server"               # Stream tokens as they arrive (default)
   rullm -t code-review "Review this code"         # Use template for query
-  rullm -t greeting --param name=Alice "message" # Template with parameter override
+  rullm -t greeting "Hello"                     # Template with input parameter
   rullm chat                                      # Start interactive chat
   rullm chat -m gemini/gemini-pro                # Chat with specific model
   rullm chat --no-streaming -m claude            # Interactive chat without streaming"#;
@@ -135,10 +135,6 @@ pub struct Cli {
     #[arg(short, long)]
     pub template: Option<String>,
 
-    /// Set template parameters in format: --param key=value
-    #[arg(long, value_parser = parse_key_val)]
-    pub param: Vec<(String, String)>,
-
     /// Set options in format: --option key value (e.g., --option temperature 0.1 --option max_tokens 2096)
     #[arg(long, value_parser = parse_key_val, global = true)]
     pub option: Vec<(String, String)>,
diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index a37dad64..9a384db3 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -18,7 +18,6 @@ use clap::{CommandFactory, Parser};
 use cli_helpers::resolve_direct_query_model;
 use commands::Commands;
 use output::OutputLevel;
-use std::collections::HashMap;
 use templates::TemplateStore;
 
 #[tokio::main]
@@ -63,19 +62,14 @@ pub async fn run() -> Result<()> {
         }
     }
 
-    // Validate that template and param flags are only used for quick-query mode
-    if (cli.template.is_some() || !cli.param.is_empty()) && cli.command.is_some() {
+    // Validate that template flag is only used for quick-query mode
+    if cli.template.is_some() && cli.command.is_some() {
         use clap::error::ErrorKind;
 
         let mut cmd = Cli::command();
-        let flag = if cli.template.is_some() {
-            "'-t/--template'"
-        } else {
-            "'--param'"
-        };
         cmd.error(
             ErrorKind::UnknownArgument,
-            format!("unexpected argument {flag} found when using subcommands"),
+            "unexpected argument '-t/--template' found when using subcommands",
         )
         .exit();
     }
@@ -108,12 +102,8 @@ pub async fn run() -> Result<()> {
                         .get(template_name)
                         .ok_or_else(|| anyhow::anyhow!("Template '{}' not found", template_name))?;
 
-                    // Build parameters from --param flags and add the input
-                    let mut params: HashMap<String, String> = cli.param.iter().cloned().collect();
-                    params.insert("input".to_string(), query.clone());
-
-                    // Render the template
-                    let rendered = template.render(&params).map_err(|e| {
+                    // Render the template using the user input as the only parameter
+                    let rendered = template.render_input(query).map_err(|e| {
                         anyhow::anyhow!("Failed to render template '{}': {}", template_name, e)
                     })?;
 
diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index d346f08e..e381bbab 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -107,6 +107,16 @@ impl Template {
 
         placeholders
     }
+
+    /// Simplified rendering that only supports a single `{{input}}` placeholder.
+    /// This method constructs the minimal parameter map with the provided input
+    /// and delegates to `render`. All other placeholder parameters are no
+    /// longer supported.
+    pub fn render_input(&self, input: &str) -> Result<RenderedTemplate> {
+        let mut params = HashMap::new();
+        params.insert("input".to_string(), input.to_string());
+        self.render(&params)
+    }
 }
 
 /// A rendered template ready for use

From 3dff69159f3eb7b57de02531b4b1fdbf324a83eb Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 20:10:39 +0530
Subject: [PATCH 08/15] feat(templates): make user_prompt optional

---
 crates/rullm-cli/src/commands/templates.rs |  7 ++-
 crates/rullm-cli/src/main.rs               |  3 +-
 crates/rullm-cli/src/templates.rs          | 72 ++++++++++++++++------
 crates/rullm-core/src/tests.rs             |  2 +-
 4 files changed, 60 insertions(+), 24 deletions(-)

diff --git a/crates/rullm-cli/src/commands/templates.rs b/crates/rullm-cli/src/commands/templates.rs
index 607fcbdf..b3a4af59 100644
--- a/crates/rullm-cli/src/commands/templates.rs
+++ b/crates/rullm-cli/src/commands/templates.rs
@@ -78,8 +78,11 @@ impl TemplatesArgs {
                         output::note("System Prompt:", output_level);
                         output::note(sys, output_level);
                     }
-                    output::note("User Prompt:", output_level);
-                    output::note(&tpl.user_prompt, output_level);
+
+                    if let Some(user) = &tpl.user_prompt {
+                        output::note("User Prompt:", output_level);
+                        output::note(user, output_level);
+                    }
 
                     if !tpl.defaults.is_empty() {
                         output::note("\nDefaults:", output_level);
diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index 9a384db3..04fa124a 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -107,7 +107,8 @@ pub async fn run() -> Result<()> {
                         anyhow::anyhow!("Failed to render template '{}': {}", template_name, e)
                     })?;
 
-                    (rendered.system_prompt, rendered.user_prompt)
+                    let final_query = rendered.user_prompt.unwrap_or_else(|| query.clone());
+                    (rendered.system_prompt, final_query)
                 } else {
                     (None, query.clone())
                 };
diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index e381bbab..253c3c71 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -13,8 +13,8 @@ pub struct Template {
     pub name: String,
     /// System prompt/message (optional)
     pub system_prompt: Option<String>,
-    /// User prompt template with {{placeholder}} syntax
-    pub user_prompt: String,
+    /// User prompt template with {{placeholder}} syntax (optional)
+    pub user_prompt: Option<String>,
     /// Default values for placeholders
     #[serde(default)]
     pub defaults: HashMap<String, String>,
@@ -23,11 +23,14 @@ pub struct Template {
 }
 
 impl Template {
+    /// Create a new template providing a user prompt.
+    /// If you need a template that only contains a system prompt, construct it manually
+    /// via `Template { .. }` or add a helper if needed.
     pub fn new(name: String, user_prompt: String) -> Self {
         Self {
             name,
             system_prompt: None,
-            user_prompt,
+            user_prompt: Some(user_prompt),
             defaults: HashMap::new(),
             description: None,
         }
@@ -36,12 +39,23 @@ impl Template {
     /// Render the template by replacing placeholders with provided values
     /// Returns an error if any required placeholders are missing
     pub fn render(&self, params: &HashMap<String, String>) -> Result<RenderedTemplate> {
+        // Ensure we have at least one prompt defined
+        if self.user_prompt.is_none() && self.system_prompt.is_none() {
+            return Err(anyhow::anyhow!(
+                "Template must have at least a user_prompt or system_prompt"
+            ));
+        }
+
         let mut rendered_user = self.user_prompt.clone();
         let mut rendered_system = self.system_prompt.clone();
         let mut missing_placeholders = Vec::new();
 
-        // Extract all placeholders from user prompt
-        let user_placeholders = extract_placeholders(&self.user_prompt);
+        // Extract placeholders from user prompt if it exists
+        let user_placeholders = if let Some(ref user) = self.user_prompt {
+            extract_placeholders(user)
+        } else {
+            Vec::new()
+        };
 
         // Extract placeholders from system prompt if it exists
         let system_placeholders = if let Some(ref system) = self.system_prompt {
@@ -67,7 +81,9 @@ impl Template {
             match value {
                 Some(val) => {
                     let pattern = format!("{{{{{placeholder}}}}}");
-                    rendered_user = rendered_user.replace(&pattern, val);
+                    if let Some(ref mut user) = rendered_user {
+                        *user = user.replace(&pattern, val);
+                    }
                     if let Some(ref mut system) = rendered_system {
                         *system = system.replace(&pattern, val);
                     }
@@ -94,7 +110,11 @@ impl Template {
     /// Get all placeholders required by this template
     #[allow(dead_code)]
     pub fn get_placeholders(&self) -> Vec<String> {
-        let mut placeholders = extract_placeholders(&self.user_prompt);
+        let mut placeholders = if let Some(ref user) = self.user_prompt {
+            extract_placeholders(user)
+        } else {
+            Vec::new()
+        };
 
         if let Some(ref system) = self.system_prompt {
             let system_placeholders = extract_placeholders(system);
@@ -123,7 +143,7 @@ impl Template {
 #[derive(Debug)]
 pub struct RenderedTemplate {
     pub system_prompt: Option<String>,
-    pub user_prompt: String,
+    pub user_prompt: Option<String>,
 }
 
 /// Store for managing templates
@@ -314,7 +334,7 @@ mod tests {
         let template = Template {
             name: "test".to_string(),
             system_prompt: Some("You are a {{role}}".to_string()),
-            user_prompt: "Hello {{name}}, the weather is {{weather}}".to_string(),
+            user_prompt: Some("Hello {{name}}, the weather is {{weather}}".to_string()),
             defaults: [("weather".to_string(), "sunny".to_string())].into(),
             description: None,
         };
@@ -328,7 +348,10 @@ mod tests {
             rendered.system_prompt,
             Some("You are a assistant".to_string())
         );
-        assert_eq!(rendered.user_prompt, "Hello Alice, the weather is sunny");
+        assert_eq!(
+            rendered.user_prompt,
+            Some("Hello Alice, the weather is sunny".to_string())
+        );
     }
 
     #[test]
@@ -336,7 +359,7 @@ mod tests {
         let template = Template {
             name: "test".to_string(),
             system_prompt: None,
-            user_prompt: "Hello {{name}}".to_string(),
+            user_prompt: Some("Hello {{name}}".to_string()),
             defaults: HashMap::new(),
             description: None,
         };
@@ -371,7 +394,7 @@ mod tests {
 
         let loaded = store.get("test").unwrap();
         assert_eq!(loaded.name, "test");
-        assert_eq!(loaded.user_prompt, "Hello {{name}}");
+        assert_eq!(loaded.user_prompt, Some("Hello {{name}}".to_string()));
     }
 
     #[test]
@@ -388,7 +411,10 @@ mod tests {
         params.insert("name".to_string(), "Alice".to_string());
 
         let rendered = template.render(&params).unwrap();
-        assert_eq!(rendered.user_prompt, "Hello Alice, how are you!");
+        assert_eq!(
+            rendered.user_prompt,
+            Some("Hello Alice, how are you!".to_string())
+        );
     }
 
     #[test]
@@ -406,7 +432,10 @@ mod tests {
         params.insert("greeting".to_string(), "welcome".to_string()); // Override default
 
         let rendered = template.render(&params).unwrap();
-        assert_eq!(rendered.user_prompt, "Hello Bob, welcome!");
+        assert_eq!(
+            rendered.user_prompt,
+            Some("Hello Bob, welcome!".to_string())
+        );
     }
 
     #[test]
@@ -414,7 +443,7 @@ mod tests {
         let template = Template {
             name: "assistant".to_string(),
             system_prompt: Some("You are a helpful {{role}} assistant. Be {{tone}}.".to_string()),
-            user_prompt: "Help me with {{task}}".to_string(),
+            user_prompt: Some("Help me with {{task}}".to_string()),
             defaults: [("tone".to_string(), "professional".to_string())].into(),
             description: Some("Assistant template".to_string()),
         };
@@ -428,7 +457,10 @@ mod tests {
             rendered.system_prompt,
             Some("You are a helpful coding assistant. Be professional.".to_string())
         );
-        assert_eq!(rendered.user_prompt, "Help me with debugging");
+        assert_eq!(
+            rendered.user_prompt,
+            Some("Help me with debugging".to_string())
+        );
     }
 
     #[test]
@@ -463,7 +495,7 @@ mod tests {
         let template = Template {
             name: "test".to_string(),
             system_prompt: Some("System: {{role}} with {{mood}}".to_string()),
-            user_prompt: "User: {{input}} for {{task}}".to_string(),
+            user_prompt: Some("User: {{input}} for {{task}}".to_string()),
             defaults: HashMap::new(),
             description: None,
         };
@@ -522,7 +554,7 @@ mod tests {
         let template = Template {
             name: "test".to_string(),
             system_prompt: Some("".to_string()),
-            user_prompt: "Hello {{name}}".to_string(),
+            user_prompt: Some("Hello {{name}}".to_string()),
             defaults: HashMap::new(),
             description: None,
         };
@@ -532,7 +564,7 @@ mod tests {
 
         let rendered = template.render(&params).unwrap();
         assert_eq!(rendered.system_prompt, Some("".to_string()));
-        assert_eq!(rendered.user_prompt, "Hello ");
+        assert_eq!(rendered.user_prompt, Some("Hello ".to_string()));
     }
 
     #[test]
@@ -540,7 +572,7 @@ mod tests {
         let template = Template {
             name: "test".to_string(),
             system_prompt: Some("System {{a}} {{b}}".to_string()),
-            user_prompt: "User {{c}} {{d}}".to_string(),
+            user_prompt: Some("User {{c}} {{d}}".to_string()),
             defaults: HashMap::new(),
             description: None,
         };
diff --git a/crates/rullm-core/src/tests.rs b/crates/rullm-core/src/tests.rs
index b5c1e2ab..882b39a6 100644
--- a/crates/rullm-core/src/tests.rs
+++ b/crates/rullm-core/src/tests.rs
@@ -31,7 +31,7 @@ impl MockProvider {
 #[async_trait::async_trait]
 impl LlmProvider for MockProvider {
     fn name(&self) -> &'static str {
-        ""
+        self.name
     }
 
     fn aliases(&self) -> &'static [&'static str] {

From cd8c7ee12b64b25588632e922fbc73f3b75a5128 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 21:40:11 +0530
Subject: [PATCH 09/15] docs(readme): remove --param examples and update
 placeholders

---
 README.md | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index 95c42c04..a1c86f2a 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ rullm --model gpt4 "Explain quantum computing"
 rullm --model claude "Write a poem about the ocean"
 rullm --model gemini "What's the weather like?"
 
-# Use templates for structured queries
+# Use templates for structured queries ({{input}} placeholder is automatically filled)
 rullm -t code-review "Review this function"
 rullm -t greeting --param name=Alice "Welcome message"
 
@@ -59,14 +59,8 @@ Templates provide a way to create reusable prompt structures with placeholders f
 ### Template Usage
 
 ```bash
-# Use a template with the default parameters
+# Use a template ({{input}} is replaced by your query)
 rullm -t my-template "input text"
-
-# Override template parameters
-rullm -t code-review --param language=rust --param style=detailed "Review this code"
-
-# Multiple parameter overrides
-rullm -t greeting --param name=Alice --param time="morning" "Create a message"
 ```
 
 ### Template Format
@@ -86,10 +80,12 @@ style = "standard"
 
 ### Template Placeholders
 
-- `{{input}}` - Automatically filled with the user's query text
-- `{{custom}}` - Any custom placeholder defined in your template
-- Parameters can be overridden using `--param key=value`
-- Default values are used when no override is provided
+- `{{input}}` – Automatically filled with the user's query text.
+- Any additional placeholders **must** have a default value specified in the
+  `[defaults]` table of the template file, since the CLI no longer supports
+  runtime `--param` overrides.
+
+If a placeholder other than `input` lacks a default, rendering will fail.
 
 ### Built-in Model Aliases
 

From c30550f9b9ac6b34aaf0a9aceccf7c0ef08d543f Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 21:49:57 +0530
Subject: [PATCH 10/15] docs(readme): purge remaining --param example

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index a1c86f2a..aa6dd8c5 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,6 @@ rullm --model gemini "What's the weather like?"
 
 # Use templates for structured queries ({{input}} placeholder is automatically filled)
 rullm -t code-review "Review this function"
-rullm -t greeting --param name=Alice "Welcome message"
 
 # Interactive chat
 rullm chat --model claude

From c5291d175f362e5c929f9e73d01830f2a0dac9fb Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 21:53:52 +0530
Subject: [PATCH 11/15] docs(readme): simplify template format and remove
 defaults note

---
 README.md | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index aa6dd8c5..a2b4654c 100644
--- a/README.md
+++ b/README.md
@@ -53,8 +53,6 @@ rullm keys list
 
 ## 📝 Templates
 
-Templates provide a way to create reusable prompt structures with placeholders for dynamic content. They're stored as TOML files in your system's configuration directory.
-
 ### Template Usage
 
 ```bash
@@ -69,22 +67,22 @@ Templates are stored as TOML files in `~/.config/rullm/templates/` (or your syst
 ```toml
 name = "code-review"
 description = "Template for code review requests"
-system_prompt = "You are an expert {{language}} developer. Review the code with {{style}} analysis."
-user_prompt = "Please review this {{language}} code: {{input}}"
-
-[defaults]
-language = "generic"
-style = "standard"
+# You can include multi-line prompts using TOML triple-quoted strings:
+system_prompt = """
+You are a senior Rust engineer.
+
+Provide a thorough review with the following structure:
+1. Summary
+2. Strengths
+3. Weaknesses
+4. Suggestions
+"""
+user_prompt = "Please review this code: {{input}}"
 ```
 
 ### Template Placeholders
 
 - `{{input}}` – Automatically filled with the user's query text.
-- Any additional placeholders **must** have a default value specified in the
-  `[defaults]` table of the template file, since the CLI no longer supports
-  runtime `--param` overrides.
-
-If a placeholder other than `input` lacks a default, rendering will fail.
 
 ### Built-in Model Aliases
 

From 2c30ea09cd08d42c408d71833f13328a70cf19f0 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 22:07:21 +0530
Subject: [PATCH 12/15] feat(cli): dynamic template completer and ad-hoc
 @file.toml support for -t/--template

---
 crates/rullm-cli/src/args.rs | 42 +++++++++++++++++++++++++++-
 crates/rullm-cli/src/main.rs | 53 ++++++++++++++++++++++++------------
 2 files changed, 76 insertions(+), 19 deletions(-)

diff --git a/crates/rullm-cli/src/args.rs b/crates/rullm-cli/src/args.rs
index 5a076dfd..a74d5a07 100644
--- a/crates/rullm-cli/src/args.rs
+++ b/crates/rullm-cli/src/args.rs
@@ -11,6 +11,7 @@ use crate::commands::models::load_cached_models;
 use crate::commands::{Commands, ModelsCache};
 use crate::config::{self, Config};
 use crate::constants::{BINARY_NAME, KEYS_CONFIG_FILE};
+use crate::templates::TemplateStore;
 
 // Example strings for after_long_help
 const CLI_EXAMPLES: &str = r#"EXAMPLES:
@@ -132,7 +133,7 @@ pub struct Cli {
     pub model: Option<String>,
 
     /// Template to use for the query (only available for quick-query mode)
-    #[arg(short, long)]
+    #[arg(short, long, add = ArgValueCompleter::new(template_completer))]
     pub template: Option<String>,
 
     /// Set options in format: --option key value (e.g., --option temperature 0.1 --option max_tokens 2096)
@@ -220,6 +221,45 @@ pub fn model_completer(current: &OsStr) -> Vec<CompletionCandidate> {
         .collect()
 }
 
+pub fn template_completer(current: &std::ffi::OsStr) -> Vec<clap_complete::CompletionCandidate> {
+    let cur_str = current.to_string_lossy();
+    let mut candidates = Vec::new();
+
+    // Only suggest .toml files in CWD as @filename.toml if user input starts with '@'
+    if let Some(prefix) = cur_str.strip_prefix('@') {
+        if let Ok(entries) = std::fs::read_dir(".") {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if let Some(ext) = path.extension() {
+                    if ext == "toml" {
+                        if let Some(fname) = path.file_name().and_then(|f| f.to_str()) {
+                            if fname.starts_with(prefix) {
+                                candidates.push(format!("@{fname}").into());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    } else {
+        // Otherwise, suggest installed template names
+        let strategy = match etcetera::choose_base_strategy() {
+            Ok(s) => s,
+            Err(_) => return candidates,
+        };
+        let config_base_path = strategy.config_dir().join(BINARY_NAME);
+        let mut store = TemplateStore::new(&config_base_path);
+        if store.load().is_ok() {
+            for name in store.list() {
+                if name.starts_with(cur_str.as_ref()) {
+                    candidates.push(name.into());
+                }
+            }
+        }
+    }
+    candidates
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index 04fa124a..222154f8 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -91,24 +91,41 @@ pub async fn run() -> Result<()> {
 
                 // Handle template if provided
                 let (system_prompt, final_query) = if let Some(template_name) = &cli.template {
-                    // Load template store
-                    let mut template_store = TemplateStore::new(&cli_config.config_base_path);
-                    template_store
-                        .load()
-                        .map_err(|e| anyhow::anyhow!("Failed to load templates: {}", e))?;
-
-                    // Get the template
-                    let template = template_store
-                        .get(template_name)
-                        .ok_or_else(|| anyhow::anyhow!("Template '{}' not found", template_name))?;
-
-                    // Render the template using the user input as the only parameter
-                    let rendered = template.render_input(query).map_err(|e| {
-                        anyhow::anyhow!("Failed to render template '{}': {}", template_name, e)
-                    })?;
-
-                    let final_query = rendered.user_prompt.unwrap_or_else(|| query.clone());
-                    (rendered.system_prompt, final_query)
+                    if template_name.starts_with('@') {
+                        // Ad-hoc template from file
+                        let path = template_name.trim_start_matches('@');
+                        let content = std::fs::read_to_string(path).map_err(|e| {
+                            anyhow::anyhow!("Failed to read template file '{}': {}", path, e)
+                        })?;
+                        let template: templates::Template =
+                            toml::from_str(&content).map_err(|e| {
+                                anyhow::anyhow!("Failed to parse template file '{}': {}", path, e)
+                            })?;
+                        let rendered = template.render_input(query).map_err(|e| {
+                            anyhow::anyhow!("Failed to render template from '{}': {}", path, e)
+                        })?;
+                        let final_query = rendered.user_prompt.unwrap_or_else(|| query.clone());
+                        (rendered.system_prompt, final_query)
+                    } else {
+                        // Load template store
+                        let mut template_store = TemplateStore::new(&cli_config.config_base_path);
+                        template_store
+                            .load()
+                            .map_err(|e| anyhow::anyhow!("Failed to load templates: {}", e))?;
+
+                        // Get the template
+                        let template = template_store.get(template_name).ok_or_else(|| {
+                            anyhow::anyhow!("Template '{}' not found", template_name)
+                        })?;
+
+                        // Render the template using the user input as the only parameter
+                        let rendered = template.render_input(query).map_err(|e| {
+                            anyhow::anyhow!("Failed to render template '{}': {}", template_name, e)
+                        })?;
+
+                        let final_query = rendered.user_prompt.unwrap_or_else(|| query.clone());
+                        (rendered.system_prompt, final_query)
+                    }
                 } else {
                     (None, query.clone())
                 };

From 6476dfa7ca0b5c58f6983eeb7d9d0fe9c393d7e1 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 22:52:40 +0530
Subject: [PATCH 13/15] feat(templates): add edit subcommand to open template
 in $EDITOR and add tab complete for other subcommands

---
 crates/rullm-cli/src/commands/templates.rs | 50 ++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/crates/rullm-cli/src/commands/templates.rs b/crates/rullm-cli/src/commands/templates.rs
index b3a4af59..ad2ec66c 100644
--- a/crates/rullm-cli/src/commands/templates.rs
+++ b/crates/rullm-cli/src/commands/templates.rs
@@ -1,8 +1,10 @@
+use crate::args::template_completer;
 use crate::args::{Cli, CliConfig};
 use crate::output::{self, OutputLevel};
 use crate::templates::TemplateStore;
 use anyhow::Result;
 use clap::{Args, Subcommand};
+use clap_complete::engine::ArgValueCompleter;
 
 #[derive(Args)]
 pub struct TemplatesArgs {
@@ -17,11 +19,19 @@ pub enum TemplateAction {
     /// Show a specific template's details
     Show {
         /// Template name
+        #[arg(value_name = "NAME", add = ArgValueCompleter::new(template_completer))]
         name: String,
     },
     /// Remove a template file
     Remove {
         /// Template name to delete
+        #[arg(value_name = "NAME", add = ArgValueCompleter::new(template_completer))]
+        name: String,
+    },
+    /// Edit a template file in $EDITOR
+    Edit {
+        /// Template name to edit
+        #[arg(value_name = "NAME", add = ArgValueCompleter::new(template_completer))]
         name: String,
     },
     /// Create a new template
@@ -104,6 +114,46 @@ impl TemplatesArgs {
                     output_level,
                 ),
             },
+            TemplateAction::Edit { name } => {
+                use std::env;
+                use std::process::Command;
+                use std::process::Stdio;
+
+                if !store.contains(name) {
+                    output::error(&format!("Template '{name}' not found."), output_level);
+                    return Ok(());
+                }
+
+                let file_path = store.templates_dir().join(format!("{name}.toml"));
+                let editor = env::var("EDITOR").unwrap_or_else(|_| "nvim".to_string());
+
+                let status = Command::new(&editor)
+                    .arg(&file_path)
+                    .stdin(Stdio::inherit())
+                    .stdout(Stdio::inherit())
+                    .stderr(Stdio::inherit())
+                    .status();
+
+                match status {
+                    Ok(s) if s.success() => {
+                        // Reload the store to refresh in-memory state
+                        if let Err(e) = store.load() {
+                            output::warning(
+                                &format!("Edited, but failed to reload templates: {e}"),
+                                output_level,
+                            );
+                        } else {
+                            output::success(&format!("Edited template '{name}'."), output_level);
+                        }
+                    }
+                    Ok(s) => {
+                        output::error(&format!("Editor exited with status: {s}"), output_level);
+                    }
+                    Err(e) => {
+                        output::error(&format!("Failed to launch editor: {e}"), output_level);
+                    }
+                }
+            }
             TemplateAction::Create {
                 name,
                 user_prompt,

From 71cc3b63d0d55da9f777b520f4e3ad96550a9072 Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 22:58:53 +0530
Subject: [PATCH 14/15] fix(templates): update save to refresh in-memory map on
 save

---
 crates/rullm-cli/src/templates.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index 253c3c71..fabc1b24 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -208,7 +208,11 @@ impl TemplateStore {
     }
 
     /// Save a template to disk
-    pub fn save(&self, template: &Template) -> Result<()> {
+    pub fn save(&mut self, template: &Template) -> Result<()> {
+        // Update in-memory map so caller sees it immediately
+        self.templates
+            .insert(template.name.clone(), template.clone());
+
         if !self.templates_dir.exists() {
             fs::create_dir_all(&self.templates_dir)
                 .context("Failed to create templates directory")?;

From 6680d175e69df42b1cd73f0f9a4ba657751bedfc Mon Sep 17 00:00:00 2001
From: itzlambda <git@itzlambda.com>
Date: Mon, 30 Jun 2025 23:03:04 +0530
Subject: [PATCH 15/15] refactor(cli): extract template resolution to helper fn

---
 crates/rullm-cli/src/main.rs      | 38 ++------------------------
 crates/rullm-cli/src/templates.rs | 44 +++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 36 deletions(-)

diff --git a/crates/rullm-cli/src/main.rs b/crates/rullm-cli/src/main.rs
index 222154f8..93adb825 100644
--- a/crates/rullm-cli/src/main.rs
+++ b/crates/rullm-cli/src/main.rs
@@ -18,7 +18,7 @@ use clap::{CommandFactory, Parser};
 use cli_helpers::resolve_direct_query_model;
 use commands::Commands;
 use output::OutputLevel;
-use templates::TemplateStore;
+use templates::resolve_template_prompts;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -91,41 +91,7 @@ pub async fn run() -> Result<()> {
 
                 // Handle template if provided
                 let (system_prompt, final_query) = if let Some(template_name) = &cli.template {
-                    if template_name.starts_with('@') {
-                        // Ad-hoc template from file
-                        let path = template_name.trim_start_matches('@');
-                        let content = std::fs::read_to_string(path).map_err(|e| {
-                            anyhow::anyhow!("Failed to read template file '{}': {}", path, e)
-                        })?;
-                        let template: templates::Template =
-                            toml::from_str(&content).map_err(|e| {
-                                anyhow::anyhow!("Failed to parse template file '{}': {}", path, e)
-                            })?;
-                        let rendered = template.render_input(query).map_err(|e| {
-                            anyhow::anyhow!("Failed to render template from '{}': {}", path, e)
-                        })?;
-                        let final_query = rendered.user_prompt.unwrap_or_else(|| query.clone());
-                        (rendered.system_prompt, final_query)
-                    } else {
-                        // Load template store
-                        let mut template_store = TemplateStore::new(&cli_config.config_base_path);
-                        template_store
-                            .load()
-                            .map_err(|e| anyhow::anyhow!("Failed to load templates: {}", e))?;
-
-                        // Get the template
-                        let template = template_store.get(template_name).ok_or_else(|| {
-                            anyhow::anyhow!("Template '{}' not found", template_name)
-                        })?;
-
-                        // Render the template using the user input as the only parameter
-                        let rendered = template.render_input(query).map_err(|e| {
-                            anyhow::anyhow!("Failed to render template '{}': {}", template_name, e)
-                        })?;
-
-                        let final_query = rendered.user_prompt.unwrap_or_else(|| query.clone());
-                        (rendered.system_prompt, final_query)
-                    }
+                    resolve_template_prompts(template_name, query, &cli_config.config_base_path)?
                 } else {
                     (None, query.clone())
                 };
diff --git a/crates/rullm-cli/src/templates.rs b/crates/rullm-cli/src/templates.rs
index fabc1b24..4492fe4a 100644
--- a/crates/rullm-cli/src/templates.rs
+++ b/crates/rullm-cli/src/templates.rs
@@ -310,6 +310,50 @@ fn extract_placeholders(template: &str) -> Vec<String> {
     placeholders
 }
 
+/// Resolves a template (by name or @file) and renders it with the user query.
+pub fn resolve_template_prompts(
+    template_name: &str,
+    user_query: &str,
+    config_base_path: &std::path::Path,
+) -> anyhow::Result<(Option<String>, String)> {
+    if template_name.starts_with('@') {
+        // Ad-hoc template from file
+        let path = template_name.trim_start_matches('@');
+        let content = std::fs::read_to_string(path)
+            .map_err(|e| anyhow::anyhow!("Failed to read template file '{}': {}", path, e))?;
+        let template: Template = toml::from_str(&content)
+            .map_err(|e| anyhow::anyhow!("Failed to parse template file '{}': {}", path, e))?;
+        let rendered = template
+            .render_input(user_query)
+            .map_err(|e| anyhow::anyhow!("Failed to render template from '{}': {}", path, e))?;
+        let final_query = rendered
+            .user_prompt
+            .unwrap_or_else(|| user_query.to_string());
+        Ok((rendered.system_prompt, final_query))
+    } else {
+        // Load template store
+        let mut template_store = TemplateStore::new(config_base_path);
+        template_store
+            .load()
+            .map_err(|e| anyhow::anyhow!("Failed to load templates: {}", e))?;
+
+        // Get the template
+        let template = template_store
+            .get(template_name)
+            .ok_or_else(|| anyhow::anyhow!("Template '{}' not found", template_name))?;
+
+        // Render the template using the user input as the only parameter
+        let rendered = template
+            .render_input(user_query)
+            .map_err(|e| anyhow::anyhow!("Failed to render template '{}': {}", template_name, e))?;
+
+        let final_query = rendered
+            .user_prompt
+            .unwrap_or_else(|| user_query.to_string());
+        Ok((rendered.system_prompt, final_query))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;