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

janito/search_replace/replacer.py

@@ -0,0 +1,36 @@
+from typing import List
+from .searcher import Searcher
+
+class Replacer:
+    """Handles replacement operations with proper indentation."""
+
+    def __init__(self, debug: bool = False):
+        """Initialize replacer with debug mode."""
+        self.searcher = Searcher(debug=debug)
+        self.debug_mode = debug
+
+    def create_indented_replacement(self, match_indent: str, search_pattern: str, replacement: str) -> List[str]:
+        """Create properly indented replacement lines."""
+        search_first, search_start_idx = self.searcher.get_first_non_empty_line(search_pattern)
+        replace_first, replace_start_idx = self.searcher.get_first_non_empty_line(replacement)
+
+        search_indent = self.searcher.get_indentation(search_first)
+        replace_indent = self.searcher.get_indentation(replace_first)
+
+        replace_lines = replacement.splitlines()
+        indented_replacement = []
+
+        # Calculate indentation shifts
+        context_shift = len(match_indent) - len(search_indent)
+        pattern_shift = len(replace_indent) - len(search_indent)
+
+        for i, line in enumerate(replace_lines):
+            if i < replace_start_idx or not line.strip():
+                indented_replacement.append('')
+            else:
+                line_indent = self.searcher.get_indentation(line)
+                rel_indent = len(line_indent) - len(replace_indent)
+                final_indent = ' ' * (len(match_indent) + rel_indent)
+                indented_replacement.append(final_indent + line.lstrip())
+
+        return indented_replacement

janito/search_replace/searcher.py

@@ -0,0 +1,299 @@
+from typing import List, Optional, Dict, Type
+from abc import ABC, abstractmethod
+import re
+
+LINE_OVER_LINE_DEBUG = False
+
+class SearchStrategy(ABC):
+    """Base class for search strategies."""
+    @abstractmethod
+    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
+        pass
+
+class ExactMatchStrategy(SearchStrategy):
+    """Exact match including indentation."""
+    def match(self, source_lines: List[str], pattern_lines: List[str], pos: int, searcher: 'Searcher') -> bool:
+        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:
+        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:
+        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:
+        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:
+        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 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 based on line number (earliest match)."""
+        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]) -> bool:
+        """Try matching using multiple strategies in order."""
+        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 True
+        return False
+
+    def _find_matches(self, source_lines: List[str], pattern_lines: List[str], 
+                     file_ext: Optional[str] = None) -> List[int]:
+        """Find all matches using configured strategies."""
+        strategies = self.get_strategies(file_ext)
+        
+        if self.debug_mode:
+            print("\nTrying search strategies:")
+            print("-" * 50)
+            
+        # Try each strategy in order of preference
+        for strategy in strategies:
+            matches = []
+            strategy_name = strategy.__class__.__name__.replace('Strategy', '')
+            
+            if self.debug_mode:
+                print(f"\n→ {strategy_name}...")
+                
+            for i in range(len(source_lines)):
+                if strategy.match(source_lines, pattern_lines, i, self):
+                    matches.append(i)
+
+            if matches:
+                if self.debug_mode:
+                    # Show 1-based line numbers consistently
+                    print(f"✓ {strategy_name}: Found {len(matches)} match(es) at line(s) {[m+1 for m in matches]}")
+                return matches
+            elif self.debug_mode:
+                print(f"✗ {strategy_name}: No matches found")
+                
+        return []
+
+    def exact_match(self, source: str, pattern: str) -> List[int]:
+        """Perform exact line-by-line matching, preserving all whitespace except newlines."""
+        source_lines = source.splitlines()
+        pattern_lines = pattern.splitlines()
+        pattern_len = len(pattern_lines)
+        matches = []
+
+        for i in range(len(source_lines) - pattern_len + 1):
+            is_match = True
+            for j in range(pattern_len):
+                if source_lines[i + j] != pattern_lines[j]:
+                    is_match = False
+                    break
+
+            if is_match:
+                matches.append(i)
+
+        if self.debug_mode and matches:
+            print(f"[DEBUG] Found {len(matches)} exact matches")
+            
+        return matches

janito/shell/__init__.py

@@ -0,0 +1,39 @@
+"""Shell package initialization for Janito."""
+from typing import Optional
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from pathlib import Path
+from rich.console import Console
+from janito.config import config
+from janito.workspace import workspace
+from .processor import CommandProcessor
+
+def start_shell() -> None:
+    """Start the Janito interactive shell."""
+    history_file = Path.home() / ".janito_history"
+    session = PromptSession(history=FileHistory(str(history_file)))
+    processor = CommandProcessor()
+
+    # Perform workspace analysis
+    console = Console()
+
+    # Use configured paths or default to workspace_dir
+    scan_paths = config.include if config.include else [config.workspace_dir]
+    workspace.collect_content(scan_paths)
+    workspace.analyze()
+
+    # Store workspace content in processor for session
+    processor.workspace_content = workspace.get_content()
+
+    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

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

@@ -0,0 +1,195 @@
+"""Command system for Janito shell."""
+from dataclasses import dataclass
+from typing import Optional, Callable, Dict
+from pathlib import Path
+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 janito.config import config
+from janito.workspace import collect_files_content
+from janito.workspace.analysis import analyze_workspace_content
+
+@dataclass
+class Command:
+    """Command definition with handler."""
+    name: str
+    description: str
+    usage: Optional[str]
+    handler: Callable[[str], None]
+
+class CommandSystem:
+    """Centralized command management system."""
+    _instance = None
+    _commands: Dict[str, Command] = {}
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._commands = {}
+        return cls._instance
+
+    def register(self, command: Command) -> None:
+        """Register a command."""
+        self._commands[command.name] = command
+
+    def get_command(self, name: str) -> Optional[Command]:
+        """Get a command by name."""
+        return self._commands.get(name)
+
+    def get_commands(self) -> Dict[str, Command]:
+        """Get all registered commands."""
+        return self._commands.copy()
+
+    def register_alias(self, alias: str, command_name: str) -> None:
+        """Register an alias for a command."""
+        if command := self.get_command(command_name):
+            if alias in self._commands:
+                raise ValueError(f"Alias '{alias}' already registered")
+            self._commands[alias] = command
+
+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()
+    system = CommandSystem()
+
+    command = args.strip() if args else None
+    if command and (cmd := system.get_command(command)):
+        console.print(f"\n[bold]{command}[/bold]: {cmd.description}")
+        if cmd.usage:
+            console.print(f"Usage: {cmd.usage}")
+        return
+
+    table = Table(title="Available Commands")
+    table.add_column("Command", style="cyan")
+    table.add_column("Description")
+
+    for name, cmd in sorted(system.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())
+
+    config.set_include(resolved_paths)
+    content = collect_files_content(resolved_paths)
+    analyze_workspace_content(content)
+
+    console.print("[green]Updated include paths:[/green]")
+    for path in resolved_paths:
+        console.print(f"  {path}")
+
+from prompt_toolkit.completion import PathCompleter
+from prompt_toolkit.document import Document
+
+def handle_rinclude(args: str) -> None:
+    """Handle recursive include command."""
+    console = Console()
+    session = PromptSession()
+    completer = PathCompleter(only_directories=True)
+
+    try:
+        if not args:
+            args = session.prompt("Enter directory paths (space separated): ", completer=completer)
+        else:
+            # For partial paths, show completion options
+            doc = Document(args)
+            completions = list(completer.get_completions(doc, None))
+            if completions:
+                # If single completion, use it directly
+                if len(completions) == 1:
+                    args = completions[0].text
+                else:
+                    # Show available completions
+                    console.print("\nAvailable directories:")
+                    for comp in completions:
+                        console.print(f"  {comp.text}")
+                    return
+    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())
+
+    config.set_recursive(resolved_paths)
+    config.set_include(resolved_paths)
+    content = collect_files_content(resolved_paths)
+    analyze_workspace_content(content)
+
+    console.print("[green]Updated recursive include paths:[/green]")
+    for path in resolved_paths:
+        console.print(f"  {path}")
+
+def register_commands() -> None:
+    """Register all available commands."""
+    system = CommandSystem()
+
+    # Register main commands
+    system.register(Command("/clear", "Clear the terminal screen", None, handle_clear))
+    system.register(Command("/request", "Submit a change request", "/request <change request text>", handle_request))
+    system.register(Command("/ask", "Ask a question about the codebase", "/ask <question>", handle_ask))
+    system.register(Command("/quit", "Exit the shell", None, handle_exit))
+    system.register(Command("/help", "Show help for commands", "/help [command]", handle_help))
+    system.register(Command("/include", "Set paths to include in analysis", "/include <path1> [path2 ...]", handle_include))
+    system.register(Command("/rinclude", "Set paths to include recursively", "/rinclude <path1> [path2 ...]", handle_rinclude))
+
+    # Register aliases
+    system.register_alias("clear", "/clear")
+    system.register_alias("quit", "/quit")
+    system.register_alias("help", "/help")
+    system.register_alias("/inc", "/include")
+    system.register_alias("/rinc", "/rinclude")