hashcli 0.1.0__py3-none-any.whl

hashcli/__init__.py

@@ -0,0 +1,29 @@
+"""Hash (HAcker SHell) - Intelligent CLI system with dual-mode functionality.
+
+This package provides a modern CLI that combines LLM conversational assistance
+with command proxy functionality, operating in two distinct modes:
+
+- LLM Chat Mode: Natural language queries for intelligent assistance
+- Command Proxy Mode: Slash-prefixed commands for direct functionality
+
+The system is designed for cross-platform compatibility and extensibility,
+supporting multiple LLM providers and built-in command extensions.
+"""
+
+from .command_proxy import CommandProxy
+from .config import HashConfig
+from .history import ConversationHistory
+from .llm_handler import LLMHandler
+from .main import app
+
+__version__ = "0.1.0"
+__author__ = "Hash CLI Team"
+__email__ = "team@hashcli.dev"
+
+__all__ = [
+    "app",
+    "HashConfig",
+    "LLMHandler",
+    "CommandProxy",
+    "ConversationHistory",
+]

hashcli/command_proxy.py

@@ -0,0 +1,240 @@
+"""Command proxy system for handling slash-prefixed commands."""
+
+import os
+import platform
+import shlex
+import subprocess
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console
+
+from .config import HashConfig
+
+console = Console()
+
+
+class Command(ABC):
+    """Abstract base class for all commands."""
+
+    @abstractmethod
+    def execute(self, args: List[str], config: HashConfig) -> str:
+        """Execute the command with given arguments."""
+        pass
+
+    @abstractmethod
+    def get_help(self) -> str:
+        """Get help text for this command."""
+        pass
+
+    def validate_args(self, args: List[str]) -> bool:
+        """Validate command arguments. Override if needed."""
+        return True
+
+
+class CommandProxy:
+    """Main command proxy that routes slash commands to their handlers."""
+
+    def __init__(self, config: HashConfig):
+        self.config = config
+        self.commands = self._register_commands()
+
+    def execute(self, command_line: str) -> str:
+        """Execute a slash command."""
+        # Remove leading slash and parse command
+        command_line = command_line.lstrip().lstrip("/")
+
+        if not command_line:
+            return "No command specified. Use /help for available commands."
+
+        # Parse command and arguments safely
+        try:
+            parts = shlex.split(command_line)
+        except ValueError as e:
+            return f"Error parsing command: {e}"
+
+        if not parts:
+            return "No command specified. Use /help for available commands."
+
+        cmd = parts[0]
+        args = parts[1:] if len(parts) > 1 else []
+
+        # Check if command exists
+        if cmd not in self.commands:
+            return f"Unknown command: /{cmd}\nUse /help for available commands."
+
+        # Get command handler
+        handler = self.commands[cmd]
+
+        # Validate arguments
+        if not handler.validate_args(args):
+            return f"Invalid arguments for /{cmd}\n{handler.get_help()}"
+
+        # Execute command
+        try:
+            return handler.execute(args, self.config)
+        except Exception as e:
+            if self.config.show_debug:
+                import traceback
+
+                return f"Command execution error: {e}\n{traceback.format_exc()}"
+            else:
+                return f"Command execution error: {e}"
+
+    def _register_commands(self) -> Dict[str, Command]:
+        """Register all available commands."""
+        from .commands import (
+            ClearCommand,
+            ConfigCommand,
+            FixCommand,
+            HelpCommand,
+            LSCommand,
+            ModelCommand,
+        )
+
+        return {
+            "ls": LSCommand(),
+            "dir": LSCommand(),  # Windows alias
+            "clear": ClearCommand(),
+            "model": ModelCommand(),
+            "fix": FixCommand(),
+            "help": HelpCommand(),
+            "config": ConfigCommand(),
+            "history": HistoryCommand(),
+            "exit": ExitCommand(),
+            "quit": ExitCommand(),
+        }
+
+    def get_available_commands(self) -> List[str]:
+        """Get list of available command names."""
+        return sorted(self.commands.keys())
+
+    def get_command_help(self, command: str) -> Optional[str]:
+        """Get help for a specific command."""
+        if command in self.commands:
+            return self.commands[command].get_help()
+        return None
+
+
+class SystemCommand(Command):
+    """Base class for system commands that execute shell operations."""
+
+    def execute_system_command(self, cmd_args: List[str], config: HashConfig) -> str:
+        """Execute a system command with security checks."""
+
+        # Security check: validate command against blocked list
+        cmd_str = " ".join(cmd_args)
+        for blocked in config.blocked_commands:
+            if blocked.lower() in cmd_str.lower():
+                return f"Blocked command detected: {blocked}"
+
+        # Security check: validate against allowed list if configured
+        if config.allowed_commands:
+            base_cmd = cmd_args[0] if cmd_args else ""
+            if base_cmd not in config.allowed_commands:
+                return f"Command not in allowed list: {base_cmd}"
+
+        try:
+            # Execute command with timeout
+            result = subprocess.run(
+                cmd_args,
+                capture_output=True,
+                text=True,
+                timeout=config.command_timeout,
+                shell=False,  # Never use shell=True for security
+            )
+
+            # Format output
+            output = ""
+            if result.stdout:
+                output += result.stdout
+            if result.stderr:
+                if output:
+                    output += "\n"
+                output += f"stderr: {result.stderr}"
+
+            if result.returncode != 0 and not output:
+                output = f"Command failed with exit code {result.returncode}"
+
+            return output.strip()
+
+        except subprocess.TimeoutExpired:
+            return f"Command timed out after {config.command_timeout} seconds"
+        except subprocess.CalledProcessError as e:
+            return f"Command failed: {e}"
+        except FileNotFoundError:
+            return f"Command not found: {cmd_args[0] if cmd_args else 'unknown'}"
+        except Exception as e:
+            return f"Execution error: {e}"
+
+
+# History command for conversation history management
+class HistoryCommand(Command):
+    """Command to manage conversation history."""
+
+    def execute(self, args: List[str], config: HashConfig) -> str:
+        from .history import ConversationHistory
+
+        if not config.history_enabled:
+            return "History is disabled in configuration."
+
+        history = ConversationHistory(config.history_dir)
+
+        if not args or args[0] == "list":
+            # List recent conversations
+            sessions = history.list_sessions()
+            if not sessions:
+                return "No conversation history found."
+
+            output = "Recent conversations:\n"
+            for session in sessions[-10:]:  # Show last 10
+                output += f"  {session['id']}: {session['created']} ({session['message_count']} messages)\n"
+            return output.strip()
+
+        elif args[0] == "show" and len(args) > 1:
+            # Show specific conversation
+            session_id = args[1]
+            messages = history.get_session_messages(session_id)
+            if not messages:
+                return f"No messages found for session {session_id}"
+
+            output = f"Conversation {session_id}:\n\n"
+            for msg in messages:
+                role = msg["role"].upper()
+                content = (
+                    msg["content"][:200] + "..."
+                    if len(msg["content"]) > 200
+                    else msg["content"]
+                )
+                output += f"[{role}] {content}\n\n"
+            return output.strip()
+
+        elif args[0] == "clear":
+            # Clear all history
+            if history.clear_all_history():
+                return "All conversation history cleared."
+            else:
+                return "Failed to clear history."
+
+        else:
+            return self.get_help()
+
+    def get_help(self) -> str:
+        return """Manage conversation history:
+  /history list        - List recent conversations
+  /history show <id>   - Show specific conversation
+  /history clear       - Clear all history"""
+
+
+# Exit command
+class ExitCommand(Command):
+    """Command to exit the application."""
+
+    def execute(self, args: List[str], config: HashConfig) -> str:
+        import sys
+
+        console.print("[yellow]Goodbye![/yellow]")
+        sys.exit(0)
+
+    def get_help(self) -> str:
+        return "Exit the Hash CLI application."

hashcli/commands/__init__.py

@@ -0,0 +1,17 @@
+"""Built-in command implementations for command proxy mode."""
+
+from .clear import ClearCommand
+from .config import ConfigCommand
+from .fix import FixCommand
+from .help import HelpCommand
+from .ls import LSCommand
+from .model import ModelCommand
+
+__all__ = [
+    "LSCommand",
+    "ClearCommand",
+    "ModelCommand",
+    "FixCommand",
+    "HelpCommand",
+    "ConfigCommand",
+]

hashcli/commands/clear.py

@@ -0,0 +1,70 @@
+"""Clear command implementation for clearing conversation history."""
+
+from typing import List
+
+from ..command_proxy import Command
+from ..config import HashConfig
+
+
+class ClearCommand(Command):
+    """Command to clear conversation history."""
+
+    def execute(self, args: List[str], config: HashConfig) -> str:
+        """Clear conversation history."""
+        from ..history import ConversationHistory
+
+        if not config.history_enabled:
+            return "History is disabled in configuration."
+
+        # Parse arguments
+        clear_all = "--all" in args or "-a" in args
+
+        try:
+            history = ConversationHistory(config.history_dir)
+
+            if clear_all:
+                # Clear all history
+                success = history.clear_all_history()
+                if success:
+                    return "All conversation history cleared successfully."
+                else:
+                    return "Failed to clear conversation history."
+            else:
+                # Clear old history (default: 30 days)
+                days = 30
+
+                # Check for custom days argument
+                for i, arg in enumerate(args):
+                    if arg == "--days" or arg == "-d":
+                        if i + 1 < len(args):
+                            try:
+                                days = int(args[i + 1])
+                            except ValueError:
+                                return f"Invalid days value: {args[i + 1]}"
+                        break
+
+                cleared_count = history.clear_old_history(days)
+                if cleared_count > 0:
+                    return f"Cleared {cleared_count} old conversations (older than {days} days)."
+                else:
+                    return f"No conversations older than {days} days found."
+
+        except Exception as e:
+            if config.show_debug:
+                import traceback
+
+                return f"Error clearing history: {e}\n{traceback.format_exc()}"
+            else:
+                return f"Error clearing history: {e}"
+
+    def get_help(self) -> str:
+        """Get help text for the clear command."""
+        return """Clear conversation history:
+  /clear                    - Clear conversations older than 30 days
+  /clear --days N          - Clear conversations older than N days
+  /clear --all             - Clear ALL conversation history
+  
+Examples:
+  /clear                   - Clear old conversations
+  /clear --days 7          - Clear conversations older than 7 days
+  /clear --all             - Clear everything (cannot be undone)"""

hashcli/commands/config.py

@@ -0,0 +1,124 @@
+"""Config command implementation for configuration management."""
+
+from typing import List
+
+from ..command_proxy import Command
+from ..config import HashConfig, save_config
+
+
+class ConfigCommand(Command):
+    """Command to show and manage configuration."""
+
+    def execute(self, args: List[str], config: HashConfig) -> str:
+        """Show or manage configuration."""
+
+        if not args:
+            return self._show_config(config)
+
+        command = args[0].lower()
+
+        if command == "show":
+            return self._show_config(config)
+        elif command == "save":
+            return self._save_config(config)
+        elif command == "stats":
+            return self._show_stats(config)
+        else:
+            return f"Unknown config command: {command}\n{self.get_help()}"
+
+    def _show_config(self, config: HashConfig) -> str:
+        """Show current configuration."""
+        output = "Hash CLI Configuration:\n\n"
+
+        # LLM Configuration
+        output += "[bold blue]LLM Configuration:[/bold blue]\n"
+        output += f"  Provider: {config.llm_provider.value}\n"
+        output += f"  Model: {config.get_current_model()}\n"
+        output += f"  API Key: {'✓ Set' if config.get_current_api_key() else '✗ Not set'}\n\n"
+
+        # Tool Configuration
+        output += "[bold blue]Tool Configuration:[/bold blue]\n"
+        output += f"  Command execution: {'Enabled' if config.allow_command_execution else 'Disabled'}\n"
+        output += f"  Confirmation required: {'Yes' if config.require_confirmation else 'No'}\n"
+        output += f"  Command timeout: {config.command_timeout}s\n"
+        output += (
+            f"  Sandbox commands: {'Yes' if config.sandbox_commands else 'No'}\n\n"
+        )
+
+        # History Configuration
+        output += "[bold blue]History Configuration:[/bold blue]\n"
+        output += f"  History enabled: {'Yes' if config.history_enabled else 'No'}\n"
+        if config.history_enabled:
+            output += f"  History directory: {config.history_dir}\n"
+            output += f"  Max history size: {config.max_history_size}\n"
+            output += f"  Retention days: {config.history_retention_days}\n"
+        output += "\n"
+
+        # Output Configuration
+        output += "[bold blue]Output Configuration:[/bold blue]\n"
+        output += f"  Rich output: {'Yes' if config.rich_output else 'No'}\n"
+        output += f"  Debug mode: {'Yes' if config.show_debug else 'No'}\n"
+        output += f"  Log level: {config.log_level.value}\n\n"
+
+        # Security Configuration
+        output += "[bold blue]Security Configuration:[/bold blue]\n"
+        if config.allowed_commands:
+            output += f"  Allowed commands: {', '.join(config.allowed_commands)}\n"
+        else:
+            output += f"  Allowed commands: All (no whitelist)\n"
+        output += f"  Blocked commands: {', '.join(config.blocked_commands)}\n"
+
+        return output.strip()
+
+    def _save_config(self, config: HashConfig) -> str:
+        """Save current configuration to file."""
+        try:
+            success = save_config(config)
+            if success:
+                config_path = config.history_dir.parent / "config.toml"
+                return f"Configuration saved to {config_path}"
+            else:
+                return "Failed to save configuration"
+        except Exception as e:
+            return f"Error saving configuration: {e}"
+
+    def _show_stats(self, config: HashConfig) -> str:
+        """Show usage statistics."""
+        if not config.history_enabled:
+            return "History is disabled - no statistics available."
+
+        try:
+            from ..history import ConversationHistory
+
+            history = ConversationHistory(config.history_dir)
+            stats = history.get_statistics()
+
+            output = "Hash CLI Usage Statistics:\n\n"
+            output += f"Total conversations: {stats['total_sessions']}\n"
+            output += f"Total messages: {stats['total_messages']}\n"
+            output += f"Recent conversations (7d): {stats['recent_sessions_7d']}\n"
+            output += f"Recent messages (7d): {stats['recent_messages_7d']}\n"
+            output += f"Database size: {stats['database_size_bytes'] / 1024:.1f} KB\\n"
+            output += f"Database location: {stats['database_path']}\\n"
+
+            if stats["total_sessions"] > 0:
+                avg_messages = stats["total_messages"] / stats["total_sessions"]
+                output += f"Average messages per conversation: {avg_messages:.1f}\\n"
+
+            return output
+
+        except Exception as e:
+            return f"Error getting statistics: {e}"
+
+    def get_help(self) -> str:
+        """Get help text for the config command."""
+        return """Show and manage configuration:
+  /config                  - Show current configuration
+  /config show             - Show current configuration (same as above)  
+  /config save             - Save current config to file
+  /config stats            - Show usage statistics
+  
+Examples:
+  /config                  - View all settings
+  /config save             - Save to ~/.hashcli/config.toml
+  /config stats            - See usage statistics"""

hashcli/commands/fix.py

@@ -0,0 +1,54 @@
+"""Fix command implementation for coding assistance."""
+
+from typing import List
+
+from ..command_proxy import Command
+from ..config import HashConfig
+
+
+class FixCommand(Command):
+    """Command for coding-specialized assistance."""
+
+    def execute(self, args: List[str], config: HashConfig) -> str:
+        """Execute fix command for coding assistance."""
+
+        if not args:
+            return self.get_help()
+
+        # Join all arguments into a description
+        description = " ".join(args)
+
+        # Create a specialized prompt for coding assistance
+        coding_prompt = f"""I need help with a coding issue. Please provide a practical solution:
+
+Issue: {description}
+
+Please provide:
+1. A clear explanation of the problem
+2. A concrete solution with code examples if applicable
+3. Any relevant best practices or alternatives
+4. Commands to run if needed (I can execute them with your guidance)
+
+Focus on being practical and actionable."""
+
+        # This would normally trigger LLM mode with the specialized prompt
+        # For now, return a message indicating the prompt would be processed
+        return f"Coding assistance request: '{description}'\n\nThis would normally trigger an LLM conversation with specialized coding context. In a full implementation, this would seamlessly switch to LLM mode with the enhanced prompt above."
+
+    def get_help(self) -> str:
+        """Get help text for the fix command."""
+        return """Get coding assistance for development issues:
+  /fix <description>       - Get help with a coding problem
+  
+Examples:
+  /fix my python script has a syntax error
+  /fix how do I implement authentication in Express.js
+  /fix git merge conflict resolution
+  /fix optimize this slow database query
+  /fix unit test is failing with TypeError
+  
+This command provides specialized coding assistance with:
+- Problem analysis and solutions
+- Code examples and best practices  
+- Command suggestions for fixes
+- Step-by-step guidance"""

hashcli/commands/help.py

@@ -0,0 +1,89 @@
+"""Help command implementation for showing available commands."""
+
+from typing import List
+
+from ..command_proxy import Command
+from ..config import HashConfig
+
+
+class HelpCommand(Command):
+    """Command to show help information."""
+
+    def execute(self, args: List[str], config: HashConfig) -> str:
+        """Show help information."""
+
+        if args and args[0] != "":
+            # Show help for specific command
+            return self._show_command_help(args[0])
+        else:
+            # Show general help
+            return self._show_general_help()
+
+    def _show_general_help(self) -> str:
+        """Show general help with all available commands."""
+        help_text = """Hash CLI - Intelligent Terminal Assistant
+
+DUAL MODE OPERATION:
+  hashcli <natural language>  - LLM chat mode for questions & assistance
+  hashcli /<command>          - Command proxy mode for direct actions
+
+AVAILABLE COMMANDS:
+  /ls [args]                  - List directory contents (cross-platform)
+  /clear [options]            - Clear conversation history  
+  /model [options]            - Switch LLM models and providers
+  /fix <description>          - Get coding assistance
+  /help [command]             - Show help (this message)
+  /config                     - Show current configuration
+  /history [options]          - Manage conversation history
+  /exit, /quit                - Exit the application
+
+EXAMPLES:
+  # LLM Mode:
+  hashcli how do I find large files?
+  hashcli explain this error: permission denied
+  hashcli help me optimize this Python script
+  
+  # Command Mode:
+  hashcli /ls -la
+  hashcli /model set gpt-5-mini
+  hashcli /clear --days 7
+  hashcli /fix my tests are failing
+
+GETTING STARTED:
+  1. Set API key: export OPENAI_API_KEY="your-key"
+  2. Try: hashcli hello world
+  3. Or: hashcli /help model
+
+For command-specific help: /help <command>"""
+
+        return help_text
+
+    def _show_command_help(self, command_name: str) -> str:
+        """Show help for a specific command."""
+        # Import here to avoid circular imports
+        from ..command_proxy import CommandProxy
+        from ..config import HashConfig
+
+        # Create a temporary config to access command registry
+        temp_config = HashConfig()
+        proxy = CommandProxy(temp_config)
+
+        # Get help for the specific command
+        command_help = proxy.get_command_help(command_name)
+
+        if command_help:
+            return f"Help for /{command_name}:\\n\\n{command_help}"
+        else:
+            available_commands = ", ".join(proxy.get_available_commands())
+            return f"Unknown command: /{command_name}\\n\\nAvailable commands: {available_commands}\\n\\nUse '/help' for full help."
+
+    def get_help(self) -> str:
+        """Get help text for the help command."""
+        return """Show help information:
+  /help                    - Show general help and all commands
+  /help <command>          - Show help for specific command
+  
+Examples:
+  /help                    - Show this help
+  /help model              - Show help for model command
+  /help ls                 - Show help for ls command"""