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

janito/search_replace/searcher.py

@@ -1,411 +0,0 @@
-from typing import List, Optional, Dict, Type
-from abc import ABC, abstractmethod
-import re
-from .strategy_result import StrategyResult
-
-LINE_OVER_LINE_DEBUG = False
-
-class SearchStrategy(ABC):
-    """Base class for search strategies."""
-
-    def __init__(self):
-        """Initialize strategy with name derived from class name."""
-        self.name = self.__class__.__name__.replace('Strategy', '')
-
-    @abstractmethod
-    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
-        """Check if pattern matches source at given position.
-        
-        Args:
-            source_lines: List of source code lines to search in
-            pattern_lines: List of pattern lines to match
-            pos: Position in source_lines to start matching
-            searcher: Searcher instance for utility methods
-            
-        Returns:
-            bool: True if pattern matches at position, False otherwise
-        """
-        pass
-
-class ExactMatchStrategy(SearchStrategy):
-    """Strategy for exact match including indentation."""
-
-    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
-        """Match pattern exactly with indentation.
-        
-        Args:
-            source_lines: List of source code lines to search in
-            pattern_lines: List of pattern lines to match
-            pos: Position in source_lines to start matching
-            searcher: Searcher instance for utility methods
-            
-        Returns:
-            bool: True if pattern matches exactly at position, False otherwise
-        """
-        if pos + len(pattern_lines) > len(source_lines):
-            return False
-        return all(source_lines[pos + i] == pattern_line 
-                  for i, pattern_line in enumerate(pattern_lines))
-
-class ExactContentStrategy(SearchStrategy):
-    """Exact content match ignoring all indentation."""
-
-    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
-        """Match pattern exactly ignoring indentation.
-        
-        Args:
-            source_lines: List of source code lines to search in
-            pattern_lines: List of pattern lines to match
-            pos: Position in source_lines to start matching
-            searcher: Searcher instance for utility methods
-            
-        Returns:
-            bool: True if pattern matches exactly at position, False otherwise
-        """
-        if pos + len(pattern_lines) > len(source_lines):
-            return False
-        return all(source_lines[pos + i].strip() == pattern_line.strip()
-                  for i, pattern_line in enumerate(pattern_lines)
-                  if pattern_line.strip())
-
-class IndentAwareStrategy(SearchStrategy):
-    """Indentation-aware matching preserving relative indentation."""
-
-    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
-        """Match pattern preserving relative indentation.
-        
-        Args:
-            source_lines: List of source code lines to search in
-            pattern_lines: List of pattern lines to match
-            pos: Position in source_lines to start matching
-            searcher: Searcher instance for utility methods
-            
-        Returns:
-            bool: True if pattern matches preserving indentation at position, False otherwise
-        """
-        if pos + len(pattern_lines) > len(source_lines):
-            return False
-        match_indent = searcher.get_indentation(source_lines[pos])
-        return all(source_lines[pos + i].startswith(match_indent + pattern_line)
-                  for i, pattern_line in enumerate(pattern_lines)
-                  if pattern_line.strip())
-
-class ExactContentNoComments(SearchStrategy):
-    """Exact content match ignoring indentation, comments, and empty lines."""
-
-    def _strip_comments(self, line: str) -> str:
-        """Remove comments from line."""
-        if '#' in line:
-            line = line.split('#')[0]
-        if '//' in line:
-            line = line.split('//')[0]
-        return line.strip()
-
-    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
-        """Match pattern ignoring comments and empty lines.
-        
-        Args:
-            source_lines: List of source code lines to search in
-            pattern_lines: List of pattern lines to match
-            pos: Position in source_lines to start matching
-            searcher: Searcher instance for utility methods
-            
-        Returns:
-            bool: True if pattern matches ignoring comments at position, False otherwise
-        """
-        if pos + len(pattern_lines) > len(source_lines):
-            return False
-
-        if searcher.debug_mode and LINE_OVER_LINE_DEBUG:
-            print("\n[DEBUG] ExactContentNoComments trying to match at line", pos + 1)
-
-        # Filter out comments and empty lines from pattern
-        pattern_content = [self._strip_comments(line) for line in pattern_lines]
-        pattern_content = [line for line in pattern_content if line]
-
-        if searcher.debug_mode and LINE_OVER_LINE_DEBUG:
-            print("[DEBUG] Pattern after processing:")
-            for i, line in enumerate(pattern_content):
-                print(f"[DEBUG]   {i+1}: '{line}'")
-
-        # Match against source, ignoring comments and empty lines
-        source_idx = pos
-        pattern_idx = 0
-        
-        while pattern_idx < len(pattern_content) and source_idx < len(source_lines):
-            source_line = self._strip_comments(source_lines[source_idx])
-            if not source_line:
-                source_idx += 1
-                continue
-                
-            if searcher.debug_mode and LINE_OVER_LINE_DEBUG:
-                print(f"[DEBUG] Line {source_idx + 1}: '{source_line}' vs '{pattern_content[pattern_idx]}'")
-                
-            if source_line != pattern_content[pattern_idx]:
-                if searcher.debug_mode and LINE_OVER_LINE_DEBUG:
-                    print("[DEBUG] Line mismatch")
-                return False
-                
-            pattern_idx += 1
-            source_idx += 1
-
-        match_result = pattern_idx == len(pattern_content)
-        if match_result and searcher.debug_mode:
-            print("[DEBUG] Match found")
-            return True
-                
-        return False
-
-class ExactContentNoCommentsFirstLinePartial(SearchStrategy):
-    """Match first line partially, ignoring comments."""
-
-    def _strip_comments(self, line: str) -> str:
-        """Remove comments from line."""
-        if '#' in line:
-            line = line.split('#')[0]
-        if '//' in line:
-            line = line.split('//')[0]
-        return line.strip()
-
-    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
-        """Match first line of pattern partially ignoring comments.
-        
-        Args:
-            source_lines: List of source code lines to search in
-            pattern_lines: List of pattern lines to match
-            pos: Position in source_lines to start matching
-            searcher: Searcher instance for utility methods
-            
-        Returns:
-            bool: True if first line of pattern matches partially at position, False otherwise
-        """
-        if pos >= len(source_lines):
-            return False
-
-        # Get first non-empty pattern line
-        pattern_content = []
-        for line in pattern_lines:
-            stripped = self._strip_comments(line)
-            if stripped:
-                pattern_content.append(stripped)
-                break
-
-        if not pattern_content:
-            return False
-
-        # Get source line content
-        source_line = self._strip_comments(source_lines[pos])
-        if not source_line:
-            return False
-
-        # Check if pattern content is part of source line
-        return pattern_content[0] in source_line
-
-class Searcher:
-    """Handles pattern searching in source code with configurable strategies."""
-    
-    def __init__(self, debug: bool = False):
-        """Initialize searcher with debug mode."""
-        self.debug_mode = debug
-
-    @classmethod
-    def set_debug(cls, enabled: bool):
-        """Enable or disable debug mode - deprecated, use instance property instead"""
-        # Remove the class-level debug setting as it's no longer needed
-        raise DeprecationWarning("Class-level debug setting is deprecated. Use instance debug_mode property instead.")
-
-    # Updated extension to strategy mapping to include ExactContentNoComments
-    EXTENSION_STRATEGIES = {
-        '.py': [ExactMatchStrategy(), IndentAwareStrategy(), ExactContentStrategy(), ExactContentNoComments(), ExactContentNoCommentsFirstLinePartial()],
-        '.java': [ExactMatchStrategy(), IndentAwareStrategy(), ExactContentStrategy(), ExactContentNoComments(), ExactContentNoCommentsFirstLinePartial()],
-        '.js': [ExactMatchStrategy(), IndentAwareStrategy(), ExactContentStrategy(), ExactContentNoComments(), ExactContentNoCommentsFirstLinePartial()],
-        '.ts': [ExactMatchStrategy(), IndentAwareStrategy(), ExactContentStrategy(), ExactContentNoComments(), ExactContentNoCommentsFirstLinePartial()],
-        '*': [ExactMatchStrategy(), ExactContentStrategy(), ExactContentNoComments(), ExactContentNoCommentsFirstLinePartial()]  # updated default fallback
-    }
-
-    def get_strategies(self, file_ext: Optional[str]) -> List[SearchStrategy]:
-        """Get search strategies for given file extension."""
-        if not file_ext:
-            return self.EXTENSION_STRATEGIES['*']
-        return self.EXTENSION_STRATEGIES.get(file_ext.lower(), self.EXTENSION_STRATEGIES['*'])
-
-    @staticmethod
-    def get_indentation(line: str) -> str:
-        """Get the leading whitespace of a line."""
-        return re.match(r'^[ \t]*', line).group()
-
-    @staticmethod
-    def get_first_non_empty_line(text: str) -> tuple[str, int]:
-        """Get first non-empty line and its index."""
-        lines = text.splitlines()
-        for i, line in enumerate(lines):
-            if line.strip():
-                return line, i
-        return '', 0
-
-    @staticmethod
-    def get_last_non_empty_line(text: str) -> tuple[str, int]:
-        """Get last non-empty line and its index."""
-        lines = text.splitlines()
-        for i in range(len(lines) - 1, -1, -1):
-            if lines[i].strip():
-                return lines[i], i
-        return '', 0
-
-    def _build_indent_map(self, text: str) -> dict[int, int]:
-        """Build a map of line numbers to their indentation levels.
-        
-        Args:
-            text: Source text to analyze
-            
-        Returns:
-            dict[int, int]: Mapping of line numbers to indentation levels
-        """
-        indent_map = {}
-        for i, line in enumerate(text.splitlines()):
-            if line.strip():  # Only track non-empty lines
-                indent_map[i] = len(self.get_indentation(line))
-                if self.debug_mode:
-                    print(f"[DEBUG] Line {i}: Indentation level {indent_map[i]}")
-        return indent_map
-
-    def normalize_pattern(self, pattern: str, base_indent: str = '') -> str:
-        """Remove base indentation from pattern to help with matching."""
-        lines = pattern.splitlines()
-        first_line, start_idx = self.get_first_non_empty_line(pattern)
-        last_line, end_idx = self.get_last_non_empty_line(pattern)
-        
-        # Calculate minimum indentation from first and last non-empty lines
-        first_indent = len(self.get_indentation(first_line))
-        last_indent = len(self.get_indentation(last_line))
-        min_indent = min(first_indent, last_indent)
-
-        if self.debug_mode:
-            print(f"[DEBUG] First line indent: {first_indent}")
-            print(f"[DEBUG] Last line indent: {last_indent}")
-            print(f"[DEBUG] Using minimum indent: {min_indent}")
-
-        normalized = []
-        for i, line in enumerate(lines):
-            if not line.strip():
-                normalized.append('')
-            else:
-                line_indent = len(self.get_indentation(line))
-                if line_indent < min_indent:
-                    if self.debug_mode:
-                        print(f"[DEBUG] Warning: Line {i} has less indentation ({line_indent}) than minimum ({min_indent})")
-                    normalized.append(line)
-                else:
-                    normalized.append(line[min_indent:])
-                    if self.debug_mode:
-                        print(f"[DEBUG] Normalized line {i}: '{normalized[-1]}'")
-
-        return '\n'.join(normalized)
-
-    def _find_best_match_position(self, positions: List[int], source_lines: List[str], pattern_base_indent: int) -> Optional[int]:
-        """Find the best matching position among candidates.
-        
-        Args:
-            positions: List of candidate line positions
-            source_lines: List of source code lines
-            pattern_base_indent: Base indentation level of pattern
-            
-        Returns:
-            Optional[int]: Best matching position or None if no matches
-        """
-        if self.debug_mode:
-            print(f"[DEBUG] Finding best match among positions: {[p+1 for p in positions]}")  # Show 1-based line numbers
-
-        if not positions:
-            return None
-
-        best_pos = min(positions)  # Simply take the earliest match
-        if self.debug_mode:
-            print(f"[DEBUG] Selected match at line {best_pos + 1}")  # Show 1-based line number
-        return best_pos
-
-    def try_match_with_strategies(self, source_lines: List[str], pattern_lines: List[str],
-                                pos: int, strategies: List[SearchStrategy]) -> StrategyResult:
-        """Try matching using multiple strategies in sequence.
-        
-        Args:
-            source_lines: List of source code lines
-            pattern_lines: List of pattern lines to match
-            pos: Position to start matching
-            strategies: List of strategies to try
-            
-        Returns:
-            StrategyResult: Result containing match success and strategy used
-        """
-        if self.debug_mode and LINE_OVER_LINE_DEBUG:
-            print(f"\n[DEBUG] Trying to match at line {pos + 1}")
-
-        for strategy in strategies:
-            if strategy.match(source_lines, pattern_lines, pos, self):
-                if self.debug_mode:
-                    print(f"[DEBUG] Match found with {strategy.__class__.__name__}")
-                    print(f"[DEBUG] Stopping strategy chain at line {pos + 1}")
-                return StrategyResult(success=True, strategy_name=strategy.name, match_position=pos)
-        return StrategyResult(success=False)
-
-    def _find_matches(self, source_lines: List[str], pattern_lines: List[str],
-                     file_ext: Optional[str] = None) -> List[int]:
-        """Find all matching positions using available strategies.
-        
-        Args:
-            source_lines: List of source code lines
-            pattern_lines: List of pattern lines to match
-            file_ext: Optional file extension to determine strategies
-            
-        Returns:
-            List[int]: List of matching line positions
-        """
-        strategies = self.get_strategies(file_ext)
-
-        if self.debug_mode:
-            print("\nTrying search strategies:")
-            print("-" * 50)
-
-        # Track positions already matched to avoid redundant attempts
-        matched_positions = set()
-        all_matches = []
-
-        for strategy in strategies:
-            strategy_name = strategy.__class__.__name__.replace('Strategy', '')
-
-            if self.debug_mode:
-                print(f"\n→ {strategy_name}...")
-
-            for i in range(len(source_lines)):
-                if i in matched_positions:
-                    continue
-
-                if strategy.match(source_lines, pattern_lines, i, self):
-                    matched_positions.add(i)
-                    all_matches.append(i)
-                    if self.debug_mode:
-                        print(f"✓ Match found at line {i+1} using {strategy_name}")
-
-            if all_matches and isinstance(strategy, ExactMatchStrategy):
-                # If we found exact matches, no need to try other strategies
-                break
-
-        if self.debug_mode and all_matches:
-            print(f"\nFound {len(all_matches)} total match(es) at line(s) {[m+1 for m in sorted(all_matches)]}")
-
-        return sorted(all_matches)
-
-    def _check_exact_match(self, source_lines: List[str], pattern_lines: List[str], pos: int) -> bool:
-        """Check for exact line-by-line match at position.
-        
-        Args:
-            source_lines: List of source code lines
-            pattern_lines: List of pattern lines to match
-            pos: Position to check for match
-            
-        Returns:
-            bool: True if exact match found, False otherwise
-        """
-        if pos + len(pattern_lines) > len(source_lines):
-            return False
-        return all(source_lines[pos + j] == pattern_lines[j] for j in range(len(pattern_lines)))

janito/search_replace/strategy_result.py

@@ -1,10 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional
-
-@dataclass
-class StrategyResult:
-    """Encapsulates the result of a strategy match attempt."""
-    success: bool
-    strategy_name: Optional[str] = None
-    match_position: Optional[int] = None
-    file_type: Optional[str] = None

janito/shell/__init__.py

@@ -1,38 +0,0 @@
-"""Shell package initialization for Janito."""
-from typing import Optional
-from prompt_toolkit import PromptSession
-from rich.console import Console
-from janito.config import config
-from janito.workspace.workset import Workset
-from .processor import CommandProcessor
-from .commands import register_commands
-from .registry import CommandRegistry
-
-def start_shell() -> None:
-    """Start the Janito interactive shell."""
-    # Create single registry instance
-    registry = CommandRegistry()
-    register_commands(registry)
-    
-    # Create shell components with shared registry
-    from .prompt import create_shell_session
-    session = create_shell_session(registry)
-    processor = CommandProcessor(registry)
-
-    # Initialize and show workset content
-    workset = Workset()
-    workset.refresh()
-    workset.show()
-
-    while True:
-        try:
-            text = session.prompt("janito🤖 ")
-            if text.strip():
-                processor.process_command(text)
-        except KeyboardInterrupt:
-            continue
-        except EOFError:
-            break
-        except Exception as e:
-            print(f"Error: {e}")
-    print("Goodbye!")

janito/shell/bus.py

@@ -1,31 +0,0 @@
-"""Command bus implementation for Janito shell."""
-from typing import Dict, Callable, Any, Optional
-from dataclasses import dataclass
-
-@dataclass
-class Command:
-    """Command message for command bus."""
-    name: str
-    args: str
-
-class CommandBus:
-    """Simple command bus implementation."""
-    _instance = None
-    _handlers: Dict[str, Callable[[Command], None]] = {}
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._handlers = {}
-        return cls._instance
-
-    def register_handler(self, command_name: str, handler: Callable[[Command], None]) -> None:
-        """Register a handler for a command."""
-        self._handlers[command_name] = handler
-
-    def handle(self, command: Command) -> None:
-        """Handle a command by dispatching to appropriate handler."""
-        if handler := self._handlers.get(command.name):
-            handler(command)
-        else:
-            raise ValueError(f"No handler registered for command: {command.name}")

janito/shell/commands.py

@@ -1,136 +0,0 @@
-"""Command system for Janito shell."""
-from rich.console import Console
-from rich.table import Table
-from prompt_toolkit import PromptSession
-from prompt_toolkit.shortcuts import clear as ptk_clear
-from prompt_toolkit.completion import PathCompleter
-from prompt_toolkit.document import Document
-from pathlib import Path
-from janito.config import config
-from janito.workspace import workset  # Updated import
-from janito.workspace.analysis import analyze_workspace_content
-from .registry import CommandRegistry, Command, get_path_completer
-
-def handle_request(args: str) -> None:
-    """Handle a change request."""
-    if not args:
-        Console().print("[red]Error: Change request required[/red]")
-        return
-    from janito.cli.commands import handle_request as cli_handle_request
-    cli_handle_request(args)
-
-def handle_exit(_: str) -> None:
-    """Handle exit command."""
-    raise EOFError()
-
-def handle_clear(_: str) -> None:
-    """Handle clear command."""
-    ptk_clear()
-
-def handle_ask(args: str) -> None:
-    """Handle ask command."""
-    if not args:
-        Console().print("[red]Error: Question required[/red]")
-        return
-    from janito.cli.commands import handle_ask as cli_handle_ask
-    cli_handle_ask(args)
-
-def handle_help(args: str) -> None:
-    """Handle help command."""
-    console = Console()
-    registry = CommandRegistry()
-    command = args.strip() if args else None
-    if command and (cmd := registry.get_command(command)):
-        console.print(f"\n[bold]{command}[/bold]: {cmd.description}")
-        if cmd.usage:
-            console.print(f"Usage: {cmd.usage}")
-    else:
-        table = Table(title="Available Commands")
-        table.add_column("Command", style="cyan")
-        table.add_column("Description")
-
-        for name, cmd in sorted(registry.get_commands().items()):
-            table.add_row(name, cmd.description)
-
-        console.print(table)
-
-def handle_include(args: str) -> None:
-    """Handle include command."""
-    console = Console()
-    session = PromptSession()
-
-    if not args:
-        try:
-            args = session.prompt("Enter paths (space separated): ")
-        except (KeyboardInterrupt, EOFError):
-            return
-
-    paths = [p.strip() for p in args.split() if p.strip()]
-    if not paths:
-        console.print("[red]Error: At least one path required[/red]")
-        return
-
-    resolved_paths = []
-    for path_str in paths:
-        path = Path(path_str)
-        if not path.is_absolute():
-            path = config.workspace_dir / path
-        resolved_paths.append(path.resolve())
-
-    workset.include(resolved_paths)
-    workset.show()
-
-    console.print("[green]Updated include paths:[/green]")
-    for path in resolved_paths:
-        console.print(f"  {path}")
-
-def handle_rinclude(args: str) -> None:
-    """Handle recursive include command."""
-    console = Console()
-    session = PromptSession()
-    completer = get_path_completer(only_directories=True)
-
-    if not args:
-        try:
-            args = session.prompt("Enter directory paths (space separated): ", completer=completer)
-        except (KeyboardInterrupt, EOFError):
-            return
-
-    paths = [p.strip() for p in args.split() if p.strip()]
-    if not paths:
-        console.print("[red]Error: At least one path required[/red]")
-        return
-
-    resolved_paths = []
-    for path_str in paths:
-        path = Path(path_str)
-        if not path.is_absolute():
-            path = config.workspace_dir / path
-        resolved_paths.append(path.resolve())
-
-    workset.recursive(resolved_paths)
-    workset.include(resolved_paths)  # Add recursive paths to include paths
-    workset.refresh()
-    workset.show()
-
-    console.print("[green]Updated recursive include paths:[/green]")
-    for path in resolved_paths:
-        console.print(f"  {path}")
-
-def register_commands(registry: CommandRegistry) -> None:
-    """Register all available commands."""
-    # Register main commands
-    registry.register(Command("/clear", "Clear the terminal screen", None, handle_clear))
-    registry.register(Command("/request", "Submit a change request", "/request <change request text>", handle_request))
-    registry.register(Command("/ask", "Ask a question about the codebase", "/ask <question>", handle_ask))
-    registry.register(Command("/quit", "Exit the shell", None, handle_exit))
-    registry.register(Command("/help", "Show help for commands", "/help [command]", handle_help))
-    registry.register(Command("/include", "Set paths to include in analysis", "/include <path1> [path2 ...]", handle_include, get_path_completer()))
-    registry.register(Command("/rinclude", "Set paths to include recursively", "/rinclude <path1> [path2 ...]", handle_rinclude, get_path_completer(True)))
-
-    # Register aliases
-    registry.register_alias("clear", "/clear")
-    registry.register_alias("quit", "/quit")
-    registry.register_alias("help", "/help")
-    registry.register_alias("/inc", "/include")
-    registry.register_alias("/rinc", "/rinclude")

janito/shell/history.py

@@ -1,20 +0,0 @@
-"""Command history management for Janito shell."""
-from pathlib import Path
-from typing import List, Optional
-from prompt_toolkit.history import FileHistory
-
-class CommandHistory:
-    """Manages shell command history."""
-
-    def __init__(self, history_file: Optional[Path] = None):
-        if history_file is None:
-            history_file = Path.home() / ".janito_history"
-        self.history = FileHistory(str(history_file))
-
-    def add(self, command: str) -> None:
-        """Add a command to history."""
-        self.history.append_string(command)
-
-    def get_last(self, n: int = 10) -> List[str]:
-        """Get last n commands from history."""
-        return list(self.history.get_strings())[-n:]

janito/shell/processor.py

@@ -1,32 +0,0 @@
-"""Command processor for Janito shell."""
-from typing import Optional
-from rich.console import Console
-from .registry import CommandRegistry
-
-class CommandProcessor:
-    """Processes shell commands."""
-
-    def __init__(self, registry: CommandRegistry) -> None:
-        """Initialize command processor with registry."""
-        super().__init__()
-        self.console = Console()
-        self.registry = registry
-
-    def process_command(self, command_line: str) -> None:
-        """Process a command line input."""
-        command_line = command_line.strip()
-        if not command_line:
-            return
-
-        parts = command_line.split(maxsplit=1)
-        cmd = parts[0].lower()
-        args = parts[1] if len(parts) > 1 else ""
-
-        if command := self.registry.get_command(cmd):
-            command.handler(args)
-        else:
-            # Treat as request command
-            if request_cmd := self.registry.get_command("/request"):
-                request_cmd.handler(command_line)
-            else:
-                self.console.print("[red]Error: Request command not registered[/red]")