janito 0.3.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

@@ -0,0 +1,334 @@
+from pathlib import Path
+from typing import Dict, Tuple, List, Optional, Union
+from dataclasses import dataclass
+import re
+import ast
+import sys
+import os  # Add this import
+from rich.console import Console
+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, create or replace instructions"""
+    path: Path
+    description: str
+    is_new_file: bool
+    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"""
+        if self.search_blocks is None:
+            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()
+        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()
+        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 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()
+    
+    # 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()
+        
+        # Show debug info for create actions
+        if config.debug and action == 'create':
+            console.print(f"[green]Found new file block:[/green] {filepath}")
+            
+        # 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:
+            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]
+                
+                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)
+                
+            # 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)
+        
+        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]")
+        
+    return changes

janito/prompts.py

@@ -1,25 +1,12 @@
 import re
+import uuid
+from typing import List, Union
+from dataclasses import dataclass
+from .analysis import parse_analysis_options, AnalysisOption
 
 # Core system prompt focused on role and purpose
-SYSTEM_PROMPT = """You are Janito, an AI assistant for software development tasks. Be concise.
-"""
-
+SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. I help you with coding tasks while being clear and concise in my responses."""
 
-CHANGE_ANALISYS_PROMPT = """
-Current files:
-<files>
-{files_content}
-</files>
-
-Considering the current files content, provide a table of options for the requested change.
-Always provide options using a header label "=== **Option 1** : ...", "=== **Option 2**: ...", etc.
-Provide the header with a short description followed by the file changes on the next line
-What files should be modified and what should they contain? (one line description)
-Do not provide the content of any of the file suggested to be created or modified.
-
-Request:
-{request}
-"""
 
 SELECTED_OPTION_PROMPT = """
 Original request: {request}
@@ -32,66 +19,63 @@ Current files:
 {files_content}
 </files>
 
-After checking the above files and the provided implementation, please provide the following:
-
-## <uuid4> filename begin "short description of the change" ##
-<entire file content>
-## <uuid4> filename end ##
-
-ALWAYS provide the entire file content, not just the changes.
-If no changes are needed answer to any worksppace just reply <
+RULES:
+- 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>
+## {uuid} replace with ##
+<replace_content>
+## {uuid} file end ##
+
+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 file removal:
+## {uuid} file <filepath> remove "short removal reason" ##
+## {uuid} file end ##
+
+RULES:
+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_number: int, request: str, initial_response: str, files_content: str = "") -> str:
-    """Build prompt for selected option details"""
-    options = parse_options(initial_response)
-    if option_number not in options:
-        raise ValueError(f"Option {option_number} not found in response")
+def build_selected_option_prompt(option_text: str, request: str, files_content: str = "") -> str:
+    """Build prompt for selected option details
+    
+    Args:
+        option_text: Formatted text describing the selected option
+        request: The original user request
+        files_content: Content of relevant files
+    """
+    short_uuid = str(uuid.uuid4())[:8]
     
     return SELECTED_OPTION_PROMPT.format(
-        option_text=options[option_number],
+        option_text=option_text,
         request=request,
-        files_content=files_content
-    )
-
-def parse_options(response: str) -> dict[int, str]:
-    """Parse options from the response text, including any list items after the option label"""
-    options = {}
-    pattern = r"===\s*\*\*Option (\d+)\*\*\s*:\s*(.+?)(?====\s*\*\*Option|\Z)"
-    matches = re.finditer(pattern, response, re.DOTALL)
-    
-    for match in matches:
-        option_num = int(match.group(1))
-        option_text = match.group(2).strip()
-        
-        # Split into description and list items
-        lines = option_text.splitlines()
-        description = lines[0]
-        list_items = []
-        
-        # Collect list items that follow
-        for line in lines[1:]:
-            line = line.strip()
-            if line.startswith(('- ', '* ', '• ')):
-                list_items.append(line)
-            elif not line:
-                continue
-            else:
-                break
-                
-        # Combine description with list items if any exist
-        if list_items:
-            option_text = description + '\n' + '\n'.join(list_items)
-        
-        options[option_num] = option_text
-        
-    return options
-
-
-def build_request_analisys_prompt(files_content: str, request: str) -> str:
-    """Build prompt for information requests"""
-
-    return CHANGE_ANALISYS_PROMPT.format(
         files_content=files_content,
-        request=request
+        uuid=short_uuid
     )