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

janito/change/__init__.py

@@ -0,0 +1,32 @@
+"""
+This package provides the following change flow steps:
+
+- Create a preview directory
+- Build change request prompt
+- Send change request to AI agent
+- Parse the response into changes
+- Save response to history file
+- Preview the changes (applying them to the preview directory)
+- Validate the changes
+- Run tests if specified
+- Show the change view (using janito.changeviewer)
+- Prompt the user to apply the changes to the working directory
+- Apply the changes
+"""
+
+from typing import Tuple
+from pathlib import Path
+from ..agents import agent  # Updated import to use singleton directly
+from .parser import build_change_request_prompt, parse_response
+from .preview import setup_workspace_dir_preview
+from .applier.main import ChangeApplier
+
+__all__ = [
+    'build_change_request_prompt',
+    'get_change_response',
+    'parse_response',
+    'setup_workspace_dir_preview',
+    'parse_change_response',
+    'save_change_response',
+    'ChangeApplier'
+]

janito/change/analysis/__init__.py

@@ -0,0 +1,23 @@
+"""Analysis module for Janito.
+
+This module provides functionality for analyzing and displaying code changes.
+"""
+
+from .options import AnalysisOption, parse_analysis_options
+from .view import format_analysis, prompt_user, get_option_selection
+from .prompts import (
+    build_request_analysis_prompt,
+    validate_option_letter
+)
+from .analyze import analyze_request
+
+__all__ = [
+    'AnalysisOption',
+    'parse_analysis_options',
+    'format_analysis',
+    'build_request_analysis_prompt',
+    'get_option_selection',
+    'prompt_user',
+    'validate_option_letter',
+    'analyze_request'
+]

janito/change/analysis/__main__.py

@@ -0,0 +1,7 @@
+"""Main entry point for the analysis module."""
+
+from .analyze import analyze_request
+from janito.config import config
+from janito.workspace import collect_files_content
+from pathlib import Path
+

janito/change/analysis/analyze.py

@@ -0,0 +1,61 @@
+"""Core analysis functionality."""
+
+from typing import Optional, Dict
+
+from janito.agents import agent
+from janito.common import progress_send_message
+from janito.config import config
+from .view import format_analysis
+from .options import AnalysisOption, parse_analysis_options
+from .prompts import (
+    build_request_analysis_prompt,
+    get_option_selection,
+    validate_option_letter
+)
+
+def analyze_request(
+    request: str,        
+    files_content_xml: str,
+    pre_select: str = ""
+) -> Optional[AnalysisOption]:
+    """
+    Analyze changes and get user selection.
+    
+    Args:
+        files_content: Content of files to analyze
+        request: User's change request
+        pre_select: Optional pre-selected option letter
+        
+    Returns:
+        Selected AnalysisOption or None if modified
+    """
+    # Build and send prompt
+    prompt = build_request_analysis_prompt(request, files_content_xml)
+    response = progress_send_message(prompt)
+    
+    # Parse options
+    options = parse_analysis_options(response)
+    if not options:
+        return None
+
+    if pre_select:
+        return options.get(pre_select.upper())
+
+    if config.tui:
+        from janito.tui import TuiApp
+        app = TuiApp(options=options)
+        app.run()
+        return app.selected_option
+        
+    # Display formatted analysis in terminal mode
+    format_analysis(response, config.raw)
+    
+    # Get user selection
+    while True:
+        selection = get_option_selection()
+        
+        if selection == 'M':
+            return None
+            
+        if validate_option_letter(selection, options):
+            return options[selection.upper()]

janito/change/analysis/formatting.py

@@ -0,0 +1,78 @@
+"""Centralized formatting utilities for analysis display."""
+
+from typing import Dict, List, Text
+from rich.text import Text
+from rich.columns import Columns
+from rich.padding import Padding
+from pathlib import Path
+
+# Layout constants
+COLUMN_SPACING = 6  # Increased spacing between columns
+MIN_PANEL_WIDTH = 45  # Wider minimum width for better readability
+SECTION_PADDING = (2, 0)  # More vertical padding
+
+# Color scheme constants
+STATUS_COLORS = {
+    'new': 'bright_green',
+    'modified': 'yellow',
+    'removed': 'red',
+    'default': 'white'
+}
+
+STRUCTURAL_COLORS = {
+    'directory': 'dim',
+    'separator': 'blue dim',
+    'repeat': 'bright_magenta bold'
+}
+
+def create_header(text: str, style: str = "bold cyan") -> Text:
+    """Create formatted header with separator."""
+    content = Text()
+    content.append(text, style=style)
+    content.append("\n")
+    content.append("═" * len(text), style="cyan")
+    return content
+
+def create_section_header(text: str, width: int = 20) -> Text:
+    """Create centered section header with separator."""
+    content = Text()
+    padding = (width - len(text)) // 2
+    content.append(" " * padding + text, style="bold cyan")
+    content.append("\n")
+    content.append("─" * width, style="cyan")
+    return content
+
+def format_file_path(path: str, status: str, max_dir_length: int = 0, is_repeated: bool = False) -> Text:
+    """Format file path with status indicators and consistent alignment.
+
+    Args:
+        path: File path to format
+        status: File status (Modified, New, Removed)
+        max_dir_length: Maximum directory name length for padding
+        is_repeated: Whether this directory was seen before
+    """
+    content = Text()
+    style = STATUS_COLORS.get(status.lower(), STATUS_COLORS['default'])
+
+    parts = Path(path).parts
+    parent_dir = str(Path(path).parent)
+
+    if parent_dir != '.':
+        # Add 4 spaces for consistent base padding
+        base_padding = 4
+        dir_padding = max_dir_length + base_padding
+
+        if is_repeated:
+            # Add arrow with consistent spacing
+            content.append(" " * base_padding)
+            content.append("↑ ", style="magenta")
+            content.append(" " * (dir_padding - base_padding - 2))
+        else:
+            # Left-align directory name with consistent padding
+            content.append(" " * base_padding)
+            content.append(parent_dir, style="dim")
+            content.append(" " * (dir_padding - len(parent_dir) - base_padding))
+
+    # Add filename with consistent spacing
+    content.append(parts[-1], style=style)
+    return content

janito/change/analysis/options.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass, field
+from typing import Dict, List
+from pathlib import Path
+
+@dataclass
+class AnalysisOption:
+    """Represents an analysis option with letter identifier and details"""
+    letter: str
+    summary: str
+    description_items: List[str] = field(default_factory=list)
+    affected_files: List[str] = field(default_factory=list)
+
+    def format_option_text(self) -> str:
+        """Format option details as text for change core"""
+        text = f"Option {self.letter} - {self.summary}\n"
+        text += "=" * len(f"Option {self.letter} - {self.summary}") + "\n\n"
+        
+        if self.description_items:
+            text += "Description:\n"
+            for item in self.description_items:
+                text += f"- {item}\n"
+            text += "\n"
+            
+        if self.affected_files:
+            text += "Affected files:\n"
+            for file in self.affected_files:
+                text += f"- {file}\n"
+                
+        return text
+
+    def is_new_directory(self, file_path: str) -> bool:
+        """Check if file path represents the first occurrence of a directory"""
+        parent = str(Path(file_path).parent)
+        return parent != '.' and not any(
+            parent in self.get_clean_path(file)
+            for file in self.affected_files
+            if self.get_clean_path(file) != file_path
+        )
+
+    def get_clean_path(self, file_path: str) -> str:
+        """Remove status markers from file path"""
+        return file_path.split(' (')[0].strip()
+
+def parse_analysis_options(content: str) -> Dict[str, AnalysisOption]:
+    """Parse analysis options from formatted text file"""
+    options = {}
+    current_option = None
+    current_section = None
+    
+    for line in content.splitlines():
+        line = line.strip()
+        
+        # Skip empty lines and section separators
+        if not line or line.startswith('---') or line == 'END_OF_OPTIONS':
+            continue
+            
+        # New option starts with a letter and period
+        if line[0].isalpha() and line[1:3] == '. ':
+            letter, summary = line.split('. ', 1)
+            current_option = AnalysisOption(letter=letter.upper(), summary=summary)
+            options[letter.upper()] = current_option
+            current_section = None
+            continue
+            
+        # Section headers
+        if line.lower() == 'description:':
+            current_section = 'description'
+            continue
+        elif line.lower() == 'affected files:':
+            current_section = 'files'
+            continue
+            
+        # Add items to current section
+        if current_option and line.startswith('- '):
+            content = line[2:].strip()
+            if current_section == 'description':
+                current_option.description_items.append(content)
+            elif current_section == 'files':
+                current_option.affected_files.append(content)
+    
+    return options

janito/change/analysis/prompts.py

@@ -0,0 +1,98 @@
+"""User prompts and input handling for analysis."""
+
+from typing import List, Dict
+from rich.console import Console
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.prompt import Prompt
+from rich import box
+
+
+from .options import AnalysisOption
+
+# Keep only prompt-related functionality
+CHANGE_ANALYSIS_PROMPT = """
+Current files:
+<files>
+{files_content}
+</files>
+
+Considering the above current files content, provide 3 sections, each identified by a keyword and representing an option.
+Each option should include a concise description and a list of affected files.
+1st option should be basic style change, 2nd organized style, 3rd exntensible style.
+Do not use style as keyword, instead focus on the changes summary.
+
+Use the following format:
+
+A. Keyword summary of the change
+-----------------
+Description:
+- Concise description of the change
+
+Affected files:
+- path/file1.py (new)
+- path/file2.py (modified)
+- path/file3.py (removed)
+
+END_OF_OPTIONS (mandatory marker)
+
+RULES:
+- do NOT provide the content of the files
+- do NOT offer to implement the changes
+- description items should be 80 chars or less
+
+Request:
+{request}
+"""
+
+def prompt_user(message: str, choices: List[str] = None) -> str:
+    """Display a prominent user prompt with optional choices"""
+    console = Console()
+    term_width = console.width or 80
+    console.print()
+    console.print(Rule(" User Input Required ", style="bold cyan", align="center"))
+    
+    if choices:
+        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
+        console.print(Panel(choice_text, box=box.ROUNDED, justify="center"))
+    
+    # Center the prompt with padding
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+    return Prompt.ask(f"[bold cyan]{padded_message}[/bold cyan]")
+
+def validate_option_letter(letter: str, options: Dict[str, AnalysisOption]) -> bool:
+    """Validate if the given letter is a valid option or 'M' for modify"""
+    if letter.upper() == 'M':
+        return True
+    return letter.upper() in options
+
+def get_option_selection() -> str:
+    """Get user input for option selection with modify option"""
+    console = Console()
+    term_width = console.width or 80
+    message = "Enter option letter or 'M' to modify request"
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+    
+    console.print(f"\n[cyan]{padded_message}[/cyan]")
+    while True:
+        letter = prompt_user("Select option").strip().upper()
+        if letter == 'M' or (letter.isalpha() and len(letter) == 1):
+            return letter
+        
+        error_msg = "Please enter a valid letter or 'M'"
+        error_padding = (term_width - len(error_msg)) // 2
+        padded_error = " " * error_padding + error_msg
+        console.print(f"[red]{padded_error}[/red]")
+
+def build_request_analysis_prompt(request: str, files_content_xml: str) -> str:
+    """Build prompt for information requests"""
+    return CHANGE_ANALYSIS_PROMPT.format(
+        files_content=files_content_xml,
+        request=request
+    )
+
+    def build_request_analysis_prompt(request: str, files_content_xml: str) -> str:
+        """Build analysis prompt with minimal formatting."""
+        return f"Current files:\n{files_content_xml}\n\nRequest:\n{request}"

janito/change/analysis/view/__init__.py

@@ -0,0 +1,9 @@
+"""View package for analysis UI components."""
+
+from .terminal import format_analysis, prompt_user, get_option_selection
+
+__all__ = [
+    'format_analysis',
+    'prompt_user',
+    'get_option_selection'
+]

janito/change/analysis/view/terminal.py

@@ -0,0 +1,171 @@
+"""Terminal UI components for analysis display."""
+
+from typing import Dict, List, Optional
+from rich.console import Console
+from rich.columns import Columns
+from rich.text import Text
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.padding import Padding
+from rich.prompt import Prompt
+from rich import box
+from pathlib import Path
+
+from ..options import AnalysisOption
+from ..formatting import (
+    COLUMN_SPACING,
+    MIN_PANEL_WIDTH,
+    SECTION_PADDING,
+    STATUS_COLORS,
+    STRUCTURAL_COLORS,
+    create_header,
+    create_section_header,
+    format_file_path
+)
+
+def prompt_user(message: str, choices: List[str] = None) -> str:
+    """Display a prominent user prompt with optional choices"""
+    console = Console()
+    term_width = console.width or 80
+    console.print()
+    console.print(Rule(" User Input Required ", style="bold cyan", align="center"))
+
+    if choices:
+        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
+        console.print(Panel(choice_text, box=box.ROUNDED, justify="center"))
+
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+    return Prompt.ask(f"[bold cyan]{padded_message}[/bold cyan]")
+
+def get_option_selection() -> str:
+    """Get user input for option selection with modify option"""
+    console = Console()
+    term_width = console.width or 80
+    message = "Enter option letter or 'M' to modify request"
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+
+    console.print(f"\n[cyan]{padded_message}[/cyan]")
+    while True:
+        letter = prompt_user("Select option").strip().upper()
+        if letter == 'M' or (letter.isalpha() and len(letter) == 1):
+            return letter
+
+        error_msg = "Please enter a valid letter or 'M'"
+        error_padding = (term_width - len(error_msg)) // 2
+        padded_error = " " * error_padding + error_msg
+        console.print(f"[red]{padded_error}[/red]")
+
+def _create_option_content(option: AnalysisOption) -> Text:
+    """Create rich formatted content for a single option."""
+    content = Text()
+    content.append("\n")
+
+    header = create_header(f"Option {option.letter} - {option.summary}")
+    content.append(header)
+    content.append("\n")
+
+    if option.description_items:
+        for item in option.description_items:
+            content.append("• ", style="cyan")
+            content.append(f"{item}\n")
+        content.append("\n")
+
+    # Add consistent padding before file list
+    content.append("\n" * 2)
+
+    if option.affected_files:
+        files = {status: [] for status in ['New', 'Modified', 'Removed']}
+        for file in option.affected_files:
+            if '(new)' in file.lower():
+                files['New'].append(file)
+            elif '(removed)' in file.lower():
+                files['Removed'].append(file)
+            else:
+                files['Modified'].append(file)
+
+        for status, status_files in files.items():
+            if status_files:
+                content.append(create_section_header(f"{status} Files"))
+                content.append("\n")
+                sorted_files = sorted(status_files)
+                prev_path = None
+                seen_dirs = {}
+                for file in sorted_files:
+                    path = option.get_clean_path(file)
+                    current_parts = Path(path).parts
+                    parent_dir = str(Path(path).parent)
+
+                    if parent_dir != '.':
+                        is_repeated = parent_dir in seen_dirs
+                        if not is_repeated:
+                            content.append(parent_dir, style=STRUCTURAL_COLORS['directory'])
+                            content.append("/", style=STRUCTURAL_COLORS['separator'])
+                            seen_dirs[parent_dir] = True
+                        else:
+                            padding = " " * (len(parent_dir) - 1)
+                            content.append(padding)
+                            content.append("↑ ", style=STRUCTURAL_COLORS['repeat'])
+                            content.append("/", style=STRUCTURAL_COLORS['separator'])
+                        content.append(current_parts[-1], style=STATUS_COLORS[status.lower()])
+                    else:
+                        content.append(current_parts[-1], style=STATUS_COLORS[status.lower()])
+                    content.append("\n")
+            content.append("\n")
+
+        content.append("\n")
+
+    return content
+
+def create_columns_layout(options_content: List[Text], term_width: int) -> Columns:
+    """Create a columns layout with consistent spacing."""
+    num_columns = len(options_content)
+    spacing = COLUMN_SPACING * (num_columns - 1)
+    safety_margin = 4 + 2
+
+    usable_width = term_width - spacing - safety_margin
+    column_width = max((usable_width // num_columns), MIN_PANEL_WIDTH)
+
+    rendered_columns = [
+        Padding(content, (0, COLUMN_SPACING // 2))
+        for content in options_content
+    ]
+
+    return Columns(
+        rendered_columns,
+        equal=True,
+        expand=True,
+        width=column_width,
+        align="left",
+        padding=(0, 0),
+    )
+
+def format_analysis(analysis: str, raw: bool = False) -> None:
+    """Format and display the analysis output."""
+    from ..options import parse_analysis_options
+
+    console = Console()
+    term_width = console.width or 100
+
+    if raw:
+        console.print(analysis)
+        return
+
+    options = parse_analysis_options(analysis)
+    if not options:
+        console.print("\n[yellow]Warning: No valid options found in response.[/yellow]\n")
+        console.print(analysis)
+        return
+
+    columns_content = [_create_option_content(options[letter])
+                      for letter in sorted(options.keys())]
+
+    columns = create_columns_layout(columns_content, term_width)
+
+    console.print("\n")
+    console.print(Text("Analysis Options", style="bold cyan"))
+    console.print(Text("─" * term_width, style="cyan dim"))
+    console.print(columns)
+    console.print(Text("─" * term_width, style="cyan dim"))
+    console.print("\n")

janito/change/applier/__init__.py

@@ -0,0 +1,5 @@
+from .file import FileChangeApplier
+from .text import TextChangeApplier
+from .workspace_dir import apply_changes
+
+__all__ = ['FileChangeApplier', 'TextChangeApplier', 'apply_changes']

janito/change/applier/file.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+from typing import Tuple, Optional
+from rich.console import Console
+from ..parser import FileChange, ChangeOperation
+
+class FileChangeApplier:
+    def __init__(self, preview_dir: Path, console: Console = None):
+        self.preview_dir = preview_dir
+        self.console = console or Console()
+
+    def apply_file_operation(self, change: FileChange) -> Tuple[bool, Optional[str]]:
+        """Apply a file operation (create/replace/remove/rename/move)
+        Returns: (success, error_message)"""
+        path = self.preview_dir / change.name
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Store original content before any changes
+        if path.exists():
+            change.original_content = path.read_text()
+
+        if change.operation == ChangeOperation.REMOVE_FILE:
+            return self._handle_remove(path)
+        elif change.operation in (ChangeOperation.CREATE_FILE, ChangeOperation.REPLACE_FILE):
+            return self._handle_create_replace(path, change)
+        elif change.operation in (ChangeOperation.RENAME_FILE, ChangeOperation.MOVE_FILE):
+            return self._handle_move(path, change)
+
+        return False, f"Unsupported operation: {change.operation}"
+
+    def _handle_remove(self, path: Path) -> Tuple[bool, Optional[str]]:
+        """Handle file removal"""
+        if path.exists():
+            path.unlink()
+        return True, None
+
+    def _handle_create_replace(self, path: Path, change: FileChange) -> Tuple[bool, Optional[str]]:
+        """Handle file creation or replacement"""
+        if change.operation == ChangeOperation.CREATE_FILE and path.exists():
+            return False, f"Cannot create file {path} - already exists"
+
+        if change.content is not None:
+            path.write_text(change.content)
+            return True, None
+
+        return False, "No content provided for create/replace operation"
+
+    def _handle_move(self, path: Path, change: FileChange) -> Tuple[bool, Optional[str]]:
+        """Handle file move/rename operations"""
+        if not path.exists():
+            return False, f"Cannot move/rename non-existent file {path}"
+
+        if not change.target:
+            return False, "No target path provided for move/rename operation"
+
+        new_path = self.preview_dir / change.target
+        new_path.parent.mkdir(parents=True, exist_ok=True)
+        path.rename(new_path)
+        return True, None