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

janito/change/applier/text.py

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

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

janito/change/core.py

@@ -0,0 +1,124 @@
+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/{changehistory.py → change/history.py}

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

janito/change/operations.py

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