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

janito/console.py

@@ -1,60 +1,330 @@
 from prompt_toolkit import PromptSession
 from prompt_toolkit.history import FileHistory
+from prompt_toolkit.completion import WordCompleter, PathCompleter
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.formatted_text import HTML
 from pathlib import Path
 from rich.console import Console
 from janito.claude import ClaudeAPIAgent
-from janito.prompts import build_request_analisys_prompt, SYSTEM_PROMPT
+from janito.prompts import SYSTEM_PROMPT
+from janito.analysis import build_request_analysis_prompt
 from janito.scan import collect_files_content
 from janito.__main__ import handle_option_selection
+from rich.panel import Panel
+from rich.align import Align
+from janito.common import progress_send_message
+from rich.table import Table
+from rich.layout import Layout
+from rich.live import Live
+from typing import List, Optional
+import shutil
 
-def start_console_session(workdir: Path, include: list[Path] = None) -> None:
-    """Start an interactive console session using prompt_toolkit"""
+def create_completer(workdir: Path) -> WordCompleter:
+    """Create command completer with common commands and paths"""
+    commands = [
+        'ask', 'request', 'help', 'exit', 'quit',
+        '--raw', '--verbose', '--debug', '--test'
+    ]
+    return WordCompleter(commands, ignore_case=True)
+
+def format_prompt(workdir: Path) -> HTML:
+    """Format the prompt with current directory"""
+    cwd = workdir.name
+    return HTML(f'<ansigreen>janito</ansigreen> <ansiblue>{cwd}</ansiblue>> ')
+
+def display_help() -> None:
+    """Display available commands, options and their descriptions"""
+    console = Console()
+    
+    layout = Layout()
+    layout.split_column(
+        Layout(name="header"),
+        Layout(name="commands"),
+        Layout(name="options"),
+        Layout(name="examples")
+    )
+    
+    # Header
+    header_table = Table(box=None, show_header=False)
+    header_table.add_row("[bold cyan]Janito Console Help[/bold cyan]")
+    header_table.add_row("[dim]Your AI-powered software development buddy[/dim]")
+    
+    # Commands table
+    commands_table = Table(title="Available Commands", box=None)
+    commands_table.add_column("Command", style="cyan", width=20)
+    commands_table.add_column("Description", style="white")
+    
+
+    commands_table.add_row(
+        "/ask <text> (/a)",
+        "Ask a question about the codebase without making changes"
+    )
+    commands_table.add_row(
+        "<text> or /request <text> (/r)",
+        "Request code modifications or improvements"
+    )
+    commands_table.add_row(
+        "/help (/h)",
+        "Display this help message"
+    )
+    commands_table.add_row(
+        "/quit or /exit (/q)",
+        "Exit the console session"
+    )
+
+    # Options table
+    options_table = Table(title="Common Options", box=None)
+    options_table.add_column("Option", style="cyan", width=20)
+    options_table.add_column("Description", style="white")
+
+    options_table.add_row(
+        "--raw",
+        "Display raw response without formatting"
+    )
+    options_table.add_row(
+        "--verbose",
+        "Show additional information during execution"
+    )
+    options_table.add_row(
+        "--debug",
+        "Display detailed debug information"
+    )
+    options_table.add_row(
+        "--test <cmd>",
+        "Run specified test command before applying changes"
+    )
+    
+    # Examples panel
+    examples = Panel(
+        "\n".join([
+            "[dim]Basic Commands:[/dim]",
+            "  ask how does the error handling work?",
+            "  request add input validation to user functions",
+            "",
+            "[dim]Using Options:[/dim]",
+            "  request update tests --verbose",
+            "  ask explain auth flow --raw",
+            "  request optimize code --test 'pytest'",
+            "",
+            "[dim]Complex Examples:[/dim]",
+            "  request refactor login function --verbose --test 'python -m unittest'",
+            "  ask code structure --raw --debug"
+        ]),
+        title="Examples",
+        border_style="blue"
+    )
+    
+    # Update layout
+    layout["header"].update(header_table)
+    layout["commands"].update(commands_table)
+    layout["options"].update(options_table)
+    layout["examples"].update(examples)
+    
+    console.print(layout)
+
+
+
+def process_command(command: str, args: str, workdir: Path, include: List[Path], claude: ClaudeAPIAgent) -> 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(claude, 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, claude)
+        handle_option_selection(claude, 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"
+    ))
+
+def start_console_session(workdir: Path, include: Optional[List[Path]] = None) -> None:
+    """Start an enhanced interactive console session"""
     console = Console()
     claude = ClaudeAPIAgent(system_prompt=SYSTEM_PROMPT)
 
-    # Setup prompt session with history
+    # Setup history with persistence
     history_file = workdir / '.janito' / 'console_history'
     history_file.parent.mkdir(parents=True, exist_ok=True)
-    session = PromptSession(history=FileHistory(str(history_file)))
+    
+    # Create session with history and completions
+    session = PromptSession(
+        history=FileHistory(str(history_file)),
+        completer=create_completer(workdir),
+        auto_suggest=AutoSuggestFromHistory(),
+        complete_while_typing=True
+    )
 
+    # Get version and terminal info
     from importlib.metadata import version
     try:
         ver = version("janito")
     except:
         ver = "dev"
+    
+    term_width = shutil.get_terminal_size().columns
+    
 
-    console.print("\n[bold blue]╔═══════════════════════════════════════════╗[/bold blue]")
-    console.print("[bold blue]║           Janito AI Assistant             ║[/bold blue]")
-    console.print("[bold blue]║                v" + ver.ljust(8) + "                  ║[/bold blue]")
-    console.print("[bold blue]╠═══════════════════════════════════════════╣[/bold blue]")
-    console.print("[bold blue]║  Your AI-powered development companion    ║[/bold blue]")
-    console.print("[bold blue]╚═══════════════════════════════════════════╝[/bold blue]")
-    console.print("\n[cyan]Type your requests or 'exit' to quit[/cyan]\n")
+
+    # Create welcome message with consistent colors and enhanced information
+    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
+    }
+    
+    welcome_text = (
+        f"[bold {COLORS['primary']}]Welcome to Janito v{ver}[/bold {COLORS['primary']}]\n"
+        f"[{COLORS['muted']}]Your AI-Powered Software Development Buddy[/{COLORS['muted']}]\n\n"
+        f"[{COLORS['accent']}]Keyboard Shortcuts:[/{COLORS['accent']}]\n"
+        "• ↑↓ : Navigate command history\n"
+        "• Tab : Complete commands and paths\n"
+        "• Ctrl+D : Exit console\n"
+        "• Ctrl+C : Cancel current operation\n\n"
+        f"[{COLORS['accent']}]Available Commands:[/{COLORS['accent']}]\n"
+        "• /ask (or /a) : Ask questions about code\n"
+        "• /request (or /r) : Request code changes\n"
+        "• /help (or /h) : Show detailed help\n"
+        "• /quit (or /q) : Exit console\n\n"
+        f"[{COLORS['accent']}]Quick Tips:[/{COLORS['accent']}]\n"
+        "• Start typing and press Tab for suggestions\n"
+        "• Use --test to run tests before changes\n"
+        "• Add --verbose for detailed output\n"
+        "• Type a request directly without /request\n\n"
+        f"[{COLORS['secondary']}]Current Version:[/{COLORS['secondary']}] v{ver}\n"
+        f"[{COLORS['muted']}]Working Directory:[/{COLORS['muted']}] {workdir.absolute()}"
+    )
+    
+    welcome_panel = Panel(
+        welcome_text,
+        width=min(80, term_width - 4),
+        border_style="blue",
+        title="Janito Console",
+        subtitle="Press Tab for completions"
+    )
+    
+    console.print("\n")
+    console.print(welcome_panel)
+    console.print("\n[cyan]How can I help you with your code today?[/cyan]\n")
 
     while True:
         try:
-            request = session.prompt("janito> ")
-            if request.lower() in ('exit', 'quit'):
-                break
-
-            if not request.strip():
+            # 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
 
-            # Get current files content
-            paths_to_scan = [workdir] if workdir else []
-            if include:
-                paths_to_scan.extend(include)
-            files_content = collect_files_content(paths_to_scan, workdir)
-
-            # Get initial analysis
-            initial_prompt = build_request_analisys_prompt(files_content, request)
-            initial_response = claude.send_message(initial_prompt)
-
-            # Show response and handle options
-            console.print(initial_response)
-            handle_option_selection(claude, initial_response, request, False, workdir, include)
+            # 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

janito/contentchange.py

@@ -1,13 +1,9 @@
-import re
 from pathlib import Path
-from typing import Dict, Tuple, TypedDict, List
+from typing import Dict, Tuple
 from rich.console import Console
-from rich.prompt import Confirm
-import tempfile
-from janito.changeviewer import show_file_changes, FileChange, show_diff_changes
-import ast
 from datetime import datetime
-import shutil
+from janito.fileparser import FileChange, parse_block_changes
+from janito.changeapplier import preview_and_apply_changes
 
 def get_file_type(filepath: Path) -> str:
     """Determine the type of saved file based on its name"""
@@ -22,24 +18,6 @@ def get_file_type(filepath: Path) -> str:
         return 'response'
     return 'unknown'
 
-def parse_block_changes(content: str) -> Dict[Path, FileChange]:
-    """Parse file changes from code blocks in the content.
-    Returns dict mapping filepath -> FileChange"""
-    changes = {}
-    pattern = r'##\s*([\da-f-]+)\s+([^\n]+)\s+begin\s*"([^"]*)"[^\n]*##\n(.*?)##\s*\1\s+\2\s+end\s*##'
-    matches = re.finditer(pattern, content, re.DOTALL)
-    
-    for match in matches:
-        filepath = Path(match.group(2))
-        description = match.group(3)
-        file_content = match.group(4).strip()
-        changes[filepath] = FileChange(
-            description=description,
-            new_content=file_content
-        )
-        
-    return changes
-
 def save_changes_to_history(content: str, request: str, workdir: Path) -> Path:
     """Save change content to history folder with timestamp and request info"""
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")  # Already in the correct format
@@ -71,8 +49,6 @@ def validate_python_syntax(content: str, filepath: Path) -> Tuple[bool, str]:
         return True, ""
     except SyntaxError as e:
         return False, f"Line {e.lineno}: {e.msg}"
-    except Exception as e:
-        return False, str(e)
 
 def format_parsed_changes(changes: Dict[Path, Tuple[str, str]]) -> str:
     """Format parsed changes to show only file change descriptions"""
@@ -81,55 +57,7 @@ def format_parsed_changes(changes: Dict[Path, Tuple[str, str]]) -> str:
         result.append(f"=== {filepath} ===\n{description}\n")
     return "\n".join(result)
 
-def validate_changes(changes: Dict[Path, FileChange]) -> Tuple[bool, List[Tuple[Path, str]]]:
-    """Validate all changes, returns (is_valid, list of errors)"""
-    errors = []
-    for filepath, change in changes.items():
-        if filepath.suffix == '.py':
-            is_valid, error = validate_python_syntax(change['new_content'], filepath)
-            if not is_valid:
-                errors.append((filepath, error))
-    return len(errors) == 0, errors
-
-def preview_and_apply_changes(changes: Dict[Path, FileChange], workdir: Path) -> bool:
-    """Preview changes in temporary directory and apply if confirmed."""
-    console = Console()
-
-    if not changes:
-        console.print("\n[yellow]No changes were found to apply[/yellow]")
-        return False
-
-    with tempfile.TemporaryDirectory() as temp_dir:
-        preview_dir = Path(temp_dir)
-        if workdir.exists():
-            shutil.copytree(workdir, preview_dir, dirs_exist_ok=True)
-        
-        for filepath, change in changes.items():
-            # Get original content
-            orig_path = workdir / filepath
-            original = orig_path.read_text() if orig_path.exists() else ""
-            
-            # Prepare preview
-            preview_path = preview_dir / filepath
-            preview_path.parent.mkdir(parents=True, exist_ok=True)
-            preview_path.write_text(change['new_content'])
-            
-            # Show changes
-            show_diff_changes(console, filepath, original, change['new_content'], change['description'])
-
-        # Apply changes if confirmed
-        if Confirm.ask("\nApply these changes?"):
-            for filepath, _ in changes.items():
-                preview_path = preview_dir / filepath
-                target_path = workdir / filepath
-                target_path.parent.mkdir(parents=True, exist_ok=True)
-                shutil.copy2(preview_path, target_path)
-                console.print(f"[green]✓[/green] Applied changes to {filepath}")
-            return True
-            
-    return False
-
-def apply_content_changes(content: str, request: str, workdir: Path) -> Tuple[bool, Path]:
+def apply_content_changes(content: str, request: str, workdir: Path, test_cmd: str = None) -> Tuple[bool, Path]:
     """Regular flow: Parse content, save to history, and apply changes."""
     console = Console()
     changes = parse_block_changes(content)
@@ -138,20 +66,11 @@ def apply_content_changes(content: str, request: str, workdir: Path) -> Tuple[bo
         console.print("\n[yellow]No file changes were found in the response[/yellow]")
         return False, None
 
-    # Validate changes before proceeding
-    is_valid, errors = validate_changes(changes)
-    if not is_valid:
-        console = Console()
-        console.print("\n[red bold]⚠️ Cannot apply changes: Python syntax errors detected![/red bold]")
-        for filepath, error in errors:
-            console.print(f"\n[red]⚠️ {filepath}: {error}[/red]")
-        return False, None
-
     history_file = save_changes_to_history(content, request, workdir)
-    success = preview_and_apply_changes(changes, workdir)
+    success = preview_and_apply_changes(changes, workdir, test_cmd)
     return success, history_file
 
-def handle_changes_file(filepath: Path, workdir: Path) -> Tuple[bool, Path]:
+def handle_changes_file(filepath: Path, workdir: Path, test_cmd: str = None) -> Tuple[bool, Path]:
     """Replay flow: Load changes from file and apply them."""
     content = filepath.read_text()
     changes = parse_block_changes(content)
@@ -161,5 +80,5 @@ def handle_changes_file(filepath: Path, workdir: Path) -> Tuple[bool, Path]:
         console.print("\n[yellow]No file changes were found in the file[/yellow]")
         return False, None
 
-    success = preview_and_apply_changes(changes, workdir)
-    return success, filepath
+    success = preview_and_apply_changes(changes, workdir, test_cmd)
+    return success, filepath

janito/contextparser.py

@@ -0,0 +1,113 @@
+from typing import List, Tuple, Optional, NamedTuple
+from difflib import SequenceMatcher
+from janito.config import config
+from rich.console import Console
+
+class ContextError(NamedTuple):
+    """Contains error details for context matching failures"""
+    pre_context: List[str]
+    post_context: List[str]
+    content: str
+
+def parse_change_block(content: str) -> Tuple[List[str], List[str], List[str]]:
+    """Parse a change block into pre-context, post-context and change lines.
+    Returns (pre_context_lines, post_context_lines, change_lines)"""
+    pre_context_lines = []
+    post_context_lines = []
+    change_lines = []
+    in_pre_context = True
+    
+    for line in content.splitlines():
+        if line.startswith('='):
+            if in_pre_context:
+                pre_context_lines.append(line[1:])
+            else:
+                post_context_lines.append(line[1:])
+        elif line.startswith('>'):
+            in_pre_context = False
+            change_lines.append(line[1:])
+            
+    return pre_context_lines, post_context_lines, change_lines
+
+def find_context_match(file_content: str, pre_context: List[str], post_context: List[str], min_context: int = 2) -> Optional[Tuple[int, int]]:
+    """Find exact matching location using line-by-line matching.
+    Returns (start_index, end_index) or None if no match found."""
+    if not (pre_context or post_context) or (len(pre_context) + len(post_context)) < min_context:
+        return None
+
+    file_lines = file_content.splitlines()
+    
+    # Function to check if lines match at a given position
+    def lines_match_at(pos: int, target_lines: List[str]) -> bool:
+        if pos + len(target_lines) > len(file_lines):
+            return False
+        return all(a == b for a, b in zip(file_lines[pos:pos + len(target_lines)], target_lines))
+
+    # For debug output
+    debug_matches = []
+    
+    # Try to find pre_context match
+    pre_match_pos = None
+    if pre_context:
+        for i in range(len(file_lines) - len(pre_context) + 1):
+            if lines_match_at(i, pre_context):
+                pre_match_pos = i
+                break
+            if config.debug:
+                # Record first 20 non-matches for debug output
+                if len(debug_matches) < 20:
+                    debug_matches.append((i, file_lines[i:i + len(pre_context)]))
+
+    # Try to find post_context match after pre_context if found
+    if pre_match_pos is not None and post_context:
+        expected_post_pos = pre_match_pos + len(pre_context)
+        if not lines_match_at(expected_post_pos, post_context):
+            pre_match_pos = None
+
+    if pre_match_pos is None and config.debug:
+        console = Console()
+        console.print("\n[bold red]Context Match Debug:[/bold red]")
+        
+        if pre_context:
+            console.print("\n[yellow]Expected pre-context:[/yellow]")
+            for i, line in enumerate(pre_context):
+                console.print(f"  {i+1:2d} | '{line}'")
+
+        if post_context:
+            console.print("\n[yellow]Expected post-context:[/yellow]")
+            for i, line in enumerate(post_context):
+                console.print(f"  {i+1:2d} | '{line}'")
+
+        console.print("\n[yellow]First 20 attempted matches in file:[/yellow]")
+        for pos, lines in debug_matches:
+            console.print(f"\n[cyan]At line {pos+1}:[/cyan]")
+            for i, line in enumerate(lines):
+                match_status = "≠" if i < len(pre_context) and line != pre_context[i] else "="
+                console.print(f"  {i+1:2d} | '{line}' {match_status}")
+
+        return None
+
+    if pre_match_pos is None:
+        return None
+
+    end_pos = pre_match_pos + len(pre_context)
+    
+    return pre_match_pos, end_pos
+
+def apply_changes(content: str, 
+                 pre_context_lines: List[str], 
+                 post_context_lines: List[str], 
+                 change_lines: List[str]) -> Optional[Tuple[str, Optional[ContextError]]]:
+    """Apply changes with context matching, returns (new_content, error_details)"""
+    if not content.strip() and not pre_context_lines and not post_context_lines:
+        return '\n'.join(change_lines), None
+
+    pre_context = '\n'.join(pre_context_lines)
+    post_context = '\n'.join(post_context_lines)
+    
+    if pre_context and pre_context not in content:
+        return None, ContextError(pre_context_lines, post_context_lines, content)
+    
+    if post_context and post_context not in content:
+        return None, ContextError(pre_context_lines, post_context_lines, content)
+