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

janito/change/view/panels.py

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

@@ -0,0 +1,69 @@
+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])

janito/change/view/styling.py

@@ -0,0 +1,140 @@
+from rich.text import Text
+from rich.console import Console
+from typing import List
+from .diff import find_similar_lines
+from .themes import DEFAULT_THEME, ColorTheme, ThemeType, get_theme_by_type
+
+current_theme = DEFAULT_THEME
+
+def set_theme(theme: ColorTheme) -> None:
+    """Set the current color theme"""
+    global current_theme
+    current_theme = theme
+
+def get_min_indent(lines: List[str]) -> int:
+    """Calculate the minimum indentation level across all non-empty lines."""
+    non_empty_lines = [line for line in lines if line.strip()]
+    if not non_empty_lines:
+        return 0
+    return min(len(line) - len(line.lstrip()) for line in non_empty_lines)
+
+def apply_line_style(line: str, style: str, width: int, full_width: bool = False) -> Text:
+    """Apply consistent styling to a single line with optional full width background"""
+    text = Text()
+    if full_width:
+        # For full width, pad the entire line
+        padded_line = line.ljust(width)
+        text.append(padded_line, style=style)
+    else:
+        # Left align the content and pad to width
+        text.append(line, style=style)
+        padding = " " * max(0, width - len(line))
+        text.append(padding, style=style)
+    
+    text.append("\n", style=style)
+    return text
+
+from textwrap import wrap
+
+def format_content(lines: List[str], search_lines: List[str] = None, replace_lines: List[str] = None,
+                  is_search: bool = False, width: int = 80, is_delete: bool = False, 
+                  is_removal: bool = False, syntax_type: str = None, is_append: bool = False) -> Text:
+    """Format content with appropriate styling based on operation type.
+    
+    Handles different content types:
+    - Regular content with diff highlighting
+    - Delete operations (red background)
+    - Append operations (green background)
+    - Text wrapping for long lines
+    """
+    text = Text()
+
+    # For delete operations, show all content with red background in a single column
+    if is_delete or is_removal:
+        bg_color = current_theme.line_backgrounds['removed' if is_removal else 'deleted']
+        style = f"{current_theme.text_color} on {bg_color}"
+        min_indent = get_min_indent(lines)
+        for line in lines:
+            processed_line = line[min_indent:] if line.strip() else line
+            text.append(apply_line_style(processed_line, style, width, full_width=True))
+        return text
+
+    # For append operations, show all lines as added
+    if is_append:
+        bg_color = current_theme.line_backgrounds['added']
+        style = f"{current_theme.text_color} on {bg_color}"
+        min_indent = get_min_indent(lines)
+        for line in lines:
+            if line.strip():
+                line = line[min_indent:]
+            text.append(apply_line_style(line, style, width, full_width=True))
+        return text
+
+    # Regular diff formatting
+    if search_lines and replace_lines:
+        # Find similar lines for better diff visualization
+        similar_pairs = find_similar_lines(search_lines, replace_lines)
+        similar_added = {j for _, j, _ in similar_pairs}
+        similar_deleted = {i for i, _, _ in similar_pairs}
+
+        # Create sets for comparison
+        search_set = set(search_lines)
+        replace_set = set(replace_lines)
+        common_lines = search_set & replace_set
+
+        def add_line(line: str, line_type: str = 'unchanged'):
+            bg_color = current_theme.line_backgrounds.get(line_type, current_theme.line_backgrounds['unchanged'])
+            style = f"{current_theme.text_color} on {bg_color}"
+
+            if syntax_type == 'python':
+                # Just use the background color without syntax highlighting
+                text.append(apply_line_style(line, style, width))
+                return
+
+            # Wrap long lines
+            if len(line) > width:
+                wrapped_lines = wrap(line, width=width, break_long_words=True, break_on_hyphens=False)
+                for wrapped in wrapped_lines:
+                    text.append(apply_line_style(wrapped, style, width))
+            else:
+                text.append(apply_line_style(line, style, width))
+
+        for i, line in enumerate(lines):
+            if not line.strip():  # Handle empty lines
+                add_line("", 'unchanged')
+            elif line in common_lines:
+                add_line(line, 'unchanged')
+            elif not is_search:
+                add_line(line, 'added')
+            else:
+                add_line(line, 'deleted')
+
+    return text
+
+from rich.panel import Panel
+from rich.columns import Columns
+
+def create_legend_items(console: Console) -> Panel:
+    """Create a compact legend panel with color blocks
+
+    Args:
+        console: Console instance for width calculation
+    """
+    text = Text()
+    term_width = console.width or 120
+
+    # Add color blocks for each type
+    for label, bg_type in [("Unchanged", "unchanged"),
+                          ("Deleted", "deleted"),
+                          ("Added", "added")]:
+        style = f"{current_theme.text_color} on {current_theme.line_backgrounds[bg_type]}"
+        text.append("  ", style=style)  # Color block
+        text.append(" " + label + " ")  # Label with spacing
+
+    return Panel(
+        text,
+        padding=(0, 1),
+        expand=False,
+        title="Legend",
+        title_align="center"
+    )

janito/change/view/summary.py

@@ -0,0 +1,37 @@
+from rich.table import Table
+from rich.console import Console
+from typing import List, Dict
+
+def show_changes_summary(changes_summary: List[Dict], console: Console) -> None:
+    """Show summary table of all changes."""
+    table = Table(title="Changes Summary")
+    table.add_column("File", style="cyan")
+    table.add_column("Type", style="magenta")
+    table.add_column("Lines Changed", justify="right", style="yellow")
+    table.add_column("Delta", justify="right", style="green")
+    table.add_column("Block", style="blue", justify="center")
+    table.add_column("Reason")
+
+    for change in changes_summary:
+        delta = change['lines_modified'] - change['lines_original']
+        delta_str = f"{'+' if delta > 0 else ''}{delta}"
+        
+        if change['type'] == "CREATE":
+            lines_info = f"+{change['lines_modified']} lines"
+        elif change['type'] in ("DELETE", "CLEAN"):
+            lines_info = f"-{change['lines_original']} lines"
+        else:
+            lines_info = f"{change['lines_original']} → {change['lines_modified']} lines"
+
+        table.add_row(
+            str(change['file']),
+            change['type'],
+            lines_info,
+            delta_str,
+            change['block_marker'] or '-',
+            change['reason']
+        )
+
+    console.print("\n")
+    console.print(table, justify="center")
+    console.print("\n")

janito/change/{viewer → view}/themes.py

@@ -1,55 +1,62 @@
-from dataclasses import dataclass
-from typing import Dict
-from enum import Enum
-
-class ThemeType(Enum):
-    DARK = "dark"
-    LIGHT = "light"
-
-# Dark theme colors
-DARK_LINE_BACKGROUNDS = {
-    'unchanged': '#1A1A1A',        
-    'added': '#003300',        
-    'deleted': '#660000'          
-}
-
-# Light theme colors
-LIGHT_LINE_BACKGROUNDS = {
-    'unchanged': 'grey93',         # Light gray for unchanged
-    'added': 'light_green',       # Semantic light green for additions
-    'deleted': 'light_red'        # Semantic light red for deletions
-}
-
-@dataclass
-class ColorTheme:
-    text_color: str
-    line_backgrounds: Dict[str, str]
-    theme_type: ThemeType
-
-# Predefined themes
-DARK_THEME = ColorTheme(
-    text_color="white",
-    line_backgrounds=DARK_LINE_BACKGROUNDS,
-    theme_type=ThemeType.DARK
-)
-
-LIGHT_THEME = ColorTheme(
-    text_color="black",
-    line_backgrounds=LIGHT_LINE_BACKGROUNDS,
-    theme_type=ThemeType.LIGHT
-)
-
-DEFAULT_THEME = DARK_THEME
-
-def validate_theme(theme: ColorTheme) -> bool:
-    """Validate that a theme contains all required colors"""
-    required_line_backgrounds = {'unchanged', 'added', 'deleted'}
-    
-    if not isinstance(theme, ColorTheme):
-        return False
-        
-    return all(bg in theme.line_backgrounds for bg in required_line_backgrounds)
-
-def get_theme_by_type(theme_type: ThemeType) -> ColorTheme:
-    """Get a predefined theme by type"""
-    return LIGHT_THEME if theme_type == ThemeType.LIGHT else DARK_THEME
+from dataclasses import dataclass
+from typing import Dict
+from enum import Enum
+
+class ThemeType(Enum):
+    DARK = "dark"
+    LIGHT = "light"
+
+# Dark theme colors
+DARK_LINE_BACKGROUNDS = {
+    'unchanged': '#1A1A1A',
+    'added': '#003300',
+    'deleted': '#330000',
+    'removed': '#330000',
+    'success': '#004400'  # Dark green for success messages
+}
+
+# Light theme colors
+LIGHT_LINE_BACKGROUNDS = {
+    'unchanged': 'grey93',         # Light gray for unchanged
+    'added': 'light_green',       # Semantic light green for additions
+    'deleted': '#FFE6E6',         # Soft light red for deletions
+    'removed': '#FFE6E6',
+    'success': '#E6FFE6'          # Light green for success messages
+}
+
+@dataclass
+class ColorTheme:
+    text_color: str
+    line_backgrounds: Dict[str, str]
+    theme_type: ThemeType
+    success_color: str = "green"
+
+# Predefined themes
+DARK_THEME = ColorTheme(
+    text_color="white",
+    line_backgrounds=DARK_LINE_BACKGROUNDS,
+    theme_type=ThemeType.DARK,
+    success_color="green"
+)
+
+LIGHT_THEME = ColorTheme(
+    text_color="black",
+    line_backgrounds=LIGHT_LINE_BACKGROUNDS,
+    theme_type=ThemeType.LIGHT,
+    success_color="dark_green"
+)
+
+DEFAULT_THEME = DARK_THEME
+
+def validate_theme(theme: ColorTheme) -> bool:
+    """Validate that a theme contains all required colors"""
+    required_line_backgrounds = {'unchanged', 'added', 'deleted'}
+    
+    if not isinstance(theme, ColorTheme):
+        return False
+        
+    return all(bg in theme.line_backgrounds for bg in required_line_backgrounds)
+
+def get_theme_by_type(theme_type: ThemeType) -> ColorTheme:
+    """Get a predefined theme by type"""
+    return LIGHT_THEME if theme_type == ThemeType.LIGHT else DARK_THEME

janito/change/view/viewer.py

@@ -0,0 +1,59 @@
+from rich.console import Console
+from ..applied_blocks import AppliedBlocks
+from .panels import create_diff_columns
+from .summary import show_changes_summary
+
+class ChangeViewer:
+    def __init__(self):
+        self.console = Console()
+        
+    def show_changes(self, applied_blocks: AppliedBlocks):
+        """Show all changes with diffs and summary"""
+        for block in applied_blocks.blocks:
+            self._show_block(block)
+            
+        # Show summary table
+        show_changes_summary(applied_blocks.get_changes_summary(), self.console)
+        
+    def _show_block(self, block):
+        """Show a single change block with appropriate visualization"""
+        if block.edit_type.name == "CREATE":
+            header, columns = create_diff_columns(
+                [],  # No original content
+                block.modified_content,
+                str(block.filename),
+                0,
+                self.console.width
+            )
+        elif block.edit_type.name == "DELETE":
+            header, columns = create_diff_columns(
+                block.original_content,
+                [],  # No modified content
+                str(block.filename),
+                0,
+                self.console.width,
+                is_removal=True
+            )
+        elif block.edit_type.name == "CLEAN":
+            header, columns = create_diff_columns(
+                block.original_content,
+                [],  # No modified content for clean
+                str(block.filename),
+                block.range_start - 1,
+                self.console.width,
+                operation="Clean",
+                reason=block.reason,
+                is_removal=True
+            )
+        else:  # EDIT operation
+            header, columns = create_diff_columns(
+                block.original_content,
+                block.modified_content,
+                str(block.filename),
+                block.range_start - 1,
+                self.console.width,
+                reason=block.reason
+            )
+            
+        self.console.print(header)
+        self.console.print(columns)

janito/cli/__init__.py

@@ -1,2 +1,2 @@
-
+
 # This file is intentionally left empty to make the cli directory a package.