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

janito/console/display.py

@@ -0,0 +1,157 @@
+from pathlib import Path
+import shutil
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.formatted_text import HTML
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.layout import Layout
+from importlib.metadata import version
+
+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 display_welcome(workdir: Path) -> None:
+    """Display welcome message and console information"""
+    console = Console()
+    try:
+        ver = version("janito")
+    except:
+        ver = "dev"
+    
+    term_width = shutil.get_terminal_size().columns
+
+    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['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")

janito/fileparser.py

@@ -1,20 +1,57 @@
 from pathlib import Path
-from typing import Dict, Tuple, List, Optional
+from typing import Dict, Tuple, List, Optional, Union
 from dataclasses import dataclass
 import re
 import ast
-import sys  # Add this import
+import sys
+import os  # Add this import
 from rich.console import Console
-from rich.panel import Panel  # Add this import
-from janito.config import config  # Add this import
+from rich.panel import Panel
+from janito.config import config
+
+def validate_file_path(filepath: Path) -> Tuple[bool, str]:
+    """
+    Validate that the file path exists and is readable
+    
+    Args:
+        filepath: Path object to validate
+        
+    Returns:
+        Tuple[bool, str]: (is_valid, error_message)
+    """
+    if not filepath.exists():
+        return False, f"File does not exist: {filepath}"
+    if not os.access(filepath, os.R_OK):
+        return False, f"File is not readable: {filepath}"
+    return True, ""
+
+def validate_file_content(content: str) -> Tuple[bool, str]:
+    """
+    Validate that the content is not empty and contains valid text
+    
+    Args:
+        content: String content to validate
+        
+    Returns:
+        Tuple[bool, str]: (is_valid, error_message)
+    """
+    if not content:
+        return False, "Content cannot be empty"
+    if not isinstance(content, str):
+        return False, "Content must be a string"
+    return True, ""
 
 @dataclass
 class FileChange:
-    """Represents a file change with search/replace, search/delete or create instructions"""
+    """Represents a file change with search/replace, search/delete, create or replace instructions"""
+    path: Path
     description: str
     is_new_file: bool
-    content: str = ""  # For new files
+    content: str = ""  # For new files or replace operations
+    original_content: str = ""  # Original content for file replacements
     search_blocks: List[Tuple[str, Optional[str], Optional[str]]] = None  # (search, replace, description)
+    replace_file: bool = False  # Flag for complete file replacement
+    remove_file: bool = False  # Flag for file deletion
 
     def add_search_block(self, search: str, replace: Optional[str], description: Optional[str] = None) -> None:
         """Add a search/replace or search/delete block with optional description"""
@@ -22,104 +59,276 @@ class FileChange:
             self.search_blocks = []
         self.search_blocks.append((search, replace, description))
 
+@dataclass
+class FileBlock:
+    """Raw file block data extracted from response"""
+    uuid: str
+    filepath: str
+    action: str
+    description: str
+    content: str
+
 def validate_python_syntax(content: str, filepath: Path) -> Tuple[bool, str]:
     """Validate Python syntax and return (is_valid, error_message)"""
     try:
         ast.parse(content)
         console = Console()
-        console.print(f"[green]✓ Python syntax validation passed:[/green] {filepath.absolute()}")
+        try:
+            rel_path = filepath.relative_to(Path.cwd())
+            display_path = f"./{rel_path}"
+        except ValueError:
+            display_path = str(filepath)
+        console.print(f"[green]✓ Python syntax validation passed:[/green] {display_path}")
         return True, ""
     except SyntaxError as e:
         error_msg = f"Line {e.lineno}: {e.msg}"
         console = Console()
-        console.print(f"[red]✗ Python syntax validation failed:[/red] {filepath.absolute()}")
+        try:
+            rel_path = filepath.relative_to(Path.cwd())
+            display_path = f"./{rel_path}"
+        except ValueError:
+            display_path = str(filepath)
+        console.print(f"[red]✗ Python syntax validation failed:[/red] {display_path}")
         console.print(f"[red]  {error_msg}[/red]")
         return False, error_msg
 
+def count_lines(text: str) -> int:
+    """Count the number of lines in a text block."""
+    return len(text.splitlines())
 
-def parse_block_changes(response_text: str) -> Dict[Path, FileChange]:
-    """Parse file changes from response blocks"""
-    changes = {}
+def extract_file_blocks(response_text: str) -> List[Tuple[str, str, str, str]]:
+    """Extract file blocks from response text and return list of (uuid, filepath, action, description, content)"""
+    file_blocks = []
     console = Console()
-    # Match file blocks with UUID
-    file_pattern = r'## ([a-f0-9]{8}) file (.*?) (modify|create) "(.*?)" ##\n?(.*?)## \1 file end ##'
     
-    for match in re.finditer(file_pattern, response_text, re.DOTALL):
-        uuid, filepath, action, description, content = match.groups()
-        path = Path(filepath.strip())
+    # Find file blocks with improved quoted description handling
+    file_start_pattern = r'## ([a-f0-9]{8}) file (.*?) (modify|create|remove|replace)(?:\s+"([^"]*?)")?\s*##'
+    # Find the first UUID to check for duplicates
+    first_match = re.search(file_start_pattern, response_text)
+    if not first_match:
+        console.print("[red]FATAL ERROR: No file blocks found in response[/red]")
+        sys.exit(1)
+    fist_uuid = first_match.group(1)
+    
+    # Find all file blocks
+    for match in re.finditer(file_start_pattern, response_text):
+        block_uuid, filepath, action, description = match.groups()
         
-        if action == 'create':
-            changes[path] = FileChange(
-                description=description,
-                is_new_file=True,
-                content=content[1:] if content.startswith('\n') else content,
-                search_blocks=[]
-            )
-            continue
+        # Show debug info for create actions
+        if config.debug and action == 'create':
+            console.print(f"[green]Found new file block:[/green] {filepath}")
             
-        # For modifications, find all search/replace and search/delete blocks
-        search_blocks = []
-        block_patterns = [
-            # Match search/replace blocks with description - updated pattern
-            (r'## ' + re.escape(uuid) + r' search/replace "(.*?)" ##\n?(.*?)## ' + 
-             re.escape(uuid) + r' replace with ##\n?(.*?)(?=## ' + re.escape(uuid) + r'|$)', False),
-            # Match search/delete blocks with description
-            (r'## ' + re.escape(uuid) + r' search/delete "(.*?)" ##\n?(.*?)(?=## ' + re.escape(uuid) + r'|$)', True)
-        ]
+        # Now find the complete block
+        full_block_pattern = (
+            f"## {block_uuid} file.*?##\n?"
+            f"(.*?)"
+            f"## {block_uuid} file end ##"
+        )
+        
+        block_match = re.search(full_block_pattern, response_text[match.start():], re.DOTALL)
+        if not block_match:
+            # Show context around the incomplete block
+            context_start = max(0, match.start() - 100)
+            context_end = min(len(response_text), match.start() + 100)
+            context = response_text[context_start:context_end]
+            
+            console.print(f"\n[red]FATAL ERROR: Found file start but no matching end for {filepath}[/red]")
+            console.print("[red]Context around incomplete block:[/red]")
+            console.print(Panel(context, title="Context", border_style="red"))
+            sys.exit(1)
+            
+        content = block_match.group(1)
+        # For new files, preserve the first newline if it exists
+        if action == 'create' and content.startswith('\n'):
+            content = content[1:]
+            
+        file_blocks.append((block_uuid, filepath.strip(), action, description or "", content))
         
         if config.debug:
-            console.print("\n[blue]Updated regex patterns:[/blue]")
-            for pattern, is_delete in block_patterns:
-                console.print(Panel(pattern, title="Search/Replace Pattern" if not is_delete else "Search/Delete Pattern", border_style="blue"))
+            action_type = "Creating new file" if action == "create" else "Modifying file"
+            console.print(f"[green]Found valid block:[/green] {action_type} {filepath}")
+            console.print(f"[blue]Content length:[/blue] {len(content)} chars")
+            
+    return file_blocks
+
+def extract_modification_blocks(uuid: str, content: str) -> List[Tuple[str, str, Optional[str], str]]:
+    """Extract all modification blocks from content, returns list of (type, description, replace, search)"""
+    blocks = []
+    console = Console()
+    
+    # Find all modification blocks in sequence
+    block_start = r'## ' + re.escape(uuid) + r' (search/replace|search/delete) "(.*?)" ##\n'
+    current_pos = 0
+    
+    while True:
+        # Find next block start
+        start_match = re.search(block_start, content[current_pos:], re.DOTALL)
+        if not start_match:
+            break
+            
+        block_type, description = start_match.groups()
+        block_start_pos = current_pos + start_match.end()
+        
+        # Find block end based on type
+        if block_type == 'search/replace':
+            replace_marker = f"## {uuid} replace with ##\n"
+            end_marker = f"## {uuid}"
+            
+            # Find replace marker
+            replace_pos = content.find(replace_marker, block_start_pos)
+            if replace_pos == -1:
+                # Show context around the incomplete block
+                context_start = max(0, current_pos + start_match.start() - 100)
+                context_end = min(len(content), current_pos + start_match.end() + 100)
+                context = content[context_start:context_end]
                 
-        for pattern, is_delete in block_patterns:
-            if config.debug:
-                console.print(f"\n[blue]Looking for pattern:[/blue]")
-                console.print(Panel(pattern, title="Pattern", border_style="blue"))
-                console.print(f"\n[blue]In content:[/blue]")
-                console.print(Panel(content, title="Content", border_style="blue"))
+                console.print(f"\n[red]FATAL ERROR: Missing 'replace with' marker for block:[/red] {description}")
+                console.print("[red]Context around incomplete block:[/red]")
+                console.print(Panel(context, title="Context", border_style="red"))
+                sys.exit(1)
                 
-            for block_match in re.finditer(pattern, content, re.DOTALL):
-                if is_delete:
-                    description, search = block_match.groups()
-                    search = search.rstrip('\n') + '\n'  # Ensure single trailing newline
-                    replace = None
-                else:
-                    description, search, replace = block_match.groups()
-                    search = search.rstrip('\n') + '\n'  # Ensure single trailing newline
-                    replace = (replace.rstrip('\n') + '\n') if replace else None
-                    
-                    # Abort parsing if replace content is empty
-                    if not is_delete and (replace is None or replace.strip() == ''):
-                        console.print(f"\n[red]Error: Empty replace content found![/red]")
-                        console.print(f"[red]File:[/red] {filepath}")
-                        console.print(f"[red]Description:[/red] {description}")
-                        console.print("[yellow]Search block:[/yellow]")
-                        console.print(Panel(search, title="Search Content", border_style="yellow"))
-                        console.print("[red]Replace block is empty or contains only whitespace![/red]")
-                        console.print("[red]Aborting due to empty replace content.[/red]")
-                        sys.exit(1)
-                    
-                    # Enhanced debug info
-                    if config.debug or (not is_delete and (replace is None or replace.strip() == '')):
-                        console.print(f"\n[yellow]Search/Replace block analysis:[/yellow]")
-                        console.print(f"[yellow]File:[/yellow] {filepath}")
-                        console.print(f"[yellow]Description:[/yellow] {description}")
-                        console.print("[yellow]Search block:[/yellow]")
-                        console.print(Panel(search, title="Search Content", border_style="yellow"))
-                        console.print("[yellow]Replace block:[/yellow]")
-                        console.print(Panel(replace if replace else "<empty>", title="Replace Content", border_style="yellow"))
-                        console.print("\n[blue]Match groups:[/blue]")
-                        for i, group in enumerate(block_match.groups()):
-                            console.print(Panel(str(group), title=f"Group {i}", border_style="blue"))
-                    
-                search_blocks.append((search, replace, description))
+            # Get search content
+            search = content[block_start_pos:replace_pos]
+            
+            # Find end of replacement
+            replace_start = replace_pos + len(replace_marker)
+            next_block = content.find(end_marker, replace_start)
+            if next_block == -1:
+                # Use rest of content if no end marker found
+                replace = content[replace_start:]
+            else:
+                replace = content[replace_start:next_block]
+            
+            blocks.append(('replace', description, replace, search))
+            current_pos = next_block if next_block != -1 else len(content)
+            
+        else:  # search/delete
+            # Find either next block start or end of content
+            next_block_marker = content.find(f"## {uuid}", block_start_pos)
+            if next_block_marker == -1:
+                # Use rest of content if no more blocks
+                search = content[block_start_pos:]
+            else:
+                search = content[block_start_pos:next_block_marker]
+                
+            blocks.append(('delete', description, None, search))
+            current_pos = next_block_marker if next_block_marker != -1 else len(content)
+            
+        if config.debug:
+            console.print(f"[green]Found {block_type} block:[/green] {description}")
+            
+    return blocks
+
+def handle_file_block(block: FileBlock) -> FileChange:
+    """Process a single file block and return a FileChange object"""
+    console = Console()
+    
+    # Handle file removal action
+    if block.action == 'remove':
+        return FileChange(
+            path=Path(block.filepath),
+            description=block.description,
+            is_new_file=False,
+            content="",
+            search_blocks=[],
+            remove_file=True
+        )
+    
+    # Validate file path
+    path = Path(block.filepath)
+    is_valid, error = validate_file_path(path)
+    if block.action == 'replace' and not is_valid:
+        console.print(f"[red]Invalid file path for replacement:[/red] {error}")
+        sys.exit(1)
+    
+    # Handle file replacement action
+    if block.action == 'replace':
+        # Read original content if file exists
+        original_content = ""
+        if path.exists():
+            try:
+                original_content = path.read_text()
+            except Exception as e:
+                console.print(f"[red]Error reading original file for replacement:[/red] {e}")
+                sys.exit(1)
+                
+        return FileChange(
+            path=Path(block.filepath),
+            description=block.description,
+            is_new_file=False,
+            content=block.content.lstrip('\n'),
+            original_content=original_content,
+            search_blocks=[],
+            replace_file=True
+        )
+    
+    # Validate content for new files
+    if block.action == 'create':
+        is_valid, error = validate_file_content(block.content)
+        if not is_valid:
+            console.print(f"[red]Invalid file content for {block.filepath}:[/red] {error}")
+            sys.exit(1)
+    
+    if block.action == 'create':
+        return FileChange(
+            path=Path(block.filepath),
+            description=block.description,
+            is_new_file=True,
+            content=block.content[1:] if block.content.startswith('\n') else block.content,
+            search_blocks=[]
+        )
+    
+    # Extract and process modification blocks
+    search_blocks = []
+    for block_type, description, replace, search in extract_modification_blocks(block.uuid, block.content):
+        # Ensure consistent line endings
+        search = search.rstrip('\n') + '\n'
+        if replace is not None:
+            replace = replace.rstrip('\n') + '\n'
+            
+        if config.debug:
+            console.print(f"\n[cyan]Processing {block_type} block:[/cyan] {description}")
+            console.print(Panel(search, title="Search Content"))
+            if replace:
+                console.print(Panel(replace, title="Replace Content"))
+                
+        search_blocks.append((search, replace, description))
+    
+    return FileChange(
+        path=Path(block.filepath),
+        description=block.description,
+        is_new_file=False,
+        search_blocks=search_blocks
+    )
+
+def parse_block_changes(response_text: str) -> List[FileChange]:
+    """Parse file changes from response blocks and return list of FileChange"""
+    changes = []
+    console = Console()
+    
+    # First extract all file blocks
+    file_blocks = extract_file_blocks(response_text)
+    
+    # Process each file block independently
+    for block_uuid, filepath, action, description, content in file_blocks:
+        path = Path(filepath)
         
-        # Add debug info if no blocks were found
-        if config.debug and not search_blocks:
-            console.print(f"\n[red]No search/replace blocks found for file:[/red] {filepath}")
-            console.print("[red]Check if the content format matches the expected patterns[/red]")
+        file_block = FileBlock(
+            uuid=block_uuid,
+            filepath=filepath,
+            action=action,
+            description=description,
+            content=content
+        )
+        
+        file_change = handle_file_block(file_block)
+        # For remove action, ensure remove_file flag is set
+        if action == 'remove':
+            file_change.remove_file = True
+        file_change.path = path
+        changes.append(file_change)
+
+    if config.debug:
+        console.print(f"\n[cyan]Processed {len(file_blocks)} file blocks[/cyan]")
         
-        changes[path] = FileChange(description=description, is_new_file=False, search_blocks=search_blocks)
-    
     return changes

janito/prompts.py

@@ -20,12 +20,17 @@ Current files:
 </files>
 
 RULES:
-- When revmoing constants, ensure they are not used elsewhere
+- When removing constants, ensure they are not used elsewhere
 - When adding new features to python files, add the necessary imports
 - Python imports should be inserted at the top of the file
+- For complete file replacements, only use for existing files marked as modified
+- File replacements must preserve the essential functionality
+- When multiple changes affect the same code block, combine them into a single change
+- if no changes are required answer only the reason in the format: <no_changes_required>reason for no changes<no_changes_required>
 
 Please provide the changes in this format:
 
+For incremental changes:
 ## {uuid} file <filepath> modify "short file change description" ##
 ## {uuid} search/replace "short change description" ##
 <search_content>
@@ -33,19 +38,29 @@ Please provide the changes in this format:
 <replace_content>
 ## {uuid} file end ##
 
-Or to delete content:
+For complete file replacement (only for existing modified files):
+## {uuid} file <filepath> replace "short file description" ##
+<full_file_content>
+## {uuid} file end ##
+
+For new files:
+## {uuid} file <filepath> create "short file description" ##
+<full_file_content>
+## {uuid} file end ##
+
+For content deletion:
 ## {uuid} file <filepath> modify ##
 ## {uuid} search/delete "short change description" ##
 <content_to_delete>
 ## {uuid} file end ##
 
-For new files:
-## {uuid} file <filepath> create "short description" ##
-<full_file_content>
+For file removal:
+## {uuid} file <filepath> remove "short removal reason" ##
 ## {uuid} file end ##
 
 RULES:
-1. search_content MUST preserve the original identation/whitespace 
+1. search_content MUST preserve the original indentation/whitespace
+2. file replacement can only be used for existing files marked as 
 """
 
 def build_selected_option_prompt(option_text: str, request: str, files_content: str = "") -> str:

janito/qa.py

@@ -4,10 +4,9 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
 from rich.rule import Rule
-from janito.claude import ClaudeAPIAgent
+from janito.agents import AIAgent
 from janito.common import progress_send_message
-from typing import Dict, List
-import re
+from janito.scan import show_content_stats
 
 QA_PROMPT = """Please provide a clear and concise answer to the following question about the codebase:
 
@@ -22,13 +21,16 @@ Focus on providing factual information and explanations. Do not suggest code cha
 Format your response using markdown with appropriate headers and code blocks.
 """
 
-def ask_question(question: str, files_content: str, claude: ClaudeAPIAgent) -> str:
+def ask_question(question: str, files_content: str) -> str:
     """Process a question about the codebase and return the answer"""
+    # Show content stats before processing
+    show_content_stats(files_content)
+    
     prompt = QA_PROMPT.format(
         question=question,
         files_content=files_content
     )
-    return progress_send_message(claude, prompt)
+    return progress_send_message(prompt)
 
 
 def display_answer(answer: str, raw: bool = False) -> None: