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

janito/analysis/display.py

@@ -0,0 +1,149 @@
+"""Display formatting for analysis results."""
+
+from typing import Optional, Dict
+from pathlib import Path
+from datetime import datetime, timezone
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+from rich.columns import Columns
+from rich.rule import Rule
+from janito.agents import AIAgent, AgentSingleton
+from .options import AnalysisOption
+from .options import parse_analysis_options
+
+MIN_PANEL_WIDTH = 40
+
+def get_analysis_summary(options: Dict[str, AnalysisOption]) -> str:
+    """Generate a summary of affected directories and their file counts."""
+    dirs_summary = {}
+    for _, option in options.items():
+        for file in option.affected_files:
+            clean_path = option.get_clean_path(file)
+            dir_path = str(Path(clean_path).parent)
+            dirs_summary[dir_path] = dirs_summary.get(dir_path, 0) + 1
+    
+    return " | ".join([f"{dir}: {count} files" for dir, count in dirs_summary.items()])
+
+def _display_options(options: Dict[str, AnalysisOption]) -> None:
+    """Display available options in a single horizontal row with equal widths."""
+    console = Console()
+    
+    console.print()
+    console.print(Rule(" Available Options ", style="bold cyan", align="center"))
+    console.print()
+    
+    term_width = console.width or 100
+    spacing = 4
+    total_spacing = spacing * (len(options) - 1)
+    panel_width = max(MIN_PANEL_WIDTH, (term_width - total_spacing) // len(options))
+    
+    panels = []
+    for letter, option in options.items():
+        content = Text()
+        
+        content.append("Description:\n", style="bold cyan")
+        for item in option.description_items:
+            content.append(f"• {item}\n", style="white")
+        content.append("\n")
+        
+        if option.affected_files:
+            content.append("Affected files:\n", style="bold cyan")
+            unique_files = {}
+            for file in option.affected_files:
+                clean_path = option.get_clean_path(file)
+                unique_files[clean_path] = file
+                
+            for file in unique_files.values():
+                if '(new)' in file:
+                    color = "green"
+                elif '(removed)' in file:
+                    color = "red"
+                else:
+                    color = "yellow"
+                content.append(f"• {file}\n", style=color)
+
+        panel = Panel(
+            content,
+            box=box.ROUNDED,
+            border_style="cyan",
+            title=f"Option {letter}: {option.summary}",
+            title_align="center",
+            padding=(1, 2),
+            width=panel_width
+        )
+        panels.append(panel)
+    
+    if panels:
+        columns = Columns(
+            panels,
+            align="center",
+            expand=True,
+            equal=True,
+            padding=(0, spacing // 2)
+        )
+        console.print(columns)
+
+def _display_markdown(content: str) -> None:
+    """Display content in markdown format."""
+    console = Console()
+    md = Markdown(content)
+    console.print(md)
+
+def _display_raw_history(agent: AIAgent) -> None:
+    """Display raw message history from Claude agent."""
+    console = Console()
+    console.print("\n=== Message History ===")
+    for role, content in agent.messages_history:
+        console.print(f"\n[bold cyan]{role.upper()}:[/bold cyan]")
+        console.print(content)
+    console.print("\n=== End Message History ===\n")
+
+def format_analysis(analysis: str, raw: bool = False, workdir: Optional[Path] = None) -> None:
+    """Format and display the analysis output with enhanced capabilities."""
+    console = Console()
+    
+    agent = AgentSingleton.get_agent()
+    if raw and agent:
+        _display_raw_history(agent)
+    else:
+        options = parse_analysis_options(analysis)
+        if options:
+            _display_options(options)
+        else:
+            console.print("\n[yellow]Warning: No valid options found in response. Displaying as markdown.[/yellow]\n")
+            _display_markdown(analysis)
+
+def get_history_file_type(filepath: Path) -> str:
+    """Determine the type of saved file based on its name"""
+    name = filepath.name.lower()
+    if 'changes' in name:
+        return 'changes'
+    elif 'selected' in name:
+        return 'selected'
+    elif 'analysis' in name:
+        return 'analysis'
+    elif 'response' in name:
+        return 'response'
+    return 'unknown'
+
+def get_history_path(workdir: Path) -> Path:
+    """Create and return the history directory path"""
+    history_dir = workdir / '.janito' / 'history'
+    history_dir.mkdir(parents=True, exist_ok=True)
+    return history_dir
+
+def get_timestamp() -> str:
+    """Get current UTC timestamp in YMD_HMS format with leading zeros"""
+    return datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
+
+def save_to_file(content: str, prefix: str, workdir: Path) -> Path:
+    """Save content to a timestamped file in history directory"""
+    history_dir = get_history_path(workdir)
+    timestamp = get_timestamp()
+    filename = f"{timestamp}_{prefix}.txt"
+    file_path = history_dir / filename
+    file_path.write_text(content)
+    return file_path

janito/analysis/options.py

@@ -0,0 +1,112 @@
+"""Options handling for analysis module."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Dict, Tuple
+import re
+
+@dataclass
+class AnalysisOption:
+    letter: str
+    summary: str
+    affected_files: List[str]
+    description_items: List[str]
+
+    def get_clean_path(self, file_path: str) -> str:
+        """Get clean path without markers"""
+        return file_path.split(' (')[0].strip()
+        
+    def is_new_file(self, file_path: str) -> bool:
+        """Check if file is marked as new"""
+        return '(new)' in file_path
+        
+    def is_removed_file(self, file_path: str) -> bool:
+        """Check if file is marked as removed"""
+        return '(removed)' in file_path
+
+    def get_affected_paths(self, workdir: Path = None) -> List[Path]:
+        """Get list of affected paths, resolving against workdir if provided"""
+        paths = []
+        for file_path in self.affected_files:
+            clean_path = self.get_clean_path(file_path)
+            path = workdir / clean_path if workdir else Path(clean_path)
+            paths.append(path)
+        return paths
+
+    def process_file_path(self, path: str) -> Tuple[str, bool, bool, bool]:
+        """Process a file path to extract clean path and modification flags
+        Returns: (clean_path, is_new, is_modified, is_removed)
+        """
+        clean_path = path.strip()
+        is_new = False
+        is_modified = False
+        is_removed = False
+        
+        if "(new)" in clean_path:
+            is_new = True
+            clean_path = clean_path.replace("(new)", "").strip()
+        if "(modified)" in clean_path:
+            is_modified = True
+            clean_path = clean_path.replace("(modified)", "").strip()
+        if "(removed)" in clean_path:
+            is_removed = True
+            clean_path = clean_path.replace("(removed)", "").strip()
+            
+        return clean_path, is_new, is_modified, is_removed
+
+def parse_analysis_options(response: str) -> Dict[str, AnalysisOption]:
+    """Parse options from the response text."""
+    options = {}
+    
+    if 'END_OF_OPTIONS' in response:
+        response = response.split('END_OF_OPTIONS')[0]
+    
+    current_option = None
+    current_section = None
+    
+    lines = response.split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        option_match = re.match(r'^([A-Z])\.\s+(.+)$', line)
+        if option_match:
+            if current_option:
+                options[current_option.letter] = current_option
+                
+            letter, summary = option_match.groups()
+            current_option = AnalysisOption(
+                letter=letter,
+                summary=summary,
+                affected_files=[],
+                description_items=[]
+            )
+            current_section = None
+            continue
+            
+        if re.match(r'^-+$', line):
+            continue
+        
+        if current_option:
+            if line.lower() == 'description:':
+                current_section = 'description'
+                continue
+            elif line.lower() == 'affected files:':
+                current_section = 'files'
+                continue
+            
+            if line.startswith('- '):
+                content = line[2:].strip()
+                if current_section == 'description':
+                    current_option.description_items.append(content)
+                elif current_section == 'files':
+                    # Accept any combination of new, modified or removed markers
+                    if any(marker in content for marker in ['(new)', '(modified)', '(removed)']):
+                        current_option.affected_files.append(content)
+    
+    if current_option:
+        options[current_option.letter] = current_option
+    
+    return options

janito/analysis/prompts.py

@@ -0,0 +1,75 @@
+"""User prompts and input handling for analysis."""
+
+from typing import List
+from rich.console import Console
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.prompt import Prompt
+from rich import box
+
+# 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.
+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
+Use the following format:
+
+A. Keyword summary of the change
+-----------------
+Description:
+- Concise description of the change
+
+Affected files:
+- path/file1.py (new)
+- path/file2.py (modified)
+- path/file3.py (removed)
+
+END_OF_OPTIONS (mandatory marker)
+
+RULES:
+- do NOT provide the content of the files
+- do NOT offer to implement the changes
+- description items should be 80 chars or less
+
+Request:
+{request}
+"""
+
+def prompt_user(message: str, choices: List[str] = None) -> str:
+    """Display a prominent user prompt with optional choices"""
+    console = Console()
+    console.print()
+    console.print(Rule(" User Input Required ", style="bold cyan"))
+    
+    if choices:
+        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
+        console.print(Panel(choice_text, box=box.ROUNDED))
+    
+    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
+
+def validate_option_letter(letter: str, options: dict) -> bool:
+    """Validate if the given letter is a valid option or 'M' for modify"""
+    return letter.upper() in options or letter.upper() == 'M'
+
+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]")
+    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]")
+
+def build_request_analysis_prompt(files_content: str, request: str) -> str:
+    """Build prompt for information requests"""
+    return CHANGE_ANALYSIS_PROMPT.format(
+        files_content=files_content,
+        request=request
+    )

janito/change/__init__.py

@@ -0,0 +1,19 @@
+from .applier import apply_single_change
+from .position import parse_and_apply_changes_sequence
+from .content import (
+    get_file_type,
+    process_and_save_changes,
+    format_parsed_changes,
+    apply_content_changes,
+    handle_changes_file
+)
+
+__all__ = [
+    'apply_single_change',
+    'parse_and_apply_changes_sequence',
+    'get_file_type',
+    'process_and_save_changes',
+    'format_parsed_changes',
+    'apply_content_changes',
+    'handle_changes_file'
+]

janito/change/applier.py

@@ -0,0 +1,269 @@
+from pathlib import Path
+from typing import Tuple, Optional, Set
+from rich.console import Console
+from rich import box
+from rich.panel import Panel
+from rich.prompt import Confirm
+from datetime import datetime
+import subprocess
+import shutil
+import tempfile
+
+from janito.fileparser import FileChange
+from janito.config import config
+from .position import find_text_positions, format_whitespace_debug
+from .indentation import adjust_indentation
+from typing import List
+from ..changeviewer import preview_all_changes
+from ..fileparser import validate_python_syntax
+from ..changehistory import get_history_file_path
+
+
+def run_test_command(preview_dir: Path, 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=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 preview_and_apply_changes(changes: List[FileChange], workdir: Path, test_cmd: str = None) -> bool:
+    """Preview changes and apply if confirmed"""
+    console = Console()
+    
+    if not changes:
+        console.print("\n[yellow]No changes were found to apply[/yellow]")
+        return False
+
+    # Show change preview
+    preview_all_changes(console, changes)
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        preview_dir = Path(temp_dir)
+        console.print("\n[blue]Creating preview in temporary directory...[/blue]")
+        
+        # Create backup directory
+        backup_dir = workdir / '.janito' / 'backups' / datetime.now().strftime('%Y%m%d_%H%M%S')
+        backup_dir.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Copy existing files to preview directory
+        if workdir.exists():
+            if config.verbose:
+                console.print(f"[blue]Creating backup at:[/blue] {backup_dir}")
+            shutil.copytree(workdir, backup_dir, ignore=shutil.ignore_patterns('.janito'))
+            shutil.copytree(workdir, preview_dir, dirs_exist_ok=True, ignore=shutil.ignore_patterns('.janito'))
+            
+            # Create restore script
+            restore_script = workdir / '.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
+
+# 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}"/* "{workdir}/"
+
+echo "Files restored successfully from {backup_dir}"
+"""
+            restore_script.write_text(script_content)
+            restore_script.chmod(0o755)
+            
+            if config.verbose:
+                console.print(f"[blue]Created restore script at:[/blue] {restore_script}")
+
+        # Track modified files and apply changes to preview directory
+        modified_files: Set[Path] = set()
+        any_errors = False
+        for change in changes:
+            if config.verbose:
+                console.print(f"[dim]Previewing changes for {change.path}...[/dim]")
+            success, error = apply_single_change(change.path, change, workdir, preview_dir)
+            if success and not change.remove_file:
+                modified_files.add(change.path)
+            if not success:
+                if "file already exists" in str(error):
+                    console.print(f"\n[red]Error: Cannot create {change.path}[/red]")
+                    console.print("[red]File already exists and overwriting is not allowed.[/red]")
+                else:
+                    console.print(f"\n[red]Error previewing changes for {change.path}:[/red]")
+                    console.print(f"[red]{error}[/red]")
+                any_errors = True
+                continue
+        
+        if any_errors:
+            console.print("\n[red]Some changes could not be previewed. Aborting.[/red]")
+            return False
+
+        # Validate Python syntax
+        python_files = {change.path for change in changes if change.path.suffix == '.py'}
+        for filepath in python_files:
+            preview_path = preview_dir / filepath
+            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 {filepath}:[/red]")
+                console.print(f"[red]{error_msg}[/red]")
+                return False
+
+        # Run tests if specified
+        if test_cmd:
+            console.print(f"\n[cyan]Testing changes in preview directory:[/cyan] {test_cmd}")
+            success, output, error = run_test_command(preview_dir, 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. Changes will not be applied.[/red bold]")
+                if error:
+                    console.print(Panel(error, title="Error", border_style="red"))
+                return False
+
+        # Final confirmation
+        if not Confirm.ask("\n[cyan bold]Apply previewed changes to working directory?[/cyan bold]"):
+            console.print("\n[yellow]Changes were only previewed, not applied to working directory[/yellow]")
+            console.print("[green]Changes are stored in the history directory and can be applied later using:[/green]")
+            changes_file = get_history_file_path(workdir)
+            console.print(f"[cyan]  {changes_file.relative_to(workdir)}[/cyan]")
+            return False
+
+        # Apply changes - copy each modified file only once
+        console.print("\n[blue]Applying changes to working directory...[/blue]")
+        for file_path in modified_files:
+            console.print(f"[dim]Applying changes to {file_path}...[/dim]")
+            target_path = workdir / file_path
+            preview_path = preview_dir / file_path
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(preview_path, target_path)
+            
+        # Handle file removals separately
+        for change in changes:
+            if change.remove_file:
+                target_path = workdir / change.path
+                if target_path.exists():
+                    target_path.unlink()
+                    console.print(f"[red]Removed {change.path}[/red]")
+
+        console.print("\n[green]Changes successfully applied to working directory![/green]")
+        return True
+
+def apply_single_change(filepath: Path, change: FileChange, workdir: Path, preview_dir: Path) -> Tuple[bool, Optional[str]]:
+    """Apply a single file change"""
+    preview_path = preview_dir / filepath
+    preview_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    if change.remove_file:
+        orig_path = workdir / filepath
+        if not orig_path.exists():
+            return False, f"Cannot remove non-existent file {filepath}"
+        if config.debug:
+            console = Console()
+            console.print(f"\n[red]Removing file {filepath}[/red]")
+        # For preview, we don't create the file in preview dir
+        return True, None
+    
+    if config.debug:
+        console = Console()
+        console.print(f"\n[cyan]Processing change for {filepath}[/cyan]")
+        console.print(f"[dim]Change type: {'new file' if change.is_new_file else 'modification'}[/dim]")
+    
+    if change.is_new_file or change.replace_file:
+        if change.is_new_file and filepath.exists():
+            return False, "Cannot create file - already exists"
+        if config.debug:
+            action = "Creating new" if change.is_new_file else "Replacing"
+            console.print(f"[cyan]{action} file with content:[/cyan]")
+            console.print(Panel(change.content, title="File Content"))
+        preview_path.write_text(change.content)
+        return True, None
+        
+    orig_path = workdir / filepath
+    if not orig_path.exists():
+        return False, f"Cannot modify non-existent file {filepath}"
+        
+    content = orig_path.read_text()
+    modified = content
+    
+    for search, replace, description in change.search_blocks:
+        if config.debug:
+            console.print(f"\n[cyan]Processing search block:[/cyan] {description or 'no description'}")
+            console.print("[yellow]Search text:[/yellow]")
+            console.print(Panel(format_whitespace_debug(search)))
+            if replace is not None:
+                console.print("[yellow]Replace with:[/yellow]")
+                console.print(Panel(format_whitespace_debug(replace)))
+            else:
+                console.print("[yellow]Action:[/yellow] Delete text")
+                
+        positions = find_text_positions(modified, search)
+        
+        if config.debug:
+            console.print(f"[cyan]Found {len(positions)} matches[/cyan]")
+        
+        if not positions:
+            error_context = f" ({description})" if description else ""
+            debug_search = format_whitespace_debug(search)
+            debug_content = format_whitespace_debug(modified)
+            error_msg = (
+                f"Could not find search text in {filepath}{error_context}:\n\n"
+                f"[yellow]Search text (with whitespace markers):[/yellow]\n"
+                f"{debug_search}\n\n"
+                f"[yellow]File content (with whitespace markers):[/yellow]\n"
+                f"{debug_content}"
+            )
+            return False, error_msg
+            
+        # Apply replacements from end to start to maintain position validity
+        for start, end in reversed(positions):
+            if config.debug:
+                console.print(f"\n[cyan]Replacing text at positions {start}-{end}:[/cyan]")
+                console.print("[yellow]Original segment:[/yellow]")
+                console.print(Panel(format_whitespace_debug(modified[start:end])))
+                if replace is not None:
+                    console.print("[yellow]Replacing with:[/yellow]")
+                    console.print(Panel(format_whitespace_debug(replace)))
+            
+            # Adjust replacement text indentation
+            original_segment = modified[start:end]
+            adjusted_replace = adjust_indentation(original_segment, replace) if replace else ""
+            
+            if config.debug and replace:
+                console.print("[yellow]Adjusted replacement:[/yellow]")
+                console.print(Panel(format_whitespace_debug(adjusted_replace)))
+                    
+            modified = modified[:start] + adjusted_replace + modified[end:]
+    
+    if modified == content:
+        if config.debug:
+            console.print("\n[yellow]No changes were applied to the file[/yellow]")
+        return False, "No changes were applied"
+        
+    if config.debug:
+        console.print("\n[green]Changes applied successfully[/green]")
+        
+    preview_path.write_text(modified)
+    return True, None

janito/{contentchange.py → change/content.py}

@@ -1,9 +1,13 @@
+
 from pathlib import Path
 from typing import Dict, Tuple
 from rich.console import Console
 from datetime import datetime
+
 from janito.fileparser import FileChange, parse_block_changes
-from janito.changeapplier import preview_and_apply_changes
+from janito.changehistory import save_changes_to_history, get_history_file_path
+from janito.changeviewer import preview_all_changes
+from .applier import apply_single_change
 
 def get_file_type(filepath: Path) -> str:
     """Determine the type of saved file based on its name"""
@@ -18,38 +22,12 @@ def get_file_type(filepath: Path) -> str:
         return 'response'
     return 'unknown'
 
-def save_changes_to_history(content: str, request: str, workdir: Path) -> Path:
-    """Save change content to history folder with timestamp and request info"""
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")  # Already in the correct format
-    history_dir = workdir / '.janito' / 'history'
-    history_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Create history entry with request and changes
-    history_file = history_dir / f"changes_{timestamp}.txt"
-    
-    history_content = f"""Request: {request}
-Timestamp: {timestamp}
-
-Changes:
-{content}
-"""
-    history_file.write_text(history_content)
-    return history_file
-
 def process_and_save_changes(content: str, request: str, workdir: Path) -> Tuple[Dict[Path, Tuple[str, str]], Path]:
     """Parse changes and save to history, returns (changes_dict, history_file)"""
     changes = parse_block_changes(content)
     history_file = save_changes_to_history(content, request, workdir)
     return changes, history_file
 
-def validate_python_syntax(content: str, filepath: Path) -> Tuple[bool, str]:
-    """Validate Python syntax and return (is_valid, error_message)"""
-    try:
-        ast.parse(content)
-        return True, ""
-    except SyntaxError as e:
-        return False, f"Line {e.lineno}: {e.msg}"
-
 def format_parsed_changes(changes: Dict[Path, Tuple[str, str]]) -> str:
     """Format parsed changes to show only file change descriptions"""
     result = []