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

janito/search_replace/play.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from typing import Optional
+from .parser import parse_test_file
+from .core import SearchReplacer
+import re
+
+def _extract_file_ext(test_info: str) -> Optional[str]:
+    """Extract file extension from test description."""
+    # Try to find filename or extension in the test info
+    ext_match = re.search(r'\.([a-zA-Z0-9]+)\b', test_info)
+    if (ext_match):
+        return f".{ext_match.group(1).lower()}"
+    
+    # Look for language mentions
+    lang_map = {
+        'python': '.py',
+        'javascript': '.js',
+        'typescript': '.ts',
+        'java': '.java'
+    }
+    
+    for lang, ext in lang_map.items():
+        if lang.lower() in test_info.lower():
+            return ext
+            
+    return None
+
+def play_file(filepath: Path):
+    """Play back a test file and show detailed debugging info."""
+    test_cases = parse_test_file(filepath)
+    
+    for test in test_cases:
+        print(f"\nTest: {test['name']}")
+        print("=" * 50)
+        
+        if 'source' not in test or 'search' not in test:
+            print("Invalid test case - missing source or search pattern")
+            continue
+            
+        file_ext = _extract_file_ext(test['name'])
+        print(f"\nFile type: {file_ext or 'unknown'}")
+        
+        replacer = SearchReplacer(
+            source_code=test['source'],
+            search_pattern=test['search'],
+            replacement=test.get('replacement'),
+            file_ext=file_ext,
+            debug=True
+        )
+        
+        try:
+            print("\nAttempting search/replace...")
+            result = replacer.replace()
+            print("\nResult:")
+            print("-" * 50)
+            print(result)
+            
+        except Exception as e:
+            print(f"\nError: {str(e)}")
+        
+        print("\n" + "="*50)

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,411 @@
+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

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

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

@@ -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}")