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

janito/change/applier/file.py

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

@@ -1,156 +0,0 @@
-"""
-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())

janito/change/applier/text.py

@@ -1,247 +0,0 @@
-from typing import Tuple, List, Optional
-from rich.console import Console
-from pathlib import Path
-from datetime import datetime
-from ..parser import TextChange
-from janito.config import config
-from ...clear_statement_parser.parser import StatementParser
-from ...search_replace import SearchReplacer, PatternNotFoundException, Searcher
-
-class TextFindDebugger:
-    def __init__(self, console: Console):
-        self.console = console
-        self.find_count = 0
-
-    def _visualize_whitespace(self, text: str) -> str:
-        """Convert whitespace characters to visible markers"""
-        return text.replace(' ', '·').replace('\t', '→')
-
-    def debug_find(self, content: str, search: str) -> List[int]:
-        """Debug find operation by showing numbered matches"""
-        self.find_count += 1
-        matches = []
-
-        # Show search pattern
-        self.console.print(f"\n[cyan]Find #{self.find_count} search pattern:[/cyan]")
-        for i, line in enumerate(search.splitlines()):
-            self.console.print(f"[dim]{i+1:3d} | {self._visualize_whitespace(line)}[/dim]")
-
-        # Process content line by line
-        lines = content.splitlines()
-        for i, line in enumerate(lines):
-            if search.strip() in line.strip():
-                matches.append(i + 1)
-                self.console.print(f"[green]Match at line {i+1}:[/green] {self._visualize_whitespace(line)}")
-
-        if not matches:
-            self.console.print("[yellow]No matches found[/yellow]")
-
-        return matches
-
-class TextChangeApplier:
-    def __init__(self, console: Optional[Console] = None):
-        self.console = console or Console()
-        self.debugger = TextFindDebugger(self.console)
-        self.parser = StatementParser()
-        self.searcher = Searcher()
-        
-    def _get_last_line_indent(self, content: str) -> str:
-        """Extract indentation from the last non-empty line."""
-        lines = content.splitlines()
-        for line in reversed(lines):
-            if line.strip():
-                return self.searcher.get_indentation(line)
-        return ""
-
-    def _validate_operation(self, mod: TextChange) -> Tuple[bool, Optional[str]]:
-        """Validate text operation type and parameters
-        Returns (is_valid, error_message)"""
-        if mod.is_append:
-            if not mod.replace_content:
-                return False, "Append operation requires content"
-            return True, None
-
-        # For delete operations
-        if mod.is_delete:
-            if not mod.search_content:
-                return False, "Delete operation requires search content"
-            return True, None
-
-        # For replace operations
-        if not mod.search_content:
-            return False, "Replace operation requires search content"
-        if mod.replace_content is None:
-            return False, "Replace operation requires replacement content"
-
-        return True, None
-
-    def apply_modifications(self, content: str, changes: List[TextChange], target_path: Path, debug: bool) -> Tuple[bool, str, Optional[str]]:
-        """Apply text modifications to content"""
-        modified = content
-        any_changes = False
-        target_path = target_path.resolve()
-        file_ext = target_path.suffix  # Get file extension including the dot
-
-        for mod in changes:
-            # Validate operation
-            is_valid, error = self._validate_operation(mod)
-            if not is_valid:
-                self.console.print(f"[yellow]Warning: Invalid text operation for {target_path}: {error}[/yellow]")
-                continue
-
-            try:
-                # Handle append operations
-                if not mod.search_content:
-                    if mod.replace_content:
-                        modified = self._append_content(modified, mod.replace_content)
-                        any_changes = True
-                    continue
-
-                # Handle delete operations (either explicit or via empty replacement)
-                if mod.is_delete or (mod.replace_content == "" and mod.search_content):
-                    replacer = SearchReplacer(modified, mod.search_content, "", file_ext, debug=debug)
-
-                    modified = replacer.replace()
-                    any_changes = True
-                    continue
-
-                # Handle search and replace
-                if debug:
-                    print("************************** before replace")
-                    print(modified)
-                    print("****************************")
-                replacer = SearchReplacer(modified, mod.search_content, mod.replace_content, file_ext, debug=debug)
-                modified = replacer.replace()
-                if debug:
-                    print("************************** after replace")
-                    print(modified)
-                    print("****************************")
-                any_changes = True
-
-            except PatternNotFoundException:
-                if config.debug:
-                    self.debug_failed_finds(mod.search_content, modified, str(target_path))
-                warning_msg = self._handle_failed_search(target_path, mod.search_content, modified)
-                self.console.print(f"[yellow]Warning: {warning_msg}[/yellow]")
-                continue
-    
-        return (True, modified, None) if any_changes else (False, content, "No changes were applied")
-
-    def _append_content(self, content: str, new_content: str) -> str:
-        """Append content with proper indentation matching.
-        
-        The indentation rules are:
-        1. If new content starts with empty lines, preserve original indentation
-        2. Otherwise, use indentation from the last non-empty line of existing content as base
-        3. Preserves relative indentation between lines in new content
-        4. Adjusts indentation if new content would go into negative space
-        """
-        if not content.endswith('\n'):
-            content += '\n'
-        
-        # Add empty line if the last line is not empty
-        if content.rstrip('\n').splitlines()[-1].strip():
-            content += '\n'
-
-        # If new content starts with empty lines, preserve original indentation
-        lines = new_content.splitlines()
-        if not lines or not lines[0].strip():
-            return content + new_content
-            
-        # Get base indentation from last non-empty line
-        base_indent = self._get_last_line_indent(content)
-        
-        # Get the first non-empty line from new content
-        first_line, _ = self.searcher.get_first_non_empty_line(new_content)
-        if first_line:
-            # Get the indentation of the first line of new content
-            new_base_indent = self.searcher.get_indentation(first_line)
-            
-            # Calculate how much we need to shift if new content would go into negative space
-            indent_delta = len(base_indent) + (len(new_base_indent) - len(new_base_indent))
-            left_shift = abs(min(0, indent_delta))
-            
-            result_lines = []
-            for line in new_content.splitlines():
-                if not line.strip():
-                    result_lines.append('')
-                    continue
-                    
-                # Calculate final indentation:
-                # 1. Get current line's indentation
-                line_indent = self.searcher.get_indentation(line)
-                # 2. Calculate relative indent compared to new content's first line
-                rel_indent = len(line_indent) - len(new_base_indent)
-                # 3. Apply base indent + relative indent, adjusting for negative space
-                final_indent_len = max(0, len(line_indent) - left_shift + (len(base_indent) - len(new_base_indent)))
-                final_indent = ' ' * final_indent_len
-                result_lines.append(final_indent + line.lstrip())
-                
-            new_content = '\n'.join(result_lines)
-            
-        return content + new_content
-
-    def _handle_failed_search(self, filepath: Path, search_text: str, content: str) -> str:
-        """Handle failed search by logging debug info in a test case format"""
-        failed_file = config.workspace_dir / '.janito' / 'change_history' / f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_changes_failed.txt"
-        failed_file.parent.mkdir(parents=True, exist_ok=True)
-
-        # Create test case format debug info
-        debug_info = f"""Test: Failed search in {filepath.name}
-========================================
-Original:
-{content}
-========================================
-Search pattern:
-{search_text}
-========================================"""
-
-        failed_file.write_text(debug_info)
-
-        self.console.print(f"[yellow]Changes failed saved to: {failed_file}[/yellow]")
-        self.console.print("[yellow]Run with 'python -m janito.search_replace {failed_file}' to debug[/yellow]")
-
-        return f"Could not apply change to {filepath} - pattern not found"
-
-    def debug_failed_finds(self, search_content: str, file_content: str, filepath: str) -> None:
-        """Debug find operations without applying changes"""
-        if not search_content or not file_content:
-            self.console.print("[yellow]Missing search or file content for debugging[/yellow]")
-            return
-
-        self.console.print(f"\n[cyan]Debugging finds for {filepath}:[/cyan]")
-        self.debugger.debug_find(file_content, search_content)
-
-    def extract_debug_info(self, content: str) -> tuple[Optional[str], Optional[str], Optional[str]]:
-        """Extract search text and file content from failed change debug info.
-        
-        Only matches section markers ("========================================")
-        when they appear alone on a line.
-        """
-        try:
-            marker = "=" * 40
-            lines = content.splitlines()
-            section_starts = [i for i, line in enumerate(lines) if line.strip() == marker]
-            
-            if len(section_starts) < 3:
-                raise ValueError("Missing section markers in debug file")
-                
-            # Extract content between markers
-            original_start = section_starts[0] + 2  # +1 for section header, +1 for marker
-            search_start = section_starts[1] + 2
-            original_content = "\n".join(lines[original_start:section_starts[1]])
-            search_content = "\n".join(lines[search_start:section_starts[2]])
-
-            # Extract filename from first line
-            if not lines[0].startswith("Test: Failed search in "):
-                raise ValueError("Invalid debug file format")
-            filepath = lines[0].replace("Test: Failed search in ", "").strip()
-
-            if not all([filepath, search_content, original_content]):
-                raise ValueError("Missing required sections in debug file")
-
-            return filepath, search_content, original_content
-
-        except Exception as e:
-            self.console.print(f"[red]Error parsing debug info: {e}[/red]")
-            return None, None, None

janito/change/applier/workspace_dir.py

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

@@ -1,124 +0,0 @@
-from pathlib import Path
-from typing import Optional, Tuple, 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.workset import Workset  # Update import to use Workset directly
-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()
-    workset = Workset()  # Create workset instance
-
-    
-    # Analyze workspace content
-    workset.show()
-
-    # Get analysis of the request using workset content
-    analysis = analyze_request(request)
-    if not analysis:
-        console.print("[red]Analysis failed or interrupted[/red]")
-        return False, None
-
-    # Build and send prompt
-    prompt = build_change_request_prompt(request, analysis.format_option_text())
-    response = progress_send_message(prompt)
-    if not response:
-        console.print("[red]Failed to get response from AI[/red]")
-        return False, None
-
-    # Save to history and process response
-    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
-
-    # Show request and response info
-    response_info = extract_response_info(response)
-    console.print("\n")
-    console.print(Columns([
-        Panel(request, title="User Request", border_style="cyan", box=box.ROUNDED),
-        Panel(
-            response_info if response_info else "No additional information provided",
-            title="Response Information",
-            border_style="green",
-            box=box.ROUNDED
-        )
-    ], equal=True, expand=True))
-    console.print("\n")
-
-    if preview_only:
-        preview_all_changes(console, changes)
-        return True, history_file
-
-    # 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/change/history.py

@@ -1,44 +0,0 @@
-from pathlib import Path
-from datetime import datetime
-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() -> Path:
-    """Create and return the history directory path"""
-    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_failed' in name:
-        return 'changes_failed'
-    elif '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 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()
-    
-    # Create history entry with request and changes
-    filename = f"{APP_TIMESTAMP}_changes.txt"
-    history_file = history_dir / filename
-    history_content = f"""Request: {request}
-Timestamp: {APP_TIMESTAMP}
-
-Changes:
-{content}
-"""
-    history_file.write_text(history_content)
-    return history_file