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

janito/console/commands.py

@@ -1,112 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

janito/console/display.py

@@ -1,157 +0,0 @@
-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,334 +0,0 @@
-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