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

janito/changeviewer/themes.py

@@ -0,0 +1,57 @@
+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',          
+    'modified': '#000030'          
+}
+
+# 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
+    'modified': 'light_blue'      # Semantic light blue for modifications
+}
+
+@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', 'modified'}
+    
+    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/cli/__init__.py

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

janito/cli/commands.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+from typing import Optional, List
+from rich.console import Console
+
+from janito.agents import AIAgent
+from janito.scan import preview_scan, is_dir_empty
+from janito.config import config
+
+from .functions import (
+    process_question, replay_saved_file, ensure_workdir,
+    review_text, save_to_file, collect_files_content,
+    build_request_analysis_prompt, progress_send_message,
+    format_analysis, handle_option_selection, read_stdin
+)
+
+
+def handle_ask(question: str, workdir: Path, include: List[Path], raw: bool, agent: AIAgent):
+    """Ask a question about the codebase"""
+    workdir = ensure_workdir(workdir)
+    if question == ".":
+        question = read_stdin()
+    process_question(question, workdir, include, raw, agent)
+
+def handle_scan(paths_to_scan: List[Path], workdir: Path):
+    """Preview files that would be analyzed"""
+    workdir = ensure_workdir(workdir)
+    preview_scan(paths_to_scan, workdir)
+
+def handle_play(filepath: Path, workdir: Path, raw: bool):
+    """Replay a saved prompt file"""
+    workdir = ensure_workdir(workdir)
+    replay_saved_file(filepath, workdir, raw)
+
+def handle_request(request: str, workdir: Path, include: List[Path], raw: bool, agent: AIAgent):
+    """Process modification request"""
+    workdir = ensure_workdir(workdir)
+    paths_to_scan = include if include else [workdir]
+    
+    is_empty = is_dir_empty(workdir)
+    if is_empty and not include:
+        console = Console()
+        console.print("\n[bold blue]Empty directory - will create new files as needed[/bold blue]")
+        files_content = ""
+    else:
+        files_content = collect_files_content(paths_to_scan, workdir)
+    
+    initial_prompt = build_request_analysis_prompt(files_content, request)
+    initial_response = progress_send_message(initial_prompt)
+    save_to_file(initial_response, 'analysis', workdir)
+    
+    format_analysis(initial_response, raw, agent)
+    
+    handle_option_selection(initial_response, request, raw, workdir, include)

janito/cli/functions.py

@@ -0,0 +1,286 @@
+from typing import Optional, List
+from pathlib import Path
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+from rich.text import Text
+from rich.markdown import Markdown
+from datetime import datetime, timezone
+import tempfile
+import typer
+import sys
+
+from janito.agents import AIAgent
+from janito.config import config
+from janito.scan import collect_files_content, show_content_stats
+from janito.analysis import (
+    format_analysis, build_request_analysis_prompt, 
+    parse_analysis_options, get_history_file_type, AnalysisOption
+)
+from janito.qa import ask_question, display_answer
+from janito.common import progress_send_message
+from janito.prompts import build_selected_option_prompt
+from janito.fileparser import parse_block_changes
+from janito.change.applier import preview_and_apply_changes
+
+def prompt_user(message: str, choices: List[str] = None) -> str:
+    """Display a simple user prompt with optional choices"""
+    console = Console()
+    
+    if choices:
+        console.print(f"\n[cyan]Options: {', '.join(choices)}[/cyan]")
+    
+    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"""
+    console = Console()
+    console.print("\n[cyan]Enter option letter or 'M' to modify request[/cyan]")
+    
+    while True:
+        letter = Prompt.ask("[bold cyan]Select option[/bold cyan]").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_change_history_path(workdir: Path) -> Path:
+    """Create and return the changes history directory path"""
+    changes_history_dir = workdir / '.janito' / 'change_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"""
+    return datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
+
+def save_prompt_to_file(prompt: str) -> Path:
+    """Save prompt to a named temporary file that won't be deleted"""
+    temp_file = tempfile.NamedTemporaryFile(prefix='selected_', suffix='.txt', delete=False)
+    temp_path = Path(temp_file.name)
+    temp_path.write_text(prompt)
+    return temp_path
+
+def save_to_file(content: str, prefix: str, workdir: Path) -> Path:
+    """Save content to a timestamped file in changes history directory"""
+    changes_history_dir = get_change_history_path(workdir)
+    timestamp = get_timestamp()
+    filename = f"{timestamp}_{prefix}.txt"
+    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(initial_response: str, request: str, raw: bool = False, workdir: Optional[Path] = None, include: Optional[List[Path]] = None) -> None:
+    """Handle option selection and implementation details"""
+    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
+            # Only scan files listed in the selected option's affected_files
+            selected_option = options[option]
+            files_to_scan = selected_option.affected_files
+    
+            # Convert relative paths to absolute paths
+            absolute_paths = []
+            for file_path in files_to_scan:
+                # Remove (new) suffix if present
+                clean_path = file_path.split(' (')[0].strip()
+                path = workdir / clean_path if workdir else Path(clean_path)
+                if path.exists():
+                    absolute_paths.append(path)
+    
+            files_content = collect_files_content(absolute_paths, workdir) if absolute_paths else ""   
+            show_content_stats(files_content)         
+            initial_prompt = build_request_analysis_prompt(files_content, new_request)
+            initial_response = progress_send_message(initial_prompt)
+            save_to_file(initial_response, 'analysis', workdir)
+            
+            format_analysis(initial_response, raw)
+            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
+
+    # Only scan files listed in the selected option's affected_files
+    selected_option = options[option]
+    files_to_scan = selected_option.affected_files
+    
+    # Convert relative paths to absolute paths
+    absolute_paths = []
+    for file_path in files_to_scan:
+        # Remove (new) suffix if present
+        clean_path = file_path.split(' (')[0].strip()
+        path = workdir / clean_path if workdir else Path(clean_path)
+        if path.exists():
+            absolute_paths.append(path)
+    
+    files_content = collect_files_content(absolute_paths, workdir) if absolute_paths else ""
+    show_content_stats(files_content)
+    
+    # Format the selected option before building prompt
+    selected_option = options[option]
+    option_text = format_option_text(selected_option)
+    
+    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 = progress_send_message(selected_prompt)
+    changes_file = save_to_file(selected_response, 'changes', workdir)
+
+    if config.verbose:
+        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, config.test_cmd)
+
+def read_stdin() -> str:
+    """Read input from stdin until EOF"""
+    console = Console()
+    console.print("[dim]Enter your input (press Ctrl+D when finished):[/dim]")
+    return sys.stdin.read().strip()
+
+def replay_saved_file(filepath: Path, 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")
+    
+    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)
+        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)
+        handle_option_selection(content, content, raw, workdir)
+    elif file_type == 'selected':
+        if raw:
+            console = Console()
+            console.print("\n=== Prompt Content ===")
+            console.print(content)
+            console.print("=== End Prompt Content ===\n")
+        
+        response = progress_send_message(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(changes, workdir, config.test_cmd)
+    else:
+        response = progress_send_message(content)
+        format_analysis(response, raw)
+
+def process_question(question: str, workdir: Path, include: List[Path], raw: bool, agent: AIAgent) -> None:
+    """Process a question about the codebase"""
+    paths_to_scan = [workdir] if workdir else []
+    if include:
+        paths_to_scan.extend(include)
+    files_content = collect_files_content(paths_to_scan, workdir)
+    answer = ask_question(question, files_content)
+    display_answer(answer, raw)
+
+def ensure_workdir(workdir: Path) -> Path:
+    """Ensure working directory exists, prompt for creation if it doesn't"""
+    if workdir.exists():
+        return workdir.absolute()
+        
+    console = Console()
+    console.print(f"\n[yellow]Directory does not exist:[/yellow] {workdir}")
+    if Confirm.ask("Create directory?"):
+        workdir.mkdir(parents=True)
+        console.print(f"[green]Created directory:[/green] {workdir}")
+        return workdir.absolute()
+    raise typer.Exit(1)
+
+def review_text(text: str, raw: bool = False) -> None:
+    """Review the provided text using Claude"""
+    console = Console()
+    response = progress_send_message(f"Please review this text and provide feedback:\n\n{text}")
+    if raw:
+        console.print(response)
+    else:
+        console.print(Markdown(response))

janito/cli/registry.py

@@ -0,0 +1,26 @@
+from typing import Callable, Dict
+from dataclasses import dataclass
+
+@dataclass
+class Command:
+    name: str
+    handler: Callable
+    help_text: str
+
+class CommandRegistry:
+    def __init__(self):
+        self._commands: Dict[str, Command] = {}
+        
+    def register(self, name: str, help_text: str):
+        def decorator(handler: Callable):
+            self._commands[name] = Command(name, handler, help_text)
+            return handler
+        return decorator
+        
+    def get_command(self, name: str) -> Command:
+        return self._commands.get(name)
+        
+    def get_all_commands(self) -> Dict[str, Command]:
+        return self._commands
+
+registry = CommandRegistry()

janito/common.py

@@ -0,0 +1,23 @@
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from janito.agents import AgentSingleton
+
+def progress_send_message(message: str) -> str:
+    """
+    Send a message to the AI agent with a progress indicator and elapsed time.
+    
+    Args:
+        message: The message to send
+        
+    Returns:
+        The response from the AI agent
+    """
+    agent = AgentSingleton.get_agent()
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}", justify="center"),
+        TimeElapsedColumn(),
+    ) as progress:
+        task = progress.add_task("Waiting for response from AI agent...", total=None)
+        response = agent.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()

janito/console/__init__.py

@@ -0,0 +1,3 @@
+from .core import start_console_session
+
+__all__ = ['start_console_session']

janito/console/commands.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+from typing import List
+from rich.console import Console
+from rich.panel import Panel
+from janito.agents import AIAgent
+from janito.analysis import build_request_analysis_prompt
+from janito.scan import collect_files_content
+from janito.common import progress_send_message
+from janito.__main__ import handle_option_selection
+from .display import display_help
+
+def process_command(command: str, args: str, workdir: Path, include: List[Path], agent: AIAgent) -> None:
+    """Process console commands using CLI functions for consistent behavior"""
+    console = Console()
+    
+    # Parse command options
+    raw = False
+    verbose = False
+    debug = False
+    test_cmd = None
+    
+    # Extract options from args
+    words = args.split()
+    filtered_args = []
+    i = 0
+    while i < len(words):
+        if words[i] == '--raw':
+            raw = True
+        elif words[i] == '--verbose':
+            verbose = True
+        elif words[i] == '--debug':
+            debug = True
+        elif words[i] == '--test' and i + 1 < len(words):
+            test_cmd = words[i + 1]
+            i += 1
+        else:
+            filtered_args.append(words[i])
+        i += 1
+    
+    args = ' '.join(filtered_args)
+    
+    # Update config with command options
+    from janito.config import config
+    config.set_debug(debug)
+    config.set_verbose(verbose)
+    config.set_test_cmd(test_cmd)
+    
+    # Remove leading slash if present
+    command = command.lstrip('/')
+    
+    # Handle command aliases
+    command_aliases = {
+        'h': 'help',
+        'a': 'ask',
+        'r': 'request',
+        'q': 'quit',
+        'exit': 'quit'
+    }
+    command = command_aliases.get(command, command)
+    
+    if command == "help":
+        display_help()
+        return
+        
+    if command == "quit":
+        raise EOFError()
+        
+    if command == "ask":
+        if not args:
+            console.print(Panel(
+                "[red]Ask command requires a question[/red]",
+                title="Error",
+                border_style="red"
+            ))
+            return
+            
+        # Use CLI question processing function
+        from janito.__main__ import process_question
+        process_question(args, workdir, include, raw, claude)
+        return
+        
+    if command == "request":
+        if not args:
+            console.print(Panel(
+                "[red]Request command requires a description[/red]",
+                title="Error",
+                border_style="red"
+            ))
+            return
+            
+        paths_to_scan = [workdir] if workdir else []
+        if include:
+            paths_to_scan.extend(include)
+        files_content = collect_files_content(paths_to_scan, workdir)
+
+        # Use CLI request processing functions
+        initial_prompt = build_request_analysis_prompt(files_content, args)
+        initial_response = progress_send_message(initial_prompt)
+        
+        from janito.__main__ import save_to_file
+        save_to_file(initial_response, 'analysis', workdir)
+        
+        from janito.analysis import format_analysis
+        format_analysis(initial_response, raw)
+        handle_option_selection(initial_response, args, raw, workdir, include)
+        return
+        
+    console.print(Panel(
+        f"[red]Unknown command: /{command}[/red]\nType '/help' for available commands",
+        title="Error",
+        border_style="red"
+    ))

janito/console/core.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+from typing import List, Optional
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from rich.console import Console
+from janito.agents import AgentSingleton
+from janito.prompts import SYSTEM_PROMPT
+from .display import create_completer, format_prompt, display_welcome
+from .commands import process_command
+
+def start_console_session(workdir: Path, include: Optional[List[Path]] = None) -> None:
+    """Start an enhanced interactive console session"""
+    console = Console()
+    agent = AgentSingleton.get_agent()
+
+    # Setup history with persistence
+    history_file = workdir / '.janito' / 'console_history'
+    history_file.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Create session with history and completions
+    session = PromptSession(
+        history=FileHistory(str(history_file)),
+        completer=create_completer(workdir),
+        auto_suggest=AutoSuggestFromHistory(),
+        complete_while_typing=True
+    )
+
+    display_welcome(workdir)
+
+    while True:
+        try:
+            # Get input with formatted prompt
+            user_input = session.prompt(
+                lambda: format_prompt(workdir),
+                complete_while_typing=True
+            ).strip()
+            
+            if not user_input:
+                continue
+                
+            if user_input.lower() in ('exit', 'quit'):
+                console.print("\n[cyan]Goodbye! Have a great day![/cyan]\n")
+                break
+
+            # Split input into command and args
+            parts = user_input.split(maxsplit=1)
+            if parts[0].startswith('/'):  # Handle /command format
+                command = parts[0][1:]  # Remove the / prefix
+            else:
+                command = "request"  # Default to request if no command specified
+                
+            args = parts[1] if len(parts) > 1 else ""
+            
+            # Process command with separated args
+            process_command(command, args, workdir, include, claude)
+
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            console.print("\n[cyan]Goodbye! Have a great day![/cyan]\n")
+            break