janito 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

janito/change/applier/workspace_dir.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+from typing import Set, List
+import shutil
+from rich.console import Console
+from janito.config import config
+from ..parser import FileChange, ChangeOperation
+
+def verify_changes(changes: List[FileChange]) -> tuple[bool, str]:
+    """Verify changes can be safely applied to workspace_dir.
+    Returns (is_safe, error_message)."""
+    for change in changes:
+        source_path = config.workspace_dir / change.name
+        
+        if change.operation == ChangeOperation.CREATE_FILE:
+            if source_path.exists():
+                return False, f"Cannot create {change.name} - already exists"
+                
+        elif change.operation in (ChangeOperation.MOVE_FILE, ChangeOperation.RENAME_FILE):
+            if not source_path.exists():
+                return False, f"Cannot {change.operation.name.lower()} non-existent file {change.name}"
+            target_path = config.workspace_dir / change.target
+            if target_path.exists():
+                return False, f"Cannot {change.operation.name.lower()} {change.name} to {change.target} - target already exists"
+
+            
+    return True, ""
+
+def apply_changes(changes: List[FileChange], preview_dir: Path, console: Console) -> bool:
+    """Apply all changes from preview to workspace_dir.
+    Returns success status."""
+    is_safe, error = verify_changes(changes)
+    if not is_safe:
+        console.print(f"[red]Error: {error}[/red]")
+        return False
+
+    console.print("\n[blue]Applying changes to working directory...[/blue]")
+
+    for change in changes:
+        if change.operation == ChangeOperation.REMOVE_FILE:
+            remove_from_workspace_dir(change.name, console)
+        else:
+            filepath = change.target if change.operation == ChangeOperation.RENAME_FILE else change.name
+            target_path = config.workspace_dir / filepath
+            preview_path = preview_dir / filepath
+
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+            if preview_path.exists():
+                shutil.copy2(preview_path, target_path)
+                console.print(f"[dim]Applied changes to {filepath}[/dim]")
+
+    return True
+
+def remove_from_workspace_dir(filepath: Path, console: Console) -> None:
+    """Remove file from working directory"""
+    target_path = config.workspace_dir / filepath
+    if target_path.exists():
+        target_path.unlink()
+        console.print(f"[red]Removed {filepath}[/red]")

janito/change/core.py

@@ -0,0 +1,131 @@
+from pathlib import Path
+from typing import Optional, Tuple, Optional, List
+from rich.console import Console
+from rich.prompt import Confirm
+from rich.panel import Panel
+from rich.columns import Columns
+from rich import box
+
+from janito.common import progress_send_message
+from janito.change.history import save_changes_to_history
+from janito.config import config
+from janito.workspace.scan import collect_files_content
+from .viewer import preview_all_changes
+from janito.workspace.analysis import analyze_workspace_content as show_content_stats
+
+from . import (
+    build_change_request_prompt,
+    parse_response,
+    setup_workspace_dir_preview,
+    ChangeApplier
+)
+
+from .analysis import analyze_request
+
+def process_change_request(
+    request: str,
+    preview_only: bool = False,
+    debug: bool = False
+    ) -> Tuple[bool, Optional[Path]]:
+    """
+    Process a change request through the main flow.
+    Return:
+        success: True if the request was processed successfully
+        history_file: Path to the saved history file
+    """
+    console = Console()
+    paths_to_scan = config.include if config.include else [config.workspace_dir]
+
+    content_xml = collect_files_content(paths_to_scan)
+
+    # Show workspace content preview
+    show_content_stats(content_xml)
+
+    analysis = analyze_request(request, content_xml)
+    if not analysis:
+        console.print("[red]Analysis failed or interrupted[/red]")
+        return False, None
+
+    prompt = build_change_request_prompt(request, analysis.format_option_text(), content_xml)
+    response = progress_send_message(prompt)
+    if not response:
+        console.print("[red]Failed to get response from AI[/red]")
+        return False, None
+
+    history_file = save_changes_to_history(response, request)
+
+    # Parse changes
+    changes = parse_response(response)
+    if not changes:
+        console.print("[yellow]No changes found in response[/yellow]")
+        return False, None
+
+    # Extract response info after END_OF_INSTRUCTIONS
+    response_info = extract_response_info(response)
+
+    # Show request and response info in panels
+    request_panel = Panel(
+        request,
+        title="User Request",
+        border_style="cyan",
+        box=box.ROUNDED
+    )
+    response_panel = Panel(
+        response_info if response_info else "No additional information provided",
+        title="Response Information",
+        border_style="green",
+        box=box.ROUNDED
+    )
+
+    # Display panels side by side
+    columns = Columns([request_panel, response_panel], equal=True, expand=True)
+    console.print("\n")
+    console.print(columns)
+    console.print("\n")
+
+    if preview_only:
+        preview_all_changes(console, changes)
+        return True, history_file
+
+    # Create preview directory and apply changes
+    _, preview_dir = setup_workspace_dir_preview()
+    applier = ChangeApplier(preview_dir, debug=debug)
+
+    success, _ = applier.apply_changes(changes)
+    if success:
+        preview_all_changes(console, changes)
+
+        if not config.auto_apply:
+            apply_changes = Confirm.ask("[cyan]Apply changes to working dir?[/cyan]")
+        else:
+            apply_changes = True
+            console.print("[cyan]Auto-applying changes to working dir...[/cyan]")
+
+        if apply_changes:
+            applier.apply_to_workspace_dir(changes)
+            console.print("[green]Changes applied successfully[/green]")
+        else:
+            console.print("[yellow]Changes were not applied[/yellow]")
+
+    return success, history_file
+
+
+def extract_response_info(response: str) -> str:
+    """Extract information after END_OF_INSTRUCTIONS marker"""
+    if not response:
+        return ""
+
+    # Find the marker
+    marker = "END_INSTRUCTIONS"
+    marker_pos = response.find(marker)
+
+    if marker_pos == -1:
+        return ""
+
+    # Get text after marker, skipping the marker itself
+    info = response[marker_pos + len(marker):].strip()
+
+    # Remove any XML-style tags
+    info = info.replace("<Extra info about what was implemented/changed goes here>", "")
+
+    return info.strip()

janito/{changehistory.py → change/history.py}

@@ -1,20 +1,23 @@
 from pathlib import Path
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Tuple
+from janito.config import config
 
 # Set fixed timestamp when module is loaded
 APP_TIMESTAMP = datetime.now().strftime("%Y%m%d_%H%M%S")
 
-def get_history_path(workdir: Path) -> Path:
+def get_history_path() -> Path:
     """Create and return the history directory path"""
-    history_dir = workdir / '.janito' / 'change_history'
+    history_dir = config.workspace_dir / '.janito' / 'change_history'
     history_dir.mkdir(parents=True, exist_ok=True)
     return history_dir
 
 def determine_history_file_type(filepath: Path) -> str:
     """Determine the type of saved file based on its name"""
     name = filepath.name.lower()
-    if 'changes' in name:
+    if '_changes_failed' in name:
+        return 'changes_failed'
+    elif 'changes' in name:
         return 'changes'
     elif 'selected' in name:
         return 'selected'
@@ -24,13 +27,13 @@ def determine_history_file_type(filepath: Path) -> str:
         return 'response'
     return 'unknown'
 
-def save_changes_to_history(content: str, request: str, workdir: Path) -> Path:
+def save_changes_to_history(content: str, request: str) -> Path:
     """Save change content to history folder with timestamp and request info"""
-    history_dir = get_history_path(workdir)
+    history_dir = get_history_path()
     
     # Create history entry with request and changes
-    history_file = history_dir / f"changes_{APP_TIMESTAMP}.txt"
-    
+    filename = f"{APP_TIMESTAMP}_changes.txt"
+    history_file = history_dir / filename
     history_content = f"""Request: {request}
 Timestamp: {APP_TIMESTAMP}
 
@@ -38,9 +41,4 @@ Changes:
 {content}
 """
     history_file.write_text(history_content)
-    return history_file
-
-def get_history_file_path(workdir: Path) -> Path:
-    """Get path for a history file with app timestamp"""
-    history_path = get_history_path(workdir)
-    return history_path / f"{APP_TIMESTAMP}_changes.txt"
+    return history_file

janito/change/operations.py

@@ -0,0 +1,7 @@
+from enum import Enum, auto
+
+class TextOperation(Enum):
+    """Supported text modification operations"""
+    REPLACE = auto()
+    APPEND = auto()
+    DELETE = auto()

janito/change/parser.py

@@ -0,0 +1,289 @@
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+from rich.console import Console
+from janito.config import config
+from janito.clear_statement_parser.parser import Statement, StatementParser
+
+console = Console(stderr=True)
+
+from .prompts import CHANGE_REQUEST_PROMPT
+
+
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Dict, Union
+from rich.console import Console
+from enum import Enum, auto
+
+class ChangeOperation(Enum):
+    CREATE_FILE = auto()
+    REPLACE_FILE = auto()
+    RENAME_FILE = auto()
+    REMOVE_FILE = auto()
+    MODIFY_FILE = auto()
+    MOVE_FILE = auto()
+
+@dataclass
+class TextChange:
+    """Represents a search and replace/delete operation"""
+    search_content: Optional[str] = None
+    replace_content: Optional[str] = None
+    reason: Optional[str] = None
+    operation: Optional[str] = None
+
+    @property
+    def is_append(self) -> bool:
+        return self.operation == 'Append'
+
+    @property
+    def is_delete(self) -> bool:
+        return self.operation == 'Delete' or (self.search_content and not self.replace_content)
+    
+    def validate(self) -> bool:
+        """Validate the text change operation"""
+        if not self.search_content and self.replace_content is None:
+            return False
+        return True
+
+@dataclass
+class FileChange:
+    """Represents a file change operation"""
+    operation: ChangeOperation
+    name: Path  # Changed back from path to name
+    target: Optional[Path] = None
+    source: Optional[Path] = None
+    content: Optional[str] = None
+    text_changes: List[TextChange] = field(default_factory=list)
+    original_content: Optional[str] = None
+    reason: Optional[str] = None
+
+    def add_text_changes(self, changes: List[TextChange]):
+        """Add multiple text changes to the existing list"""
+        self.text_changes.extend(changes)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Union[str, Path]]) -> 'FileChange':
+        """Create FileChange instance from dictionary data"""
+        operation = ChangeOperation[data['operation'].upper()]
+        return cls(
+            operation=operation,
+            name=Path(data['name']),  # Changed back to name
+            target=Path(data['target']) if data.get('target') else None,
+            source=Path(data.get('source')) if data.get('source') else None,
+            content=data.get('content'),
+            reason=data.get('reason')
+        )
+
+    def validate_required_parameters(self) -> bool:
+        """Validate the file change operation and raise detailed errors if parameters are missing"""
+        if self.operation == ChangeOperation.RENAME_FILE:
+            if not self.source:
+                raise ValueError(f"Missing 'source' parameter for {self.operation.name}")
+            if not self.target:
+                raise ValueError(f"Missing 'target' parameter for {self.operation.name}")
+                
+        elif self.operation in (ChangeOperation.CREATE_FILE, ChangeOperation.REPLACE_FILE):
+            if not self.content:
+                raise ValueError(f"Missing 'content' parameter for {self.operation.name}")
+                
+        elif self.operation == ChangeOperation.MODIFY_FILE:
+            if not self.text_changes:
+                raise ValueError(f"No closed text changes found for {self.operation.name}")
+                
+        return True
+
+class CommandParser:
+    def __init__(self, debug: bool = False):
+        self.debug = debug
+        self.console = Console(stderr=True)
+        
+    def parse_statements(self, statements: List[Statement]) -> List[FileChange]:
+        """Parse a list of Statement objects into FileChange objects"""
+        if self.debug:
+            self.console.print("[dim]Starting to parse statements...[/dim]")
+            
+        changes = []
+
+        for statement in statements:
+            statement_key = statement.name.upper().replace(' ', '_') 
+            supported_opers = [op.name.title().upper() for op in ChangeOperation]
+            if statement_key not in supported_opers: 
+                raise Exception(f"{statement_key} not in supported statements: {supported_opers}")
+                
+            change = self.convert_statement_to_filechange(statement)
+            if not change:
+                raise Exception(f"Invalid change found: {statement.name}")
+            if not change.validate_required_parameters():
+                raise Exception(f"Missing required parameters for change: {statement.name}")
+            changes.append(change)
+        return changes
+
+    def convert_statement_to_filechange(self, statement: Statement) -> Optional[FileChange]:
+        """Convert a Statement to a FileChange object"""
+        try:
+            operation = ChangeOperation[statement.name.upper().replace(' ', '_')]
+            change = FileChange(
+                operation=operation,
+                name=Path(statement.parameters.get('name', '')),  # Changed back to name
+                reason=statement.parameters.get('reason')
+            )
+
+            if 'target' in statement.parameters:
+                change.target = Path(statement.parameters['target'])
+            if 'source' in statement.parameters:
+                change.source = Path(statement.parameters['source'])
+                change.name = Path(statement.parameters['source'])  # Changed back to name
+
+            content = statement.parameters.get('content')
+            if content:
+                change.content = self._clean_content(content)
+
+            # Handle multiple Changes blocks - combine all text changes
+            all_text_changes = []
+            for block_name, block_statements in statement.blocks:
+                # Handle both numbered (Changes#1) and unnumbered (Changes) blocks
+                base_name = block_name.split('#')[0]
+                if base_name == 'Changes':
+                    if self.debug:
+                        self.console.print(f"[dim]Processing Changes block: {block_name}[/dim]")
+                    new_changes = self.parse_modifications_from_list(block_statements)
+                    all_text_changes.extend(new_changes)
+
+            if all_text_changes:
+                change.text_changes = all_text_changes
+
+            return change
+        except Exception as e:
+            if self.debug:
+                self.console.print(f"[red]Error converting statement: {e}[/red]")
+            return None
+
+    def parse_modifications_from_list(self, mod_statements: List[Statement]) -> List[TextChange]:
+        """Convert parsed modifications list to TextChange objects"""
+        modifications = []
+
+        for statement in mod_statements:
+            try:
+                if statement.name == 'Replace':
+                    mod = TextChange(
+                        search_content=self._clean_content(statement.parameters.get('search', '')),
+                        replace_content=self._clean_content(statement.parameters.get('with', '')),
+                        reason=statement.parameters.get('reason'),
+                        operation='Replace'
+                    )
+                elif statement.name == 'Delete':
+                    mod = TextChange(
+                        search_content=self._clean_content(statement.parameters.get('search', '')),
+                        reason=statement.parameters.get('reason'),
+                        operation='Delete'
+                    )
+                elif statement.name == 'Append':
+                    mod = TextChange(
+                        search_content='',
+                        replace_content=self._clean_content(statement.parameters.get('content', '')),
+                        reason=statement.parameters.get('reason'),
+                        operation='Append'
+                    )
+                else:
+                    continue
+
+                if mod.validate():
+                    modifications.append(mod)
+            except Exception as e:
+                if self.debug:
+                    self.console.print(f"[red]Error processing modification: {e}[/red]")
+                continue
+
+        return modifications
+
+    @staticmethod
+    def _clean_content(content: str) -> str:
+        """Clean content by removing leading dots and normalizing line endings"""
+        if not content:
+            return ''
+        lines = content.splitlines()
+        cleaned_lines = [line[1:] if line.startswith('.') else line for line in lines]
+        return '\n'.join(cleaned_lines)
+
+def extract_instructions_section(response_text: str) -> Optional[str]:
+    """Extract text between BEGIN_INSTRUCTIONS and END_INSTRUCTIONS markers using exact line matching"""
+    try:
+        lines = response_text.splitlines()
+        start_marker = "BEGIN_INSTRUCTIONS"
+        end_marker = "END_INSTRUCTIONS"
+        
+        # Find exact line matches for markers
+        start_idx = None
+        end_idx = None
+        
+        for i, line in enumerate(lines):
+            line = line.strip()
+            if line == start_marker and start_idx is None:
+                start_idx = i
+                continue
+            if line == end_marker and start_idx is not None:
+                end_idx = i
+                break
+                
+        if start_idx is None or end_idx is None:
+            if config.debug:
+                if start_idx is None:
+                    console.print("[yellow]BEGIN_CHANGES marker not found[/yellow]")
+                else:
+                    console.print("[yellow]END_CHANGES marker not found[/yellow]")
+            return None
+            
+        # Extract lines between markers (exclusive)
+        changes_text = '\n'.join(lines[start_idx + 1:end_idx])
+        if not changes_text.strip():
+            if config.debug:
+                console.print("[yellow]Empty changes section found[/yellow]")
+            return None
+            
+        return changes_text.strip()
+        
+    except Exception as e:
+        console.print(f"[red]Error extracting changes section: {e}[/red]")
+        return None
+
+def parse_response(response_text: str) -> List[FileChange]:
+    """Parse a response string into FileChange objects"""
+    parser = CommandParser()
+    statement_parser = StatementParser()
+
+    # First extract the changes section
+    instructions = extract_instructions_section(response_text)
+    if not instructions:
+        if config.debug:
+            console.print("[yellow]No changes section found in response[/yellow]")
+        return []
+
+    statements = statement_parser.parse(instructions)
+    return parser.parse_statements(statements)
+
+def build_change_request_prompt(
+    option_text: str,
+    request: str,
+    files_content_xml: str = ""
+) -> str:
+    """Build prompt for change request details
+    
+    Args:
+        option_text: Formatted text describing the selected option
+        request: The original user request
+        files_content_xml: Content of relevant files in XML format
+    
+    Returns:
+        Formatted prompt string
+    """
+    short_uuid = str(uuid.uuid4())[:8]
+    
+    return CHANGE_REQUEST_PROMPT.format(
+        option_text=option_text,
+        request=request,
+        files_content=files_content_xml,
+        uuid=short_uuid
+    )

janito/change/play.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+from typing import Tuple, Optional
+from rich.console import Console
+from rich.prompt import Confirm
+from .parser import parse_response
+from .preview import setup_workspace_dir_preview
+from .applier.main import ChangeApplier
+from .viewer import preview_all_changes  # Add this import
+from ..config import config  # Add this import
+
+
+def play_saved_changes(history_file: Path) -> Tuple[bool, Optional[Path]]:
+    """
+    Replay changes from a saved history file
+    Returns:
+        success: True if changes were applied successfully
+        history_file: Path to the history file that was played
+    """
+    console = Console()
+
+    if not history_file.exists():
+        console.print(f"[red]History file not found: {history_file}[/red]")
+        return False, None
+
+    content = history_file.read_text()
+    changes = parse_response(content)
+
+    if not changes:
+        console.print("[yellow]No changes found in history file[/yellow]")
+        return False, None
+
+
+    # Create preview directory and apply changes
+    _, preview_dir = setup_workspace_dir_preview()
+    applier = ChangeApplier(preview_dir)
+
+    success, _ = applier.apply_changes(changes, debug=True)
+    if success:
+        preview_all_changes(console, changes)
+
+        if not config.auto_apply:
+            apply_changes = Confirm.ask("[cyan]Apply changes to working dir?[/cyan]", default=False)
+        else:
+            apply_changes = True
+            console.print("[cyan]Auto-applying changes to working dir...[/cyan]")
+
+        if apply_changes:
+            applier.apply_to_workspace_dir(changes)
+            console.print("[green]Changes applied successfully[/green]")
+        else:
+            console.print("[yellow]Changes were not applied[/yellow]")
+            return False, history_file
+
+        return success, history_file

janito/change/preview.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+import shutil
+import tempfile
+from typing import List, Set, Tuple
+from datetime import datetime
+from rich.console import Console
+from rich.panel import Panel
+
+from janito.config import config
+
+def create_backup() -> Path:
+    """Create backup directory and restore script.
+    Returns the path to the backup directory."""
+    backup_dir = config.workspace_dir / '.janito' / 'backups' / datetime.now().strftime('%Y%m%d_%H%M%S')
+    backup_dir.parent.mkdir(parents=True, exist_ok=True)
+
+    # Copy existing files to backup directory
+    if config.workspace_dir.exists():
+        shutil.copytree(config.workspace_dir, backup_dir, ignore=shutil.ignore_patterns('.janito', '.git'))
+        
+        # Create restore script
+        restore_script = config.workspace_dir / '.janito' / 'restore.sh'
+        restore_script.parent.mkdir(parents=True, exist_ok=True)
+        script_content = f"""#!/bin/bash
+# Restore script generated by Janito
+# Restores files from backup created at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+# Exit on error
+set -e
+
+# Get backup directory from argument or use latest
+BACKUP_DIR="$1"
+if [ -z "$BACKUP_DIR" ]; then
+    BACKUP_DIR="{backup_dir}"
+    echo "No backup directory specified, using latest: $BACKUP_DIR"
+fi
+
+# Show usage if --help is provided
+if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
+    echo "Usage: $0 [backup_directory]"
+    echo ""
+    echo "If no backup directory is provided, uses the latest backup at:"
+    echo "{backup_dir}"
+    exit 0
+fi
+
+# Check if backup directory exists
+if [ ! -d "$BACKUP_DIR" ]; then
+    echo "Error: Backup directory not found at $BACKUP_DIR"
+    exit 1
+fi
+
+# Restore files from backup
+echo "Restoring files from backup..."
+cp -r "$BACKUP_DIR"/* "{config.workspace_dir}/"
+
+echo "Files restored successfully from $BACKUP_DIR"
+"""
+        restore_script.write_text(script_content)
+        restore_script.chmod(0o755)
+
+    return backup_dir
+
+def setup_preview_directory() -> Path:
+    """Creates and sets up preview directory with working directory contents.
+    Returns the path to the preview directory."""
+    preview_dir = Path(tempfile.mkdtemp())
+    
+    # Copy existing files to preview directory if workspace_dir exists
+    if config.workspace_dir.exists():
+        shutil.copytree(config.workspace_dir, preview_dir, dirs_exist_ok=True, 
+                       ignore=shutil.ignore_patterns('.janito', '.git'))
+        
+    return preview_dir
+
+def setup_workspace_dir_preview() -> tuple[Path, Path]:
+    """Sets up both backup and preview directories.
+    Returns (backup_dir, preview_dir) tuple."""
+    backup_dir = create_backup()
+    preview_dir = setup_preview_directory()
+    return backup_dir, preview_dir
+