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

janito/_contextparser.py

@@ -1,113 +0,0 @@
-from typing import List, Tuple, Optional, NamedTuple
-from difflib import SequenceMatcher
-from janito.config import config
-from rich.console import Console
-
-class ContextError(NamedTuple):
-    """Contains error details for context matching failures"""
-    pre_context: List[str]
-    post_context: List[str]
-    content: str
-
-def parse_change_block(content: str) -> Tuple[List[str], List[str], List[str]]:
-    """Parse a change block into pre-context, post-context and change lines.
-    Returns (pre_context_lines, post_context_lines, change_lines)"""
-    pre_context_lines = []
-    post_context_lines = []
-    change_lines = []
-    in_pre_context = True
-    
-    for line in content.splitlines():
-        if line.startswith('='):
-            if in_pre_context:
-                pre_context_lines.append(line[1:])
-            else:
-                post_context_lines.append(line[1:])
-        elif line.startswith('>'):
-            in_pre_context = False
-            change_lines.append(line[1:])
-            
-    return pre_context_lines, post_context_lines, change_lines
-
-def find_context_match(file_content: str, pre_context: List[str], post_context: List[str], min_context: int = 2) -> Optional[Tuple[int, int]]:
-    """Find exact matching location using line-by-line matching.
-    Returns (start_index, end_index) or None if no match found."""
-    if not (pre_context or post_context) or (len(pre_context) + len(post_context)) < min_context:
-        return None
-
-    file_lines = file_content.splitlines()
-    
-    # Function to check if lines match at a given position
-    def lines_match_at(pos: int, target_lines: List[str]) -> bool:
-        if pos + len(target_lines) > len(file_lines):
-            return False
-        return all(a == b for a, b in zip(file_lines[pos:pos + len(target_lines)], target_lines))
-
-    # For debug output
-    debug_matches = []
-    
-    # Try to find pre_context match
-    pre_match_pos = None
-    if pre_context:
-        for i in range(len(file_lines) - len(pre_context) + 1):
-            if lines_match_at(i, pre_context):
-                pre_match_pos = i
-                break
-            if config.debug:
-                # Record first 20 non-matches for debug output
-                if len(debug_matches) < 20:
-                    debug_matches.append((i, file_lines[i:i + len(pre_context)]))
-
-    # Try to find post_context match after pre_context if found
-    if pre_match_pos is not None and post_context:
-        expected_post_pos = pre_match_pos + len(pre_context)
-        if not lines_match_at(expected_post_pos, post_context):
-            pre_match_pos = None
-
-    if pre_match_pos is None and config.debug:
-        console = Console()
-        console.print("\n[bold red]Context Match Debug:[/bold red]")
-        
-        if pre_context:
-            console.print("\n[yellow]Expected pre-context:[/yellow]")
-            for i, line in enumerate(pre_context):
-                console.print(f"  {i+1:2d} | '{line}'")
-
-        if post_context:
-            console.print("\n[yellow]Expected post-context:[/yellow]")
-            for i, line in enumerate(post_context):
-                console.print(f"  {i+1:2d} | '{line}'")
-
-        console.print("\n[yellow]First 20 attempted matches in file:[/yellow]")
-        for pos, lines in debug_matches:
-            console.print(f"\n[cyan]At line {pos+1}:[/cyan]")
-            for i, line in enumerate(lines):
-                match_status = "≠" if i < len(pre_context) and line != pre_context[i] else "="
-                console.print(f"  {i+1:2d} | '{line}' {match_status}")
-
-        return None
-
-    if pre_match_pos is None:
-        return None
-
-    end_pos = pre_match_pos + len(pre_context)
-    
-    return pre_match_pos, end_pos
-
-def apply_changes(content: str, 
-                 pre_context_lines: List[str], 
-                 post_context_lines: List[str], 
-                 change_lines: List[str]) -> Optional[Tuple[str, Optional[ContextError]]]:
-    """Apply changes with context matching, returns (new_content, error_details)"""
-    if not content.strip() and not pre_context_lines and not post_context_lines:
-        return '\n'.join(change_lines), None
-
-    pre_context = '\n'.join(pre_context_lines)
-    post_context = '\n'.join(post_context_lines)
-    
-    if pre_context and pre_context not in content:
-        return None, ContextError(pre_context_lines, post_context_lines, content)
-    
-    if post_context and post_context not in content:
-        return None, ContextError(pre_context_lines, post_context_lines, content)
-

janito/analysis/display.py

@@ -1,149 +0,0 @@
-"""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

@@ -1,112 +0,0 @@
-"""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/change/applier.py

@@ -1,269 +0,0 @@
-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