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

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

janito/prompts.py

@@ -1,81 +0,0 @@
-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 = """I am Janito, your friendly software development buddy. I help you with coding tasks while being clear and concise in my responses."""
-
-
-SELECTED_OPTION_PROMPT = """
-Original request: {request}
-
-Please provide detailed implementation using the following guide:
-{option_text}
-
-Current files:
-<files>
-{files_content}
-</files>
-
-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_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=option_text,
-        request=request,
-        files_content=files_content,
-        uuid=short_uuid
-    )

janito/scan.py

@@ -1,176 +0,0 @@
-from pathlib import Path
-from typing import List, Tuple, Set
-from rich.console import Console
-from rich.columns import Columns
-from rich.panel import Panel
-from janito.config import config
-from pathspec import PathSpec
-from pathspec.patterns import GitWildMatchPattern
-from collections import defaultdict
-
-
-
-SPECIAL_FILES = ["README.md", "__init__.py", "__main__.py"]
-
-def _scan_paths(paths: List[Path], workdir: Path = None) -> Tuple[List[str], List[str]]:
-    """Common scanning logic used by both preview and content collection"""
-    content_parts = []
-    file_items = []
-    skipped_files = []
-    processed_files: Set[Path] = set()  # Track processed files
-    console = Console()
-    
-    # Load gitignore if it exists
-    gitignore_path = workdir / '.gitignore' if workdir else None
-    gitignore_spec = None
-    if (gitignore_path and gitignore_path.exists()):
-        with open(gitignore_path) as f:
-            gitignore = f.read()
-        gitignore_spec = PathSpec.from_lines(GitWildMatchPattern, gitignore.splitlines())
-    
-
-    def scan_path(path: Path, level: int) -> None:
-        """
-        Scan a path and add it to the content_parts list
-        level 0 means we are scanning the root directory
-        level 1 we provide both directory directory name and file content
-        level > 1 we just return
-        """
-        if level > 1:
-            return
-        
-        path = path.resolve()
-        relative_base = workdir
-        if path.is_dir():
-            relative_path = path.relative_to(relative_base)
-            content_parts.append(f'<directory><path>{relative_path}</path>not sent</directory>')
-            file_items.append(f"[blue]•[/blue] {relative_path}/")
-            # Check for special files
-            special_found = []
-            for special_file in SPECIAL_FILES:
-                special_path = path / special_file
-                if special_path.exists() and special_path.resolve() not in processed_files:
-                    special_found.append(special_file)
-                    processed_files.add(special_path.resolve())
-            if special_found:
-                file_items[-1] = f"[blue]•[/blue] {relative_path}/ [cyan]({', '.join(special_found)})[/cyan]"
-                for special_file in special_found:
-                    special_path = path / special_file
-                    try:
-                        relative_path = special_path.relative_to(relative_base)
-                        file_content = special_path.read_text(encoding='utf-8')
-                        content_parts.append(f"<file>\n<path>{relative_path}</path>\n<content>\n{file_content}\n</content>\n</file>")
-                    except UnicodeDecodeError:
-                        skipped_files.append(str(relative_path))
-                        console.print(f"[yellow]Warning: Skipping file due to encoding issues: {relative_path}[/yellow]")
-
-            for item in path.iterdir():
-                # Skip if matches gitignore patterns
-                if gitignore_spec:
-                    rel_path = str(item.relative_to(workdir))
-                    if gitignore_spec.match_file(rel_path):
-                        continue
-                if item.resolve() not in processed_files:  # Skip if already processed
-                    scan_path(item, level+1)
-
-        else:
-            resolved_path = path.resolve()
-            if resolved_path in processed_files:  # Skip if already processed
-                return
-                
-            processed_files.add(resolved_path)
-            relative_path = path.relative_to(relative_base)
-            # check if file is binary
-            try:
-                if path.is_file() and path.read_bytes().find(b'\x00') != -1:
-                    console.print(f"[red]Skipped binary file found: {relative_path}[/red]")
-                    return
-                file_content = path.read_text(encoding='utf-8')
-                content_parts.append(f"<file>\n<path>{relative_path}</path>\n<content>\n{file_content}\n</content>\n</file>")
-                file_items.append(f"[cyan]•[/cyan] {relative_path}")
-            except UnicodeDecodeError:
-                skipped_files.append(str(relative_path))
-                console.print(f"[yellow]Warning: Skipping file due to encoding issues: {relative_path}[/yellow]")
-
-    for path in paths:
-        scan_path(path, 0)
-        
-    if skipped_files and config.verbose:
-        console.print("\n[yellow]Files skipped due to encoding issues:[/yellow]")
-        for file in skipped_files:
-            console.print(f"  • {file}")
-        
-    return content_parts, file_items
-
-def collect_files_content(paths: List[Path], workdir: Path = None) -> str:
-    """Collect content from all files in XML format"""
-    console = Console()
-    content_parts, file_items = _scan_paths(paths, workdir)
-
-    if file_items and config.verbose:
-        console.print("\n[bold blue]Contents being analyzed:[/bold blue]")
-        console.print(Columns(file_items, padding=(0, 4), expand=True))
-        
-    if config.verbose:
-        for part in content_parts:
-            if part.startswith('<file>'):
-                # Extract filename from XML content
-                path_start = part.find('<path>') + 6
-                path_end = part.find('</path>')
-                if path_start > 5 and path_end > path_start:
-                    filepath = part[path_start:path_end]
-                    console.print(f"[dim]Adding content from:[/dim] {filepath}")
-    
-    return "\n".join(content_parts)
-
-
-def preview_scan(paths: List[Path], workdir: Path = None) -> None:
-    """Preview what files and directories would be scanned"""
-    console = Console()
-    _, file_items = _scan_paths(paths, workdir)
-    
-    # Display working directory status
-    console.print("\n[bold blue]Analysis Paths:[/bold blue]")
-    console.print(f"[cyan]Working Directory:[/cyan] {workdir.absolute()}")
-    
-    # Show if working directory is being scanned
-    is_workdir_scanned = any(p.resolve() == workdir.resolve() for p in paths)
-    if is_workdir_scanned:
-        console.print("[green]✓ Working directory will be scanned[/green]")
-    else:
-        console.print("[yellow]! Working directory will not be scanned[/yellow]")
-    
-    # Show included paths relative to working directory
-    if len(paths) > (1 if is_workdir_scanned else 0):
-        console.print("\n[cyan]Additional Included Paths:[/cyan]")
-        for path in paths:
-            if path.resolve() != workdir.resolve():
-                try:
-                    rel_path = path.relative_to(workdir)
-                    console.print(f"  • ./{rel_path}")
-                except ValueError:
-                    # Path is outside working directory
-                    console.print(f"  • {path.absolute()}")
-    
-    console.print("\n[bold blue]Files that will be analyzed:[/bold blue]")
-    console.print(Columns(file_items, padding=(0, 4), expand=True))
-
-def is_dir_empty(path: Path) -> bool:
-    """Check if directory is empty, ignoring hidden files"""
-    return not any(item for item in path.iterdir() if not item.name.startswith('.'))
-
-def show_content_stats(content: str) -> None:
-    if not content:
-        return
-        
-    dir_counts = defaultdict(int)
-    for line in content.split('\n'):
-        if line.startswith('<path>'):
-            path = Path(line.replace('<path>', '').replace('</path>', '').strip())
-            dir_counts[str(path.parent)] += 1
-    
-    console = Console()
-    stats = [f"{directory} ({count} files)" for directory, count in dir_counts.items()]
-    columns = Columns(stats, equal=True, expand=True)
-    panel = Panel(columns, title="Work Context")
-    console.print(panel)

janito/tests/test_fileparser.py

@@ -1,26 +0,0 @@
-import pytest
-from pathlib import Path
-from janito.fileparser import validate_file_path, validate_file_content
-
-def test_validate_file_path():
-    # Valid paths
-    assert validate_file_path(Path("test.py")) == (True, "")
-    assert validate_file_path(Path("folder/test.py")) == (True, "")
-    
-    # Invalid paths
-    assert validate_file_path(Path("/absolute/path.py"))[0] == False
-    assert validate_file_path(Path("../escape.py"))[0] == False
-    assert validate_file_path(Path("test?.py"))[0] == False
-    assert validate_file_path(Path("test*.py"))[0] == False
-
-def test_validate_file_content():
-    # Valid content
-    assert validate_file_content("print('hello')") == (True, "")
-    assert validate_file_content("# Empty file with comment\n") == (True, "")
-    
-    # Invalid content
-    assert validate_file_content("")[0] == False
-    
-    # Test large content
-    large_content = "x" * (1024 * 1024 + 1)  # Slightly over 1MB
-    assert validate_file_content(large_content)[0] == False