Upload 5 files

ai_model_plugins.py

@@ -0,0 +1,217 @@
+# ai_model_plugins.py
+import os
+import re
+import requests
+
+# --- Model Generation Functions ---
+
+def generate_with_gemini(prompt, model_name="gemini-2.0-flash", api_key=None):
+    import google.generativeai as genai
+    actual_api_key = api_key if api_key else os.environ.get("GEMINI_API_KEY")
+    if not actual_api_key:
+        raise ValueError("Gemini API key is not set and none was provided.")
+    genai.configure(api_key=actual_api_key)
+    model = genai.GenerativeModel(model_name)
+    response = model.generate_content(prompt)
+    text = response.text
+
+    code_fence_regex = r"```[^\n]*\n(.*?)\n```"
+    match = re.search(code_fence_regex, text, re.DOTALL | re.IGNORECASE)
+    if match:
+        text = match.group(1).strip()
+    else:
+        text = text.strip()
+
+    tokens = len(text.split())  # rough token estimate
+    # Pricing: Gemini output pricing per 1M tokens
+    if model_name.lower() == "gemini-2.0-flash":
+        cost_rate = 0.40
+    elif model_name.lower() == "gemini-1.5-flash":
+        cost_rate = 0.30
+    elif model_name.lower() == "gemini-1.5-pro":
+        cost_rate = 5.00
+    else:
+        cost_rate = 0.40
+    cost = (tokens / 1_000_000) * cost_rate
+    return text, cost
+
+def generate_with_openai(prompt, model_name="gpt-3.5-turbo", api_key=None):
+    import openai
+    actual_api_key = api_key if api_key else os.environ.get("OPENAI_API_KEY")
+    if not actual_api_key:
+        raise ValueError("OpenAI API key is not set and none was provided.")
+    openai.api_key = actual_api_key
+    response = openai.ChatCompletion.create(
+        model=model_name,
+        messages=[{"role": "user", "content": prompt}],
+    )
+    text = response.choices[0].message.content
+    tokens = len(text.split())
+    cost_rate = 2.00  # example rate; adjust per official pricing
+    cost = (tokens / 1_000_000) * cost_rate
+    return text, cost
+
+def generate_with_anthropic(prompt, model_name="claude-v1", api_key=None):
+    url = "https://api.anthropic.com/v1/complete"
+    if not api_key:
+        raise ValueError("Anthropic API key is not set and none was provided.")
+    headers = {
+        "Content-Type": "application/json",
+        "x-api-key": api_key,
+    }
+    data = {
+        "prompt": prompt,
+        "model": model_name,
+        "max_tokens_to_sample": 150,
+        "temperature": 0.7,
+        "stop_sequences": ["\n\n"],
+    }
+    response = requests.post(url, json=data, headers=headers)
+    if response.status_code != 200:
+        raise ValueError("Anthropic API error: " + response.text)
+    json_data = response.json()
+    text = json_data.get("completion", "")
+    tokens = len(text.split())
+    # Example cost rate for Anthropic (update as per their official pricing)
+    cost_rate = 0.50  
+    cost = (tokens / 1_000_000) * cost_rate
+    return text, cost
+
+def generate_with_ollama(prompt, model_name="ollama-model-1", api_key=None):
+    # Ollama typically runs locally; adjust URL if needed.
+    url = "http://localhost:11434/api/v1/predict"
+    data = {
+        "model": model_name,
+        "prompt": prompt,
+        "max_tokens": 150,
+    }
+    response = requests.post(url, json=data)
+    if response.status_code != 200:
+        raise ValueError("Ollama API error: " + response.text)
+    json_data = response.json()
+    text = json_data.get("prediction", "")
+    tokens = len(text.split())
+    cost_rate = 0.25  # Replace with actual pricing if available
+    cost = (tokens / 1_000_000) * cost_rate
+    return text, cost
+
+def generate_with_lmstudios(prompt, model_name="lmstudios-model-alpha", api_key=None):
+    url = "https://api.lmstudios.com/v1/generate"
+    if not api_key:
+        raise ValueError("LMStudios API key is not set and none was provided.")
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    data = {
+        "prompt": prompt,
+        "model": model_name,
+        "max_tokens": 150,
+        "temperature": 0.7,
+    }
+    response = requests.post(url, json=data, headers=headers)
+    if response.status_code != 200:
+        raise ValueError("LMStudios API error: " + response.text)
+    json_data = response.json()
+    text = json_data.get("text", "")
+    tokens = len(text.split())
+    cost_rate = 0.35  # Replace with official pricing
+    cost = (tokens / 1_000_000) * cost_rate
+    return text, cost
+
+def generate_with_openrouter(prompt, model_name="openrouter-model-x", api_key=None):
+    url = "https://api.openrouter.ai/v2/chat/completions"
+    if not api_key:
+        raise ValueError("OpenRouter API key is not set and none was provided.")
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    data = {
+        "model": model_name,
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": 150,
+        "temperature": 0.7,
+    }
+    response = requests.post(url, json=data, headers=headers)
+    if response.status_code != 200:
+        raise ValueError("OpenRouter API error: " + response.text)
+    json_data = response.json()
+    text = json_data["choices"][0]["message"]["content"]
+    tokens = len(text.split())
+    cost_rate = 0.45  # Update per official pricing
+    cost = (tokens / 1_000_000) * cost_rate
+    return text, cost
+
+def get_model_generator(provider, model_name):
+    provider_lower = provider.lower()
+    if provider_lower == "openai":
+        return generate_with_openai
+    elif provider_lower == "anthropic":
+        return generate_with_anthropic
+    elif provider_lower == "ollama":
+        return generate_with_ollama
+    elif provider_lower == "lmstudios":
+        return generate_with_lmstudios
+    elif provider_lower == "openrouter":
+        return generate_with_openrouter
+    else:  # Default to Gemini
+        return generate_with_gemini
+
+# --- Model Listing Functions ---
+
+def list_models_openai(api_key=None):
+    import openai
+    actual_api_key = api_key if api_key else os.environ.get("OPENAI_API_KEY")
+    if not actual_api_key:
+        raise ValueError("OpenAI API key is not set and none was provided.")
+    openai.api_key = actual_api_key
+    response = openai.Model.list()
+    return [model.id for model in response.data]
+
+def list_models_gemini(api_key=None):
+    return ["gemini-2.0-flash", "gemini-1.5-flash", "gemini-1.5-pro"]
+
+def list_models_anthropic(api_key=None):
+    return ["claude-3-opus", "claude-3.5-sonnet", "claude-3-haiku"]
+
+def list_models_ollama(api_key=None):
+    url = "http://localhost:11434/api/models"
+    response = requests.get(url)
+    if response.status_code != 200:
+        raise ValueError("Ollama API error: " + response.text)
+    json_data = response.json()
+    return json_data.get("models", [])
+
+def list_models_lmstudios(api_key=None):
+    if not api_key:
+        raise ValueError("LMStudios API key is not set and none was provided.")
+    url = "https://api.lmstudios.com/v1/models"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    response = requests.get(url, headers=headers)
+    if response.status_code != 200:
+        raise ValueError("LMStudios API error: " + response.text)
+    json_data = response.json()
+    return [model["id"] for model in json_data.get("models", [])]
+
+def list_models_openrouter(api_key=None):
+    if not api_key:
+        raise ValueError("OpenRouter API key is not set and none was provided.")
+    url = "https://api.openrouter.ai/v2/models"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    response = requests.get(url, headers=headers)
+    if response.status_code != 200:
+        raise ValueError("OpenRouter API error: " + response.text)
+    json_data = response.json()
+    return [model["id"] for model in json_data.get("models", [])]
+
+def list_available_models(provider, api_key=None):
+    provider_lower = provider.lower()
+    if provider_lower == "openai":
+        return list_models_openai(api_key)
+    elif provider_lower == "gemini":
+        return list_models_gemini(api_key)
+    elif provider_lower == "anthropic":
+        return list_models_anthropic(api_key)
+    elif provider_lower == "ollama":
+        return list_models_ollama(api_key)
+    elif provider_lower == "lmstudios":
+        return list_models_lmstudios(api_key)
+    elif provider_lower == "openrouter":
+        return list_models_openrouter(api_key)
+    else:
+        return []

config_manager.py

@@ -0,0 +1,20 @@
+import json
+import os
+
+def load_config(config_path="config.json"):
+    """
+    Loads configuration settings from a JSON file.
+    Returns a dictionary of config settings, or an empty dict if the file doesn't exist or fails to parse.
+    """
+    if os.path.exists(config_path):
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                config = json.load(f)
+            return config
+        except json.JSONDecodeError as e:
+            print(f"Error parsing configuration file {config_path}: {e}")
+    return {}
+
+if __name__ == "__main__":
+    config = load_config()
+    print(config)

gradio_app.py

@@ -0,0 +1,158 @@
+import gradio as gr
+import json
+from insert_snippet import insert_snippet
+from ai_model_plugins import list_available_models
+
+def generate_snippet_gui(
+    description, language, output_dir, output_file_name, clipboard,
+    provider, model, api_key, template, params, existing_file, marker, format_code
+):
+    try:
+        try:
+            template_params = json.loads(params) if params else {}
+        except Exception as e:
+            return f"Error parsing template parameters: {e}", ""
+        
+        result = insert_snippet(
+            description,
+            language,
+            output_dir=output_dir,
+            output_file_name=output_file_name,
+            use_clipboard=clipboard,
+            model_name=model,
+            template=template,
+            template_params=template_params,
+            existing_file=existing_file if existing_file.strip() != "" else None,
+            marker=marker if marker.strip() != "" else None,
+            format_code=format_code,
+            provider=provider if provider.strip() != "" else None,
+            api_key=api_key if api_key.strip() != "" else None,
+            return_snippet=True
+        )
+        # result is a tuple: (snippet, cost)
+        return result
+    except Exception as e:
+        return f"Error generating snippet: {e}", ""
+
+def download_snippet_file_gui(
+    description, language, output_dir, output_file_name, clipboard,
+    provider, model, api_key, template, params, existing_file, marker, format_code
+):
+    try:
+        try:
+            template_params = json.loads(params) if params else {}
+        except Exception as e:
+            return f"Error parsing template parameters: {e}"
+        
+        result = insert_snippet(
+            description,
+            language,
+            output_dir=output_dir,
+            output_file_name=output_file_name,
+            use_clipboard=clipboard,
+            model_name=model,
+            template=template,
+            template_params=template_params,
+            existing_file=existing_file if existing_file.strip() != "" else None,
+            marker=marker if marker.strip() != "" else None,
+            format_code=format_code,
+            provider=provider if provider.strip() != "" else None,
+            api_key=api_key if api_key.strip() != "" else None,
+            return_file_path=True
+        )
+        return result[1]
+    except Exception as e:
+        return f"Error saving file: {e}"
+
+def list_models_gui(provider, api_key):
+    try:
+        models = list_available_models(provider, api_key if api_key.strip() != "" else None)
+        return "\n".join(models)
+    except Exception as e:
+        return f"Error listing models: {e}"
+
+def clear_fields():
+    return (
+        "", "python", "output", "snippet", False,
+        "Gemini", "gemini-2.0-flash", "", "", "{}", "", "", False, ""
+    )
+
+with gr.Blocks() as demo:
+    gr.Markdown("# HMVL Snippet Generator")
+    
+    with gr.Row():
+        description = gr.Textbox(label="Description", lines=3, placeholder="Enter code snippet description here...")
+        language = gr.Dropdown(
+            label="Language", 
+            choices=["python", "javascript", "typescript", "markdown", "html", "css",
+                      "cpp", "java", "go", "rust", "sql", "bash", "shell"],
+            value="python"
+        )
+    
+    with gr.Row():
+        output_dir = gr.Textbox(label="Output Directory", value="output")
+        output_file_name = gr.Textbox(label="Output File Name", value="snippet")
+    
+    with gr.Row():
+        clipboard = gr.Checkbox(label="Copy to Clipboard", value=False)
+    
+    with gr.Row():
+        provider = gr.Dropdown(
+            label="LLM Provider", 
+            choices=["Gemini", "OpenAI", "Anthropic", "Ollama", "LMStudios", "OpenRouter"],
+            value="Gemini"
+        )
+        model = gr.Textbox(label="Model", value="gemini-2.0-flash")
+        api_key = gr.Textbox(label="API Key", placeholder="Enter API key if required", type="password")
+    
+    with gr.Row():
+        template = gr.Textbox(label="Template (optional)", placeholder="e.g., functional_component.jsx")
+        params = gr.Textbox(label="Template Parameters (JSON)", placeholder='e.g., {"component_name": "MyComponent", "title": "Hello"}', lines=2)
+    
+    with gr.Row():
+        existing_file = gr.Textbox(label="Existing File (optional)", placeholder="Path to existing file for snippet insertion")
+        marker = gr.Textbox(label="Marker (optional)", placeholder="Marker string in file (if applicable)")
+        format_code = gr.Checkbox(label="Format Python Code", value=False)
+    
+    with gr.Row():
+        generate_button = gr.Button("Generate Snippet")
+        download_button = gr.Button("Download Snippet File")
+        list_models_button = gr.Button("List Available Models")
+        clear_button = gr.Button("Clear Fields")
+    
+    snippet_output = gr.Code(label="Generated Snippet", language="python")
+    cost_output = gr.Textbox(label="Estimated Cost (USD)", interactive=False)
+    file_output = gr.File(label="Download File")
+    models_list_output = gr.Textbox(label="Available Models", interactive=False)
+    
+    with gr.Row():
+        status = gr.Textbox(label="Status", interactive=False)
+    
+    generate_button.click(
+        fn=generate_snippet_gui, 
+        inputs=[description, language, output_dir, output_file_name, clipboard,
+                provider, model, api_key, template, params, existing_file, marker, format_code], 
+        outputs=[snippet_output, cost_output]
+    )
+    
+    download_button.click(
+        fn=download_snippet_file_gui, 
+        inputs=[description, language, output_dir, output_file_name, clipboard,
+                provider, model, api_key, template, params, existing_file, marker, format_code], 
+        outputs=file_output
+    )
+    
+    list_models_button.click(
+        fn=list_models_gui,
+        inputs=[provider, api_key],
+        outputs=models_list_output
+    )
+    
+    clear_button.click(
+        fn=clear_fields,
+        inputs=None,
+        outputs=[description, language, output_dir, output_file_name, clipboard,
+                 provider, model, api_key, template, params, existing_file, marker, format_code, snippet_output]
+    )
+    
+demo.launch()

insert_snippet.py

@@ -0,0 +1,244 @@
+# insert_snippet.py
+import os
+import argparse
+import re
+import json
+import requests
+import google.generativeai as genai
+import pyperclip  # For clipboard integration
+
+from config_manager import load_config
+from template_manager import load_template, apply_template
+from ai_model_plugins import get_model_generator
+
+def insert_snippet(description, language, output_dir="output", output_file_name="snippet",
+                   use_clipboard=False, model_name=None, template=None, template_params=None,
+                   provider=None, api_key=None,
+                   existing_file=None, marker=None, format_code=False,
+                   return_snippet=False, return_file_path=False):
+    """
+    Generates a code snippet using an AI model or a template, and either:
+      - Saves it to a new file (or inserts into an existing file if provided),
+      - Copies it to the clipboard,
+      - And/or returns the snippet string (and cost, if requested).
+    
+    New Parameters:
+      * provider: The LLM provider to use (e.g., "Gemini", "OpenAI", "Anthropic", etc.).
+      * api_key: The API key for the selected provider.
+      * existing_file: Path to an existing file where the snippet will be inserted.
+      * marker: A marker string in the existing file where the snippet should be inserted (if not found, appends).
+      * format_code: If True and language is Python, formats the snippet using Black.
+    """
+    # Determine file extension based on language (case-insensitive)
+    file_extension = ".txt"
+    lang = language.lower()
+    if lang == "python":
+        file_extension = ".py"
+    elif lang == "javascript":
+        file_extension = ".js"
+    elif lang == "typescript":
+        file_extension = ".ts"
+    elif lang == "markdown":
+        file_extension = ".md"
+    elif lang == "html":
+        file_extension = ".html"
+    elif lang == "css":
+        file_extension = ".css"
+    elif lang == "cpp":
+        file_extension = ".cpp"
+    elif lang == "java":
+        file_extension = ".java"
+    elif lang == "go":
+        file_extension = ".go"
+    elif lang == "rust":
+        file_extension = ".rs"
+    elif lang == "sql":
+        file_extension = ".sql"
+    elif lang in ["bash", "shell"]:
+        file_extension = ".sh"
+    else:
+        raise ValueError("Invalid language. Supported languages: python, javascript, typescript, markdown, html, css, cpp, java, go, rust, sql, bash, shell")
+
+    # Determine the output file path if creating a new file
+    output_file_path = os.path.join(output_dir, output_file_name + file_extension)
+
+    try:
+        # Generate snippet via template or AI model
+        if template:
+            template_content = load_template(template)
+            template_params = template_params or {}
+            snippet = apply_template(template_content, template_params)
+            cost = 0.0
+        else:
+            if lang == "markdown":
+                snippet = f"# {description}"
+                cost = 0.0
+            else:
+                # Build a language-specific prompt
+                if lang == "python":
+                    prompt = f"Generate Python code snippet for: {description}"
+                elif lang == "javascript":
+                    prompt = f"Generate Javascript code snippet for: {description}"
+                elif lang == "typescript":
+                    prompt = f"Generate Typescript code snippet for: {description}"
+                else:
+                    prompt = description
+
+                # Get the appropriate generator function using provider and model_name
+                generator = get_model_generator(provider if provider else "gemini", 
+                                                model_name if model_name else "gemini-2.0-flash")
+                # Expecting the generator to return a tuple: (snippet, cost)
+                result = generator(prompt, model_name=model_name if model_name else "gemini-2.0-flash", api_key=api_key)
+                snippet = result[0]
+                cost = result[1]
+
+                # Extract code from fenced code blocks if present
+                code_fence_regex = rf"```{language}\n(.*?)\n```"
+                match = re.search(code_fence_regex, snippet, re.DOTALL | re.IGNORECASE)
+                if match:
+                    snippet = match.group(1).strip()
+                else:
+                    snippet = snippet.strip()
+                    print("Warning: Could not extract code snippet from AI API response. Using raw response.")
+
+        snippet = snippet.strip() + "\n"
+
+        # Format the code if requested and if it's Python
+        if format_code and lang == "python":
+            try:
+                import black
+                snippet = black.format_str(snippet, mode=black.FileMode())
+            except Exception as e:
+                print("Warning: Failed to format code with Black:", e)
+
+        # Create output or insert into existing file
+        if existing_file:
+            if not os.path.exists(existing_file):
+                raise FileNotFoundError(f"Existing file '{existing_file}' not found.")
+            with open(existing_file, "r", encoding="utf-8") as f:
+                file_contents = f.read()
+            if marker:
+                idx = file_contents.find(marker)
+                if idx == -1:
+                    print("Warning: Marker not found in file. Appending snippet at the end.")
+                    new_contents = file_contents + "\n" + snippet
+                else:
+                    marker_end = file_contents.find("\n", idx)
+                    if marker_end == -1:
+                        marker_end = len(file_contents)
+                    new_contents = file_contents[:marker_end] + "\n" + snippet + file_contents[marker_end:]
+            else:
+                new_contents = file_contents + "\n" + snippet
+            with open(existing_file, "w", encoding="utf-8") as f:
+                f.write(new_contents)
+            final_path = existing_file
+        else:
+            os.makedirs(output_dir, exist_ok=True)
+            with open(output_file_path, "w", encoding="utf-8") as f:
+                f.write(snippet)
+            final_path = output_file_path
+
+        # Clipboard integration
+        if use_clipboard:
+            pyperclip.copy(snippet)
+            print("Code snippet generated and copied to clipboard!")
+
+        # Preview the snippet in console
+        print("\n--- Snippet Preview ---")
+        print(snippet)
+        print("--- End Preview ---\n")
+
+        # Return values as requested
+        if return_file_path:
+            return snippet, final_path
+        elif return_snippet:
+            return snippet, cost
+
+    except requests.exceptions.RequestException as e:
+        error_msg = ("Error: Could not connect to AI API. Please check your network connection and ensure the API is accessible.\n"
+                     f"Detailed error: {e}")
+        print(error_msg)
+        if return_file_path or return_snippet:
+            return error_msg
+    except KeyError as e:
+        error_msg = ("Error: Invalid response format from AI API. Missing key in response JSON.\n"
+                     f"KeyError details: {e}")
+        print(error_msg)
+        if return_file_path or return_snippet:
+            return error_msg
+    except IndexError as e:
+        error_msg = ("Error: Invalid response format from AI API. Index out of bounds in response array.\n"
+                     f"IndexError details: {e}")
+        print(error_msg)
+        if return_file_path or return_snippet:
+            return error_msg
+    except ValueError as ve:
+        error_msg = f"ValueError: {ve}"
+        print(error_msg)
+        if return_file_path or return_snippet:
+            return error_msg
+    except Exception as e:
+        error_msg = "An unexpected error occurred:\n" + str(e)
+        print(error_msg)
+        if return_file_path or return_snippet:
+            return error_msg
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Generate and insert code snippets using an AI model or template."
+    )
+    parser.add_argument("description", nargs="?", help="Description for code snippet (not required if using a template).")
+    parser.add_argument("-l", "--language", required=True,
+                        help="Programming/markup language (python, javascript, typescript, markdown, html, css, cpp, java, go, rust, sql, bash, shell).")
+    parser.add_argument("-o", "--output_dir", help="Output directory for the snippet (default: output).", default="output")
+    parser.add_argument("-f", "--output_file_name", help="Base name for the output file (default: snippet).", default="snippet")
+    parser.add_argument("-c", "--clipboard", action="store_true", help="Copy snippet to clipboard instead of saving.")
+    parser.add_argument("-m", "--model", help="Specify the AI model to use (e.g., gemini-2.0-flash, gemini-1.5-pro, openai-...).")
+    parser.add_argument("-t", "--template", help="Name of the template file (in the templates folder) to use.")
+    parser.add_argument("-p", "--params", help="JSON string of parameters for template substitution.", default="{}")
+    parser.add_argument("-C", "--config", help="Path to JSON configuration file.", default=None)
+    # New arguments for feature expansion:
+    parser.add_argument("--existing_file", help="Path to an existing file to insert the snippet into.", default=None)
+    parser.add_argument("--marker", help="Marker string in the existing file where the snippet should be inserted.", default=None)
+    parser.add_argument("--format", action="store_true", help="Format the generated Python code using Black.")
+    # New parameters for provider integration:
+    parser.add_argument("--provider", help="LLM provider to use (e.g., Gemini, OpenAI, Anthropic, Ollama, LMStudios, OpenRouter).", default="Gemini")
+    parser.add_argument("--api_key", help="API key for the selected provider.", default="")
+
+    args = parser.parse_args()
+
+    if args.config:
+        config = load_config(args.config)
+        defaults = {"output_dir": "output", "output_file_name": "snippet", "clipboard": False, "model": None}
+        for key, default_val in defaults.items():
+            if getattr(args, key) == default_val and key in config:
+                setattr(args, key, config[key])
+
+    try:
+        template_params = json.loads(args.params)
+    except json.JSONDecodeError as e:
+        print(f"Error parsing template parameters JSON: {e}")
+        template_params = {}
+
+    if args.template and not args.description:
+        description = ""
+    elif args.description:
+        description = args.description
+    else:
+        parser.error("You must provide a description or a template.")
+
+    insert_snippet(
+        description,
+        args.language,
+        output_dir=args.output_dir,
+        output_file_name=args.output_file_name,
+        use_clipboard=args.clipboard,
+        model_name=args.model,
+        template=args.template,
+        template_params=template_params,
+        provider=args.provider,
+        api_key=args.api_key,
+        existing_file=args.existing_file,
+        marker=args.marker,
+        format_code=args.format
+    )

template_manager.py

@@ -0,0 +1,22 @@
+import os
+
+def load_template(template_name, templates_dir="templates"):
+    """
+    Loads and returns the content of a template file from the specified templates directory.
+    """
+    template_path = os.path.join(templates_dir, template_name)
+    if not os.path.exists(template_path):
+        raise FileNotFoundError(f"Template file '{template_path}' not found.")
+    with open(template_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+def apply_template(template_content, params):
+    """
+    Applies the provided parameters to the template content using Python's format() method.
+    """
+    try:
+        return template_content.format(**params)
+    except KeyError as e:
+        raise ValueError(f"Missing template parameter: {e}")
+    except Exception as e:
+        raise ValueError(f"Error applying template: {e}")