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

janito/change/applier.py

@@ -0,0 +1,167 @@
+from typing import List
+from pathlib import Path
+from janito.config import config
+from .finder import find_range, EditContentNotFoundError
+from .edit_blocks import EditType, CodeChange
+from .applied_blocks import AppliedBlock, AppliedBlocks
+
+class ChangeApplier:
+    def __init__(self, target_dir: Path):
+        self.target_dir = target_dir
+        self.edits: List[CodeChange] = []
+        self._last_changed_line = 0
+        self.current_file = None
+        self.current_content: List[str] = []
+        self.applied_blocks = AppliedBlocks(blocks=[])
+
+    def add_edit(self, edit: CodeChange):
+        self.edits.append(edit)
+
+    def start_file_edit(self, filename: str, edit_type: EditType):
+        if self.current_file:
+            self.end_file_edit()
+        self._last_changed_line = 0
+        self.current_file = filename
+        self.current_edit_type = edit_type  # Store edit type for end_file_edit
+        
+        if edit_type == EditType.CREATE:
+            self.current_content = []
+        elif edit_type == EditType.DELETE:
+            if not (self.target_dir / filename).exists():
+                raise FileNotFoundError(f"Cannot delete non-existent file: {filename}")
+            self.current_content = []
+        else:
+            self.current_content = (self.target_dir / filename).read_text(encoding="utf-8").splitlines()
+    
+    def end_file_edit(self):
+        if self.current_file:
+            target_path = self.target_dir / self.current_file
+            if hasattr(self, 'current_edit_type') and self.current_edit_type == EditType.DELETE:
+                if target_path.exists():
+                    target_path.unlink()
+            else:
+                # Create parent directories if they don't exist
+                target_path.parent.mkdir(parents=True, exist_ok=True)
+                target_path.write_text("\n".join(self.current_content), encoding="utf-8")
+        self.current_file = None
+
+    def apply(self):
+        """Apply all edits and show summary of changes."""
+        # Ensure target directory exists
+        self.target_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Track changes as we apply them
+        changes = []
+        current_file = None
+        
+        # Process edits in order as they were added
+        for edit in self.edits:
+            if current_file != edit.filename:
+                self.end_file_edit()
+                self.start_file_edit(str(edit.filename), edit.edit_type)
+                current_file = edit.filename
+            self._apply_and_collect_change(edit)
+
+        self.end_file_edit()
+
+    def _apply_and_collect_change(self, edit: CodeChange) -> AppliedBlock:
+        """Apply a single edit and collect its change information."""
+        if edit.edit_type == EditType.CREATE:
+            self.current_content = edit.modified
+            applied_block = AppliedBlock(
+                filename=edit.filename,
+                edit_type=edit.edit_type,
+                reason=edit.reason,
+                original_content=[],
+                modified_content=edit.modified,
+                range_start=1,
+                range_end=len(edit.modified),
+                block_marker=edit.block_marker
+            )
+
+        elif edit.edit_type == EditType.DELETE:
+            applied_block = AppliedBlock(
+                filename=edit.filename,
+                edit_type=edit.edit_type,
+                reason=edit.reason,
+                original_content=self.current_content,
+                modified_content=[],
+                range_start=1,
+                range_end=len(self.current_content),
+                block_marker=edit.block_marker
+            )
+            self.current_content = []
+
+        elif edit.edit_type == EditType.CLEAN:
+            try:
+                start_range = find_range(self.current_content, edit.original, self._last_changed_line)
+                try:
+                    end_range = find_range(self.current_content, edit.modified, start_range[1])
+                except EditContentNotFoundError:
+                    end_range = (start_range[1], start_range[1])
+                
+                section = self.current_content[start_range[0]:end_range[1]]
+                applied_block = AppliedBlock(
+                    filename=edit.filename,
+                    edit_type=edit.edit_type,
+                    reason=edit.reason,
+                    original_content=section,
+                    modified_content=[],
+                    range_start=start_range[0] + 1,
+                    range_end=end_range[1],
+                    block_marker=edit.block_marker
+                )
+                
+                self.current_content[start_range[0]:end_range[1]] = []
+                self._last_changed_line = start_range[0]
+                
+            except ValueError as e:
+                error_msg = f"Failed to find clean section in {self.current_file}: {e}"
+                applied_block = AppliedBlock(
+                    filename=edit.filename,
+                    edit_type=edit.edit_type,
+                    reason=edit.reason,
+                    original_content=self.current_content,
+                    modified_content=[],
+                    range_start=1,
+                    range_end=len(self.current_content),
+                    block_marker=edit.block_marker,
+                    error_message=error_msg,
+                    has_error=True
+                )
+
+        else:  # EDIT operation
+            try:
+                edit_range = find_range(self.current_content, edit.original, self._last_changed_line)
+                original_section = self.current_content[edit_range[0]:edit_range[1]]
+                
+                applied_block = AppliedBlock(
+                    filename=edit.filename,
+                    edit_type=edit.edit_type,
+                    reason=edit.reason,
+                    original_content=original_section,
+                    modified_content=edit.modified,
+                    range_start=edit_range[0] + 1,
+                    range_end=edit_range[0] + len(edit.original),
+                    block_marker=edit.block_marker
+                )
+                
+                self._last_changed_line = edit_range[0] + len(edit.original)
+                self.current_content[edit_range[0]:edit_range[1]] = edit.modified
+            except EditContentNotFoundError as e:
+                error_msg = f"Failed to find edit section in {self.current_file}: {e}"
+                applied_block = AppliedBlock(
+                    filename=edit.filename,
+                    edit_type=edit.edit_type,
+                    reason=edit.reason,
+                    original_content=edit.original,
+                    modified_content=edit.modified,
+                    range_start=self._last_changed_line + 1,
+                    range_end=self._last_changed_line + len(edit.original),
+                    block_marker=edit.block_marker,
+                    error_message=error_msg,
+                    has_error=True
+                )
+
+        self.applied_blocks.blocks.append(applied_block)
+        return applied_block

janito/change/edit_blocks.py

@@ -0,0 +1,148 @@
+from dataclasses import dataclass
+from pathlib import Path
+from enum import Enum, auto
+from typing import List, Tuple, Dict
+import string
+
+class EditType(Enum):
+    CREATE = auto()
+    EDIT = auto()
+    DELETE = auto()
+    CLEAN = auto()
+
+@dataclass
+class CodeChange:
+    filename: Path
+    reason: str
+    original: List[str]  # Changed from 'before'
+    modified: List[str]  # Changed from 'after'
+    edit_type: EditType = EditType.EDIT
+    block_marker: str = None  # Track which code block this change came from
+
+def parse_edit_command(line: str, command: str) -> tuple[Path, str]:
+    """Parse an Edit or Create command line to extract filename and reason.
+    Expected format: Command filename "reason"
+    Example: Edit path/to/file.py "Add new feature"
+    """
+    if not line or not line.startswith(command):
+        raise ValueError(f"Invalid command format in line:\n{line}\nExpected: {command} filename \"reason\"")
+        
+    # Split by quote to separate filename from reason
+    parts = line.split('"')
+    if len(parts) < 2:
+        raise ValueError(f"Missing reason in quotes in line:\n{line}")
+        
+    filename = Path(parts[0].replace(f"{command} ", "").strip())
+    reason = parts[1].strip()
+    
+    return filename, reason
+
+def get_edit_blocks(response: str) -> Tuple[List[CodeChange], str]:
+    """Parse response text into a list of CodeChange objects and annotated response.
+    
+    The format expected from the response follows the system prompt:
+    
+    Edit file "reason"
+    <<<< original
+    {original code}
+    >>>> modified
+    {modified code}
+    ====
+    
+    Clean file "reason"
+    <<<< starting
+    {start marker lines}
+    >>>> ending
+    {end marker lines}
+    ====
+    """
+    edit_blocks = []
+    modified_response = []
+    current_block = []
+    original_content = None
+    current_command = None
+    marker_index = 0
+    in_block = False
+
+    for line in response.splitlines():
+        # Handle command lines
+        if line.startswith(("Edit ", "Create ", "Delete ", "Clean ")):
+            command = line.split(" ")[0]
+            filename, reason = parse_edit_command(line, command)
+            current_command = command
+            # Reset state for new command
+            original_content = None
+            current_block = []
+            # Add marker for this edit block
+            current_marker = string.ascii_uppercase[marker_index]
+            modified_response.append(f"[Edit Block {current_marker}]")
+            marker_index += 1
+            continue
+            
+        # Add the line to modified_response unless we're in a code block or it's a block marker
+        if not in_block and not line.startswith(("<<<< ", ">>>> ", "====")):
+            modified_response.append(line)
+            
+        # Handle block markers - Update to match system prompt
+        if line.startswith("<<<< original") or line.startswith("<<<< starting"):
+            current_block = []
+            in_block = True
+            if current_command == "Clean":
+                original_content = None
+        elif line.startswith(">>>> modified") or line.startswith(">>>> ending"):
+            if current_command == "Clean":
+                original_content = current_block
+            elif not original_content and current_block:
+                original_content = current_block
+            current_block = []
+            in_block = True
+        elif line == "====":  # End of edit block
+            # Trim empty lines at start and end of blocks
+            def trim_block(block: List[str]) -> List[str]:
+                if not block:
+                    return []
+                # Remove empty lines at start and end
+                while block and not block[0].strip():
+                    block.pop(0)
+                while block and not block[-1].strip():
+                    block.pop()
+                return block
+
+            if current_command == "Delete":
+                edit_blocks.append(CodeChange(filename, reason, [], [], EditType.DELETE, current_marker))
+            elif current_command == "Clean":
+                edit_blocks.append(CodeChange(
+                    filename, reason,
+                    trim_block(original_content or []),
+                    trim_block(current_block),
+                    EditType.CLEAN,
+                    current_marker
+                ))
+            elif current_command == "Create":
+                edit_blocks.append(CodeChange(
+                    filename, reason,
+                    [],
+                    trim_block(current_block),
+                    EditType.CREATE,
+                    current_marker
+                ))
+            elif current_command == "Edit":
+                original = trim_block(original_content or [])
+                modified = trim_block(current_block)
+                edit_blocks.append(CodeChange(
+                    filename, reason,
+                    original,
+                    modified,
+                    EditType.EDIT,
+                    current_marker
+                ))
+            
+            # Reset state after block is completed
+            current_block = []
+            in_block = False
+            current_command = None
+            original_content = None
+        elif in_block:
+            current_block.append(line)
+
+    return edit_blocks, "\n".join(modified_response)

janito/change/finder.py

@@ -0,0 +1,72 @@
+from typing import List, Tuple
+from difflib import SequenceMatcher
+
+class EditContentNotFoundError(ValueError):
+    """Raised when edit content cannot be found in the target file."""
+    pass
+
+SIMILARITY_THRESHOLD = 0.8  # Minimum similarity required for a match
+
+def find_range(full_lines: List[str], changed_lines: List[str], start: int = 0) -> Tuple[int, int]:
+    """Find the range of the first occurrence of the changed_lines in the full_lines list.
+    
+    Args:
+        full_lines: The complete text content to search within
+        changed_lines: The block of lines to find
+        start: The line number to start searching from
+        
+    Returns:
+        Tuple of (start_line, end_line) where the block was found
+        
+    Raises:
+        ValueError: If no matching block is found with sufficient similarity
+    """
+    _validate_inputs(full_lines, changed_lines, start)
+    
+    if not changed_lines:
+        return (start, start)
+
+    best_match, best_score = _find_best_matching_block(full_lines, changed_lines, start)
+    
+    if not best_match or best_score < SIMILARITY_THRESHOLD:
+        _raise_no_match_error(changed_lines, start, best_score)
+        
+    return best_match
+
+def _validate_inputs(full_lines: List[str], changed_lines: List[str], start: int) -> None:
+    if start >= len(full_lines):
+        raise ValueError(f"Start position {start} is beyond content length {len(full_lines)}")
+
+def _find_best_matching_block(full_lines: List[str], changed_lines: List[str], start: int) -> Tuple[Tuple[int, int], float]:
+    best_match = None
+    best_score = 0.0
+    
+    for i in range(start, len(full_lines) - len(changed_lines) + 1):
+        window = full_lines[i:i + len(changed_lines)]
+        if len(window) != len(changed_lines):
+            continue
+            
+        similarity = _calculate_similarity(window, changed_lines)
+        
+        if similarity > best_score:
+            best_score = similarity
+            best_match = (i, i + len(changed_lines))
+            
+            if similarity == 1.0:  # Early exit on perfect match
+                break
+    
+    return best_match, best_score
+
+def _calculate_similarity(window: List[str], changed_lines: List[str]) -> float:
+    return sum(
+        SequenceMatcher(None, a, b).ratio() 
+        for a, b in zip(window, changed_lines)
+    ) / len(changed_lines)
+
+def _raise_no_match_error(changed_lines: List[str], start: int, best_score: float) -> None:
+    sample = "\n".join(changed_lines[:3]) + ("..." if len(changed_lines) > 3 else "")
+    raise EditContentNotFoundError(
+        f"Could not find matching block after line {start}. "
+        f"Looking for:\n{sample}\n"
+        f"Best match score: {best_score:.2f}"
+    )

janito/change/request.py

@@ -0,0 +1,144 @@
+from rich.console import Console
+from janito.common import progress_send_message, _get_system_prompt
+from janito.workspace import workset, workspace
+from janito.config import config
+from pathlib import Path
+import tempfile
+from janito.change.applier import ChangeApplier
+from janito.change.validator import Validator
+from janito.change.edit_blocks import EditType, CodeChange, get_edit_blocks
+from typing import List, Dict, Optional
+import shutil
+from rich.markdown import Markdown
+import importlib.resources
+from .view.viewer import ChangeViewer
+        
+def _get_change_prompt() -> str:
+    """Get the change prompt from the package data or local file."""
+    try:
+        # First try to read from package data
+        with importlib.resources.files('janito.data').joinpath('change_prompt.txt').open('r') as f:
+            return f.read()
+    except Exception:
+        # Fallback to local file for development
+        local_path = Path(__file__).parent.parent / 'data' / 'change_prompt.txt'
+        if local_path.exists():
+            return local_path.read_text()
+        raise FileNotFoundError("Could not find change_prompt.txt")
+
+def request_change(request: str) -> str:
+    """Process a change request for the codebase and return the response."""
+
+    change_prompt = _get_change_prompt()
+    
+    prompt = change_prompt.format(
+        request=request,
+        workset=workset.content
+    )
+    response = progress_send_message(prompt)
+
+    if response is None:
+        return "Sorry, the response was interrupted. Please try your request again."
+
+
+    # Store response in workspace directory
+    response_file = (config.workspace_dir or Path(".")) / '.janito_last_response.txt'
+    response_file.parent.mkdir(parents=True, exist_ok=True)
+    response_file.write_text(response, encoding='utf-8')
+    if config.debug:
+        print(f"Response saved to {response_file}")
+    handler = ResponseHandler(response)
+    handler.process()
+
+class ResponseHandler:
+
+    def __init__(self, response: str):
+        self.response = response
+        self.console = Console()
+        self.edit_blocks = []
+        self.viewer = None
+        self.applied_blocks = None  # Store applied blocks reference
+
+    def show_block_changes(self, block_marker: str):
+        """Callback to display changes for a specific block marker"""
+        if block_marker and self.applied_blocks:
+            # Find the block with matching marker and show it
+            for block in self.applied_blocks.blocks:
+                if block.block_marker == block_marker:
+                    self.viewer._show_block(block)
+                    break
+
+    def process(self):
+        self.edit_blocks, self.annotated_response = get_edit_blocks(self.response)
+        
+        # Setup preview directory and applier
+        preview_dir = workspace.setup_preview_directory()
+        applier = ChangeApplier(preview_dir)
+        self.viewer = ChangeViewer()
+
+        # Apply changes
+        for block in self.edit_blocks:
+            applier.add_edit(block)
+        applier.apply()
+        
+        # Store reference to applied blocks
+        self.applied_blocks = applier.applied_blocks
+
+        # Split response into sections and display with changes
+        sections = self.annotated_response.split("[Edit Block ")
+
+        if sections:
+            self.console.print(Markdown(sections[0]))  # Print initial text
+            for section in sections[1:]:
+                marker, text = section.split("]", 1)
+                # Find and show the corresponding block's changes
+                for block in self.applied_blocks.blocks:
+                    if block.block_marker == marker:
+                        self.viewer._show_block(block)
+                        break
+                self.console.print(Markdown(text))  # Print text after the block
+
+        # Add horizontal ruler to separate changes from validation
+        self.console.rule("[bold]Validation", style="dim")
+
+        # Collect files that need validation (excluding deleted files)
+        files_to_validate = {edit.filename for edit in self.edit_blocks 
+                           if edit.edit_type != EditType.DELETE}
+
+        # Validate changes and run tests
+        validator = Validator(preview_dir)
+        validator.validate_files(files_to_validate)
+        validator.run_tests()
+
+        # Collect the list of created/modified/deleted files
+        created_files = [edit.filename for edit in self.edit_blocks if edit.edit_type == EditType.CREATE]
+        modified_files = set(edit.filename for edit in self.edit_blocks 
+                           if edit.edit_type in (EditType.EDIT, EditType.CLEAN))  # Include cleaned files
+        deleted_files = set(edit.filename for edit in self.edit_blocks if edit.edit_type == EditType.DELETE)
+
+        # prompt the user if we want to apply the changes
+        if config.auto_apply:
+            apply_changes = True
+        else:  
+            self.console.print("\nApply changes to the workspace? [y/N] ", end="")
+            response = input().lower()
+            apply_changes = response.startswith('y')
+            if not apply_changes:
+                self.console.print("[yellow]Changes were not applied. Exiting...[/yellow]")
+                return
+
+        # Apply changes to workspace
+        workspace.apply_changes(preview_dir, created_files, modified_files, deleted_files)
+
+def replay_saved_response():
+    response_file = (config.workspace_dir or Path(".")) / '.janito_last_response.txt'
+    print(response_file)
+    if not response_file.exists():
+        print("No saved response found")
+        return
+    
+    with open(response_file, 'r', encoding="utf-8") as file:
+        response = file.read()
+        
+    handler = ResponseHandler(response)
+    handler.process()