cliops 1.0.0__tar.gz

cliops-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CliOps Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cliops-1.0.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include requirements.txt
+include LICENSE
+recursive-include core *.py
+recursive-include tests *.py
+global-exclude *.pyc
+global-exclude __pycache__

cliops-1.0.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: cliops
+Version: 1.0.0
+Summary: Advanced CLI tool for structured, pattern-based prompt optimization and state management
+Home-page: https://github.com/cliops/cliops
+Author: CliOps Development Team
+Author-email: contact@cliops.dev
+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
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# CliOps - Command Line Interface for Prompt Optimization
+
+A powerful CLI tool for structured, pattern-based prompt optimization and state management.
+
+## Features
+
+- **Pattern-based optimization**: Apply proven prompt engineering patterns
+- **State management**: Persistent CLI state for project context
+- **Rich terminal UI**: Beautiful output with syntax highlighting
+- **Extensible**: Add custom patterns and presets
+- **Cross-platform**: Works on Windows, macOS, and Linux
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Initialize configuration
+cliops init
+
+# Set project context
+cliops state set ARCHITECTURE "React + Node.js"
+cliops state set FOCUS "API development"
+
+# Optimize a prompt
+cliops "Create a user authentication endpoint"
+
+# Analyze a prompt
+cliops analyze "Make this code better"
+
+# List available patterns
+cliops patterns
+```
+
+## Usage
+
+### Basic Commands
+
+- `cliops optimize <prompt>` - Optimize a prompt using patterns
+- `cliops analyze <prompt>` - Analyze prompt for improvements
+- `cliops patterns` - List available optimization patterns
+- `cliops state set <key> <value>` - Set persistent state
+- `cliops init` - Initialize configuration
+
+### Examples
+
+```bash
+# Direct prompt optimization
+cliops "Fix this bug in my React component"
+
+# With specific pattern
+cliops optimize "Refactor this function" --pattern surgical_refactor
+
+# With overrides
+cliops optimize "Create API" --context "Express.js backend" --constraints "RESTful design"
+
+# Dry run to see what would be generated
+cliops optimize "Test prompt" --dry-run
+```
+
+## Testing
+
+```bash
+python run_tests.py
+```
+
+## License
+
+MIT License

cliops-1.0.0/README.md

@@ -0,0 +1,73 @@
+# CliOps - Command Line Interface for Prompt Optimization
+
+A powerful CLI tool for structured, pattern-based prompt optimization and state management.
+
+## Features
+
+- **Pattern-based optimization**: Apply proven prompt engineering patterns
+- **State management**: Persistent CLI state for project context
+- **Rich terminal UI**: Beautiful output with syntax highlighting
+- **Extensible**: Add custom patterns and presets
+- **Cross-platform**: Works on Windows, macOS, and Linux
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Initialize configuration
+cliops init
+
+# Set project context
+cliops state set ARCHITECTURE "React + Node.js"
+cliops state set FOCUS "API development"
+
+# Optimize a prompt
+cliops "Create a user authentication endpoint"
+
+# Analyze a prompt
+cliops analyze "Make this code better"
+
+# List available patterns
+cliops patterns
+```
+
+## Usage
+
+### Basic Commands
+
+- `cliops optimize <prompt>` - Optimize a prompt using patterns
+- `cliops analyze <prompt>` - Analyze prompt for improvements
+- `cliops patterns` - List available optimization patterns
+- `cliops state set <key> <value>` - Set persistent state
+- `cliops init` - Initialize configuration
+
+### Examples
+
+```bash
+# Direct prompt optimization
+cliops "Fix this bug in my React component"
+
+# With specific pattern
+cliops optimize "Refactor this function" --pattern surgical_refactor
+
+# With overrides
+cliops optimize "Create API" --context "Express.js backend" --constraints "RESTful design"
+
+# Dry run to see what would be generated
+cliops optimize "Test prompt" --dry-run
+```
+
+## Testing
+
+```bash
+python run_tests.py
+```
+
+## License
+
+MIT License

cliops-1.0.0/cliops.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: cliops
+Version: 1.0.0
+Summary: Advanced CLI tool for structured, pattern-based prompt optimization and state management
+Home-page: https://github.com/cliops/cliops
+Author: CliOps Development Team
+Author-email: contact@cliops.dev
+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
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: flake8>=5.0.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# CliOps - Command Line Interface for Prompt Optimization
+
+A powerful CLI tool for structured, pattern-based prompt optimization and state management.
+
+## Features
+
+- **Pattern-based optimization**: Apply proven prompt engineering patterns
+- **State management**: Persistent CLI state for project context
+- **Rich terminal UI**: Beautiful output with syntax highlighting
+- **Extensible**: Add custom patterns and presets
+- **Cross-platform**: Works on Windows, macOS, and Linux
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Initialize configuration
+cliops init
+
+# Set project context
+cliops state set ARCHITECTURE "React + Node.js"
+cliops state set FOCUS "API development"
+
+# Optimize a prompt
+cliops "Create a user authentication endpoint"
+
+# Analyze a prompt
+cliops analyze "Make this code better"
+
+# List available patterns
+cliops patterns
+```
+
+## Usage
+
+### Basic Commands
+
+- `cliops optimize <prompt>` - Optimize a prompt using patterns
+- `cliops analyze <prompt>` - Analyze prompt for improvements
+- `cliops patterns` - List available optimization patterns
+- `cliops state set <key> <value>` - Set persistent state
+- `cliops init` - Initialize configuration
+
+### Examples
+
+```bash
+# Direct prompt optimization
+cliops "Fix this bug in my React component"
+
+# With specific pattern
+cliops optimize "Refactor this function" --pattern surgical_refactor
+
+# With overrides
+cliops optimize "Create API" --context "Express.js backend" --constraints "RESTful design"
+
+# Dry run to see what would be generated
+cliops optimize "Test prompt" --dry-run
+```
+
+## Testing
+
+```bash
+python run_tests.py
+```
+
+## License
+
+MIT License

cliops-1.0.0/cliops.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+cliops.egg-info/PKG-INFO
+cliops.egg-info/SOURCES.txt
+cliops.egg-info/dependency_links.txt
+cliops.egg-info/entry_points.txt
+cliops.egg-info/not-zip-safe
+cliops.egg-info/requires.txt
+cliops.egg-info/top_level.txt
+core/__init__.py
+core/analyzer.py
+core/config.py
+core/optimizer.py
+core/patterns.py
+core/state.py
+tests/__init__.py
+tests/test_integration.py
+tests/test_optimizer.py
+tests/test_patterns.py
+tests/test_state.py

cliops-1.0.0/cliops.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cliops-1.0.0/cliops.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cliops = main:main

cliops-1.0.0/cliops.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

cliops-1.0.0/cliops.egg-info/requires.txt

@@ -0,0 +1,11 @@
+rich>=13.0.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=22.0.0
+flake8>=5.0.0
+
+[test]
+pytest>=7.0.0
+pytest-cov>=4.0.0

cliops-1.0.0/cliops.egg-info/top_level.txt

@@ -0,0 +1 @@
+core

cliops-1.0.0/core/__init__.py

@@ -0,0 +1 @@
+# Core module for cliops

cliops-1.0.0/core/analyzer.py

@@ -0,0 +1,78 @@
+import re
+import os
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+class PromptAnalyzer:
+    """Analyzes a raw prompt for common issues based on optimization principles."""
+    def __init__(self, pattern_registry):
+        self.pattern_registry = pattern_registry
+        self.principles = {
+            "Structure and Clarity": {
+                "keywords": ["directive", "scope", "constraints", "output format", "success criteria"],
+                "suggestion": "Ensure your prompt has a clear structure with explicit sections like 'DIRECTIVE', 'SCOPE', 'CONSTRAINTS', 'OUTPUT FORMAT', and 'SUCCESS CRITERIA'."
+            },
+            "Specificity and Detail": {
+                "keywords": ["specific", "detailed", "precise", "exact", "example"],
+                "suggestion": "Add more specific details about the task, desired output, edge cases, and expected behavior. Consider using few-shot examples."
+            },
+            "Context-Aware Generation": {
+                "keywords": ["context", "background", "system", "environment", "state"],
+                "suggestion": "Provide relevant context, system state, or background information the LLM needs to understand the scenario fully. Leverage `cliops state`."
+            },
+            "Output Format": {
+                "keywords": ["json", "xml", "yaml", "markdown", "code block", "format", "structure"],
+                "suggestion": "Clearly define the desired output format (e.g., JSON, YAML, Markdown code block, specific class structure)."
+            },
+            "Error Prevention": {
+                "keywords": ["handle errors", "robust", "mitigate", "assumptions", "potential issues", "safeguards"],
+                "suggestion": "Instruct the LLM on how to handle potential errors, edge cases, or invalid inputs. Define explicit assumptions."
+            }
+        }
+
+    def analyze_prompt(self, prompt_text: str):
+        """Analyzes a raw prompt for adherence to prompt engineering principles."""
+        console.print(Panel("[bold green]Prompt Analysis[/bold green]", expand=False, border_style="green"))
+        issues = []
+        recommendations = []
+
+        # Check for general structure and key fields
+        if not re.search(r"DIRECTIVE:", prompt_text, re.IGNORECASE):
+            issues.append("Missing or unclear 'DIRECTIVE'.")
+            recommendations.append(self.principles["Structure and Clarity"]["suggestion"])
+        if not re.search(r"CONSTRAINTS:", prompt_text, re.IGNORECASE):
+            issues.append("Missing or unclear 'CONSTRAINTS'.")
+            recommendations.append(self.principles["Structure and Clarity"]["suggestion"])
+        if not re.search(r"OUTPUT FORMAT:", prompt_text, re.IGNORECASE):
+            issues.append("Missing or unclear 'OUTPUT FORMAT'.")
+            recommendations.append(self.principles["Output Format"]["suggestion"])
+
+        # Check for keywords related to other principles
+        for principle, data in self.principles.items():
+            if principle in ["Structure and Clarity", "Output Format"]:
+                continue
+
+            found_keyword = False
+            for keyword in data["keywords"]:
+                if re.search(r"\b" + re.escape(keyword) + r"\b", prompt_text, re.IGNORECASE):
+                    found_keyword = True
+                    break
+            if not found_keyword:
+                recommendations.append(f"Consider: {data['suggestion']}")
+
+        if issues:
+            console.print(Panel("[bold red]Identified Issues[/bold red]", expand=False, border_style="red"))
+            for issue in sorted(list(set(issues))):
+                console.print(f"[red]- {issue}[/red]")
+        else:
+            console.print("[bold green]No critical issues identified in prompt structure.[/bold green]", style="green")
+
+        if recommendations:
+            console.print(Panel("[bold yellow]Recommendations for Improvement[/bold yellow]", expand=False, border_style="yellow"))
+            for rec in sorted(list(set(recommendations))):
+                console.print(f"[yellow]- {rec}[/yellow]")
+        else:
+            console.print("[bold green]Prompt appears well-structured and comprehensive.[/bold green]", style="green")
+        console.print(Panel.fit("[dim]Analysis Complete[/dim]", border_style="dim"))

cliops-1.0.0/core/config.py

@@ -0,0 +1,35 @@
+import os
+from pathlib import Path
+
+class Config:
+    """Manages application configuration, including state file path and pattern definitions."""
+    APP_NAME = "cliops"
+    STATE_FILE_NAME = "cliops_state.json"
+    PATTERNS_FILE_NAME = "patterns.json"
+
+    @staticmethod
+    def get_app_data_dir():
+        """Returns the appropriate application data directory for the OS."""
+        if os.name == 'nt':  # Windows
+            return Path(os.environ.get('APPDATA', Path.home() / Config.APP_NAME)) / Config.APP_NAME
+        elif os.name == 'posix':  # Linux, macOS, etc.
+            xdg_data_home = os.environ.get('XDG_DATA_HOME')
+            if xdg_data_home:
+                return Path(xdg_data_home) / Config.APP_NAME
+            return Path.home() / ".local" / "share" / Config.APP_NAME
+        else:
+            return Path.home() / f".{Config.APP_NAME}"
+
+    @staticmethod
+    def get_state_file_path():
+        """Returns the full path to the CLI state file."""
+        data_dir = Config.get_app_data_dir()
+        data_dir.mkdir(parents=True, exist_ok=True)
+        return data_dir / Config.STATE_FILE_NAME
+
+    @staticmethod
+    def get_patterns_file_path():
+        """Returns the full path to the user-defined patterns file."""
+        data_dir = Config.get_app_data_dir()
+        data_dir.mkdir(parents=True, exist_ok=True)
+        return data_dir / Config.PATTERNS_FILE_NAME

cliops-1.0.0/core/optimizer.py

@@ -0,0 +1,143 @@
+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
+
+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 optimize_prompt(self, raw_prompt: str, pattern_name: str, overrides: dict, dry_run: bool = False) -> str:
+        """Applies an optimization pattern to a raw prompt."""
+        pattern = self.pattern_registry.get_pattern(pattern_name)
+        if not pattern:
+            raise ValueError(f"Pattern '{pattern_name}' not found.")
+
+        # Extract components from raw_prompt
+        extracted_fields = self._extract_components(raw_prompt, pattern)
+
+        # Prepare fields for template formatting
+        template_fields = {}
+        for key in extracted_fields:
+            template_fields[key] = extracted_fields[key]
+
+        # Inject CLI state
+        cli_state_values = {key: self.cli_state.get(key) for key in self.cli_state.state.keys()}
+        StateObject = type('StateObject', (object,), cli_state_values)
+        template_fields['STATE'] = StateObject()
+
+        # Apply explicit CLI argument overrides
+        for key, value in overrides.items():
+            if key in template_fields:
+                template_fields[key] = value
+            elif key.upper() in cli_state_values:
+                setattr(template_fields['STATE'], key.upper(), value)
+
+        # Set defaults if fields are still missing
+        default_fields = {
+            'directive': 'Please complete the task.',
+            'scope': 'The entire codebase.',
+            'constraints': 'No specific constraints.',
+            'output_format': 'Clean code/text.',
+            'success_criteria': 'The task is completed as per the directive.',
+            'code_here': 'No code provided.',
+            'context': 'General context.',
+            'current_focus': 'Overall system.',
+            'mindset': 'Standard development mindset.',
+            'examples': 'No examples provided.'
+        }
+
+        for field, default_value in default_fields.items():
+            if field not in template_fields or template_fields[field] is None or template_fields[field] == '':
+                template_fields[field] = default_value
+
+        if dry_run:
+            console.print(Panel("[bold blue]Dry Run: Prompt Optimization Details[/bold blue]", expand=False, border_style="blue"))
+            console.print("Dry run complete. No prompt generated.")
+            return "Dry run complete. No prompt generated."
+
+        try:
+            optimized_prompt = pattern.template.format(**template_fields)
+            return optimized_prompt
+        except KeyError as e:
+            raise ValueError(f"Template for pattern '{pattern_name}' missing field {e}.")

cliops-1.0.0/core/patterns.py

@@ -0,0 +1,142 @@
+import json
+import re
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich.syntax import Syntax
+from rich import box
+from .config import Config
+
+console = Console()
+
+class OptimizationPattern:
+    """Represents a prompt optimization pattern with its template and extraction logic."""
+    def __init__(self, name: str, description: str, template: str, principles: list[str], specific_extract_func=None):
+        self.name = name
+        self.description = description
+        self.template = template
+        self.principles = principles
+        self.specific_extract_func = specific_extract_func
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Creates an OptimizationPattern instance from a dictionary."""
+        return cls(
+            name=data['name'],
+            description=data['description'],
+            template=data['template'],
+            principles=data.get('principles', []),
+            specific_extract_func=None
+        )
+
+    def to_dict(self):
+        """Converts the pattern to a dictionary for serialization."""
+        return {
+            'name': self.name,
+            'description': self.description,
+            'template': self.template,
+            'principles': self.principles
+        }
+
+class PatternRegistry:
+    """Manages available optimization patterns."""
+    def __init__(self, cli_state):
+        self.patterns: dict[str, OptimizationPattern] = {}
+        self.cli_state = cli_state
+        self._load_default_patterns()
+        self._load_user_patterns()
+
+    def _load_default_patterns(self):
+        """Loads hardcoded default patterns."""
+        # Generic extraction helpers
+        def extract_colon_value(text, field_name):
+            match = re.search(rf"^{re.escape(field_name)}:\s*(.*?)(?:\n##|\n<|\Z)", text, re.MULTILINE | re.DOTALL | re.IGNORECASE)
+            if match:
+                content = match.group(1).strip()
+                next_header_match = re.search(r"##\s*\w+", content, re.DOTALL)
+                if next_header_match:
+                    content = content[:next_header_match.start()].strip()
+                next_tag_match = re.search(r"<\w+>", content, re.DOTALL)
+                if next_tag_match:
+                    content = content[:next_tag_match.start()].strip()
+                return content
+            return None
+
+        def extract_between_tags(text, start_tag, end_tag):
+            match = re.search(rf"{re.escape(start_tag)}(.*?){re.escape(end_tag)}", text, re.DOTALL)
+            return match.group(1).strip() if match else None
+
+        # Pattern-specific extraction functions
+        def specific_extract_context_aware(prompt_text):
+            extracted = {}
+            extracted['CONTEXT'] = extract_between_tags(prompt_text, "<CONTEXT>", "</CONTEXT>")
+            extracted['CURRENT_FOCUS'] = extract_colon_value(prompt_text, "Current Focus")
+            extracted['MINDSET'] = extract_colon_value(prompt_text, "Mindset")
+            return {k: v for k, v in extracted.items() if v is not None}
+
+        default_patterns_data = [
+            {"name": "context_aware_generation",
+             "description": "Guides generation based on specific context, mindset, and current focus.",
+             "template": "# DIRECTIVE: {directive}\n\n"
+                         "## CONTEXT:\n"
+                         "<CONTEXT>{context}</CONTEXT>\n\n"
+                         "## CURRENT FOCUS:\n"
+                         "{current_focus}\n\n"
+                         "## MINDSET:\n"
+                         "{mindset}\n\n"
+                         "## CONSTRAINTS:\n"
+                         "{constraints}\n\n"
+                         "## OUTPUT FORMAT:\n"
+                         "{output_format}\n\n"
+                         "## EXAMPLES:\n"
+                         "{examples}\n\n"
+                         "## SUCCESS CRITERIA:\n"
+                         "{success_criteria}\n\n"
+                         "## STATE:\n"
+                         "Project Architecture: {STATE.ARCHITECTURE}\n"
+                         "Common Patterns: {STATE.PATTERNS}\n"
+                         "Current Project Focus: {STATE.FOCUS}\n\n"
+                         "{code_here}",
+             "principles": ["Context-Aware Generation", "Adaptive Nuance", "State Anchoring"],
+             "specific_extract_func": specific_extract_context_aware}
+        ]
+
+        for p_data in default_patterns_data:
+            pattern = OptimizationPattern.from_dict(p_data)
+            if pattern.name == "context_aware_generation":
+                pattern.specific_extract_func = specific_extract_context_aware
+            self.patterns[pattern.name] = pattern
+
+    def _load_user_patterns(self):
+        """Loads user-defined patterns from patterns.json."""
+        patterns_file = Config.get_patterns_file_path()
+        if patterns_file.exists():
+            try:
+                with open(patterns_file, 'r') as f:
+                    user_patterns_data = json.load(f)
+                    for p_data in user_patterns_data:
+                        pattern_name = p_data.get('name')
+                        if pattern_name:
+                            pattern = OptimizationPattern.from_dict(p_data)
+                            self.patterns[pattern_name] = pattern
+            except json.JSONDecodeError:
+                console.print(f"[bold yellow]Warning:[/bold yellow] Could not decode JSON from user patterns file {patterns_file}. Ignoring user patterns.", style="yellow")
+            except Exception as e:
+                console.print(f"[bold red]Error:[/bold red] loading user patterns from {patterns_file}: {e}", style="red")
+
+    def get_pattern(self, name: str) -> OptimizationPattern | None:
+        """Retrieves a pattern by name."""
+        return self.patterns.get(name)
+
+    def list_patterns(self):
+        """Lists all available patterns."""
+        table = Table(title="Available Optimization Patterns", box=box.ROUNDED, style="magenta")
+        table.add_column("Pattern Name", style="bold cyan", justify="left")
+        table.add_column("Description", style="green", justify="left")
+        table.add_column("Principles", style="blue", justify="left")
+
+        for name, pattern in self.patterns.items():
+            principles_text = ", ".join(pattern.principles) if pattern.principles else "N/A"
+            table.add_row(name, pattern.description, principles_text)
+        
+        console.print(table)

cliops-1.0.0/core/state.py

@@ -0,0 +1,60 @@
+import json
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+console = Console()
+
+class CLIState:
+    """Manages persistent key-value state for CLI operations."""
+    def __init__(self, file_path: Path):
+        self.file_path = file_path
+        self.state = self._load_state()
+
+    def _load_state(self) -> dict:
+        """Loads state from the JSON file."""
+        if self.file_path.exists():
+            try:
+                with open(self.file_path, 'r') as f:
+                    return json.load(f)
+            except json.JSONDecodeError:
+                console.print(f"[bold yellow]Warning:[/bold yellow] Could not decode JSON from {self.file_path}. Starting with empty state.", style="yellow")
+                return {}
+        return {}
+
+    def _save_state(self):
+        """Saves the current state to the JSON file."""
+        with open(self.file_path, 'w') as f:
+            json.dump(self.state, f, indent=4)
+
+    def set(self, key: str, value: str):
+        """Sets a key-value pair in the state."""
+        self.state[key.upper()] = value
+        self._save_state()
+        console.print(f"State '[bold green]{key.upper()}[/bold green]' set to '[cyan]{value}[/cyan]'.")
+
+    def get(self, key: str) -> str | None:
+        """Gets a value from the state."""
+        return self.state.get(key.upper())
+
+    def show(self):
+        """Displays the current state."""
+        if not self.state:
+            console.print("No CLI state currently set.", style="italic dim")
+            return
+        
+        table = Table(title="Current CLI State", box=box.ROUNDED, style="blue")
+        table.add_column("Key", style="bold cyan")
+        table.add_column("Value", style="green")
+
+        for key, value in self.state.items():
+            table.add_row(key, value)
+        
+        console.print(table)
+
+    def clear(self):
+        """Clears all entries from the state."""
+        self.state = {}
+        self._save_state()
+        console.print("CLI state cleared.", style="red")

cliops-1.0.0/requirements.txt

@@ -0,0 +1 @@
+rich>=13.0.0

cliops-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cliops-1.0.0/setup.py

@@ -0,0 +1,66 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+# Read README for long description
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding='utf-8')
+
+# Read requirements
+requirements = (this_directory / "requirements.txt").read_text().strip().split('\n')
+
+setup(
+    name='cliops',
+    version='1.0.0',
+    author='CliOps Development Team',
+    author_email='contact@cliops.dev',
+    description='Advanced CLI tool for structured, pattern-based prompt optimization and state management',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/cliops/cliops',
+    project_urls={
+        'Bug Reports': 'https://github.com/cliops/cliops/issues',
+        'Source': 'https://github.com/cliops/cliops',
+        'Documentation': 'https://cliops.readthedocs.io',
+    },
+    packages=find_packages(exclude=['tests*']),
+    include_package_data=True,
+    install_requires=requirements,
+    extras_require={
+        'dev': [
+            'pytest>=7.0.0',
+            'pytest-cov>=4.0.0',
+            'black>=22.0.0',
+            'flake8>=5.0.0',
+        ],
+        'test': [
+            'pytest>=7.0.0',
+            'pytest-cov>=4.0.0',
+        ],
+    },
+    entry_points={
+        'console_scripts': [
+            'cliops=main:main',
+        ],
+    },
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Intended Audience :: System Administrators',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+        'Topic :: Software Development :: Build Tools',
+        'Topic :: System :: Systems Administration',
+        'Topic :: Utilities',
+        'Topic :: Text Processing :: Linguistic',
+        'Environment :: Console',
+    ],
+    keywords='cli prompt optimization ai llm prompt-engineering patterns state-management',
+    python_requires='>=3.8',
+    zip_safe=False,
+)

cliops-1.0.0/tests/__init__.py

@@ -0,0 +1 @@
+# Test module for cliops

cliops-1.0.0/tests/test_integration.py

@@ -0,0 +1,51 @@
+import unittest
+import subprocess
+import tempfile
+import os
+from pathlib import Path
+
+class TestCLIIntegration(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.original_home = os.environ.get('HOME')
+        os.environ['HOME'] = self.temp_dir
+
+    def tearDown(self):
+        if self.original_home:
+            os.environ['HOME'] = self.original_home
+        else:
+            os.environ.pop('HOME', None)
+
+    def run_cliops(self, args):
+        """Helper to run cliops command and return result"""
+        cmd = ['python', 'main.py'] + args
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd=Path(__file__).parent.parent)
+        return result
+
+    def test_init_command(self):
+        result = self.run_cliops(['init'])
+        self.assertEqual(result.returncode, 0)
+        self.assertIn("Initialization complete", result.stdout)
+
+    def test_state_set_and_show(self):
+        # Set state
+        result = self.run_cliops(['state', 'set', 'TEST_KEY', 'test_value'])
+        self.assertEqual(result.returncode, 0)
+        
+        # Show state
+        result = self.run_cliops(['state', 'show'])
+        self.assertEqual(result.returncode, 0)
+        self.assertIn('TEST_KEY', result.stdout)
+
+    def test_patterns_list(self):
+        result = self.run_cliops(['patterns'])
+        self.assertEqual(result.returncode, 0)
+        self.assertIn('context_aware_generation', result.stdout)
+
+    def test_optimize_basic(self):
+        result = self.run_cliops(['optimize', 'Create a function', '--dry-run'])
+        self.assertEqual(result.returncode, 0)
+        self.assertIn('Dry run complete', result.stdout)
+
+if __name__ == '__main__':
+    unittest.main()

cliops-1.0.0/tests/test_optimizer.py

@@ -0,0 +1,49 @@
+import unittest
+from unittest.mock import Mock
+from core.optimizer import PromptOptimizer
+from core.patterns import OptimizationPattern
+
+class TestPromptOptimizer(unittest.TestCase):
+    def setUp(self):
+        self.mock_cli_state = Mock()
+        self.mock_cli_state.state = {"ARCHITECTURE": "Test Architecture"}
+        self.mock_cli_state.get.return_value = "Test Architecture"
+        
+        self.mock_pattern_registry = Mock()
+        self.test_pattern = OptimizationPattern(
+            name="test_pattern",
+            description="Test pattern",
+            template="# DIRECTIVE: {directive}\n## CONTEXT: {context}\n{code_here}",
+            principles=["Test"]
+        )
+        self.mock_pattern_registry.get_pattern.return_value = self.test_pattern
+        
+        self.optimizer = PromptOptimizer(self.mock_pattern_registry, self.mock_cli_state)
+
+    def test_parse_prompt_into_sections(self):
+        prompt = "## DIRECTIVE:\nTest directive\n## CONTEXT:\nTest context\n<CODE>test code</CODE>"
+        sections = self.optimizer._parse_prompt_into_sections(prompt)
+        
+        self.assertIn("DIRECTIVE", sections)
+        self.assertIn("CONTEXT", sections)
+        self.assertIn("CODE_HERE", sections)
+        self.assertEqual(sections["DIRECTIVE"], "Test directive")
+        self.assertEqual(sections["CONTEXT"], "Test context")
+        self.assertEqual(sections["CODE_HERE"], "test code")
+
+    def test_optimize_prompt_basic(self):
+        raw_prompt = "## DIRECTIVE:\nCreate a function\n## CONTEXT:\nPython project"
+        result = self.optimizer.optimize_prompt(raw_prompt, "test_pattern", {})
+        
+        self.assertIn("Create a function", result)
+        self.assertIn("Python project", result)
+
+    def test_optimize_prompt_with_overrides(self):
+        raw_prompt = "## DIRECTIVE:\nCreate a function"
+        overrides = {"context": "Override context"}
+        result = self.optimizer.optimize_prompt(raw_prompt, "test_pattern", overrides)
+        
+        self.assertIn("Override context", result)
+
+if __name__ == '__main__':
+    unittest.main()

cliops-1.0.0/tests/test_patterns.py

@@ -0,0 +1,51 @@
+import unittest
+from unittest.mock import Mock
+from core.patterns import OptimizationPattern, PatternRegistry
+
+class TestOptimizationPattern(unittest.TestCase):
+    def test_from_dict(self):
+        data = {
+            "name": "test_pattern",
+            "description": "Test pattern",
+            "template": "Test template: {field}",
+            "principles": ["Test Principle"]
+        }
+        pattern = OptimizationPattern.from_dict(data)
+        self.assertEqual(pattern.name, "test_pattern")
+        self.assertEqual(pattern.description, "Test pattern")
+        self.assertEqual(pattern.template, "Test template: {field}")
+        self.assertEqual(pattern.principles, ["Test Principle"])
+
+    def test_to_dict(self):
+        pattern = OptimizationPattern(
+            name="test_pattern",
+            description="Test pattern",
+            template="Test template: {field}",
+            principles=["Test Principle"]
+        )
+        result = pattern.to_dict()
+        expected = {
+            "name": "test_pattern",
+            "description": "Test pattern",
+            "template": "Test template: {field}",
+            "principles": ["Test Principle"]
+        }
+        self.assertEqual(result, expected)
+
+class TestPatternRegistry(unittest.TestCase):
+    def setUp(self):
+        self.mock_cli_state = Mock()
+        self.mock_cli_state.state = {}
+        self.registry = PatternRegistry(self.mock_cli_state)
+
+    def test_get_pattern(self):
+        pattern = self.registry.get_pattern("context_aware_generation")
+        self.assertIsNotNone(pattern)
+        self.assertEqual(pattern.name, "context_aware_generation")
+
+    def test_get_nonexistent_pattern(self):
+        pattern = self.registry.get_pattern("nonexistent_pattern")
+        self.assertIsNone(pattern)
+
+if __name__ == '__main__':
+    unittest.main()

cliops-1.0.0/tests/test_state.py

@@ -0,0 +1,39 @@
+import unittest
+import tempfile
+import json
+from pathlib import Path
+from core.state import CLIState
+
+class TestCLIState(unittest.TestCase):
+    def setUp(self):
+        self.temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.json')
+        self.temp_file.close()
+        self.state_file = Path(self.temp_file.name)
+        self.cli_state = CLIState(self.state_file)
+
+    def tearDown(self):
+        if self.state_file.exists():
+            self.state_file.unlink()
+
+    def test_set_and_get(self):
+        self.cli_state.set("TEST_KEY", "test_value")
+        self.assertEqual(self.cli_state.get("TEST_KEY"), "test_value")
+        self.assertEqual(self.cli_state.get("test_key"), "test_value")  # Case insensitive
+
+    def test_persistence(self):
+        self.cli_state.set("PERSIST_KEY", "persist_value")
+        
+        # Create new instance to test persistence
+        new_cli_state = CLIState(self.state_file)
+        self.assertEqual(new_cli_state.get("PERSIST_KEY"), "persist_value")
+
+    def test_clear(self):
+        self.cli_state.set("CLEAR_KEY", "clear_value")
+        self.cli_state.clear()
+        self.assertIsNone(self.cli_state.get("CLEAR_KEY"))
+
+    def test_nonexistent_key(self):
+        self.assertIsNone(self.cli_state.get("NONEXISTENT"))
+
+if __name__ == '__main__':
+    unittest.main()