cliops 1.0.0__tar.gz → 1.0.2__tar.gz

{cliops-1.0.0/cliops.egg-info → cliops-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cliops
-Version: 1.0.0
+Version: 1.0.2
 Summary: Advanced CLI tool for structured, pattern-based prompt optimization and state management
 Home-page: https://github.com/cliops/cliops
 Author: CliOps Development Team

{cliops-1.0.0 → cliops-1.0.2/cliops.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cliops
-Version: 1.0.0
+Version: 1.0.2
 Summary: Advanced CLI tool for structured, pattern-based prompt optimization and state management
 Home-page: https://github.com/cliops/cliops
 Author: CliOps Development Team

{cliops-1.0.0 → cliops-1.0.2}/cliops.egg-info/SOURCES.txt

@@ -1,6 +1,8 @@
 LICENSE
 MANIFEST.in
 README.md
+main.py
+presets.py
 requirements.txt
 setup.py
 cliops.egg-info/PKG-INFO

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

@@ -0,0 +1,3 @@
+core
+main
+presets

cliops-1.0.2/main.py

@@ -0,0 +1,177 @@
+import argparse
+import sys
+import os
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+from core.config import Config
+from core.state import CLIState
+from core.patterns import PatternRegistry
+from core.analyzer import PromptAnalyzer
+from core.optimizer import PromptOptimizer
+from presets import suggest_preset_from_prompt, apply_preset_interactive
+
+console = Console()
+
+def _define_subparsers(subparsers):
+    # Optimize command
+    optimize_parser = subparsers.add_parser("optimize", aliases=['opt'], help="Optimize a raw prompt using a specified pattern.")
+    optimize_parser.add_argument("prompt", type=str, nargs='?', help="The raw prompt string to optimize. If omitted, tries to read from stdin.")
+    optimize_parser.add_argument("--pattern", type=str, required=False, help="The name of the optimization pattern to apply.")
+    optimize_parser.add_argument("--dry-run", action="store_true", help="Show parsed fields and final template before generation.")
+    
+    # Common override arguments
+    optimize_parser.add_argument("--directive", type=str, help="Override the 'DIRECTIVE' field.")
+    optimize_parser.add_argument("--scope", type=str, help="Override the 'SCOPE' field.")
+    optimize_parser.add_argument("--constraints", type=str, help="Override the 'CONSTRAINTS' field.")
+    optimize_parser.add_argument("--output-format", type=str, help="Override the 'OUTPUT FORMAT' field.")
+    optimize_parser.add_argument("--success-criteria", type=str, help="Override the 'SUCCESS CRITERIA' field.")
+    optimize_parser.add_argument("--code", type=str, help="Override the 'CODE' block content.")
+    optimize_parser.add_argument("--context", type=str, help="Override the 'CONTEXT' for context-aware patterns.")
+    optimize_parser.add_argument("--current-focus", type=str, help="Override 'CURRENT FOCUS' for context-aware patterns.")
+    optimize_parser.add_argument("--mindset", type=str, help="Override 'MINDSET' for context-aware patterns.")
+
+    # Analyze command
+    analyze_parser = subparsers.add_parser("analyze", aliases=['an'], help="Analyze a raw prompt for optimization recommendations.")
+    analyze_parser.add_argument("prompt", type=str, nargs='?', help="The raw prompt string to analyze.")
+
+    # Patterns command
+    patterns_parser = subparsers.add_parser("patterns", aliases=['ls'], help="List available optimization patterns.")
+    patterns_parser.add_argument("pattern_name", nargs="?", type=str, help="Optional: Name of a specific pattern to get details for.")
+
+    # State command
+    state_parser = subparsers.add_parser("state", help="Manage persistent CLI state.")
+    state_subparsers = state_parser.add_subparsers(dest="state_command", help="State commands")
+
+    state_set_parser = state_subparsers.add_parser("set", help="Set a key-value pair in the CLI state.")
+    state_set_parser.add_argument("key", type=str, help="The key for the state variable.")
+    state_set_parser.add_argument("value", type=str, help="The value to set.")
+
+    state_show_parser = state_subparsers.add_parser("show", help="Show the current CLI state.")
+    state_clear_parser = state_subparsers.add_parser("clear", help="Clear all entries from the CLI state.")
+
+    # Init command
+    init_parser = subparsers.add_parser("init", help="Initialize CliOps configuration files.")
+
+def _run_init_command(cli_state: CLIState, pattern_registry: PatternRegistry):
+    """Handles the 'cliops init' command to set up config files."""
+    console.print(Panel("[bold green]Initializing CliOps Configuration[/bold green]", expand=False, border_style="green"))
+    
+    state_file = Config.get_state_file_path()
+    if not state_file.exists() or cli_state.state == {}:
+        state_file.parent.mkdir(parents=True, exist_ok=True)
+        cli_state.clear()
+        console.print(f"Created/reset CLI state file: [bold cyan]{state_file}[/bold cyan]", style="green")
+    else:
+        console.print(f"CLI state file already exists at [bold cyan]{state_file}[/bold cyan].", style="dim")
+
+    console.print(Panel("[bold green]Initialization complete![/bold green]", expand=False, border_style="green"))
+
+def main():
+    # Create a dummy parser to peek at the arguments
+    temp_parser = argparse.ArgumentParser(add_help=False)
+    temp_parser.add_argument("first_arg", nargs='?', help=argparse.SUPPRESS)
+    temp_parser.add_argument("--verbose", action="store_true", help=argparse.SUPPRESS)
+    
+    temp_args, remaining_argv = temp_parser.parse_known_args(sys.argv[1:])
+    verbose_mode = temp_args.verbose
+
+    known_commands = ["optimize", "opt", "analyze", "an", "patterns", "ls", "state", "init"]
+
+    # Check if the first argument looks like a prompt
+    is_direct_prompt = (temp_args.first_arg and
+                        temp_args.first_arg not in known_commands and
+                        not temp_args.first_arg.startswith('-'))
+
+    if is_direct_prompt:
+        new_argv = ["optimize", temp_args.first_arg] + remaining_argv
+        sys.argv = [sys.argv[0]] + new_argv
+    
+    # Set up the real parser
+    parser = argparse.ArgumentParser(
+        description="CliOps: Command Line Interface for Prompt Optimization and State Management (v3.2)",
+        formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output for debugging.")
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    _define_subparsers(subparsers)
+    
+    args = parser.parse_args()
+
+    if hasattr(args, 'verbose') and args.verbose:
+        verbose_mode = True
+
+    cli_state = CLIState(Config.get_state_file_path())
+    pattern_registry = PatternRegistry(cli_state)
+
+    # Handle cases where prompt might be piped via stdin
+    if hasattr(args, 'prompt') and args.prompt is None and not sys.stdin.isatty():
+        args.prompt = sys.stdin.read().strip()
+        if not args.prompt:
+            console.print("[bold red]Error:[/bold red] No prompt provided via argument or stdin.", style="red")
+            sys.exit(1)
+    elif hasattr(args, 'prompt') and args.prompt is None and sys.stdin.isatty() and args.command in ["optimize", "analyze"]:
+        console.print(f"[bold red]Error:[/bold red] Missing prompt argument for '{args.command}' command.", style="red")
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    # Set default pattern if not specified
+    if args.command in ["optimize", "opt"] and (not hasattr(args, 'pattern') or args.pattern is None):
+        default_pattern = cli_state.get("DEFAULT_PATTERN")
+        if default_pattern and pattern_registry.get_pattern(default_pattern):
+            args.pattern = default_pattern
+        else:
+            args.pattern = "context_aware_generation"
+
+    if args.command in ["optimize", "opt"]:
+        overrides = {k: v for k, v in vars(args).items() if v is not None and k not in ['command', 'prompt', 'pattern', 'dry_run', 'verbose']}
+        
+        try:
+            optimizer = PromptOptimizer(pattern_registry, cli_state, verbose=verbose_mode)
+            optimized_prompt = optimizer.optimize_prompt(args.prompt, args.pattern, overrides, args.dry_run)
+            
+            if not args.dry_run:
+                console.print(Panel("[bold green]Optimized Prompt[/bold green]", expand=False, border_style="green"))
+                console.print(Syntax(optimized_prompt, "markdown", theme="monokai", line_numbers=True, word_wrap=True))
+                console.print(Panel.fit("[dim]Prompt Optimization Complete[/dim]", border_style="dim"))
+            
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] {e}", style="red")
+            sys.exit(1)
+        
+    elif args.command in ["analyze", "an"]:
+        analyzer = PromptAnalyzer(pattern_registry)
+        analyzer.analyze_prompt(args.prompt)
+    elif args.command in ["patterns", "ls"]:
+        if args.pattern_name:
+            pattern = pattern_registry.get_pattern(args.pattern_name)
+            if pattern:
+                console.print(Panel(f"[bold blue]Pattern Details: {pattern.name}[/bold blue]", expand=False, border_style="blue"))
+                console.print(f"[bold]Description:[/bold] {pattern.description}")
+                console.print(f"[bold]Principles:[/bold] {', '.join(pattern.principles)}")
+                console.print(Panel(
+                    Syntax(pattern.template, "jinja2", theme="monokai", line_numbers=True, word_wrap=True),
+                    title="[bold]Template[/bold]", border_style="dim"
+                ))
+            else:
+                console.print(f"[bold red]Error:[/bold red] Pattern '{args.pattern_name}' not found.", style="red")
+                pattern_registry.list_patterns()
+        else:
+            pattern_registry.list_patterns()
+    elif args.command == "state":
+        if args.state_command == "set":
+            cli_state.set(args.key, args.value)
+        elif args.state_command == "show":
+            cli_state.show()
+        elif args.state_command == "clear":
+            cli_state.clear()
+    elif args.command == "init":
+        _run_init_command(cli_state, pattern_registry)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

cliops-1.0.2/presets.py

@@ -0,0 +1,93 @@
+# presets.py
+import json
+import re
+from pathlib import Path
+
+BUILTIN_PRESETS = {
+    "react-tailwind": {
+        "ARCHITECTURE": "React + Tailwind CSS",
+        "FOCUS": "UI layout",
+        "PATTERNS": "context_aware_generation, state_anchoring",
+        "DEFAULT_PATTERN": "context_aware_generation"
+    },
+    "django-api": {
+        "ARCHITECTURE": "Django REST Framework",
+        "FOCUS": "API endpoints and serializers",
+        "PATTERNS": "bug_fix_precision",
+        "DEFAULT_PATTERN": "bug_fix_precision"
+    },
+    "bash-script": {
+        "ARCHITECTURE": "Shell scripting",
+        "FOCUS": "Automation and CLI behavior",
+        "PATTERNS": "context_aware_generation",
+        "DEFAULT_PATTERN": "context_aware_generation"
+    }
+}
+
+CUSTOM_PRESET_FILE = Path.home() / ".cliops_presets.json"
+
+def suggest_preset_from_prompt(prompt: str) -> str | None:
+    prompt = prompt.lower()
+    if "tailwind" in prompt or "jsx" in prompt:
+        return "react-tailwind"
+    if "endpoint" in prompt or "serializer" in prompt or "django" in prompt:
+        return "django-api"
+    if re.search(r'#!/bin/bash|\\.sh|chmod|\\bcron\\b', prompt):
+        return "bash-script"
+    return None
+
+def save_custom_preset(name, preset_dict):
+    if CUSTOM_PRESET_FILE.exists():
+        with open(CUSTOM_PRESET_FILE, 'r') as f:
+            all_presets = json.load(f)
+    else:
+        all_presets = {}
+    all_presets[name] = preset_dict
+    with open(CUSTOM_PRESET_FILE, 'w') as f:
+        json.dump(all_presets, f, indent=2)
+    print(f"✅ Custom preset '{name}' saved.")
+
+def apply_preset_interactive(suggested_name, state):
+    print(f"\n🤖 Suggested preset based on your prompt: {suggested_name}")
+    use = input("Would you like to use this preset? (y/n): ").strip().lower()
+    if use != 'y':
+        print("❌ Preset declined.")
+        return
+
+    fields = {}
+    for key in BUILTIN_PRESETS.get(suggested_name, {}):
+        default = BUILTIN_PRESETS[suggested_name][key]
+        user_val = input(f"{key} [{default}]: ").strip()
+        fields[key] = user_val or default
+        state.set(key, fields[key])
+
+    save = input("Save this as a custom preset? (y/n): ").strip().lower()
+    if save == 'y':
+        name = input("Enter a name for your preset: ").strip()
+        if name:
+            save_custom_preset(name, fields)
+
+def list_all_presets():
+    print("\n📦 Available Presets:")
+    for name in BUILTIN_PRESETS:
+        print(f"  - {name} (built-in)")
+    if CUSTOM_PRESET_FILE.exists():
+        with open(CUSTOM_PRESET_FILE, 'r') as f:
+            custom = json.load(f)
+            for name in custom:
+                print(f"  - {name} (custom)")
+
+
+def apply_named_preset(name, state):
+    preset = BUILTIN_PRESETS.get(name)
+    if not preset and CUSTOM_PRESET_FILE.exists():
+        with open(CUSTOM_PRESET_FILE, 'r') as f:
+            preset = json.load(f).get(name)
+
+    if not preset:
+        print(f"❌ Preset '{name}' not found.")
+        return
+
+    for key, value in preset.items():
+        state.set(key, value)
+    print(f"✅ Preset '{name}' applied.")

{cliops-1.0.0 → cliops-1.0.2}/setup.py

@@ -10,7 +10,7 @@ requirements = (this_directory / "requirements.txt").read_text().strip().split('
 
 setup(
     name='cliops',
-    version='1.0.0',
+    version='1.0.2',
     author='CliOps Development Team',
     author_email='contact@cliops.dev',
     description='Advanced CLI tool for structured, pattern-based prompt optimization and state management',
@@ -23,6 +23,7 @@ setup(
         'Documentation': 'https://cliops.readthedocs.io',
     },
     packages=find_packages(exclude=['tests*']),
+    py_modules=['main', 'presets'],
     include_package_data=True,
     install_requires=requirements,
     extras_require={

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

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