nc1709 1.15.4__py3-none-any.whl

nc1709/custom_commands.py

@@ -0,0 +1,300 @@
+"""
+Custom Slash Commands for NC1709
+
+Allows users to define their own slash commands in:
+- ~/.nc1709/commands/ (personal commands)
+- .nc1709/commands/ (project commands)
+
+Similar to Claude Code's custom command system.
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass
+
+
+@dataclass
+class CustomCommand:
+    """A user-defined custom command"""
+    name: str           # Command name (without /)
+    content: str        # Command content/prompt
+    description: str    # Optional description (first line of file)
+    file_path: Path     # Path to the command file
+    scope: str          # "personal" or "project"
+
+
+class CustomCommandManager:
+    """
+    Manages custom slash commands defined in markdown files.
+
+    Commands are loaded from:
+    - ~/.nc1709/commands/*.md (personal commands, available everywhere)
+    - .nc1709/commands/*.md (project commands, available in current project)
+
+    The filename becomes the command name (e.g., fix-bug.md -> /project:fix-bug)
+    The first line starting with # is used as the description.
+    The rest is the command content/prompt.
+    """
+
+    def __init__(self, project_path: Optional[str] = None):
+        """
+        Initialize the custom command manager.
+
+        Args:
+            project_path: Path to current project (defaults to cwd)
+        """
+        self.project_path = Path(project_path) if project_path else Path.cwd()
+        self.personal_dir = Path.home() / ".nc1709" / "commands"
+        self.project_dir = self.project_path / ".nc1709" / "commands"
+
+        # Ensure personal commands directory exists
+        self.personal_dir.mkdir(parents=True, exist_ok=True)
+
+        # Cache loaded commands
+        self._commands: Dict[str, CustomCommand] = {}
+        self._loaded = False
+
+    def _load_commands(self) -> None:
+        """Load all custom commands from disk"""
+        self._commands = {}
+
+        # Load personal commands
+        if self.personal_dir.exists():
+            for file_path in self.personal_dir.glob("*.md"):
+                cmd = self._load_command_file(file_path, scope="personal")
+                if cmd:
+                    self._commands[cmd.name] = cmd
+
+        # Load project commands (override personal if same name)
+        if self.project_dir.exists():
+            for file_path in self.project_dir.glob("*.md"):
+                cmd = self._load_command_file(file_path, scope="project")
+                if cmd:
+                    # Use project: prefix to avoid collisions
+                    self._commands[f"project:{cmd.name}"] = cmd
+
+        self._loaded = True
+
+    def _load_command_file(self, file_path: Path, scope: str) -> Optional[CustomCommand]:
+        """Load a single command file"""
+        try:
+            content = file_path.read_text(encoding='utf-8')
+            lines = content.strip().split('\n')
+
+            # Extract description from first heading line
+            description = ""
+            content_start = 0
+
+            for i, line in enumerate(lines):
+                if line.startswith('#'):
+                    # Extract text after # (the description)
+                    description = line.lstrip('#').strip()
+                    content_start = i + 1
+                    break
+                elif line.strip():
+                    # First non-empty, non-heading line - no description
+                    break
+
+            # Command name is filename without extension
+            name = file_path.stem
+
+            # Content is everything after the description
+            command_content = '\n'.join(lines[content_start:]).strip()
+
+            return CustomCommand(
+                name=name,
+                content=command_content,
+                description=description or f"Custom command: {name}",
+                file_path=file_path,
+                scope=scope
+            )
+
+        except Exception:
+            return None
+
+    def reload(self) -> None:
+        """Force reload all commands"""
+        self._loaded = False
+        self._load_commands()
+
+    def get_command(self, name: str) -> Optional[CustomCommand]:
+        """
+        Get a custom command by name.
+
+        Args:
+            name: Command name (with or without /)
+
+        Returns:
+            CustomCommand if found, None otherwise
+        """
+        if not self._loaded:
+            self._load_commands()
+
+        # Remove leading / if present
+        if name.startswith('/'):
+            name = name[1:]
+
+        return self._commands.get(name)
+
+    def list_commands(self) -> List[CustomCommand]:
+        """Get all available custom commands"""
+        if not self._loaded:
+            self._load_commands()
+
+        return list(self._commands.values())
+
+    def get_commands_for_autocomplete(self) -> List[Dict[str, str]]:
+        """Get commands formatted for autocomplete"""
+        if not self._loaded:
+            self._load_commands()
+
+        return [
+            {
+                "name": cmd.name,
+                "description": cmd.description,
+                "scope": cmd.scope
+            }
+            for cmd in self._commands.values()
+        ]
+
+    def create_command(
+        self,
+        name: str,
+        content: str,
+        description: str = "",
+        scope: str = "personal"
+    ) -> CustomCommand:
+        """
+        Create a new custom command.
+
+        Args:
+            name: Command name (without /)
+            content: Command content/prompt
+            description: Optional description
+            scope: "personal" or "project"
+
+        Returns:
+            The created CustomCommand
+        """
+        # Determine target directory
+        if scope == "project":
+            target_dir = self.project_dir
+        else:
+            target_dir = self.personal_dir
+
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create the file content
+        file_content = ""
+        if description:
+            file_content = f"# {description}\n\n"
+        file_content += content
+
+        # Write the file
+        file_path = target_dir / f"{name}.md"
+        file_path.write_text(file_content, encoding='utf-8')
+
+        # Create and cache the command
+        cmd = CustomCommand(
+            name=name if scope == "personal" else f"project:{name}",
+            content=content,
+            description=description or f"Custom command: {name}",
+            file_path=file_path,
+            scope=scope
+        )
+
+        self._commands[cmd.name] = cmd
+        return cmd
+
+    def delete_command(self, name: str) -> bool:
+        """
+        Delete a custom command.
+
+        Args:
+            name: Command name
+
+        Returns:
+            True if deleted, False if not found
+        """
+        cmd = self.get_command(name)
+        if cmd and cmd.file_path.exists():
+            cmd.file_path.unlink()
+            del self._commands[cmd.name]
+            return True
+        return False
+
+    def get_example_commands(self) -> str:
+        """Get example custom commands for users"""
+        return """# Example Custom Commands
+
+Create markdown files in ~/.nc1709/commands/ or .nc1709/commands/
+
+## Example: fix-bug.md
+
+```markdown
+# Fix a bug in the codebase
+
+Look at the error message or description provided.
+Find the relevant code files.
+Analyze the root cause.
+Propose and implement a fix.
+Test that the fix works.
+```
+
+## Example: add-tests.md
+
+```markdown
+# Add unit tests for a file
+
+Read the specified file.
+Identify all public functions and classes.
+Generate comprehensive unit tests.
+Include edge cases and error handling tests.
+Write tests to a corresponding test file.
+```
+
+## Example: review-pr.md
+
+```markdown
+# Review a pull request
+
+Check the diff for:
+- Code style and best practices
+- Potential bugs or edge cases
+- Security vulnerabilities
+- Performance issues
+- Missing tests
+
+Provide actionable feedback.
+```
+"""
+
+
+# Global custom command manager
+_custom_command_manager: Optional[CustomCommandManager] = None
+
+
+def get_custom_command_manager() -> CustomCommandManager:
+    """Get or create the global custom command manager"""
+    global _custom_command_manager
+    if _custom_command_manager is None:
+        _custom_command_manager = CustomCommandManager()
+    return _custom_command_manager
+
+
+def execute_custom_command(name: str) -> Optional[str]:
+    """
+    Get the prompt content for a custom command.
+
+    Args:
+        name: Command name
+
+    Returns:
+        Command prompt content if found, None otherwise
+    """
+    manager = get_custom_command_manager()
+    cmd = manager.get_command(name)
+    if cmd:
+        return cmd.content
+    return None

nc1709/executor.py

@@ -0,0 +1,333 @@
+"""
+Execution Sandbox for Safe Command Execution
+Validates and executes shell commands with safety checks
+"""
+import subprocess
+import shlex
+import os
+from typing import Tuple, List, Optional
+from pathlib import Path
+
+from .config import get_config
+
+
+class CommandExecutor:
+    """Executes shell commands with safety validation"""
+    
+    def __init__(self):
+        """Initialize the command executor"""
+        self.config = get_config()
+        self.execution_log: List[dict] = []
+    
+    def execute(
+        self,
+        command: str,
+        cwd: Optional[str] = None,
+        timeout: Optional[int] = None,
+        confirm: bool = True
+    ) -> Tuple[int, str, str]:
+        """Execute a shell command with safety checks
+        
+        Args:
+            command: Command to execute
+            cwd: Working directory (default: current directory)
+            timeout: Timeout in seconds (default: from config)
+            confirm: Whether to ask for confirmation
+        
+        Returns:
+            Tuple of (return_code, stdout, stderr)
+        
+        Raises:
+            ValueError: If command is not allowed
+            subprocess.TimeoutExpired: If command times out
+        """
+        # Validate command
+        if not self._is_command_allowed(command):
+            raise ValueError(f"Command not allowed: {command}")
+        
+        # Check for destructive operations
+        if self._is_destructive(command):
+            if not self._confirm_destructive(command):
+                return (-1, "", "Command cancelled by user")
+        
+        # Confirm execution if required
+        if confirm and self.config.get("safety.confirm_commands", True):
+            print(f"\n💻 About to execute: {command}")
+            if cwd:
+                print(f"   Working directory: {cwd}")
+            response = input("Execute this command? [y/N]: ").strip().lower()
+            if response != 'y':
+                print("Execution cancelled.")
+                return (-1, "", "Command cancelled by user")
+        
+        # Set timeout
+        if timeout is None:
+            timeout = self.config.get("execution.command_timeout", 60)
+        
+        # Set working directory
+        if cwd is None:
+            cwd = os.getcwd()
+        
+        # Execute command
+        try:
+            print(f"\n🔄 Executing: {command}")
+            
+            result = subprocess.run(
+                command,
+                shell=True,
+                cwd=cwd,
+                timeout=timeout,
+                capture_output=True,
+                text=True
+            )
+            
+            # Log execution
+            self._log_execution(command, cwd, result.returncode, result.stdout, result.stderr)
+            
+            # Print output
+            if result.stdout:
+                print("\n📤 Output:")
+                print(result.stdout)
+            
+            if result.stderr:
+                print("\n⚠️  Errors/Warnings:")
+                print(result.stderr)
+            
+            if result.returncode == 0:
+                print("✅ Command completed successfully")
+            else:
+                print(f"❌ Command failed with exit code {result.returncode}")
+            
+            return (result.returncode, result.stdout, result.stderr)
+        
+        except subprocess.TimeoutExpired:
+            error_msg = f"Command timed out after {timeout} seconds"
+            print(f"\n⏱️  {error_msg}")
+            self._log_execution(command, cwd, -1, "", error_msg)
+            return (-1, "", error_msg)
+        
+        except Exception as e:
+            error_msg = f"Execution error: {str(e)}"
+            print(f"\n❌ {error_msg}")
+            self._log_execution(command, cwd, -1, "", error_msg)
+            return (-1, "", error_msg)
+    
+    def execute_multiple(
+        self,
+        commands: List[str],
+        cwd: Optional[str] = None,
+        stop_on_error: bool = True
+    ) -> List[Tuple[int, str, str]]:
+        """Execute multiple commands in sequence
+        
+        Args:
+            commands: List of commands to execute
+            cwd: Working directory
+            stop_on_error: Whether to stop if a command fails
+        
+        Returns:
+            List of (return_code, stdout, stderr) tuples
+        """
+        results = []
+        
+        for i, command in enumerate(commands, 1):
+            print(f"\n{'='*60}")
+            print(f"Command {i}/{len(commands)}")
+            print(f"{'='*60}")
+            
+            result = self.execute(command, cwd=cwd, confirm=False)
+            results.append(result)
+            
+            # Stop on error if requested
+            if stop_on_error and result[0] != 0:
+                print(f"\n⚠️  Stopping execution due to error in command {i}")
+                break
+        
+        return results
+    
+    def _is_command_allowed(self, command: str) -> bool:
+        """Check if a command is allowed
+
+        Args:
+            command: Command to check
+
+        Returns:
+            True if command is allowed
+        """
+        # Parse command to get the base command
+        try:
+            parts = shlex.split(command)
+            if not parts:
+                return False
+            base_command = parts[0]
+        except ValueError:
+            # If parsing fails, be conservative and reject
+            print("⛔ Command parsing failed - rejecting for safety")
+            return False
+
+        # Normalize the command for security checks
+        normalized_cmd = command.lower().replace("\\", "")
+
+        # Check against blocked commands with improved pattern matching
+        blocked = self.config.get("execution.blocked_commands", [])
+        for blocked_cmd in blocked:
+            blocked_lower = blocked_cmd.lower()
+            # Check for exact match or as part of a command chain
+            if (blocked_lower in normalized_cmd or
+                normalized_cmd.startswith(blocked_lower) or
+                f"; {blocked_lower}" in normalized_cmd or
+                f"&& {blocked_lower}" in normalized_cmd or
+                f"| {blocked_lower}" in normalized_cmd or
+                f"|| {blocked_lower}" in normalized_cmd):
+                print(f"⛔ Blocked command detected: {blocked_cmd}")
+                return False
+
+        # Check for shell injection patterns
+        dangerous_patterns = [
+            "$(", "`",           # Command substitution
+            "${",               # Variable expansion that could be exploited
+            "; rm", "&& rm",    # Chained destructive commands
+            "| sh", "| bash",   # Piping to shell
+            "> /dev/sd",        # Writing to block devices
+            "eval ", "exec ",   # Dangerous execution primitives
+        ]
+        for pattern in dangerous_patterns:
+            if pattern in command:
+                print(f"⛔ Potentially dangerous pattern detected: {pattern}")
+                return False
+
+        # Check against allowed commands (if whitelist is enabled)
+        allowed = self.config.get("execution.allowed_commands", [])
+        if allowed:
+            # Extract just the command name (without path)
+            cmd_name = os.path.basename(base_command)
+            if cmd_name not in allowed and base_command not in allowed:
+                print(f"⛔ Command not in whitelist: {base_command}")
+                print(f"   Allowed commands: {', '.join(allowed)}")
+                return False
+
+        return True
+    
+    def _is_destructive(self, command: str) -> bool:
+        """Check if a command is potentially destructive
+        
+        Args:
+            command: Command to check
+        
+        Returns:
+            True if command is destructive
+        """
+        destructive_patterns = [
+            "rm ", "rmdir", "del ", "format", "mkfs",
+            "dd ", ">", "truncate", "shred"
+        ]
+        
+        return any(pattern in command for pattern in destructive_patterns)
+    
+    def _confirm_destructive(self, command: str) -> bool:
+        """Ask for confirmation for destructive commands
+        
+        Args:
+            command: Command to confirm
+        
+        Returns:
+            True if user confirms
+        """
+        if not self.config.get("safety.confirm_destructive", True):
+            return True
+        
+        print(f"\n⚠️  WARNING: Potentially destructive command detected!")
+        print(f"   Command: {command}")
+        print(f"   This command may delete or modify data.")
+        response = input("Are you absolutely sure you want to execute this? [yes/NO]: ").strip().lower()
+        
+        return response == "yes"
+    
+    def _log_execution(
+        self,
+        command: str,
+        cwd: str,
+        return_code: int,
+        stdout: str,
+        stderr: str
+    ) -> None:
+        """Log command execution
+        
+        Args:
+            command: Executed command
+            cwd: Working directory
+            return_code: Exit code
+            stdout: Standard output
+            stderr: Standard error
+        """
+        from datetime import datetime
+        
+        log_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "command": command,
+            "cwd": cwd,
+            "return_code": return_code,
+            "stdout_length": len(stdout),
+            "stderr_length": len(stderr),
+            "success": return_code == 0
+        }
+        
+        self.execution_log.append(log_entry)
+        
+        # Keep only last N entries
+        max_log_size = 1000
+        if len(self.execution_log) > max_log_size:
+            self.execution_log = self.execution_log[-max_log_size:]
+    
+    def get_execution_history(self, limit: int = 10) -> List[dict]:
+        """Get recent command execution history
+        
+        Args:
+            limit: Number of recent entries to return
+        
+        Returns:
+            List of execution log entries
+        """
+        return self.execution_log[-limit:]
+    
+    def validate_command(self, command: str) -> Tuple[bool, str]:
+        """Validate a command without executing it
+        
+        Args:
+            command: Command to validate
+        
+        Returns:
+            Tuple of (is_valid, message)
+        """
+        if not command.strip():
+            return (False, "Empty command")
+        
+        if not self._is_command_allowed(command):
+            return (False, "Command not allowed by security policy")
+        
+        if self._is_destructive(command):
+            return (True, "Command is valid but potentially destructive")
+        
+        return (True, "Command is valid")
+    
+    def suggest_safe_alternative(self, command: str) -> Optional[str]:
+        """Suggest a safer alternative for a command
+        
+        Args:
+            command: Original command
+        
+        Returns:
+            Suggested alternative command or None
+        """
+        # Common dangerous patterns and their safer alternatives
+        alternatives = {
+            "rm -rf /": "# This command would delete your entire system! Never run this.",
+            "rm -rf": "rm -ri",  # Interactive mode
+            "dd if=/dev/zero": "# This would wipe data. Use with extreme caution.",
+        }
+        
+        for pattern, alternative in alternatives.items():
+            if pattern in command:
+                return alternative
+        
+        return None