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

janito/change/request.py

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

janito/change/validator.py

@@ -1,87 +0,0 @@
-from pathlib import Path
-from typing import Set
-import ast
-import yaml
-import subprocess
-import sys
-import os
-
-class Validator:
-    def __init__(self, preview_dir: Path):
-        self.preview_dir = preview_dir
-        self.validated_files: Set[Path] = set()
-
-    def validate_python_syntax(self, filepath: Path):
-        """Validate Python file syntax using ast."""
-        try:
-            with open(filepath, 'r', encoding="utf-8") as file:
-                content = file.read()
-            ast.parse(content, filename=str(filepath))
-        except SyntaxError as e:
-            raise ValueError(f"Python syntax error in {filepath}: {e}")
-        except Exception as e:
-            raise ValueError(f"Error validating {filepath}: {e}")
-
-    def validate_files(self, files: Set[Path]):
-        """Validate all modified files."""
-        for filepath in files:
-            full_path = self.preview_dir / filepath
-            if not full_path.exists():
-                raise ValueError(f"File not found after changes: {filepath}")
-                
-            if filepath.suffix == '.py':
-                self.validate_python_syntax(full_path)
-            
-            self.validated_files.add(filepath)
-            from rich import print as rprint
-            rprint(f"[green]✓[/green] Validated [cyan]{filepath}[/cyan]")
-
-    def run_tests(self):
-        """Run tests if configured in janito.yaml."""
-        config_file = self.preview_dir / 'janito.yaml'
-        if not config_file.exists():
-            print("No test configuration found")
-            return
-
-        try:
-            with open(config_file) as f:
-                config = yaml.safe_load(f)
-            
-            test_cmd = config.get('test_cmd')
-            if not test_cmd:
-                print("No test_cmd found in configuration")
-                return
-
-            print(f"Running test command: {test_cmd}")
-            
-            # Save current directory
-            original_dir = Path.cwd()
-            try:
-                # Change to preview directory
-                os.chdir(self.preview_dir)
-                # Run the test command
-                exit_code = os.system(test_cmd)
-            finally:
-                # Restore original directory
-                os.chdir(original_dir)
-            
-            if exit_code != 0:
-                raise ValueError(f"Test command failed with exit code {exit_code}")
-            
-            from rich.panel import Panel
-            from rich import print as rprint
-            
-            # Create a summary panel
-            validated_files_list = "\n".join([f"[cyan]• {f}[/cyan]" for f in sorted(self.validated_files)])
-            summary = Panel(
-                f"[green]✓[/green] All files validated successfully:\n\n{validated_files_list}",
-                title="[bold green]Validation Summary[/bold green]",
-                border_style="green"
-            )
-            rprint("\n" + summary + "\n")
-            print("Tests completed successfully")
-
-        except yaml.YAMLError as e:
-            raise ValueError(f"Error parsing janito.yaml: {e}")
-        except Exception as e:
-            raise ValueError(f"Error running tests: {e}")

janito/change/view/content.py

@@ -1,63 +0,0 @@
-from typing import Optional
-from pathlib import Path
-from rich.syntax import Syntax
-
-
-# Mapping of file extensions to syntax lexer names
-FILE_EXTENSION_MAP = {
-    '.py': 'python',
-    '.js': 'javascript',
-    '.ts': 'typescript',
-    '.html': 'html',
-    '.css': 'css',
-    '.json': 'json',
-    '.md': 'markdown',
-    '.yaml': 'yaml',
-    '.yml': 'yaml',
-    '.sh': 'bash',
-    '.bash': 'bash',
-    '.sql': 'sql',
-    '.xml': 'xml',
-    '.cpp': 'cpp',
-    '.c': 'c',
-    '.h': 'cpp',
-    '.hpp': 'cpp',
-    '.java': 'java',
-    '.go': 'go',
-    '.rs': 'rust',
-}
-
-def get_file_syntax(filepath: Path) -> Optional[str]:
-    """Get syntax lexer name based on file extension.
-    
-    Args:
-        filepath: Path object containing the file path
-        
-    Returns:
-        String containing the syntax lexer name or None if not found
-    """
-    return ext_map.get(filepath.suffix.lower())
-
-def create_content_preview(filepath: Path, content: str, is_new: bool = False) -> Syntax:
-    """Create a preview with syntax highlighting using consistent styling
-
-    Args:
-        filepath: Path to the file being previewed
-        content: Content to preview
-        is_new: Whether this is a new file preview
-
-    Returns:
-        Syntax highlighted content
-    """
-    # Get file info
-    syntax_type = get_file_syntax(filepath)
-
-    # Create syntax highlighted content
-    return Syntax(
-        content,
-        syntax_type or "text",
-        theme="monokai",
-        line_numbers=True,
-        word_wrap=True,
-        tab_size=4
-    )

janito/change/view/diff.py

@@ -1,44 +0,0 @@
-from typing import List, Tuple
-from difflib import SequenceMatcher
-
-def find_common_sections(search_lines: List[str], replace_lines: List[str]) -> Tuple[List[str], List[str], List[str], List[str], List[str]]:
-    """Find common sections between search and replace content"""
-    # Find common lines from top
-    common_top = []
-    for s, r in zip(search_lines, replace_lines):
-        if s == r:
-            common_top.append(s)
-        else:
-            break
-
-    # Find common lines from bottom
-    search_remaining = search_lines[len(common_top):]
-    replace_remaining = replace_lines[len(common_top):]
-
-    common_bottom = []
-    for s, r in zip(reversed(search_remaining), reversed(replace_remaining)):
-        if s == r:
-            common_bottom.insert(0, s)
-        else:
-            break
-
-    # Get the unique middle sections
-    search_middle = search_remaining[:-len(common_bottom)] if common_bottom else search_remaining
-    replace_middle = replace_remaining[:-len(common_bottom)] if common_bottom else replace_remaining
-
-    return common_top, search_middle, replace_middle, common_bottom, search_lines
-
-
-def find_similar_lines(deleted_lines: List[str], added_lines: List[str], similarity_threshold: float = 0.5) -> List[Tuple[int, int, float]]:
-    """Find similar lines between deleted and added content"""
-    similar_pairs = []
-    for i, del_line in enumerate(deleted_lines):
-        for j, add_line in enumerate(added_lines):
-            similarity = get_line_similarity(del_line, add_line)
-            if similarity >= similarity_threshold:
-                similar_pairs.append((i, j, similarity))
-    return similar_pairs
-
-def get_line_similarity(line1: str, line2: str) -> float:
-    """Calculate similarity ratio between two lines"""
-    return SequenceMatcher(None, line1, line2).ratio()

janito/change/view/panels.py

@@ -1,201 +0,0 @@
-from rich.console import Console
-from typing import List, Tuple
-from rich.panel import Panel
-from rich.syntax import Syntax
-from pathlib import Path
-from rich.columns import Columns
-from rich.text import Text
-from rich.layout import Layout
-from ..edit_blocks import EditType, CodeChange
-from .styling import format_content
-from .sections import find_modified_sections
-
-# Constants for panel layout
-PANEL_MIN_WIDTH = 40
-PANEL_MAX_WIDTH = 120
-PANEL_PADDING = 4
-COLUMN_SPACING = 4
-
-def create_diff_columns(
-    original_section: List[str], 
-    modified_section: List[str], 
-    filename: str,
-    start: int,
-    term_width: int,
-    context_lines: int = 3,
-    current_change: int = 1,
-    total_changes: int = 1,
-    operation: str = "Edit",
-    reason: str = None,
-    is_removal: bool = False
-) -> Tuple[Text, Columns]:  # Changed return type to return header and content separately
-    """Create side-by-side diff view with consistent styling and context."""
-    # Create header with progress info and rule
-    header = Text()
-    header_text, header_style = create_progress_header(
-        operation=operation,
-        filename=filename,
-        current=current_change,
-        total=total_changes,
-        term_width=term_width,
-        reason=reason
-    )
-    
-    header.append(header_text)
-    header.append("\n")
-    header.append("─" * term_width, style="dim")
-
-    # Find sections that have changed
-    sections = find_modified_sections(
-        original_section,
-        modified_section,
-        context_lines=context_lines
-    )
-    
-    if not sections:
-        # If no differences, show full content
-        diff_columns = _create_single_section_columns(
-            original_section,
-            modified_section,
-            filename,
-            start,
-            term_width,
-            is_removal=is_removal
-        )
-    else:
-        # Create columns for each modified section
-        rendered_sections = []
-        for i, (orig, mod) in enumerate(sections):
-            if i > 0:
-                rendered_sections.append(Text("...\n", style="dim"))
-                
-            section_columns = _create_single_section_columns(
-                orig, mod, filename, start, term_width, is_removal=is_removal
-            )
-            rendered_sections.append(section_columns)
-        
-        # Create single column containing all sections
-        diff_columns = Columns(
-            rendered_sections,
-            equal=False,
-            expand=False,
-            padding=(0, 0)
-        )
-
-    return header, diff_columns
-
-def _create_single_section_columns(
-    original: List[str],
-    modified: List[str],
-    filename: str, 
-    start: int,
-    term_width: int,
-    is_removal: bool = False  # Add parameter with default value
-) -> Columns:
-    """Create columns for a single diff section."""
-    left_width, right_width = calculate_panel_widths(
-        '\n'.join(original),
-        '\n'.join(modified),
-        term_width
-    )
-
-    # Format content with correct parameters
-    left_content = format_content(
-        original,
-        search_lines=original,
-        replace_lines=modified,
-        is_search=True,  # This indicates it's the original/search content
-        width=left_width,
-        is_removal=is_removal  # Pass the parameter
-    )
-    right_content = format_content(
-        modified,
-        search_lines=original,
-        replace_lines=modified,
-        is_search=False,  # This indicates it's the modified/replace content
-        width=right_width
-    )
-
-    left_text = create_panel_text("Original", left_content, left_width)
-    right_text = create_panel_text("Modified", right_content, right_width)
-
-    # Create columns without manual padding
-    columns = Columns(
-        [
-            left_text,
-            Text(" " * COLUMN_SPACING),
-            right_text
-        ],
-        equal=False,
-        expand=False,
-        padding=(0, 0)
-    )
-
-    return columns
-
-def calculate_panel_widths(left_content: str, right_content: str, term_width: int) -> Tuple[int, int]:
-    """Calculate optimal widths for side-by-side panels with overflow protection."""
-    available_width = term_width - PANEL_PADDING - COLUMN_SPACING
-
-    left_max = max((len(line) for line in left_content.splitlines()), default=0)
-    right_max = max((len(line) for line in right_content.splitlines()), default=0)
-
-    left_max = max(PANEL_MIN_WIDTH, min(left_max, PANEL_MAX_WIDTH))
-    right_max = max(PANEL_MIN_WIDTH, min(right_max, PANEL_MAX_WIDTH))
-
-    if (left_max + right_max) <= available_width:
-        return left_max, right_max
-
-    ratio = left_max / (left_max + right_max)
-    left_width = min(
-        PANEL_MAX_WIDTH,
-        max(PANEL_MIN_WIDTH, int(available_width * ratio))
-    )
-    right_width = min(
-        PANEL_MAX_WIDTH,
-        max(PANEL_MIN_WIDTH, available_width - left_width)
-    )
-
-    return left_width, right_width
-
-def create_panel_text(title: str, content: str, width: int) -> Text:
-    """Create a text container with centered title."""
-    text = Text()
-    title_padding = (width - len(title)) // 2
-    color = "red" if title == "Original" else "green"
-    text.append(" " * title_padding + title + " " * title_padding, style=f"{color} bold")
-    text.append("\n")
-    text.append(content)
-    return text
-
-def create_progress_header(operation: str, filename: str, current: int, total: int,
-                          term_width: int, reason: str = None, style: str = "cyan") -> Tuple[Text, str]:
-    """Create a header showing filename and global change counter.
-
-    Args:
-        operation: Type of operation being performed
-        filename: Name of the file being modified
-        current: Current global change number
-        total: Total number of changes
-        term_width: Width of the terminal
-        reason: Optional reason for the change
-        style: Color style for the header
-
-    Returns:
-        Tuple of (Rich Text object, style)
-    """
-    text = Text()
-    header = f"{operation}: {filename} | Progress {current}/{total}"
-    if reason:
-        header += f" | {reason}"
-    
-    # Calculate padding for centering
-    padding = (term_width - len(header)) // 2
-    
-    # Create full-width background by padding both sides
-    full_line = " " * padding + header + " " * (term_width - len(header) - padding)
-    
-    # Apply background color to entire line with better contrast
-    text.append(full_line, style=f"white on dark_blue")
-
-    return text, style

janito/change/view/sections.py

@@ -1,69 +0,0 @@
-from typing import List, Tuple, Set
-
-def find_modified_sections(original: list[str], modified: list[str], context_lines: int = 3) -> list[tuple[list[str], list[str]]]:
-    """
-    Find modified sections between original and modified text with surrounding context.
-    Merges sections with separator lines.
-
-    Args:
-        original: List of original lines
-        modified: List of modified linesn
-        context_lines: Number of unchanged context lines to include
-
-    Returns:
-        List of tuples containing (original_section, modified_section) line pairs
-    """
-    # Find different lines
-    different_lines = get_different_lines(original, modified)
-    if not different_lines:
-        return []
-
-    return create_sections(original, modified, different_lines, context_lines)
-
-def get_different_lines(original: List[str], modified: List[str]) -> Set[int]:
-    """Find lines that differ between original and modified content"""
-    different_lines = set()
-    for i in range(max(len(original), len(modified))):
-        if i >= len(original) or i >= len(modified):
-            different_lines.add(i)
-        elif original[i] != modified[i]:
-            different_lines.add(i)
-    return different_lines
-
-def create_sections(original: List[str], modified: List[str], 
-                   different_lines: Set[int], context_lines: int) -> List[Tuple[List[str], List[str]]]:
-    """Create sections from different lines with context"""
-    current_section = set()
-    orig_content = []
-    mod_content = []
-
-    for line_num in sorted(different_lines):
-        if not current_section or line_num <= max(current_section) + context_lines * 2:
-            current_section.add(line_num)
-        else:
-            process_section(original, modified, current_section, orig_content, 
-                          mod_content, context_lines)
-            current_section = {line_num}
-
-    if current_section:
-        process_section(original, modified, current_section, orig_content, 
-                       mod_content, context_lines)
-
-    return [(orig_content, mod_content)] if orig_content else []
-
-def process_section(original: List[str], modified: List[str], 
-                   current_section: Set[int], orig_content: List[str], 
-                   mod_content: List[str], context_lines: int) -> None:
-    """Process a section and add it to the content lists"""
-    start = max(0, min(current_section) - context_lines)
-    end = min(max(len(original), len(modified)),
-             max(current_section) + context_lines + 1)
-
-    # Add separator if needed
-    if orig_content:
-        orig_content.append("...")
-        mod_content.append("...")
-
-    # Add section content
-    orig_content.extend(original[start:end])
-    mod_content.extend(modified[start:end])