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

janito/{analysis → change/analysis}/prompts.py

@@ -1,23 +1,24 @@
 """User prompts and input handling for analysis."""
 
-from typing import List
+from typing import List, Dict
 from rich.console import Console
 from rich.panel import Panel
 from rich.rule import Rule
 from rich.prompt import Prompt
 from rich import box
 
+
+from .options import AnalysisOption
+
 # Keep only prompt-related functionality
 CHANGE_ANALYSIS_PROMPT = """
-Current files:
-<files>
-{files_content}
-</files>
 
-Considering the above current files content, provide 3 sections, each identified by a keyword and representing an option.
+
+Considering the above workset content, provide 3 sections, each identified by a keyword and representing an option.
 Each option should include a concise description and a list of affected files.
-1st option should be minimalistic style change, 2nd organized style, 3rd exntensible style.
-Do not use style as keyword, instead focus on the changes summaru
+1st option should be basic style change, 2nd organized style, 3rd exntensible style.
+Do not use style as keyword, instead focus on the changes summary.
+
 Use the following format:
 
 A. Keyword summary of the change
@@ -44,32 +45,46 @@ Request:
 def prompt_user(message: str, choices: List[str] = None) -> str:
     """Display a prominent user prompt with optional choices"""
     console = Console()
+    term_width = console.width or 80
     console.print()
-    console.print(Rule(" User Input Required ", style="bold cyan"))
+    console.print(Rule(" User Input Required ", style="bold cyan", align="center"))
     
     if choices:
         choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
-        console.print(Panel(choice_text, box=box.ROUNDED))
+        console.print(Panel(choice_text, box=box.ROUNDED, justify="center"))
     
-    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
+    # Center the prompt with padding
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+    return Prompt.ask(f"[bold cyan]{padded_message}[/bold cyan]")
 
-def validate_option_letter(letter: str, options: dict) -> bool:
+def validate_option_letter(letter: str, options: Dict[str, AnalysisOption]) -> bool:
     """Validate if the given letter is a valid option or 'M' for modify"""
-    return letter.upper() in options or letter.upper() == 'M'
+    if letter.upper() == 'M':
+        return True
+    return letter.upper() in options
 
 def get_option_selection() -> str:
     """Get user input for option selection with modify option"""
     console = Console()
-    console.print("\n[cyan]Enter option letter or 'M' to modify request[/cyan]")
+    term_width = console.width or 80
+    message = "Enter option letter or 'M' to modify request"
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+    
+    console.print(f"\n[cyan]{padded_message}[/cyan]")
     while True:
         letter = prompt_user("Select option").strip().upper()
         if letter == 'M' or (letter.isalpha() and len(letter) == 1):
             return letter
-        console.print("[red]Please enter a valid letter or 'M'[/red]")
+        
+        error_msg = "Please enter a valid letter or 'M'"
+        error_padding = (term_width - len(error_msg)) // 2
+        padded_error = " " * error_padding + error_msg
+        console.print(f"[red]{padded_error}[/red]")
 
-def build_request_analysis_prompt(files_content: str, request: str) -> str:
+def build_request_analysis_prompt(request: str) -> str:
     """Build prompt for information requests"""
     return CHANGE_ANALYSIS_PROMPT.format(
-        files_content=files_content,
         request=request
-    )
+    )

janito/change/analysis/view/__init__.py

@@ -0,0 +1,9 @@
+"""View package for analysis UI components."""
+
+from .terminal import format_analysis, prompt_user, get_option_selection
+
+__all__ = [
+    'format_analysis',
+    'prompt_user',
+    'get_option_selection'
+]

janito/change/analysis/view/terminal.py

@@ -0,0 +1,181 @@
+"""Terminal UI components for analysis display."""
+
+from typing import Dict, List, Optional
+from rich.console import Console
+from rich.columns import Columns
+from rich.text import Text
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.padding import Padding
+from rich.prompt import Prompt
+from rich import box
+from rich.style import Style
+from rich.segment import Segment
+from rich.containers import Renderables
+from pathlib import Path
+
+from ..options import AnalysisOption
+from ..formatting import (
+    COLUMN_SPACING,
+    MIN_PANEL_WIDTH,
+    SECTION_PADDING,
+    STATUS_COLORS,
+    STRUCTURAL_COLORS,
+    create_header,
+    create_section_header,
+    format_file_path
+)
+
+def prompt_user(message: str, choices: List[str] = None) -> str:
+    """Display a prominent user prompt with optional choices"""
+    console = Console()
+    term_width = console.width or 80
+    console.print()
+    console.print(Rule(" User Input Required ", style="bold cyan", align="center"))
+
+    if choices:
+        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
+        console.print(Panel(choice_text, box=box.ROUNDED, justify="center"))
+
+    message_text = Text(message, style="bold cyan")
+    padded_message = Padding(message_text, pad=(0, "center"))
+    console.print(padded_message)
+    return Prompt.ask("")
+
+def get_option_selection() -> str:
+    """Get user input for option selection with modify option"""
+    console = Console()
+    term_width = console.width or 80
+    message = "Enter option letter or 'M' to modify request"
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+
+    console.print(f"\n[cyan]{padded_message}[/cyan]")
+    while True:
+        letter = prompt_user("Select option").strip().upper()
+        if letter == 'M' or (letter.isalpha() and len(letter) == 1):
+            return letter
+
+        error_msg = "Please enter a valid letter or 'M'"
+        error_text = Text(error_msg, style="red")
+        padded_error = Padding(error_text, pad=(0, "center"))
+        console.print(padded_error)
+
+def _create_option_content(option: AnalysisOption) -> Text:
+    """Create rich formatted content for a single option."""
+    content = Text()
+    content.append("\n")
+
+    header = create_header(f"Option {option.letter} - {option.summary}")
+    content.append(header)
+    content.append("\n")
+
+    if option.description_items:
+        for item in option.description_items:
+            content.append("• ", style="cyan")
+            content.append(f"{item}\n")
+        content.append("\n")
+
+    # Add consistent padding before file list
+    content.append("\n" * 2)
+
+    if option.affected_files:
+        files = {status: [] for status in ['New', 'Modified', 'Removed']}
+        for file in option.affected_files:
+            if '(new)' in file.lower():
+                files['New'].append(file)
+            elif '(removed)' in file.lower():
+                files['Removed'].append(file)
+            else:
+                files['Modified'].append(file)
+
+        for status, status_files in files.items():
+            if status_files:
+                content.append(create_section_header(f"{status} Files"))
+                content.append("\n")
+                sorted_files = sorted(status_files)
+                prev_path = None
+                seen_dirs = {}
+                for file in sorted_files:
+                    path = option.get_clean_path(file)
+                    current_parts = Path(path).parts
+                    parent_dir = str(Path(path).parent)
+
+                    if parent_dir != '.':
+                        is_repeated = parent_dir in seen_dirs
+                        if not is_repeated:
+                            content.append(parent_dir, style=STRUCTURAL_COLORS['directory'])
+                            content.append("/", style=STRUCTURAL_COLORS['separator'])
+                            seen_dirs[parent_dir] = True
+                        else:
+                            dir_width = len(parent_dir)
+                            # Calculate padding to match full directory width
+                            arrow = "↑"
+                            total_padding = dir_width - len(arrow)
+                            left_padding = total_padding // 2
+                            right_padding = total_padding - left_padding
+                            content.append(" " * left_padding + arrow + " " * right_padding, 
+                                         style=STRUCTURAL_COLORS['repeat'])
+                            content.append("/", style=STRUCTURAL_COLORS['separator'])
+                        content.append(current_parts[-1], style=STATUS_COLORS[status.lower()])
+                    else:
+                        content.append(current_parts[-1], style=STATUS_COLORS[status.lower()])
+                    content.append("\n")
+            content.append("\n")
+
+        content.append("\n")
+
+    return content
+
+def create_columns_layout(options_content: List[Text], term_width: int) -> Columns:
+    """Create a columns layout with consistent spacing."""
+    num_columns = len(options_content)
+    spacing = COLUMN_SPACING * (num_columns - 1)
+    safety_margin = 4 + 2
+
+    usable_width = term_width - spacing - safety_margin
+    column_width = max((usable_width // num_columns), MIN_PANEL_WIDTH)
+
+    # Create padded content items
+    rendered_items: List[Renderables] = [
+        Padding(content, (0, COLUMN_SPACING // 2))
+        for content in options_content
+    ]
+
+    return Columns(
+        rendered_items,
+        equal=True,
+        expand=True,
+        width=column_width,
+        align="left",
+        padding=(0, 0),
+    )
+
+def format_analysis(analysis: str, raw: bool = False) -> None:
+    """Format and display the analysis output."""
+    from ..options import parse_analysis_options
+
+    console = Console()
+    term_width = console.width or 100
+
+    if raw:
+        console.print(analysis)
+        return
+
+    options = parse_analysis_options(analysis)
+    if not options:
+        console.print("\n[yellow]Warning: No valid options found in response.[/yellow]\n")
+        console.print(analysis)
+        return
+
+    columns_content = [_create_option_content(options[letter])
+                      for letter in sorted(options.keys())]
+
+    columns = create_columns_layout(columns_content, term_width)
+
+    console.print("\n")
+    console.print(Text("Analysis Options", style="bold cyan"))
+    console.print(Text("─" * term_width, style="cyan dim"))
+    console.print(columns)
+    console.print(Text("─" * term_width, style="cyan dim"))
+    console.print("\n")

janito/change/applier/__init__.py

@@ -0,0 +1,5 @@
+from .file import FileChangeApplier
+from .text import TextChangeApplier
+from .workspace_dir import apply_changes
+
+__all__ = ['FileChangeApplier', 'TextChangeApplier', 'apply_changes']

janito/change/applier/file.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+from typing import Tuple, Optional
+from rich.console import Console
+from ..parser import FileChange, ChangeOperation
+
+class FileChangeApplier:
+    def __init__(self, preview_dir: Path, console: Console = None):
+        self.preview_dir = preview_dir
+        self.console = console or Console()
+
+    def apply_file_operation(self, change: FileChange) -> Tuple[bool, Optional[str]]:
+        """Apply a file operation (create/replace/remove/rename/move)
+        Returns: (success, error_message)"""
+        path = self.preview_dir / change.name
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Store original content before any changes
+        if path.exists():
+            change.original_content = path.read_text()
+
+        if change.operation == ChangeOperation.REMOVE_FILE:
+            return self._handle_remove(path)
+        elif change.operation in (ChangeOperation.CREATE_FILE, ChangeOperation.REPLACE_FILE):
+            return self._handle_create_replace(path, change)
+        elif change.operation in (ChangeOperation.RENAME_FILE, ChangeOperation.MOVE_FILE):
+            return self._handle_move(path, change)
+
+        return False, f"Unsupported operation: {change.operation}"
+
+    def _handle_remove(self, path: Path) -> Tuple[bool, Optional[str]]:
+        """Handle file removal"""
+        if path.exists():
+            path.unlink()
+        return True, None
+
+    def _handle_create_replace(self, path: Path, change: FileChange) -> Tuple[bool, Optional[str]]:
+        """Handle file creation or replacement"""
+        if change.operation == ChangeOperation.CREATE_FILE and path.exists():
+            return False, f"Cannot create file {path} - already exists"
+
+        if change.content is not None:
+            path.write_text(change.content)
+            return True, None
+
+        return False, "No content provided for create/replace operation"
+
+    def _handle_move(self, path: Path, change: FileChange) -> Tuple[bool, Optional[str]]:
+        """Handle file move/rename operations"""
+        if not path.exists():
+            return False, f"Cannot move/rename non-existent file {path}"
+
+        if not change.target:
+            return False, "No target path provided for move/rename operation"
+
+        new_path = self.preview_dir / change.target
+        new_path.parent.mkdir(parents=True, exist_ok=True)
+        path.rename(new_path)
+        return True, None

janito/change/applier/main.py

@@ -0,0 +1,156 @@
+"""
+Applies file changes to preview directory and runs tests
+
+The following situations should result in error:
+- Creating a file that already exists
+- Replace operation on a non-existent file
+- Rename operation on a non-existent file
+- Modify operation with search text not found
+- No changes applied to a file
+"""
+
+from pathlib import Path
+from typing import Tuple, Optional, List, Set
+from rich.console import Console
+from rich.panel import Panel
+from rich import box
+import subprocess
+from ..validator import validate_python_syntax
+from .workspace_dir import apply_changes as apply_to_workspace_dir_impl
+from janito.config import config
+from .file import FileChangeApplier
+from .text import TextChangeApplier
+from ..parser import FileChange, ChangeOperation
+from ..validator import validate_all_changes
+
+
+class ChangeApplier:
+    """Handles applying changes to files."""
+
+    def __init__(self, preview_dir: Path, debug: bool = False):
+        self.preview_dir = preview_dir
+        self.debug = debug
+        self.console = Console()
+        self.file_applier = FileChangeApplier(preview_dir, self.console)
+        self.text_applier = TextChangeApplier(self.console)
+
+    def run_test_command(self, test_cmd: str) -> Tuple[bool, str, Optional[str]]:
+        """Run test command in preview directory.
+        Returns (success, output, error)"""
+        try:
+            result = subprocess.run(
+                test_cmd,
+                shell=True,
+                cwd=self.preview_dir,
+                capture_output=True,
+                text=True,
+                timeout=300  # 5 minute timeout
+            )
+            return (
+                result.returncode == 0,
+                result.stdout,
+                result.stderr if result.returncode != 0 else None
+            )
+        except subprocess.TimeoutExpired:
+            return False, "", "Test command timed out after 5 minutes"
+        except Exception as e:
+            return False, "", f"Error running test: {str(e)}"
+
+    def apply_changes(self, changes: List[FileChange], debug: bool = None) -> tuple[bool, Set[Path]]:
+        """Apply changes in preview directory, runs tests if specified.
+        Returns (success, modified_files)"""
+        debug = debug if debug is not None else self.debug
+        console = Console()
+        
+        # Validate all changes using consolidated validator
+        is_valid, error = validate_all_changes(changes, set(Path(c.name) for c in changes))
+        if not is_valid:
+            console.print(f"\n[red]{error}[/red]")
+            return False, set()
+        
+        # Track modified files and apply changes
+        modified_files: Set[Path] = set()
+        for change in changes:
+            if config.verbose:
+                console.print(f"[dim]Previewing changes for {change.name}...[/dim]")
+            success, error = self.apply_single_change(change, debug)
+            if not success:
+                console.print(f"\n[red]Error previewing {change.name}: {error}[/red]")
+                return False, modified_files
+            if not change.operation == 'remove_file':
+                modified_files.add(change.name)
+            elif change.operation == 'rename_file':
+                modified_files.add(change.target)
+
+        # Validate Python syntax (skip deleted and moved files)
+        python_files = {f for f in modified_files if f.suffix == '.py'}
+
+        for change in changes:
+            if change.operation == ChangeOperation.REMOVE_FILE:
+                python_files.discard(change.name)  # Skip validation for deleted files
+            elif change.operation in (ChangeOperation.RENAME_FILE, ChangeOperation.MOVE_FILE):
+                python_files.discard(change.source)  # Skip validation for moved/renamed sources
+
+        for path in python_files:
+            preview_path = self.preview_dir / path
+            is_valid, error_msg = validate_python_syntax(preview_path.read_text(), preview_path)
+            if not is_valid:
+                console.print(f"\n[red]Python syntax validation failed for {path}:[/red]")
+                console.print(f"[red]{error_msg}[/red]")
+                return False, modified_files
+
+        # Show success message with syntax validation status
+        console.print("\n[cyan]Changes applied successfully.[/cyan]")
+        if python_files:
+            console.print(f"[green]✓ Python syntax validated for {len(python_files)} file(s)[/green]")
+        
+        # Run tests if specified
+        if config.test_cmd:
+            console.print(f"\n[cyan]Testing changes in preview directory:[/cyan] {config.test_cmd}")
+            success, output, error = self.run_test_command(config.test_cmd)
+            if output:
+                console.print("\n[bold]Test Output:[/bold]")
+                console.print(Panel(output, box=box.ROUNDED))
+            if not success:
+                console.print("\n[red bold]Tests failed in preview.[/red bold]")
+                if error:
+                    console.print(Panel(error, title="Error", border_style="red"))
+                return False, modified_files
+
+        return True, modified_files
+
+    def apply_single_change(self, change: FileChange, debug: bool) -> Tuple[bool, Optional[str]]:
+        """Apply a single file change to preview directory"""
+        path = self.preview_dir / change.name  # Changed back from path to name
+        
+        # Handle file operations first
+        if change.operation != ChangeOperation.MODIFY_FILE:
+            return self.file_applier.apply_file_operation(change)
+
+        # Handle text modifications
+        if not path.exists():
+            original_path = Path(change.name)  # Changed back from path to name
+            if not original_path.exists():
+                return False, f"Original file not found: {original_path}"
+            if self.console:
+                self.console.print(f"[dim]Copying {original_path} to preview directory {path}[/dim]")
+            path.write_text(original_path.read_text())
+
+        current_content = path.read_text()
+        success, modified_content, error = self.text_applier.apply_modifications(
+            current_content, 
+            change.text_changes, 
+            path,
+            debug
+        )
+
+        if not success:
+            return False, error
+
+        path.write_text(modified_content)
+        return True, None
+
+    def apply_to_workspace_dir(self, changes: List[FileChange], debug: bool = None) -> bool:
+        """Apply changes from preview to working directory"""
+        debug = debug if debug is not None else self.debug
+        return apply_to_workspace_dir_impl(changes, self.preview_dir, Console())