cliops 4.0.0__tar.gz → 4.2.2__tar.gz

{cliops-4.0.0/cliops.egg-info → cliops-4.2.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: cliops
-Version: 4.0.0
+Version: 4.2.2
 Summary: Advanced CLI tool for structured, pattern-based prompt optimization and state management
-Home-page: https://github.com/iammabd/cliops
+Home-page: https://github.com/cliops/cliops
 Author: cliops by mabd
 Author-email: iammabd@substack.com
-Project-URL: Bug Reports, https://github.com/iammabd/cliops/issues
-Project-URL: Source, https://github.com/iammabd/cliops
-Project-URL: Documentation, https://cliops.hashnode.space
+Project-URL: Bug Reports, https://github.com/cliops/cliops/issues
+Project-URL: Source, https://github.com/cliops/cliops
+Project-URL: Documentation, https://cliops.readthedocs.io
 Keywords: cli prompt optimization ai llm prompt-engineering patterns state-management
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -29,9 +29,6 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rich>=13.0.0
-Requires-Dist: jinja2>=3.0.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -54,7 +51,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Cliops - Command Line Interface for Prompt Optimization
+# CliOps - Command Line Interface for Prompt Optimization
 
 A powerful CLI tool for structured, pattern-based prompt optimization and state management.
 

{cliops-4.0.0 → cliops-4.2.2}/README.md

@@ -1,4 +1,4 @@
-# Cliops - Command Line Interface for Prompt Optimization
+# CliOps - Command Line Interface for Prompt Optimization
 
 A powerful CLI tool for structured, pattern-based prompt optimization and state management.
 

{cliops-4.0.0 → cliops-4.2.2/cliops.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: cliops
-Version: 4.0.0
+Version: 4.2.2
 Summary: Advanced CLI tool for structured, pattern-based prompt optimization and state management
-Home-page: https://github.com/iammabd/cliops
+Home-page: https://github.com/cliops/cliops
 Author: cliops by mabd
 Author-email: iammabd@substack.com
-Project-URL: Bug Reports, https://github.com/iammabd/cliops/issues
-Project-URL: Source, https://github.com/iammabd/cliops
-Project-URL: Documentation, https://cliops.hashnode.space
+Project-URL: Bug Reports, https://github.com/cliops/cliops/issues
+Project-URL: Source, https://github.com/cliops/cliops
+Project-URL: Documentation, https://cliops.readthedocs.io
 Keywords: cli prompt optimization ai llm prompt-engineering patterns state-management
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -29,9 +29,6 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rich>=13.0.0
-Requires-Dist: jinja2>=3.0.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -54,7 +51,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Cliops - Command Line Interface for Prompt Optimization
+# CliOps - Command Line Interface for Prompt Optimization
 
 A powerful CLI tool for structured, pattern-based prompt optimization and state management.
 

{cliops-4.0.0 → cliops-4.2.2}/cliops.egg-info/SOURCES.txt

@@ -15,18 +15,12 @@ cliops.egg-info/requires.txt
 cliops.egg-info/top_level.txt
 core/__init__.py
 core/analyzer.py
-core/branding.py
-core/cache.py
 core/config.py
+core/intelligence.py
 core/optimizer.py
 core/patterns.py
-core/setup.py
 core/state.py
-core/validation.py
 tests/__init__.py
-tests/test_cache.py
-tests/test_cli_integration.py
 tests/test_integration.py
 tests/test_optimizer.py
-tests/test_patterns.py
-tests/test_validation.py
+tests/test_patterns.py

{cliops-4.0.0 → cliops-4.2.2}/cliops.egg-info/requires.txt

@@ -1,7 +1,4 @@
 rich>=13.0.0
-jinja2>=3.0.0
-pydantic>=2.0.0
-typing-extensions>=4.0.0
 
 [dev]
 pytest>=7.0.0

cliops-4.2.2/core/intelligence.py

@@ -0,0 +1,199 @@
+import re
+from typing import Dict, List, Tuple
+
+class PromptIntelligence:
+    """Analyzes prompts to determine optimal patterns and generate contextual content."""
+    
+    DOMAIN_PATTERNS = {
+        'web_frontend': [
+            r'\b(react|vue|angular|svelte|next|nuxt|gatsby|html|css|sass|scss|less|tailwind)\b',
+            r'\b(component|hook|state|props|dom|browser|webpack|vite|rollup)\b',
+            r'\b(ui|ux|responsive|mobile|desktop|layout|design|frontend|landing|page|website|saas)\b'
+        ],
+        'web_backend': [
+            r'\b(api|endpoint|server|database|sql|rest|graphql|grpc)\b',
+            r'\b(express|django|flask|fastapi|spring|node|laravel|rails|asp\.net)\b',
+            r'\b(auth|middleware|route|controller|service|backend|microservice)\b'
+        ],
+        'mobile': [
+            r'\b(ios|android|flutter|react native|ionic|xamarin|swift|kotlin|dart)\b',
+            r'\b(app|mobile|device|platform|store|xcode|android studio)\b',
+            r'\b(native|hybrid|cross-platform|pwa)\b'
+        ],
+        'data_science': [
+            r'\b(pandas|numpy|matplotlib|seaborn|plotly|sklearn|tensorflow|pytorch|keras)\b',
+            r'\b(data|analysis|model|ml|ai|algorithm|dataset|jupyter|notebook)\b',
+            r'\b(statistics|regression|classification|clustering|deep learning)\b'
+        ],
+        'devops': [
+            r'\b(docker|kubernetes|aws|azure|gcp|terraform|ansible|jenkins)\b',
+            r'\b(deploy|ci/cd|pipeline|infrastructure|monitoring|helm|istio)\b',
+            r'\b(cloud|serverless|container|orchestration|automation)\b'
+        ],
+        'game_development': [
+            r'\b(unity|unreal|godot|pygame|phaser|three\.js|webgl)\b',
+            r'\b(game|gaming|2d|3d|sprite|animation|physics|collision)\b',
+            r'\b(c#|c\+\+|lua|gdscript|shader|texture|mesh)\b'
+        ],
+        'blockchain': [
+            r'\b(solidity|ethereum|bitcoin|web3|smart contract|dapp|nft)\b',
+            r'\b(blockchain|crypto|defi|dao|token|wallet|metamask)\b',
+            r'\b(truffle|hardhat|ganache|remix|openzeppelin)\b'
+        ],
+        'desktop': [
+            r'\b(electron|tauri|qt|gtk|wpf|winforms|javafx|swing)\b',
+            r'\b(desktop|gui|window|native|cross-platform)\b',
+            r'\b(c#|java|c\+\+|python|rust|go)\b'
+        ],
+        'embedded': [
+            r'\b(arduino|raspberry pi|esp32|microcontroller|firmware|rtos)\b',
+            r'\b(embedded|iot|sensor|actuator|gpio|i2c|spi|uart)\b',
+            r'\b(c|c\+\+|assembly|micropython|circuitpython)\b'
+        ],
+        'security': [
+            r'\b(security|vulnerability|penetration|exploit|malware|encryption)\b',
+            r'\b(auth|oauth|jwt|ssl|tls|https|firewall|vpn)\b',
+            r'\b(cybersecurity|infosec|pentest|owasp|cve)\b'
+        ],
+        'testing': [
+            r'\b(test|testing|unit|integration|e2e|selenium|cypress|jest)\b',
+            r'\b(mock|stub|fixture|assertion|coverage|tdd|bdd)\b',
+            r'\b(pytest|junit|mocha|jasmine|karma|playwright)\b'
+        ],
+        'database': [
+            r'\b(mysql|postgresql|mongodb|redis|elasticsearch|cassandra|sqlite)\b',
+            r'\b(database|db|sql|nosql|query|schema|migration|orm)\b',
+            r'\b(prisma|sequelize|mongoose|sqlalchemy|hibernate)\b'
+        ],
+        'system_programming': [
+            r'\b(rust|c|c\+\+|go|zig|assembly|kernel|driver|compiler)\b',
+            r'\b(system|low-level|memory|performance|optimization|concurrency)\b',
+            r'\b(linux|unix|windows|macos|operating system)\b'
+        ],
+        'ai_ml': [
+            r'\b(machine learning|deep learning|neural network|ai|artificial intelligence)\b',
+            r'\b(tensorflow|pytorch|scikit-learn|huggingface|openai|llm|gpt)\b',
+            r'\b(model|training|inference|dataset|feature|algorithm)\b'
+        ],
+        'api_integration': [
+            r'\b(api|rest|graphql|webhook|integration|third-party|sdk)\b',
+            r'\b(postman|curl|axios|fetch|http|json|xml)\b',
+            r'\b(oauth|authentication|rate limit|pagination)\b'
+        ]
+    }
+    
+    COMPLEXITY_INDICATORS = [
+        r'\b(implement|create|build|develop|design)\b',
+        r'\b(optimize|refactor|improve|enhance)\b',
+        r'\b(integrate|connect|sync|merge)\b',
+        r'\b(test|debug|fix|solve)\b'
+    ]
+    
+    @classmethod
+    def detect_domain(cls, prompt: str) -> str:
+        """Detects the primary domain of the prompt."""
+        prompt_lower = prompt.lower()
+        domain_scores = {}
+        
+        for domain, patterns in cls.DOMAIN_PATTERNS.items():
+            score = 0
+            for pattern in patterns:
+                matches = len(re.findall(pattern, prompt_lower))
+                score += matches
+            domain_scores[domain] = score
+        
+        if not any(domain_scores.values()):
+            return 'general'
+        
+        return max(domain_scores, key=domain_scores.get)
+    
+    @classmethod
+    def assess_complexity(cls, prompt: str) -> str:
+        """Assesses prompt complexity level."""
+        if len(prompt) < 50:
+            return 'simple'
+        
+        complexity_matches = 0
+        for pattern in cls.COMPLEXITY_INDICATORS:
+            complexity_matches += len(re.findall(pattern, prompt.lower()))
+        
+        if complexity_matches >= 3 or len(prompt) > 200:
+            return 'complex'
+        elif complexity_matches >= 1 or len(prompt) > 100:
+            return 'moderate'
+        
+        return 'simple'
+    
+    @classmethod
+    def suggest_pattern(cls, prompt: str) -> str:
+        """Suggests the best pattern based on prompt analysis."""
+        domain = cls.detect_domain(prompt)
+        complexity = cls.assess_complexity(prompt)
+        
+        # Pattern selection logic
+        if complexity == 'complex' or domain != 'general':
+            return 'adaptive_generation'
+        elif any(word in prompt.lower() for word in ['fix', 'bug', 'error', 'debug']):
+            return 'precision_engineering'
+        elif complexity == 'moderate':
+            return 'adaptive_generation'
+        
+        return 'adaptive_generation'
+    
+    @classmethod
+    def generate_contextual_constraints(cls, prompt: str, domain: str) -> str:
+        """Generates domain-specific constraints."""
+        constraints_map = {
+            'web_frontend': 'Ensure responsive design, accessibility compliance, SEO optimization, and modern web standards.',
+            'web_backend': 'Follow REST/GraphQL principles, implement proper error handling, security, and scalability.',
+            'mobile': 'Optimize for performance, battery life, follow platform guidelines, and ensure intuitive UX.',
+            'data_science': 'Validate data integrity, document assumptions, ensure reproducibility, and statistical rigor.',
+            'devops': 'Prioritize reliability, implement monitoring, follow IaC principles, and ensure security.',
+            'game_development': 'Optimize for performance, frame rate, memory usage, and engaging gameplay mechanics.',
+            'blockchain': 'Ensure security, gas optimization, audit readiness, and decentralization principles.',
+            'desktop': 'Follow platform UI guidelines, ensure cross-platform compatibility, and optimize resource usage.',
+            'embedded': 'Minimize memory footprint, optimize power consumption, ensure real-time constraints.',
+            'security': 'Follow OWASP guidelines, implement defense in depth, and ensure compliance standards.',
+            'testing': 'Ensure comprehensive coverage, maintainable tests, and fast execution times.',
+            'database': 'Optimize queries, ensure ACID properties, implement proper indexing, and data integrity.',
+            'system_programming': 'Ensure memory safety, optimize performance, handle concurrency, and system compatibility.',
+            'ai_ml': 'Validate model performance, ensure data privacy, implement proper evaluation metrics.',
+            'api_integration': 'Handle rate limits, implement proper error handling, ensure data validation.',
+            'general': 'Follow clean code principles, ensure maintainability, and include comprehensive documentation.'
+        }
+        
+        base_constraint = constraints_map.get(domain, constraints_map['general'])
+        
+        # Add specific constraints based on prompt content
+        if 'performance' in prompt.lower():
+            base_constraint += ' Focus on optimization and performance.'
+        if 'security' in prompt.lower():
+            base_constraint += ' Implement security best practices.'
+        if 'test' in prompt.lower():
+            base_constraint += ' Include comprehensive testing.'
+            
+        return base_constraint
+    
+    @classmethod
+    def generate_success_criteria(cls, prompt: str, domain: str) -> str:
+        """Generates contextual success criteria."""
+        criteria_map = {
+            'web_frontend': 'UI renders correctly across devices, accessibility standards met, performance optimized.',
+            'web_backend': 'API endpoints respond correctly, security implemented, scalability considered.',
+            'mobile': 'App functions on target platforms, smooth performance, intuitive user experience.',
+            'data_science': 'Analysis produces accurate results, code is reproducible, insights are actionable.',
+            'devops': 'Infrastructure deploys successfully, monitoring implemented, system is reliable and secure.',
+            'game_development': 'Game runs smoothly, engaging mechanics implemented, performance targets met.',
+            'blockchain': 'Smart contracts are secure, gas-optimized, and thoroughly tested.',
+            'desktop': 'Application runs on target platforms, UI follows guidelines, performance is optimal.',
+            'embedded': 'System meets real-time constraints, power consumption optimized, hardware compatibility ensured.',
+            'security': 'Vulnerabilities identified and mitigated, compliance requirements met, security tested.',
+            'testing': 'Comprehensive test coverage achieved, tests are maintainable, CI/CD integration works.',
+            'database': 'Queries perform efficiently, data integrity maintained, backup/recovery implemented.',
+            'system_programming': 'Code is memory-safe, performance optimized, system compatibility verified.',
+            'ai_ml': 'Model meets accuracy targets, training is reproducible, deployment is scalable.',
+            'api_integration': 'Integration works reliably, error handling robust, rate limits respected.',
+            'general': 'Code works as intended, follows best practices, is well-documented and maintainable.'
+        }
+        
+        return criteria_map.get(domain, criteria_map['general'])

cliops-4.2.2/core/optimizer.py

@@ -0,0 +1,202 @@
+import re
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.syntax import Syntax
+from rich.text import Text
+from rich import box
+from .intelligence import PromptIntelligence
+
+console = Console()
+
+class PromptOptimizer:
+    """Optimizes raw prompts using predefined patterns."""
+    def __init__(self, pattern_registry, cli_state, verbose: bool = False):
+        self.pattern_registry = pattern_registry
+        self.cli_state = cli_state
+        self.verbose = verbose
+
+    def _parse_prompt_into_sections(self, raw_prompt: str) -> dict:
+        """Parses a raw prompt into a dictionary of sections based on '## SECTION:' headers and <TAG>...</TAG> blocks."""
+        sections = {}
+        main_body_content = raw_prompt
+        extracted_sections = {}
+
+        # Extract tagged blocks (e.g., <CODE>, <CONTEXT>)
+        tag_block_pattern = re.compile(r"<(\w+)>(.*?)</\1>", re.DOTALL | re.IGNORECASE)
+        
+        matches_to_remove = []
+        for match in tag_block_pattern.finditer(main_body_content):
+            tag_name = match.group(1).upper()
+            content = match.group(2).strip()
+            extracted_sections[tag_name] = content
+            matches_to_remove.append(match.span())
+        
+        # Remove extracted tag blocks from the main body content
+        for start, end in sorted(matches_to_remove, key=lambda x: x[0], reverse=True):
+            main_body_content = main_body_content[:start] + main_body_content[end:]
+
+        # Extract ## sections from the remaining text
+        parts = re.split(r'(?m)^(##\s*[\w\s\/]+?:)', main_body_content)
+
+        current_key = "MAIN_BODY"
+        if parts and parts[0].strip():
+            extracted_sections[current_key] = parts[0].strip()
+        
+        for i in range(1, len(parts), 2):
+            header = parts[i].strip()
+            key = header.replace('##', '').replace(':', '').strip().replace(' ', '_').upper()
+            content = parts[i+1].strip() if i+1 < len(parts) else ""
+            extracted_sections[key] = content
+
+        # Handle 'code_here' specifically if it's the main body or implied
+        if "CODE" in extracted_sections:
+             extracted_sections["CODE_HERE"] = extracted_sections.pop("CODE")
+
+        return extracted_sections
+
+    def _extract_components(self, raw_prompt: str, pattern) -> dict:
+        """Extracts common and pattern-specific components from a raw prompt."""
+        parsed_sections = self._parse_prompt_into_sections(raw_prompt)
+        extracted_fields = {}
+
+        # Map common section names to expected template field names
+        common_mappings = {
+            'DIRECTIVE': 'directive',
+            'SCOPE': 'scope',
+            'CONSTRAINTS': 'constraints',
+            'OUTPUT_FORMAT': 'output_format',
+            'SUCCESS_CRITERIA': 'success_criteria',
+            'CODE_HERE': 'code_here',
+            'CODE': 'code_here',
+            'CONTEXT': 'context',
+            'CURRENT_FOCUS': 'current_focus',
+            'MINDSET': 'mindset',
+            'MAIN_BODY': 'code_here'
+        }
+
+        for section_key, template_field in common_mappings.items():
+            if section_key in parsed_sections and parsed_sections[section_key] != "":
+                extracted_fields[template_field] = parsed_sections[section_key]
+
+        # Apply pattern-specific extraction logic
+        if pattern.specific_extract_func:
+            specific_extracted = pattern.specific_extract_func(raw_prompt)
+            for k,v in specific_extracted.items():
+                if v is not None and v != '':
+                    extracted_fields[k.lower()] = v
+
+        return {k: v for k, v in extracted_fields.items() if v is not None}
+
+    def _generate_intelligent_content(self, field_name: str, raw_prompt: str, domain: str, extracted_fields: dict) -> str:
+        """Generates clean, actionable content sections."""
+        arch = self.cli_state.get('ARCHITECTURE') or 'modern tech stack'
+        focus = self.cli_state.get('FOCUS') or 'core functionality'
+        
+        # Remove test values
+        if arch == 'Test Architecture':
+            arch = 'modern tech stack'
+        if focus == 'Test Focus':
+            focus = 'core functionality'
+        
+        generators = {
+            'requirements_section': f"- {domain.replace('_', ' ')} solution using {arch}\n- clean, maintainable code\n- best practices implementation\n- focus on {focus}",
+            
+            'tech_specs_section': {
+                'web_frontend': "- mobile-first responsive design\n- WCAG accessibility\n- SEO optimization\n- semantic HTML",
+                'web_backend': "- RESTful API design\n- JWT authentication\n- database integration\n- scalable architecture",
+                'mobile': "- native performance\n- platform UI guidelines\n- state management\n- cross-platform compatibility",
+                'blockchain': "- gas-optimized contracts\n- security auditing\n- Web3 integration\n- decentralized architecture",
+                'data_science': "- data validation\n- statistical analysis\n- model deployment\n- reproducible workflows",
+                'general': "- clean architecture\n- error handling\n- performance optimization\n- maintainable design"
+            }.get(domain, "- best practices\n- clean code\n- comprehensive testing\n- documentation"),
+            
+            'implementation_section': {
+                'web_frontend': "- component structure\n- responsive layout\n- accessibility features\n- performance optimization",
+                'web_backend': "- API endpoints\n- authentication middleware\n- validation\n- database setup",
+                'mobile': "- app structure\n- UI components\n- state management\n- platform features",
+                'general': "- architecture planning\n- core functionality\n- error handling\n- testing"
+            }.get(domain, "- structure planning\n- best practices implementation\n- testing\n- documentation"),
+            
+            'deliverables_section': {
+                'web_frontend': "- responsive web application\n- cross-browser compatibility\n- accessibility compliance\n- performance metrics",
+                'web_backend': "- production API endpoints\n- database schema\n- API documentation\n- security implementation",
+                'mobile': "- native mobile app\n- platform builds\n- app store guidelines\n- performance benchmarks",
+                'general': "- working solution\n- clean code\n- documentation\n- test coverage"
+            }.get(domain, "- complete solution\n- documented code\n- testing coverage\n- usage instructions"),
+            
+            'code_section': raw_prompt
+        }
+        
+        return generators.get(field_name, '')
+
+    def optimize_prompt(self, raw_prompt: str, pattern_name: str, overrides: dict, dry_run: bool = False) -> str:
+        """Creates highly personalized, non-repetitive optimized prompts."""
+        pattern = self.pattern_registry.get_pattern(pattern_name)
+        if not pattern:
+            raise ValueError(f"Pattern '{pattern_name}' not found.")
+
+        # Intelligent analysis and pattern selection
+        domain = PromptIntelligence.detect_domain(raw_prompt)
+        complexity = PromptIntelligence.assess_complexity(raw_prompt)
+        
+        # Auto-upgrade pattern based on intelligence
+        if pattern_name == "context_aware_generation":
+            suggested_pattern = PromptIntelligence.suggest_pattern(raw_prompt)
+            better_pattern = self.pattern_registry.get_pattern(suggested_pattern)
+            if better_pattern:
+                pattern = better_pattern
+        
+        # Extract components with domain awareness
+        extracted_fields = self._extract_components(raw_prompt, pattern)
+        extracted_fields['detected_domain'] = domain
+        extracted_fields['complexity'] = complexity
+
+        # Build dynamic template fields
+        template_fields = dict(extracted_fields)
+        
+        # Inject CLI state
+        class StateObject:
+            def __init__(self, state_dict):
+                for key, value in state_dict.items():
+                    setattr(self, key, value)
+            def __getattr__(self, name):
+                return 'Not set'
+        
+        cli_state_values = {key: self.cli_state.get(key) for key in self.cli_state.state.keys()}
+        template_fields['STATE'] = StateObject(cli_state_values)
+
+        # Apply overrides
+        template_fields.update(overrides)
+
+        # Generate intelligent content for both patterns
+        if pattern.name in ["adaptive_generation", "precision_engineering"]:
+            for field in ['requirements_section', 'tech_specs_section', 'implementation_section', 'deliverables_section', 'code_section']:
+                if field not in template_fields:
+                    template_fields[field] = self._generate_intelligent_content(field, raw_prompt, domain, extracted_fields)
+
+        # Clean directive based on user input
+        smart_defaults = {
+            'directive': extracted_fields.get('directive') or raw_prompt.capitalize(),
+        }
+
+        # Apply smart defaults only for missing fields
+        for field, default_value in smart_defaults.items():
+            if field not in template_fields or not template_fields[field]:
+                template_fields[field] = default_value
+
+        if dry_run:
+            console.print(Panel("[bold blue]Dry Run: Intelligent Prompt Analysis[/bold blue]", expand=False, border_style="blue"))
+            console.print(f"Detected Domain: {domain}")
+            console.print(f"Complexity Level: {complexity}")
+            console.print(f"Selected Pattern: {pattern.name}")
+            console.print(f"Intelligence Score: {len(raw_prompt)} chars, {len(raw_prompt.split())} words")
+            return "Dry run complete. No prompt generated."
+
+        try:
+            optimized_prompt = pattern.template.format(**template_fields)
+            return optimized_prompt
+        except KeyError as e:
+            # Fallback with missing field filled
+            template_fields[str(e).strip("'")] = f"[{e} not specified]"
+            return pattern.template.format(**template_fields)