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

janito/search_replace/searcher.py

@@ -1,18 +1,47 @@
 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):
-    """Exact match including indentation."""
+    """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 
@@ -20,7 +49,19 @@ class ExactMatchStrategy(SearchStrategy):
 
 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()
@@ -29,7 +70,19 @@ class ExactContentStrategy(SearchStrategy):
 
 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])
@@ -39,6 +92,7 @@ class IndentAwareStrategy(SearchStrategy):
 
 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:
@@ -48,6 +102,17 @@ class ExactContentNoComments(SearchStrategy):
         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
 
@@ -93,6 +158,7 @@ class ExactContentNoComments(SearchStrategy):
 
 class ExactContentNoCommentsFirstLinePartial(SearchStrategy):
     """Match first line partially, ignoring comments."""
+
     def _strip_comments(self, line: str) -> str:
         """Remove comments from line."""
         if '#' in line:
@@ -102,6 +168,17 @@ class ExactContentNoCommentsFirstLinePartial(SearchStrategy):
         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
 
@@ -176,7 +253,14 @@ class Searcher:
         return '', 0
 
     def _build_indent_map(self, text: str) -> dict[int, int]:
-        """Build a map of line numbers to indentation levels."""
+        """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
@@ -219,7 +303,16 @@ class Searcher:
         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)."""
+        """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
 
@@ -231,69 +324,88 @@ class Searcher:
             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."""
+    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 True
-        return False
+                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], 
+    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)
+        """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)
-            
-        # Try each strategy in order of preference
+
+        # Track positions already matched to avoid redundant attempts
+        matched_positions = set()
+        all_matches = []
+
         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 i in matched_positions:
+                    continue
+
                 if strategy.match(source_lines, pattern_lines, i, self):
-                    matches.append(i)
+                    matched_positions.add(i)
+                    all_matches.append(i)
+                    if self.debug_mode:
+                        print(f"✓ Match found at line {i+1} using {strategy_name}")
 
-            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")
+            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
             
-        return matches
+        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

@@ -1,29 +1,28 @@
 """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 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."""
-    history_file = Path.home() / ".janito_history"
-    session = PromptSession(history=FileHistory(str(history_file)))
-    processor = CommandProcessor()
+    # 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)
 
-    # 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()
+    # Initialize and show workset content
+    workset = Workset()
+    workset.refresh()
+    workset.show()
 
     while True:
         try:

janito/shell/commands.py

@@ -1,52 +1,15 @@
 """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 prompt_toolkit.completion import PathCompleter
+from prompt_toolkit.document import Document
+from pathlib import Path
 from janito.config import config
-from janito.workspace import collect_files_content
+from janito.workspace import workset  # Updated import
 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
+from .registry import CommandRegistry, Command, get_path_completer
 
 def handle_request(args: str) -> None:
     """Handle a change request."""
@@ -75,23 +38,21 @@ def handle_ask(args: str) -> None:
 def handle_help(args: str) -> None:
     """Handle help command."""
     console = Console()
-    system = CommandSystem()
-
+    registry = CommandRegistry()
     command = args.strip() if args else None
-    if command and (cmd := system.get_command(command)):
+    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}")
-        return
+    else:
+        table = Table(title="Available Commands")
+        table.add_column("Command", style="cyan")
+        table.add_column("Description")
 
-    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)
 
-    for name, cmd in sorted(system.get_commands().items()):
-        table.add_row(name, cmd.description)
-
-    console.print(table)
+        console.print(table)
 
 def handle_include(args: str) -> None:
     """Handle include command."""
@@ -116,42 +77,24 @@ def handle_include(args: str) -> None:
             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)
+    workset.include(resolved_paths)
+    workset.show()
 
     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)
+    completer = get_path_completer(only_directories=True)
 
-    try:
-        if not args:
+    if not args:
+        try:
             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
+        except (KeyboardInterrupt, EOFError):
+            return
 
     paths = [p.strip() for p in args.split() if p.strip()]
     if not paths:
@@ -165,31 +108,29 @@ def handle_rinclude(args: str) -> None:
             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)
+    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() -> None:
+def register_commands(registry: CommandRegistry) -> 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))
+    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
-    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")
+    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/processor.py

@@ -1,15 +1,16 @@
 """Command processor for Janito shell."""
 from typing import Optional
 from rich.console import Console
-from .commands import CommandSystem, register_commands
+from .registry import CommandRegistry
 
 class CommandProcessor:
     """Processes shell commands."""
 
-    def __init__(self):
+    def __init__(self, registry: CommandRegistry) -> None:
+        """Initialize command processor with registry."""
+        super().__init__()
         self.console = Console()
-        self.workspace_content: Optional[str] = None
-        register_commands()
+        self.registry = registry
 
     def process_command(self, command_line: str) -> None:
         """Process a command line input."""
@@ -21,32 +22,11 @@ class CommandProcessor:
         cmd = parts[0].lower()
         args = parts[1] if len(parts) > 1 else ""
 
-        system = CommandSystem()
-        if command := system.get_command(cmd):
-            # Special handling for /rinc command to support interactive completion
-            if cmd in ["/rinc", "/rinclude"] and args:
-                from prompt_toolkit.completion import PathCompleter
-                from prompt_toolkit.document import Document
-
-                completer = PathCompleter(only_directories=True)
-                doc = Document(args)
-                completions = list(completer.get_completions(doc, None))
-
-                if completions:
-                    if len(completions) == 1:
-                        # Single completion - use it
-                        args = completions[0].text
-                    else:
-                        # Show available completions
-                        self.console.print("\nAvailable directories:")
-                        for comp in completions:
-                            self.console.print(f"  {comp.text}")
-                        return
-
+        if command := self.registry.get_command(cmd):
             command.handler(args)
         else:
             # Treat as request command
-            if request_cmd := system.get_command("/request"):
+            if request_cmd := self.registry.get_command("/request"):
                 request_cmd.handler(command_line)
             else:
                 self.console.print("[red]Error: Request command not registered[/red]")

janito/shell/prompt.py

@@ -0,0 +1,48 @@
+"""Prompt creation and configuration for Janito shell."""
+from typing import Dict, Any
+from pathlib import Path
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.completion import NestedCompleter
+from rich import print as rich_print
+from janito.config import config
+from .registry import CommandRegistry
+
+def create_shell_completer(registry: CommandRegistry):
+    """Create command completer for shell with nested completions."""
+    if config.debug:
+        rich_print("[yellow]Creating shell completer...[/yellow]")
+
+    commands = registry.get_commands()
+
+    if config.debug:
+        rich_print(f"[yellow]Found {len(commands)} commands for completion[/yellow]")
+
+    # Create nested completions for commands
+    completions: Dict[str, Any] = {}
+    
+    for cmd_name, cmd in commands.items():
+        if config.debug:
+            rich_print(f"[yellow]Setting up completion for command: {cmd_name}[/yellow]")
+        completions[cmd_name] = cmd.completer
+
+    if config.debug:
+        rich_print("[yellow]Creating nested completer from completions dictionary[/yellow]")
+    return NestedCompleter.from_nested_dict(completions)
+
+def create_shell_session(registry: CommandRegistry) -> PromptSession:
+    """Create and configure the shell prompt session."""
+    if config.debug:
+        rich_print("[yellow]Creating shell session...[/yellow]")
+
+    history_file = Path.home() / ".janito_history"
+    if config.debug:
+        rich_print(f"[yellow]Using history file: {history_file}[/yellow]")
+
+    completer = create_shell_completer(registry)
+
+    return PromptSession(
+        history=FileHistory(str(history_file)),
+        completer=completer,
+        complete_while_typing=True
+    )