janito 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

janito/changeviewer.py

@@ -1,64 +1,350 @@
 from pathlib import Path
 from rich.console import Console
 from rich.text import Text
-from typing import TypedDict
-import difflib
+from rich.panel import Panel
+from rich.table import Table
+from rich.rule import Rule  # Add this import
+from typing import List, Optional, Dict
+from rich import box
+from janito.fileparser import FileChange
+from janito.analysis import AnalysisOption  # Add this import
+from rich.columns import Columns  # Add this import at the top with other imports
 
-class FileChange(TypedDict):
-    """Type definition for a file change"""
-    description: str
-    new_content: str
+MIN_PANEL_WIDTH = 40   # Minimum width for each panel
 
-def show_file_changes(console: Console, filepath: Path, original: str, new_content: str, description: str) -> None:
-    """Display side by side comparison of file changes"""
-    half_width = (console.width - 3) // 2
+
+def format_sequence_preview(lines: List[str]) -> Text:
+    """Format a sequence of prefixed lines into rich text with colors"""
+    text = Text()
+    last_was_empty = False
     
-    # Show header
-    console.print(f"\n[bold blue]Changes for {filepath}[/bold blue]")
-    console.print(f"[dim]{description}[/dim]\n")
+    for line in lines:
+        if not line:
+            # Preserve empty lines but don't duplicate them
+            if not last_was_empty:
+                text.append("\n")
+            last_was_empty = True
+            continue
+        
+        last_was_empty = False
+        prefix = line[0] if line[0] in ('=', '>', '<') else ' '
+        content = line[1:] if line[0] in ('=', '>', '<') else line
+        
+        if prefix == '=':
+            text.append(f" {content}\n", style="dim")
+        elif prefix == '>':
+            text.append(f"+{content}\n", style="green")
+        elif prefix == '<':
+            text.append(f"-{content}\n", style="red")
+        else:
+            text.append(f" {content}\n", style="yellow dim")
     
-    # Show side by side content
-    console.print(Text("OLD".center(half_width) + "│" + "NEW".center(half_width), style="blue bold"))
-    console.print(Text("─" * half_width + "┼" + "─" * half_width, style="blue"))
+    return text
+
+
+
+
+
+
+def show_changes_legend(console: Console) -> None:
+    """Display a legend explaining the colors and symbols used in change previews in a horizontal layout"""
+    # Create a list of colored text objects
+    legend_items = [
+        Text("Unchanged", style="#98C379"),
+        Text(" • ", style="dim"),
+        Text("Removed", style="#E06C75"),
+        Text(" • ", style="dim"),
+        Text("Relocated", style="#61AFEF"),
+        Text(" • ", style="dim"),
+        Text("New", style="#C678DD")
+    ]
     
-    old_lines = original.splitlines()
-    new_lines = new_content.splitlines()
+    # Combine all items into a single text object
+    legend_text = Text()
+    for item in legend_items:
+        legend_text.append_text(item)
     
-    for i in range(max(len(old_lines), len(new_lines))):
-        old = old_lines[i] if i < len(old_lines) else ""
-        new = new_lines[i] if i < len(new_lines) else ""
-        
-        old_text = Text(f"{old:<{half_width}}", style="red" if old != new else None)
-        new_text = Text(f"{new:<{half_width}}", style="green" if old != new else None)
-        console.print(old_text + Text("│", style="blue") + new_text)
-
-def show_diff_changes(console: Console, filepath: Path, original: str, new_content: str, description: str) -> None:
-    """Display file changes using unified diff format"""
-    # Show header
-    console.print(f"\n[bold blue]Changes for {filepath}[/bold blue]")
-    console.print(f"[dim]{description}[/dim]\n")
-    
-    # Generate diff
-    diff = difflib.unified_diff(
-        original.splitlines(keepends=True),
-        new_content.splitlines(keepends=True),
-        fromfile='old',
-        tofile='new',
-        lineterm=''
+    # Create a simple panel with the horizontal legend
+    legend_panel = Panel(
+        legend_text,
+        title="Changes Legend",
+        title_align="left",
+        border_style="white",
+        box=box.ROUNDED,
+        padding=(0, 1)
     )
     
-    # Print diff with colors
-    for line in diff:
-        if line.startswith('+++'):
-            console.print(Text(line.rstrip(), style="bold green"))
-        elif line.startswith('---'):
-            console.print(Text(line.rstrip(), style="bold red"))
-        elif line.startswith('+'):
-            console.print(Text(line.rstrip(), style="green"))
-        elif line.startswith('-'):
-            console.print(Text(line.rstrip(), style="red"))
-        elif line.startswith('@@'):
-            console.print(Text(line.rstrip(), style="cyan"))
+    # Center the legend panel horizontally
+    console.print(Columns([legend_panel], align="center"))
+    console.print()  # Add extra line for spacing
+
+
+def show_change_preview(console: Console, filepath: Path, change: FileChange) -> None:
+    """Display a preview of changes for a single file with side-by-side comparison"""
+    # Show changes legend first
+    show_changes_legend(console)
+      
+    # Create main file panel content
+    main_content = []
+
+    # Handle new file preview
+    if change.is_new_file:
+        new_file_panel = Panel(
+            Text(change.content),
+            title="New File Content",
+            title_align="left",
+            border_style="green",
+            box=box.ROUNDED
+        )
+        main_content.append(new_file_panel)
+        
+        # Create and display main file panel
+        file_panel = Panel(
+            Columns(main_content),
+            title=str(filepath),
+            title_align="left",
+            border_style="white",
+            box=box.ROUNDED        )
+        return
+
+    
+
+    # For modifications, create side-by-side comparison for each change
+    for i, (search, replace, description) in enumerate(change.search_blocks, 1):
+        # Show change header with description
+        header = f"Change {i}"
+        if description:
+            header += f": {description}"
+        
+        if replace is None:
+            # For deletions, show single panel with content to be deleted
+            change_panel = Panel(
+                Text(search, style="red"),
+                title=f"Content to Delete{' - ' + description if description else ''}",
+                title_align="left",
+                border_style="#E06C75",  # Brighter red
+                box=box.ROUNDED
+            )
+            main_content.append(change_panel)
         else:
-            console.print(Text(line.rstrip()))
+            # For replacements, show side-by-side panels
+
+            
+            # Find common content between search and replace
+            search_lines = search.splitlines()
+            replace_lines = replace.splitlines()
+            
+            # 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
+            
+
+
+
+            # Format content with highlighting using consistent colors and line numbers
+
+
+            def format_content(lines: List[str], is_search: bool) -> Text:
+                text = Text()
+                
+                COLORS = {
+                    'unchanged': '#98C379',  # Brighter green for unchanged lines
+                    'removed': '#E06C75',    # Clearer red for removed lines
+                    'added': '#61AFEF',      # Bright blue for added lines
+                    'new': '#C678DD',        # Purple for completely new lines
+                    'relocated': '#61AFEF'    # Use same blue for relocated lines
+                }
+                
+                # Create sets of lines for comparison
+                search_set = set(search_lines)
+                replace_set = set(replace_lines)
+                common_lines = search_set & replace_set
+                new_lines = replace_set - search_set
+                relocated_lines = common_lines - set(common_top) - set(common_bottom)
+
+                def add_line(line: str, style: str, prefix: str = " "):
+                    # Special handling for icons
+                    if style == COLORS['relocated']:
+                        prefix = "⇄"
+                    elif style == COLORS['removed'] and prefix == "-":
+                        prefix = "✕"
+                    elif style == COLORS['new'] or (style == COLORS['added'] and prefix == "+"):
+                        prefix = "✚"
+                    text.append(prefix, style=style)
+                    text.append(f" {line}\n", style=style)
+                
+                # Format common top section
+                for line in common_top:
+                    add_line(line, COLORS['unchanged'], "=")
+                
+                # Format changed middle section
+                for line in (search_middle if is_search else replace_middle):
+                    if line in relocated_lines:
+                        add_line(line, COLORS['relocated'], "⇄")
+                    elif not is_search and line in new_lines:
+                        add_line(line, COLORS['new'], "+")
+                    else:
+                        style = COLORS['removed'] if is_search else COLORS['added']
+                        prefix = "✕" if is_search else "+"
+                        add_line(line, style, prefix)
+                
+                # Format common bottom section
+                for line in common_bottom:
+                    add_line(line, COLORS['unchanged'], "=")
+                
+                return text
+            
+
+
+            # Create panels for old and new content without width constraints
+            old_panel = Panel(
+                format_content(search_lines, True),
+                title="Current Content",
+                title_align="left",
+                border_style="#E06C75",
+                box=box.ROUNDED
+            )
+            
+            new_panel = Panel(
+                format_content(replace_lines, False),
+                title="New Content",
+                title_align="left",
+                border_style="#61AFEF",
+                box=box.ROUNDED
+            )
+
+            # Add change panels to main content with auto-fitting columns
+            change_columns = Columns([old_panel, new_panel], equal=True, align="center")
+            change_panel = Panel(
+                change_columns,
+                title=header,
+                title_align="left",
+                border_style="cyan",
+                box=box.ROUNDED
+            )
+            main_content.append(change_panel)
+    
+    # Create and display main file panel
+    file_panel = Panel(
+        Columns(main_content, align="center"),
+        title=f"Modifying {filepath}",
+        title_align="left",
+        border_style="white",
+        box=box.ROUNDED
+    )
+    console.print(file_panel)
+    console.print()
+
+# Remove or comment out the unused unified panel code since we're using direct column display
+
+def preview_all_changes(console: Console, changes: Dict[Path, FileChange]) -> None:
+    """Show preview for all file changes"""
+    console.print("\n[bold blue]Change Preview[/bold blue]")
+    
+    for filepath, change in changes.items():
+        show_change_preview(console, filepath, change)
+
+
+def _display_options(options: Dict[str, AnalysisOption]) -> None:
+    """Display available options in a centered, responsive layout with consistent spacing."""
+    console = Console()
+    
+    # Display centered header with decorative rule
+    console.print()
+    console.print(Rule(" Available Options ", style="bold cyan", align="center"))
+    console.print()
+    
+    # Safety check for empty options
+    if not options:
+        console.print(Panel("[yellow]No options available[/yellow]", border_style="yellow"))
+        return
+    
+    # Calculate optimal layout dimensions based on terminal width
+    terminal_width = console.width or 100
+    panel_padding = (1, 2)  # Consistent padding for all panels
+    available_width = terminal_width - 4  # Account for margins
+    
+    # Determine optimal panel width and number of columns
+    min_panels_per_row = 1
+    max_panels_per_row = 3
+    optimal_panel_width = min(
+        available_width // max_panels_per_row,
+        available_width // min_panels_per_row
+    )
+    
+    if optimal_panel_width < MIN_PANEL_WIDTH:
+        optimal_panel_width = MIN_PANEL_WIDTH
+    
+    # Create panels with consistent styling and spacing
+    panels = []
+    for letter, option in options.items():
+        # Build content with consistent formatting
+        content = Text()
+        
+        # Add description section
+        content.append("Description:\n", style="bold cyan")
+        for item in option.description_items:
+            content.append(f"• {item}\n", style="white")
+        content.append("\n")
+        
+        # Add affected files section if present
+        if option.affected_files:
+            content.append("Affected files:\n", style="bold cyan")
+            for file in option.affected_files:
+                content.append(f"• {file}\n", style="yellow")
+        
+        # Create panel with consistent styling
+        panel = Panel(
+            content,
+            box=box.ROUNDED,
+            border_style="cyan",
+            title=f"Option {letter}: {option.summary}",
+            title_align="center",
+            padding=panel_padding,
+            width=optimal_panel_width
+        )
+        panels.append(panel)
+    
+    # Calculate optimal number of columns based on available width
+    num_columns = max(1, min(
+        len(panels),  # Don't exceed number of panels
+        available_width // optimal_panel_width,  # Width-based limit
+        max_panels_per_row  # Maximum columns limit
+    ))
+    
+    # Create a centered container panel for all options
+    container = Panel(
+        Columns(
+            panels,
+            num_columns=num_columns,
+            equal=True,
+            align="center",
+            padding=(0, 2)  # Consistent spacing between columns
+        ),
+        box=box.SIMPLE,
+        padding=(1, 4),  # Add padding around the columns for better centering
+        width=min(terminal_width - 4, num_columns * optimal_panel_width + (num_columns - 1) * 4)
+    )
 
+    # Display the centered container
+    console.print(Columns([container], align="center"))
+    console.print()

janito/claude.py

@@ -1,13 +1,8 @@
-from rich.traceback import install
 import anthropic
 import os
 from typing import Optional
-from rich.progress import Progress, SpinnerColumn, TextColumn
 from threading import Event
 
-# Install rich traceback handler
-install(show_locals=True)
-
 class ClaudeAPIAgent:
     """Handles interaction with Claude API, including message handling"""
     def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
@@ -18,7 +13,6 @@ class ClaudeAPIAgent:
             raise ValueError("ANTHROPIC_API_KEY environment variable is required")
         self.client = anthropic.Client(api_key=self.api_key)
         self.model = "claude-3-5-sonnet-20241022"
-        self.stop_progress = Event()
         self.system_message = system_prompt
         self.last_prompt = None
         self.last_full_message = None
@@ -29,46 +23,37 @@ class ClaudeAPIAgent:
 
     def send_message(self, message: str, stop_event: Event = None) -> str:
         """Send message to Claude API and return response"""
+        self.messages_history.append(("user", message))
+        # Store the full message
+        self.last_full_message = message
+        
         try:
-            self.messages_history.append(("user", message))
-            # Store the full message
-            self.last_full_message = message
-            
-            try:
-                # Check if already cancelled
-                if stop_event and stop_event.is_set():
-                    return ""
-                
-                # Start API request
-                response = self.client.messages.create(
-                    model=self.model,  # Use discovered model
-                    system=self.system_message,
-                    max_tokens=4000,
-                    messages=[
-                        {"role": "user", "content": message}
-                    ],
-                    temperature=0,
-                )
-                
-                # Handle response
-                response_text = response.content[0].text
-                
-                # Only store and process response if not cancelled
-                if not (stop_event and stop_event.is_set()):
-                    self.last_response = response_text
-                    self.messages_history.append(("assistant", response_text))
-                
-                # Always return the response, let caller handle cancellation
-                return response_text
-                
-            except KeyboardInterrupt:
-                if stop_event:
-                    stop_event.set()
-                return ""
-                
-        except Exception as e:
-            error_msg = f"Error: {str(e)}"
-            self.messages_history.append(("error", error_msg))
+            # Check if already cancelled
             if stop_event and stop_event.is_set():
                 return ""
-            return error_msg
+            
+            response = self.client.messages.create(
+                model=self.model,  # Use discovered model
+                system=self.system_message,
+                max_tokens=4000,
+                messages=[
+                    {"role": "user", "content": message}
+                ],
+                temperature=0,
+            )
+            
+            # Handle response
+            response_text = response.content[0].text
+            
+            # Only store and process response if not cancelled
+            if not (stop_event and stop_event.is_set()):
+                self.last_response = response_text
+                self.messages_history.append(("assistant", response_text))
+            
+            # Always return the response, let caller handle cancellation
+            return response_text
+            
+        except KeyboardInterrupt:
+            if stop_event:
+                stop_event.set()
+            return ""

janito/common.py

@@ -0,0 +1,23 @@
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn
+from janito.claude import ClaudeAPIAgent
+
+def progress_send_message(claude: ClaudeAPIAgent, message: str) -> str:
+    """
+    Send a message to Claude with a progress indicator and elapsed time.
+    
+    Args:
+        claude: The Claude API agent instance
+        message: The message to send
+        
+    Returns:
+        The response from Claude
+    """
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        TimeElapsedColumn(),
+    ) as progress:
+        task = progress.add_task("Waiting for response from Claude...", total=None)
+        response = claude.send_message(message)
+        progress.update(task, completed=True)
+    return response

janito/config.py

@@ -7,7 +7,8 @@ class ConfigManager:
     def __init__(self):
         self.debug = False
         self.verbose = False
-        self.debug_line = None  # Add this line
+        self.debug_line = None
+        self.test_cmd = os.getenv('JANITO_TEST_CMD')
         
     @classmethod
     def get_instance(cls) -> "ConfigManager":
@@ -21,12 +22,16 @@ class ConfigManager:
     def set_verbose(self, enabled: bool) -> None:
         self.verbose = enabled
         
-    def set_debug_line(self, line: Optional[int]) -> None:  # Add this method
+    def set_debug_line(self, line: Optional[int]) -> None:
         self.debug_line = line
         
-    def should_debug_line(self, line: int) -> bool:  # Add this method
+    def should_debug_line(self, line: int) -> bool:
         """Return True if we should show debug for this line number"""
         return self.debug and (self.debug_line is None or self.debug_line == line)
 
+    def set_test_cmd(self, cmd: Optional[str]) -> None:
+        """Set the test command, overriding environment variable"""
+        self.test_cmd = cmd if cmd is not None else os.getenv('JANITO_TEST_CMD')
+
 # Create a singleton instance
 config = ConfigManager.get_instance()