zenus-cli 0.6.1__tar.gz

zenus_cli-0.6.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: zenus-cli
+Version: 0.6.1
+Summary: Zenus - Command Line Interface
+License: MIT
+Author: Zenus Team
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: anthropic (>=0.47.0,<0.48.0)
+Requires-Dist: openai (>=1.0.0,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: rich (>=13.7.0,<14.0.0)
+Requires-Dist: zenus-core (>=0.6.1,<0.7.0)
+Description-Content-Type: text/markdown
+
+# Zenus CLI
+
+Command-line interface for Zenus.
+
+## Installation
+
+```bash
+pip install zenus-cli
+```
+
+See main [Zenus documentation](../../README.md) for details.
+

zenus_cli-0.6.1/README.md

@@ -0,0 +1,11 @@
+# Zenus CLI
+
+Command-line interface for Zenus.
+
+## Installation
+
+```bash
+pip install zenus-cli
+```
+
+See main [Zenus documentation](../../README.md) for details.

zenus_cli-0.6.1/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "zenus-cli"
+version = "0.6.1"
+description = "Zenus - Command Line Interface"
+authors = ["Zenus Team"]
+readme = "README.md"
+license = "MIT"
+packages = [{include = "zenus_cli", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+zenus-core = "^0.6.1"
+rich = "^13.7.0"
+# LLM provider dependencies (needed for runtime)
+openai = "^1.0.0"
+anthropic = "^0.47.0"
+pyyaml = "^6.0.3"
+
+[tool.poetry.scripts]
+zenus = "zenus_cli.main:main"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-cov = "^4.1.0"
+prompt-toolkit = "^3.0.52"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

zenus_cli-0.6.1/src/zenus_cli/__init__.py

@@ -0,0 +1,9 @@
+"""
+Zenus CLI - Command Line Interface
+
+User-facing command-line interface for Zenus.
+"""
+
+__version__ = "0.3.0"
+
+__all__ = ["__version__"]

zenus_cli-0.6.1/src/zenus_cli/main.py

@@ -0,0 +1,5 @@
+from zenus_cli.zenusd.main import main
+
+
+if __name__ == "__main__":
+    main()

zenus_cli-0.6.1/src/zenus_cli/router.py

@@ -0,0 +1,180 @@
+"""
+CLI Command Router
+
+Responsible for:
+- Parsing CLI arguments
+- Routing to appropriate handlers (interactive/direct/help)
+- Maintaining clear separation between parse, intent, execute
+"""
+
+from typing import Optional, List
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CLICommand:
+    """Represents a parsed CLI command"""
+    mode: str  # 'interactive', 'direct', 'help', 'version', 'status', 'model'
+    input_text: Optional[str] = None
+    flags: dict = field(default_factory=dict)
+
+
+class CommandRouter:
+    """Routes CLI invocations to appropriate handlers"""
+
+    def __init__(self):
+        self.version = "0.1.0-alpha"
+
+    def parse(self, args: List[str]) -> CLICommand:
+        """
+        Parse command line arguments into a CLICommand
+        
+        Modes:
+        - No args or 'shell' -> interactive REPL
+        - 'help' / '--help' / '-h' -> help message
+        - 'version' / '--version' / '-v' -> version info
+        - 'rollback' -> rollback commands
+        - 'history' -> history commands
+        - '--dry-run <text>' -> show plan but do not execute
+        - Direct text -> immediate intent execution
+        """
+        
+        # Check for flags
+        dry_run = False
+        iterative = False
+        force_provider: Optional[str] = None
+        force_model: Optional[str] = None
+        filtered_args = []
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg == "--dry-run":
+                dry_run = True
+            elif arg == "--iterative":
+                iterative = True
+            elif arg in ("--provider", "-p") and i + 1 < len(args):
+                force_provider = args[i + 1]
+                i += 1
+            elif arg.startswith("--provider="):
+                force_provider = arg.split("=", 1)[1]
+            elif arg == "--model" and i + 1 < len(args):
+                force_model = args[i + 1]
+                i += 1
+            elif arg.startswith("--model="):
+                force_model = arg.split("=", 1)[1]
+            else:
+                filtered_args.append(arg)
+            i += 1
+
+        args = filtered_args
+        
+        if not args or args[0] == "shell":
+            return CLICommand(mode="interactive")
+        
+        if args[0] in ("help", "--help", "-h"):
+            return CLICommand(mode="help")
+        
+        if args[0] in ("version", "--version", "-v"):
+            return CLICommand(mode="version")
+        
+        if args[0] == "status":
+            return CLICommand(mode="status")
+
+        if args[0] == "model":
+            return CLICommand(
+                mode="model",
+                input_text=" ".join(args[1:]) if len(args) > 1 else "status",
+            )
+
+        if args[0] == "rollback":
+            return CLICommand(
+                mode="rollback",
+                input_text=" ".join(args[1:]) if len(args) > 1 else None,
+                flags={"dry_run": dry_run}
+            )
+        
+        if args[0] == "history":
+            return CLICommand(
+                mode="history",
+                input_text=" ".join(args[1:]) if len(args) > 1 else None
+            )
+        
+        # Everything else is a direct command
+        input_text = " ".join(args)
+        return CLICommand(
+            mode="direct",
+            input_text=input_text,
+            flags={
+                "dry_run": dry_run,
+                "iterative": iterative,
+                "force_provider": force_provider,
+                "force_model": force_model,
+            },
+        )
+
+    def show_help(self):
+        """Display help message"""
+        help_text = f"""
+Zenus v{self.version}
+A developer-centric, CLI-first, agent-driven operating layer
+
+USAGE:
+    zenus [OPTIONS] [COMMAND]
+
+COMMANDS:
+    shell                   Start interactive REPL (default)
+    status                  Show system status and active LLM config
+    model [status]          Show current provider/model configuration
+    model list              List all available models per provider
+    model set <p> [model]   Set default provider (and optionally model)
+    rollback [N]            Rollback last N actions (default: 1)
+    history                 Show command history and failures
+    help                    Show this help message
+    version                 Show version information
+    <direct command>        Execute command immediately
+
+OPTIONS:
+    --dry-run               Show plan but do not execute
+    --iterative             Use iterative ReAct loop (for complex tasks)
+    --provider <name>       Use specific provider for this command only
+                              (anthropic, openai, deepseek, ollama)
+    --model <id>            Use specific model for this command only
+
+EXAMPLES:
+    zenus                                         # Start interactive shell
+    zenus "list files in ~/Documents"             # Direct execution
+    zenus --dry-run "delete all tmp files"        # Preview without executing
+    zenus --provider deepseek "summarize this"    # Override provider once
+    zenus --model claude-opus-4-6 "refactor src"  # Override model once
+    zenus model set anthropic claude-opus-4-6     # Change default
+    zenus --iterative "read project and improve"  # Multi-step ReAct loop
+
+INTERACTIVE SHELL SHORTCUTS:
+    @deepseek: your command    # Use deepseek for this command
+    use claude: your command   # Use anthropic for this command
+    --provider openai <cmd>    # Override provider in shell mode
+    model set deepseek         # Change default inside shell
+    status                     # Show status inside shell
+
+PROVIDER ALIASES (for inline overrides):
+    anthropic, claude, sonnet, haiku, opus → anthropic
+    openai, gpt, chatgpt, o1, o3          → openai
+    deepseek                               → deepseek
+    ollama, local, llama                   → ollama
+
+CREDENTIALS:
+    ANTHROPIC_API_KEY   Anthropic (Claude) API key
+    OPENAI_API_KEY      OpenAI API key
+    DEEPSEEK_API_KEY    DeepSeek API key
+    (or set in config.yaml / .env)
+
+LOGS:
+    Audit logs: ~/.zenus/logs/
+
+For more information, visit: https://github.com/Guillhermm/zenus
+        """.strip()
+        print(help_text)
+
+    def show_version(self):
+        """Display version information"""
+        print(f"Zenus v{self.version}")

zenus_cli-0.6.1/src/zenus_cli/zenusd/main.py

@@ -0,0 +1,159 @@
+"""
+Zenus - Main Entry Point
+
+CLI-first, agent-driven operating layer
+Routes commands through: CLI to Intent to Plan to Execute
+"""
+
+import sys
+from zenus_cli.router import CommandRouter
+from zenus_core.orchestrator import Orchestrator, OrchestratorError
+from zenus_core.rollback import get_rollback_engine, RollbackError
+from zenus_core.memory.action_tracker import get_action_tracker
+from zenus_core.memory.failure_logger import get_failure_logger
+from zenus_core.output.console import console
+
+
+def main():
+    """Main entry point for Zenus"""
+    
+    router = CommandRouter()
+    orchestrator = Orchestrator()
+    
+    # Parse CLI arguments (skip program name)
+    args = sys.argv[1:]
+    command = router.parse(args)
+    
+    # Route to appropriate handler
+    try:
+        if command.mode == "help":
+            router.show_help()
+
+        elif command.mode == "version":
+            router.show_version()
+
+        elif command.mode == "status":
+            from zenus_core.shell.commands import handle_status_command
+            handle_status_command(orchestrator)
+
+        elif command.mode == "model":
+            from zenus_core.shell.commands import handle_model_command
+            parts = (command.input_text or "status").split()
+            subcommand = parts[0]
+            args = parts[1:] if len(parts) > 1 else []
+            handle_model_command(subcommand, args)
+
+        elif command.mode == "interactive":
+            orchestrator.interactive_shell()
+        
+        elif command.mode == "rollback":
+            # Rollback command
+            rollback_engine = get_rollback_engine()
+            dry_run = command.flags.get("dry_run", False)
+            
+            # Parse number of actions to rollback
+            n = 1
+            if command.input_text:
+                try:
+                    n = int(command.input_text)
+                except ValueError:
+                    console.print("[red]Error: rollback argument must be a number[/red]")
+                    sys.exit(1)
+            
+            try:
+                result = rollback_engine.rollback_last_n_actions(n, dry_run=dry_run)
+                if result["success"]:
+                    if result.get("dry_run"):
+                        console.print("\n[green]Dry run complete - no changes made[/green]")
+                    else:
+                        console.print(f"\n[green]✓ Successfully rolled back {result['actions_rolled_back']} action(s)[/green]")
+                else:
+                    console.print(f"\n[yellow]⚠ Partial rollback: {result['actions_rolled_back']} succeeded, {result['actions_failed']} failed[/yellow]")
+                    for error in result["errors"]:
+                        console.print(f"  [red]• {error}[/red]")
+            except RollbackError as e:
+                console.print(f"[red]Rollback error: {e}[/red]")
+                sys.exit(1)
+        
+        elif command.mode == "history":
+            # History command
+            action_tracker = get_action_tracker()
+            failure_logger = get_failure_logger()
+            
+            # Check if --failures flag
+            show_failures = command.input_text == "--failures"
+            
+            if show_failures:
+                # Show failure history
+                stats = failure_logger.get_failure_stats()
+                console.print("\n[cyan]Failure History:[/cyan]")
+                console.print(f"  Total failures: {stats['total_failures']}")
+                console.print(f"  Recent (7 days): {stats['recent_7_days']}")
+                
+                if stats['by_tool']:
+                    console.print("\n[cyan]By tool:[/cyan]")
+                    for tool, count in sorted(stats['by_tool'].items(), key=lambda x: x[1], reverse=True)[:10]:
+                        console.print(f"  {tool}: {count}")
+                
+                if stats['by_error_type']:
+                    console.print("\n[cyan]By error type:[/cyan]")
+                    for error_type, count in sorted(stats['by_error_type'].items(), key=lambda x: x[1], reverse=True):
+                        console.print(f"  {error_type}: {count}")
+                
+                console.print(f"\n[cyan]Patterns with suggestions: {stats['patterns_with_suggestions']}[/cyan]")
+            else:
+                # Show transaction history
+                transactions = action_tracker.get_recent_transactions(limit=10)
+                console.print("\n[cyan]Recent Transactions:[/cyan]")
+                for tx in transactions:
+                    status_color = "green" if tx["status"] == "completed" else "red"
+                    rollback_info = " (rolled back)" if tx.get("rollback_status") else ""
+                    console.print(f"  [{status_color}]{tx['id']}[/{status_color}]: {tx['user_input']}{rollback_info}")
+                    console.print(f"    Goal: {tx['intent_goal']}")
+                    console.print(f"    Status: {tx['status']}")
+                    console.print()
+        
+        elif command.mode == "direct":
+            # Direct execution
+            dry_run = command.flags.get("dry_run", False)
+            iterative = command.flags.get("iterative", False)
+            force_provider = command.flags.get("force_provider")
+            force_model = command.flags.get("force_model")
+
+            # If --model given without --provider, embed it as an inline directive
+            # so the orchestrator's provider_override parser can infer the provider
+            input_text = command.input_text
+            if force_model and not force_provider:
+                input_text = f"--model {force_model} {input_text}"
+                force_provider = None  # let the parser infer it
+
+            if iterative:
+                result = orchestrator.execute_iterative(
+                    input_text,
+                    max_iterations=10,
+                    dry_run=dry_run,
+                    force_provider=force_provider,
+                )
+            else:
+                result = orchestrator.execute_command(
+                    input_text,
+                    dry_run=dry_run,
+                    force_provider=force_provider,
+                )
+
+            if result:
+                print(result)
+    
+    except OrchestratorError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nInterrupted")
+        sys.exit(130)
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()