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

janito/__main__.py

@@ -1,13 +1,12 @@
+import sys
 import typer
 from typing import Optional, Dict, Any, List
 from pathlib import Path
 from janito.claude import ClaudeAPIAgent
 import shutil
 from janito.prompts import (
-    build_request_analisys_prompt,
     build_selected_option_prompt,
-    SYSTEM_PROMPT,
-    parse_options
+    SYSTEM_PROMPT,    
 )
 from rich.console import Console
 from rich.markdown import Markdown
@@ -34,54 +33,51 @@ from janito.scan import collect_files_content, is_dir_empty, preview_scan
 from janito.qa import ask_question, display_answer
 from rich.prompt import Prompt, Confirm
 from janito.config import config
-from importlib.metadata import version
+from janito.version import get_version
+from janito.common import progress_send_message
+from janito.analysis import format_analysis, build_request_analysis_prompt, parse_analysis_options, get_history_file_type, AnalysisOption 
 
-def get_version() -> str:
-    try:
-        return version("janito")
-    except:
-        return "dev"
-
-def format_analysis(analysis: str, raw: bool = False, claude: Optional[ClaudeAPIAgent] = None) -> None:
-    """Format and display the analysis output"""
-    console = Console()
-    if raw and claude:
-        console.print("\n=== Message History ===")
-        for role, content in claude.messages_history:
-            console.print(f"\n[bold cyan]{role.upper()}:[/bold cyan]")
-            console.print(content)
-        console.print("\n=== End Message History ===\n")
-    else:
-        md = Markdown(analysis)
-        console.print(md)
 
 def prompt_user(message: str, choices: List[str] = None) -> str:
-    """Display a prominent user prompt with optional choices"""
+    """Display a prominent user prompt with optional choices using consistent colors"""
     console = Console()
+    
+    # Define consistent colors
+    COLORS = {
+        'primary': '#729FCF',    # Soft blue for primary elements
+        'secondary': '#8AE234',  # Bright green for actions/success
+        'accent': '#AD7FA8',     # Purple for accents
+        'muted': '#7F9F7F',      # Muted green for less important text
+    }
+    
     console.print()
-    console.print(Rule(" User Input Required ", style="bold cyan"))
+    console.print(Rule(" User Input Required ", style=f"bold {COLORS['primary']}"))
     
     if choices:
-        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
-        console.print(Panel(choice_text, box=box.ROUNDED))
+        choice_text = f"[{COLORS['accent']}]Options: {', '.join(choices)}[/{COLORS['accent']}]"
+        console.print(Panel(choice_text, box=box.ROUNDED, border_style=COLORS['primary']))
     
-    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
+    return Prompt.ask(f"[bold {COLORS['secondary']}]> {message}[/bold {COLORS['secondary']}]")
 
-def get_option_selection() -> int:
-    """Get user input for option selection"""
+def validate_option_letter(letter: str, options: dict) -> bool:
+    """Validate if the given letter is a valid option or 'M' for modify"""
+    return letter.upper() in options or letter.upper() == 'M'
+
+def get_option_selection() -> str:
+    """Get user input for option selection with modify option"""
+    console = Console()
+    console.print("\n[cyan]Enter option letter or 'M' to modify request[/cyan]")
     while True:
-        try:
-            option = int(prompt_user("Select option number"))
-            return option
-        except ValueError:
-            console = Console()
-            console.print("[red]Please enter a valid number[/red]")
+        letter = prompt_user("Select option").strip().upper()
+        if letter == 'M' or (letter.isalpha() and len(letter) == 1):
+            return letter
+        console.print("[red]Please enter a valid letter or 'M'[/red]")
 
-def get_history_path(workdir: Path) -> Path:
-    """Create and return the history directory path"""
-    history_dir = workdir / '.janito' / 'history'
-    history_dir.mkdir(parents=True, exist_ok=True)
-    return history_dir
+def get_changes_history_path(workdir: Path) -> Path:
+    """Create and return the changes history directory path"""
+    changes_history_dir = workdir / '.janito' / 'changes_history'
+    changes_history_dir.mkdir(parents=True, exist_ok=True)
+    return changes_history_dir
 
 def get_timestamp() -> str:
     """Get current UTC timestamp in YMD_HMS format with leading zeros"""
@@ -95,46 +91,148 @@ def save_prompt_to_file(prompt: str) -> Path:
     return temp_path
 
 def save_to_file(content: str, prefix: str, workdir: Path) -> Path:
-    """Save content to a timestamped file in history directory"""
-    history_dir = get_history_path(workdir)
+    """Save content to a timestamped file in changes history directory"""
+    changes_history_dir = get_changes_history_path(workdir)
     timestamp = get_timestamp()
     filename = f"{timestamp}_{prefix}.txt"
-    file_path = history_dir / filename
+    file_path = changes_history_dir / filename
     file_path.write_text(content)
     return file_path
 
+def modify_request(request: str) -> str:
+    """Display current request and get modified version with improved formatting"""
+    console = Console()
+    
+    # Display current request in a panel with clear formatting
+    console.print("\n[bold cyan]Current Request:[/bold cyan]")
+    console.print(Panel(
+        Text(request, style="white"),
+        border_style="blue",
+        title="Previous Request",
+        padding=(1, 2)
+    ))
+    
+    # Get modified request with clear prompt
+    console.print("\n[bold cyan]Enter modified request below:[/bold cyan]")
+    console.print("[dim](Press Enter to submit, Ctrl+C to cancel)[/dim]")
+    try:
+        new_request = prompt_user("Modified request")
+        if not new_request.strip():
+            console.print("[yellow]No changes made, keeping original request[/yellow]")
+            return request
+        return new_request
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Modification cancelled, keeping original request[/yellow]")
+        return request
+
+def format_option_text(option: AnalysisOption) -> str:
+    """Format an AnalysisOption into a string representation"""
+    option_text = f"Option {option.letter}:\n"
+    option_text += f"Summary: {option.summary}\n\n"
+    option_text += "Description:\n"
+    for item in option.description_items:
+        option_text += f"- {item}\n"
+    option_text += "\nAffected files:\n"
+    for file in option.affected_files:
+        option_text += f"- {file}\n"
+    return option_text
+
 def handle_option_selection(claude: ClaudeAPIAgent, initial_response: str, request: str, raw: bool = False, workdir: Optional[Path] = None, include: Optional[List[Path]] = None) -> None:
     """Handle option selection and implementation details"""
-    option = get_option_selection()
+    options = parse_analysis_options(initial_response)
+    if not options:
+        console = Console()
+        console.print("[red]No valid options found in the response[/red]")
+        return
+
+    while True:
+        option = get_option_selection()
+        
+        if option == 'M':
+            # Use the new modify_request function for better UX
+            new_request = modify_request(request)
+            if new_request == request:
+                continue
+                
+            # Rerun analysis with new request
+            paths_to_scan = [workdir] if workdir else []
+            if include:
+                paths_to_scan.extend(include)
+            files_content = collect_files_content(paths_to_scan, workdir) if paths_to_scan else ""
+            
+            initial_prompt = build_request_analysis_prompt(files_content, new_request)
+            initial_response = progress_send_message(claude, initial_prompt)
+            save_to_file(initial_response, 'analysis', workdir)
+            
+            format_analysis(initial_response, raw, claude)
+            options = parse_analysis_options(initial_response)
+            if not options:
+                console = Console()
+                console.print("[red]No valid options found in the response[/red]")
+                return
+            continue
+            
+        if not validate_option_letter(option, options):
+            console = Console()
+            console.print(f"[red]Invalid option '{option}'. Valid options are: {', '.join(options.keys())} or 'M' to modify[/red]")
+            continue
+            
+        break
+
     paths_to_scan = [workdir] if workdir else []
     if include:
         paths_to_scan.extend(include)
     files_content = collect_files_content(paths_to_scan, workdir) if paths_to_scan else ""
     
-    selected_prompt = build_selected_option_prompt(option, request, initial_response, files_content)
+    # Format the selected option before building prompt
+    selected_option = options[option]
+    option_text = format_option_text(selected_option)
+    
+    # Remove initial_response from the arguments
+    selected_prompt = build_selected_option_prompt(option_text, request, files_content)
     prompt_file = save_to_file(selected_prompt, 'selected', workdir)
     if config.verbose:
         print(f"\nSelected prompt saved to: {prompt_file}")
     
-    selected_response = claude.send_message(selected_prompt)
+    selected_response = progress_send_message(claude, selected_prompt)
     changes_file = save_to_file(selected_response, 'changes', workdir)
+
     if config.verbose:
-        print(f"\nChanges saved to: {changes_file}")
+        try:
+            rel_path = changes_file.relative_to(workdir)
+            print(f"\nChanges saved to: ./{rel_path}")
+        except ValueError:
+            print(f"\nChanges saved to: {changes_file}")
     
     changes = parse_block_changes(selected_response)
-    preview_and_apply_changes(changes, workdir)
+    preview_and_apply_changes(changes, workdir, config.test_cmd)
 
 def replay_saved_file(filepath: Path, claude: ClaudeAPIAgent, workdir: Path, raw: bool = False) -> None:
     """Process a saved prompt file and display the response"""
     if not filepath.exists():
         raise FileNotFoundError(f"File {filepath} not found")
     
-    file_type = get_file_type(filepath)
     content = filepath.read_text()
     
+    # Add debug output of file content
+    if config.debug:
+        console = Console()
+        console.print("\n[bold blue]Debug: File Content[/bold blue]")
+        console.print(Panel(
+            content,
+            title=f"Content of {filepath.name}",
+            border_style="blue",
+            padding=(1, 2)
+        ))
+        console.print()
+
+    file_type = get_history_file_type(filepath)
+    
     if file_type == 'changes':
         changes = parse_block_changes(content)
-        preview_and_apply_changes(changes, workdir)
+        success = preview_and_apply_changes(changes, workdir, config.test_cmd)
+        if not success:
+            raise typer.Exit(1)
     elif file_type == 'analysis':
         format_analysis(content, raw, claude)
         handle_option_selection(claude, content, content, raw, workdir)
@@ -144,14 +242,15 @@ def replay_saved_file(filepath: Path, claude: ClaudeAPIAgent, workdir: Path, raw
             console.print("\n=== Prompt Content ===")
             console.print(content)
             console.print("=== End Prompt Content ===\n")
-        response = claude.send_message(content)
+        
+        response = progress_send_message(claude, content)
         changes_file = save_to_file(response, 'changes_', workdir)
         print(f"\nChanges saved to: {changes_file}")
         
         changes = parse_block_changes(response)
-        preview_and_apply_changes(preview_changes, workdir)
+        preview_and_apply_changes(changes, workdir, config.test_cmd)
     else:
-        response = claude.send_message(content)
+        response = progress_send_message(claude, content)
         format_analysis(response, raw)
 
 def process_question(question: str, workdir: Path, include: List[Path], raw: bool, claude: ClaudeAPIAgent) -> None:
@@ -160,7 +259,6 @@ def process_question(question: str, workdir: Path, include: List[Path], raw: boo
     if include:
         paths_to_scan.extend(include)
     files_content = collect_files_content(paths_to_scan, workdir)
-
     answer = ask_question(question, files_content, claude)
     display_answer(answer, raw)
 
@@ -187,14 +285,15 @@ def typer_main(
     play: Optional[Path] = typer.Option(None, "--play", help="Replay a saved prompt file"),
     include: Optional[List[Path]] = typer.Option(None, "-i", "--include", help="Additional paths to include in analysis", exists=True),
     debug: bool = typer.Option(False, "--debug", help="Show debug information"),
-    debug_line: Optional[int] = typer.Option(None, "--debug-line", help="Show debug information only for specific line number"),
     verbose: bool = typer.Option(False, "-v", "--verbose", help="Show verbose output"),
     scan: bool = typer.Option(False, "--scan", help="Preview files that would be analyzed"),
     version: bool = typer.Option(False, "--version", help="Show version and exit"),
+    test: Optional[str] = typer.Option(None, "-t", "--test", help="Test command to run before applying changes"),
 ) -> None:
     """
     Analyze files and provide modification instructions.
     """
+
     if version:
         console = Console()
         console.print(f"Janito v{get_version()}")
@@ -202,7 +301,7 @@ def typer_main(
 
     config.set_debug(debug)
     config.set_verbose(verbose)
-    config.set_debug_line(debug_line)
+    config.set_test_cmd(test)
 
     claude = ClaudeAPIAgent(system_prompt=SYSTEM_PROMPT)
 
@@ -245,9 +344,9 @@ def typer_main(
     else:
         files_content = collect_files_content(paths_to_scan, workdir)
     
-    initial_prompt = build_request_analisys_prompt(files_content, request)
-    initial_response = claude.send_message(initial_prompt)
-    analysis_file = save_to_file(initial_response, 'analysis', workdir)
+    initial_prompt = build_request_analysis_prompt(files_content, request)
+    initial_response = progress_send_message(claude, initial_prompt)
+    save_to_file(initial_response, 'analysis', workdir)
     
     format_analysis(initial_response, raw, claude)
     

janito/analysis.py

@@ -0,0 +1,281 @@
+"""Analysis display module for Janito.
+
+This module handles the formatting and display of analysis results, option selection,
+and related functionality for the Janito application.
+"""
+
+from typing import Optional, Dict, List, Tuple
+from pathlib import Path
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+from rich.columns import Columns
+from rich.rule import Rule
+from rich.prompt import Prompt
+from janito.claude import ClaudeAPIAgent
+from janito.scan import collect_files_content
+from janito.common import progress_send_message
+from janito.config import config
+from dataclasses import dataclass
+import re
+
+MIN_PANEL_WIDTH = 40   # Minimum width for each panel
+
+def get_history_file_type(filepath: Path) -> str:
+    """Determine the type of saved file based on its name"""
+    name = filepath.name.lower()
+    if 'changes' in name:
+        return 'changes'
+    elif 'selected' in name:
+        return 'selected'
+    elif 'analysis' in name:
+        return 'analysis'
+    elif 'response' in name:
+        return 'response'
+    return 'unknown'
+
+@dataclass
+class AnalysisOption:
+    letter: str
+    summary: str
+    affected_files: List[str]
+    description_items: List[str]  # Changed from description to description_items
+
+CHANGE_ANALYSIS_PROMPT = """
+Current files:
+<files>
+{files_content}
+</files>
+
+Considering the above current files content, provide options for the requested change in the following format:
+
+A. Keyword summary of the change
+-----------------
+Description:
+- Detailed description of the change
+
+Affected files:
+- file1.py
+- file2.py (new)
+-----------------
+END_OF_OPTIONS (mandatory marker)
+
+RULES:
+- do NOT provide the content of the files
+- do NOT offer to implement the changes
+
+Request:
+{request}
+"""
+
+
+
+
+def prompt_user(message: str, choices: List[str] = None) -> str:
+    """Display a prominent user prompt with optional choices"""
+    console = Console()
+    console.print()
+    console.print(Rule(" User Input Required ", style="bold cyan"))
+    
+    if choices:
+        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
+        console.print(Panel(choice_text, box=box.ROUNDED))
+    
+    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
+
+def validate_option_letter(letter: str, options: dict) -> bool:
+    """Validate if the given letter is a valid option or 'M' for modify"""
+    return letter.upper() in options or letter.upper() == 'M'
+
+def get_option_selection() -> str:
+    """Get user input for option selection with modify option"""
+    console = Console()
+    console.print("\n[cyan]Enter option letter or 'M' to modify request[/cyan]")
+    while True:
+        letter = prompt_user("Select option").strip().upper()
+        if letter == 'M' or (letter.isalpha() and len(letter) == 1):
+            return letter
+        console.print("[red]Please enter a valid letter or 'M'[/red]")
+
+def _display_options(options: Dict[str, AnalysisOption]) -> None:
+    """Display available options with left-aligned content and horizontally centered panels."""
+    console = Console()
+    
+    # Display centered title using Rule
+    console.print()
+    console.print(Rule(" Available Options ", style="bold cyan", align="center"))
+    console.print()
+    
+    # Calculate optimal width based on terminal
+    term_width = console.width or 100
+    panel_width = max(MIN_PANEL_WIDTH, (term_width // 2) - 10)  # Width for two columns
+    
+    # Create panels for each option
+    panels = []
+    for letter, option in options.items():
+        content = Text()
+        
+        # Display description as bullet points
+        content.append("Description:\n", style="bold cyan")
+        for item in option.description_items:
+            content.append(f"• {item}\n", style="white")
+        content.append("\n")
+        
+        # Display affected files
+        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=(1, 2),
+            width=panel_width
+        )
+        panels.append(panel)
+    
+    # Display panels in columns with center alignment
+    if panels:
+        # Group panels into pairs for two columns
+        for i in range(0, len(panels), 2):
+            pair = panels[i:i+2]
+            columns = Columns(
+                pair,
+                align="center",
+                expand=True,
+                equal=True,
+                padding=(0, 2)
+            )
+            console.print(columns)
+            console.print()  # Add spacing between rows
+
+def _display_markdown(content: str) -> None:
+    """Display content in markdown format."""
+    console = Console()
+    md = Markdown(content)
+    console.print(md)
+
+def _display_raw_history(claude: ClaudeAPIAgent) -> None:
+    """Display raw message history from Claude agent."""
+    console = Console()
+    console.print("\n=== Message History ===")
+    for role, content in claude.messages_history:
+        console.print(f"\n[bold cyan]{role.upper()}:[/bold cyan]")
+        console.print(content)
+    console.print("\n=== End Message History ===\n")
+
+
+def format_analysis(analysis: str, raw: bool = False, claude: Optional[ClaudeAPIAgent] = None, workdir: Optional[Path] = None) -> None:
+    """Format and display the analysis output with enhanced capabilities."""
+    console = Console()
+    
+    if raw and claude:
+        _display_raw_history(claude)
+    else:
+        options = parse_analysis_options(analysis)
+        if options:
+            _display_options(options)
+        else:
+            console.print("\n[yellow]Warning: No valid options found in response. Displaying as markdown.[/yellow]\n")
+            _display_markdown(analysis)
+
+def get_history_path(workdir: Path) -> Path:
+    """Create and return the history directory path"""
+    history_dir = workdir / '.janito' / 'history'
+    history_dir.mkdir(parents=True, exist_ok=True)
+    return history_dir
+
+def get_timestamp() -> str:
+    """Get current UTC timestamp in YMD_HMS format with leading zeros"""
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
+
+def save_to_file(content: str, prefix: str, workdir: Path) -> Path:
+    """Save content to a timestamped file in history directory"""
+    history_dir = get_history_path(workdir)
+    timestamp = get_timestamp()
+    filename = f"{timestamp}_{prefix}.txt"
+    file_path = history_dir / filename
+    file_path.write_text(content)
+    return file_path
+
+
+
+def parse_analysis_options(response: str) -> dict[str, AnalysisOption]:
+    """Parse options from the response text using a line-based approach."""
+    options = {}
+    
+    # Extract content up to END_OF_OPTIONS
+    if 'END_OF_OPTIONS' in response:
+        response = response.split('END_OF_OPTIONS')[0]
+    
+    lines = response.splitlines()
+    current_option = None
+    current_section = None
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # Check for new option starting with letter
+        if len(line) >= 2 and line[0].isalpha() and line[1] == '.' and line[0].isupper():
+            if current_option:
+                options[current_option.letter] = current_option
+            
+            letter = line[0]
+            summary = line[2:].strip()
+            current_option = AnalysisOption(
+                letter=letter,
+                summary=summary,
+                affected_files=[],
+                description_items=[]
+            )
+            current_section = None
+            continue
+            
+        # Skip separator lines
+        if line.startswith('---'):
+            continue
+            
+        # Check for section headers
+        if line.startswith('Description:'):
+            current_section = 'description'
+            continue
+        elif line.startswith('Affected files:'):
+            current_section = 'files'
+            continue
+            
+        # Process content based on current section
+        if current_option and current_section and line:
+            if current_section == 'description':
+                # Strip bullet points and whitespace
+                item = line.lstrip(' -•').strip()
+                if item:
+                    current_option.description_items.append(item)
+            elif current_section == 'files':
+                # Strip bullet points and (modified)/(new) annotations
+                file_path = line.lstrip(' -')
+                file_path = re.sub(r'\s*\([^)]+\)\s*$', '', file_path)
+                if file_path:
+                    current_option.affected_files.append(file_path)
+    
+    # Add the last option if exists
+    if current_option:
+        options[current_option.letter] = current_option
+    
+    return options
+
+def build_request_analysis_prompt(files_content: str, request: str) -> str:
+    """Build prompt for information requests"""
+    return CHANGE_ANALYSIS_PROMPT.format(
+        files_content=files_content,
+        request=request
+    )