nc1709 1.15.4__py3-none-any.whl

nc1709/file_controller.py

@@ -0,0 +1,354 @@
+"""
+Filesystem Controller with Safety Features
+Handles all file operations with automatic backups and atomic transactions
+"""
+import os
+import shutil
+import hashlib
+import difflib
+from pathlib import Path
+from typing import List, Optional, Tuple
+from datetime import datetime
+
+from .config import get_config
+
+
+class FileController:
+    """Manages safe filesystem operations"""
+
+    def __init__(self):
+        """Initialize the file controller"""
+        self.config = get_config()
+        # Get backup directory from config, with fallback to default
+        backup_path = self.config.get("safety.backup_dir", "~/.nc1709/backups")
+        self.backup_dir = Path(backup_path).expanduser().resolve()
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+    
+    def read_file(self, file_path: str) -> str:
+        """Read a file safely
+        
+        Args:
+            file_path: Path to the file
+        
+        Returns:
+            File contents as string
+        
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            PermissionError: If file can't be read
+        """
+        path = Path(file_path).expanduser().resolve()
+        
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        if not path.is_file():
+            raise ValueError(f"Not a file: {file_path}")
+        
+        try:
+            with open(path, 'r', encoding='utf-8') as f:
+                return f.read()
+        except UnicodeDecodeError:
+            # Try reading as binary if UTF-8 fails
+            with open(path, 'rb') as f:
+                return f.read().decode('utf-8', errors='replace')
+    
+    def write_file(
+        self,
+        file_path: str,
+        content: str,
+        create_backup: bool = True,
+        confirm: bool = True
+    ) -> bool:
+        """Write content to a file with safety checks
+        
+        Args:
+            file_path: Path to the file
+            content: Content to write
+            create_backup: Whether to create a backup first
+            confirm: Whether to ask for confirmation
+        
+        Returns:
+            True if write was successful
+        
+        Raises:
+            PermissionError: If file can't be written
+        """
+        path = Path(file_path).expanduser().resolve()
+        
+        # Check if we should confirm
+        if confirm and self.config.get("safety.confirm_writes", True):
+            if path.exists():
+                print(f"\n⚠️  File exists: {path}")
+                print("This will overwrite the existing file.")
+                response = input("Continue? [y/N]: ").strip().lower()
+                if response != 'y':
+                    print("Write cancelled.")
+                    return False
+        
+        # Create backup if file exists
+        if create_backup and path.exists() and self.config.get("safety.auto_backup", True):
+            self._create_backup(path)
+        
+        # Ensure parent directory exists
+        path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write the file
+        try:
+            with open(path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            print(f"✅ File written: {path}")
+            return True
+        except Exception as e:
+            print(f"❌ Failed to write file: {e}")
+            return False
+    
+    def edit_file(
+        self,
+        file_path: str,
+        old_content: str,
+        new_content: str,
+        create_backup: bool = True
+    ) -> bool:
+        """Edit a file by replacing old content with new content
+        
+        Args:
+            file_path: Path to the file
+            old_content: Content to replace
+            new_content: New content
+            create_backup: Whether to create a backup first
+        
+        Returns:
+            True if edit was successful
+        """
+        path = Path(file_path).expanduser().resolve()
+        
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        # Read current content
+        current_content = self.read_file(file_path)
+        
+        # Check if old_content exists in file
+        if old_content not in current_content:
+            print(f"⚠️  Content to replace not found in {file_path}")
+            return False
+        
+        # Create backup
+        if create_backup and self.config.get("safety.auto_backup", True):
+            self._create_backup(path)
+        
+        # Replace content
+        updated_content = current_content.replace(old_content, new_content, 1)
+        
+        # Show diff
+        self._show_diff(current_content, updated_content, str(path))
+        
+        # Confirm
+        if self.config.get("safety.confirm_writes", True):
+            response = input("\nApply these changes? [y/N]: ").strip().lower()
+            if response != 'y':
+                print("Edit cancelled.")
+                return False
+        
+        # Write updated content
+        return self.write_file(file_path, updated_content, create_backup=False, confirm=False)
+    
+    def create_file(self, file_path: str, content: str = "") -> bool:
+        """Create a new file
+        
+        Args:
+            file_path: Path to the file
+            content: Initial content (default: empty)
+        
+        Returns:
+            True if creation was successful
+        """
+        path = Path(file_path).expanduser().resolve()
+        
+        if path.exists():
+            print(f"⚠️  File already exists: {file_path}")
+            return False
+        
+        return self.write_file(file_path, content, create_backup=False, confirm=False)
+    
+    def delete_file(self, file_path: str, confirm: bool = True) -> bool:
+        """Delete a file with confirmation
+        
+        Args:
+            file_path: Path to the file
+            confirm: Whether to ask for confirmation
+        
+        Returns:
+            True if deletion was successful
+        """
+        path = Path(file_path).expanduser().resolve()
+        
+        if not path.exists():
+            print(f"⚠️  File not found: {file_path}")
+            return False
+        
+        # Create backup before deleting
+        if self.config.get("safety.auto_backup", True):
+            self._create_backup(path)
+        
+        # Confirm deletion
+        if confirm and self.config.get("safety.confirm_destructive", True):
+            print(f"\n⚠️  About to delete: {path}")
+            response = input("Are you sure? [y/N]: ").strip().lower()
+            if response != 'y':
+                print("Deletion cancelled.")
+                return False
+        
+        try:
+            path.unlink()
+            print(f"✅ File deleted: {path}")
+            return True
+        except Exception as e:
+            print(f"❌ Failed to delete file: {e}")
+            return False
+    
+    def list_files(self, directory: str, pattern: str = "*") -> List[str]:
+        """List files in a directory
+        
+        Args:
+            directory: Directory path
+            pattern: Glob pattern (default: all files)
+        
+        Returns:
+            List of file paths
+        """
+        path = Path(directory).expanduser().resolve()
+        
+        if not path.exists():
+            raise FileNotFoundError(f"Directory not found: {directory}")
+        
+        if not path.is_dir():
+            raise ValueError(f"Not a directory: {directory}")
+        
+        return [str(p) for p in path.glob(pattern) if p.is_file()]
+    
+    def get_file_info(self, file_path: str) -> dict:
+        """Get information about a file
+        
+        Args:
+            file_path: Path to the file
+        
+        Returns:
+            Dictionary with file information
+        """
+        path = Path(file_path).expanduser().resolve()
+        
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        stat = path.stat()
+        
+        return {
+            "path": str(path),
+            "name": path.name,
+            "size": stat.st_size,
+            "modified": datetime.fromtimestamp(stat.st_mtime).isoformat(),
+            "is_file": path.is_file(),
+            "is_dir": path.is_dir(),
+            "extension": path.suffix
+        }
+    
+    def _create_backup(self, file_path: Path) -> Path:
+        """Create a backup of a file
+        
+        Args:
+            file_path: Path to the file
+        
+        Returns:
+            Path to the backup file
+        """
+        # Generate backup filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        file_hash = hashlib.md5(str(file_path).encode()).hexdigest()[:8]
+        backup_name = f"{file_path.name}.{timestamp}.{file_hash}.backup"
+        backup_path = self.backup_dir / backup_name
+        
+        # Copy file to backup
+        shutil.copy2(file_path, backup_path)
+        
+        return backup_path
+    
+    def _show_diff(self, old_content: str, new_content: str, filename: str) -> None:
+        """Show a diff between old and new content
+        
+        Args:
+            old_content: Original content
+            new_content: New content
+            filename: Name of the file (for display)
+        """
+        old_lines = old_content.splitlines(keepends=True)
+        new_lines = new_content.splitlines(keepends=True)
+        
+        diff = difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile=f"{filename} (original)",
+            tofile=f"{filename} (modified)",
+            lineterm=''
+        )
+        
+        print("\n" + "="*60)
+        print("PROPOSED CHANGES:")
+        print("="*60)
+        for line in diff:
+            if line.startswith('+') and not line.startswith('+++'):
+                print(f"\033[92m{line}\033[0m", end='')  # Green for additions
+            elif line.startswith('-') and not line.startswith('---'):
+                print(f"\033[91m{line}\033[0m", end='')  # Red for deletions
+            else:
+                print(line, end='')
+        print("="*60)
+    
+    def restore_from_backup(self, backup_path: str, target_path: Optional[str] = None) -> bool:
+        """Restore a file from backup
+        
+        Args:
+            backup_path: Path to the backup file
+            target_path: Target path (default: original location)
+        
+        Returns:
+            True if restore was successful
+        """
+        backup = Path(backup_path)
+        
+        if not backup.exists():
+            print(f"⚠️  Backup not found: {backup_path}")
+            return False
+        
+        if target_path is None:
+            # Extract original filename from backup name
+            original_name = backup.name.split('.')[0]
+            target_path = Path.cwd() / original_name
+        else:
+            target_path = Path(target_path)
+        
+        try:
+            shutil.copy2(backup, target_path)
+            print(f"✅ File restored from backup: {target_path}")
+            return True
+        except Exception as e:
+            print(f"❌ Failed to restore from backup: {e}")
+            return False
+    
+    def list_backups(self) -> List[Tuple[str, datetime]]:
+        """List all available backups
+        
+        Returns:
+            List of (backup_path, timestamp) tuples
+        """
+        backups = []
+        for backup_file in self.backup_dir.glob("*.backup"):
+            stat = backup_file.stat()
+            timestamp = datetime.fromtimestamp(stat.st_mtime)
+            backups.append((str(backup_file), timestamp))
+        
+        # Sort by timestamp (newest first)
+        backups.sort(key=lambda x: x[1], reverse=True)
+        
+        return backups

nc1709/git_integration.py

@@ -0,0 +1,308 @@
+"""
+Git Integration for NC1709
+
+Provides automatic git commits and git-related utilities.
+Similar to Aider's git integration.
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class GitStatus:
+    """Status of a git repository"""
+    is_repo: bool
+    branch: str
+    has_changes: bool
+    staged_files: List[str]
+    modified_files: List[str]
+    untracked_files: List[str]
+
+
+class GitIntegration:
+    """
+    Git integration for automatic commits and git operations.
+
+    Features:
+    - Automatic commits after file changes
+    - Smart commit message generation
+    - Git status and diff display
+    """
+
+    def __init__(self, repo_path: Optional[str] = None, auto_commit: bool = True):
+        """
+        Initialize git integration.
+
+        Args:
+            repo_path: Path to git repository (defaults to cwd)
+            auto_commit: Whether to auto-commit changes
+        """
+        self.repo_path = Path(repo_path) if repo_path else Path.cwd()
+        self.auto_commit = auto_commit
+        self._is_repo = self._check_git_repo()
+
+    def _check_git_repo(self) -> bool:
+        """Check if current directory is a git repository"""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                cwd=str(self.repo_path),
+                capture_output=True,
+                text=True
+            )
+            return result.returncode == 0
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+
+    @property
+    def is_repo(self) -> bool:
+        """Check if we're in a git repository"""
+        return self._is_repo
+
+    def _run_git(self, *args, check: bool = True) -> subprocess.CompletedProcess:
+        """Run a git command"""
+        return subprocess.run(
+            ["git"] + list(args),
+            cwd=str(self.repo_path),
+            capture_output=True,
+            text=True,
+            check=check
+        )
+
+    def get_status(self) -> GitStatus:
+        """Get current git status"""
+        if not self._is_repo:
+            return GitStatus(
+                is_repo=False,
+                branch="",
+                has_changes=False,
+                staged_files=[],
+                modified_files=[],
+                untracked_files=[]
+            )
+
+        # Get branch name
+        try:
+            result = self._run_git("branch", "--show-current")
+            branch = result.stdout.strip()
+        except subprocess.CalledProcessError:
+            branch = "unknown"
+
+        # Get status --porcelain
+        result = self._run_git("status", "--porcelain", check=False)
+        lines = result.stdout.strip().split("\n") if result.stdout.strip() else []
+
+        staged_files = []
+        modified_files = []
+        untracked_files = []
+
+        for line in lines:
+            if len(line) < 3:
+                continue
+            index_status = line[0]
+            worktree_status = line[1]
+            filename = line[3:]
+
+            if index_status in "MADRC":
+                staged_files.append(filename)
+            if worktree_status == "M":
+                modified_files.append(filename)
+            if index_status == "?" and worktree_status == "?":
+                untracked_files.append(filename)
+
+        return GitStatus(
+            is_repo=True,
+            branch=branch,
+            has_changes=bool(staged_files or modified_files or untracked_files),
+            staged_files=staged_files,
+            modified_files=modified_files,
+            untracked_files=untracked_files
+        )
+
+    def get_diff(self, staged: bool = False) -> str:
+        """Get git diff"""
+        if not self._is_repo:
+            return ""
+
+        args = ["diff"]
+        if staged:
+            args.append("--staged")
+
+        result = self._run_git(*args, check=False)
+        return result.stdout
+
+    def stage_file(self, file_path: str) -> bool:
+        """Stage a file for commit"""
+        if not self._is_repo:
+            return False
+
+        try:
+            self._run_git("add", file_path)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def stage_all(self) -> bool:
+        """Stage all changes"""
+        if not self._is_repo:
+            return False
+
+        try:
+            self._run_git("add", "-A")
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def commit(self, message: str, files: Optional[List[str]] = None) -> bool:
+        """
+        Create a commit.
+
+        Args:
+            message: Commit message
+            files: Specific files to commit (stages them first)
+
+        Returns:
+            True if commit was successful
+        """
+        if not self._is_repo:
+            return False
+
+        try:
+            # Stage specific files if provided
+            if files:
+                for f in files:
+                    self.stage_file(f)
+
+            # Check if there's anything to commit
+            status = self.get_status()
+            if not status.staged_files:
+                return False
+
+            # Create commit
+            self._run_git("commit", "-m", message)
+            return True
+
+        except subprocess.CalledProcessError:
+            return False
+
+    def auto_commit_files(
+        self,
+        files: List[str],
+        tool_name: str = "NC1709",
+        description: str = ""
+    ) -> Optional[str]:
+        """
+        Automatically commit changed files with a generated message.
+
+        Args:
+            files: List of file paths that were modified
+            tool_name: Name of the tool that made the change
+            description: Optional description of what changed
+
+        Returns:
+            Commit hash if successful, None otherwise
+        """
+        if not self._is_repo or not self.auto_commit:
+            return None
+
+        # Filter to files that actually have changes
+        changed_files = []
+        for f in files:
+            result = self._run_git("status", "--porcelain", f, check=False)
+            if result.stdout.strip():
+                changed_files.append(f)
+
+        if not changed_files:
+            return None
+
+        # Generate commit message
+        file_names = [Path(f).name for f in changed_files]
+        if len(file_names) == 1:
+            file_desc = file_names[0]
+        elif len(file_names) <= 3:
+            file_desc = ", ".join(file_names)
+        else:
+            file_desc = f"{file_names[0]} and {len(file_names) - 1} other files"
+
+        if description:
+            message = f"{description}\n\nModified: {file_desc}\n\n[{tool_name}]"
+        else:
+            message = f"Update {file_desc}\n\n[{tool_name}]"
+
+        # Stage and commit
+        for f in changed_files:
+            self.stage_file(f)
+
+        try:
+            self._run_git("commit", "-m", message)
+
+            # Get the commit hash
+            result = self._run_git("rev-parse", "--short", "HEAD")
+            return result.stdout.strip()
+
+        except subprocess.CalledProcessError:
+            return None
+
+    def get_recent_commits(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get recent commit history"""
+        if not self._is_repo:
+            return []
+
+        try:
+            result = self._run_git(
+                "log",
+                f"-{limit}",
+                "--pretty=format:%h|%s|%an|%ar",
+                check=False
+            )
+
+            commits = []
+            for line in result.stdout.strip().split("\n"):
+                if "|" in line:
+                    parts = line.split("|", 3)
+                    if len(parts) >= 4:
+                        commits.append({
+                            "hash": parts[0],
+                            "message": parts[1],
+                            "author": parts[2],
+                            "time_ago": parts[3]
+                        })
+
+            return commits
+
+        except subprocess.CalledProcessError:
+            return []
+
+    def init_repo(self) -> bool:
+        """Initialize a new git repository"""
+        try:
+            self._run_git("init")
+            self._is_repo = True
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+
+# Global git integration instance
+_git_integration: Optional[GitIntegration] = None
+
+
+def get_git_integration(auto_commit: bool = True) -> GitIntegration:
+    """Get or create the global git integration"""
+    global _git_integration
+    if _git_integration is None:
+        _git_integration = GitIntegration(auto_commit=auto_commit)
+    return _git_integration
+
+
+def auto_commit_after_edit(file_path: str, tool_name: str = "Edit") -> Optional[str]:
+    """Convenience function to auto-commit after editing a file"""
+    git = get_git_integration()
+    if git.is_repo and git.auto_commit:
+        return git.auto_commit_files([file_path], tool_name=tool_name)
+    return None