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

janito/shell/commands.py

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

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

@@ -0,0 +1,32 @@
+"""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]")

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
+    )

janito/shell/registry.py

@@ -0,0 +1,60 @@
+"""Command registry and validation system for Janito shell."""
+from dataclasses import dataclass
+from typing import Optional, Callable, Dict, Any
+from pathlib import Path
+from prompt_toolkit.completion import PathCompleter
+
+@dataclass
+class Command:
+    """Command definition with handler and metadata."""
+    name: str
+    description: str
+    usage: Optional[str]
+    handler: Callable[[str], None]
+    completer: Optional[Any] = None
+
+class CommandRegistry:
+    """Centralized command registry with validation."""
+    def __init__(self):
+        """Initialize registry."""
+        if not hasattr(self, '_commands'):
+            self._commands = {}
+
+
+    def register(self, command: Command) -> None:
+        """Register a command with validation."""
+        if command.name in self._commands:
+            raise ValueError(f"Command '{command.name}' already registered")
+        if not callable(command.handler):
+            raise ValueError(f"Handler for command '{command.name}' must be callable")
+        self._commands[command.name] = command
+
+    def register_alias(self, alias: str, command_name: str) -> None:
+        """Register an alias for an existing command."""
+        if alias in self._commands:
+            raise ValueError(f"Alias '{alias}' already registered")
+        if command := self.get_command(command_name):
+            self._commands[alias] = command
+        else:
+            raise ValueError(f"Command '{command_name}' not found")
+
+    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 validate_command(self, command: Command) -> None:
+        """Validate command properties."""
+        if not command.name:
+            raise ValueError("Command name cannot be empty")
+        if not command.description:
+            raise ValueError(f"Command '{command.name}' must have a description")
+        if not callable(command.handler):
+            raise ValueError(f"Command '{command.name}' handler must be callable")
+
+def get_path_completer(only_directories: bool = False) -> PathCompleter:
+    """Get a configured path completer."""
+    return PathCompleter(only_directories=only_directories)

janito/tui/__init__.py

@@ -0,0 +1,21 @@
+"""Terminal User Interface package for Janito."""
+from .base import BaseTuiApp
+from typing import Dict, Optional
+from janito.change.analysis.options import AnalysisOption
+
+class TuiApp(BaseTuiApp):
+    """Main TUI application with flow-based navigation"""
+
+    def on_mount(self) -> None:
+        """Initialize appropriate flow based on input"""
+        if self.options:
+            from .flows.selection import SelectionFlow
+            self.push_screen(SelectionFlow(self.options))
+        elif self.changes:
+            from .flows.changes import ChangesFlow
+            self.push_screen(ChangesFlow(self.changes))
+        elif self.content:
+            from .flows.content import ContentFlow
+            self.push_screen(ContentFlow(self.content))
+
+__all__ = ['TuiApp']

janito/tui/base.py

@@ -0,0 +1,22 @@
+from textual.app import App
+from typing import List, Optional, Dict
+from janito.change.parser import FileChange
+from janito.change.analysis.options import AnalysisOption
+
+class BaseTuiApp(App):
+    """Base class for TUI applications with common functionality"""
+    CSS = """
+    Screen {
+        align: center middle;
+    }
+    """
+
+    def __init__(self,
+                 content: Optional[str] = None,
+                 options: Optional[Dict[str, AnalysisOption]] = None,
+                 changes: Optional[List[FileChange]] = None):
+        super().__init__()
+        self.content = content
+        self.options = options
+        self.changes = changes
+        self.selected_option = None

janito/tui/flows/__init__.py

@@ -0,0 +1,5 @@
+from .selection import SelectionFlow
+from .content import ContentFlow
+from .changes import ChangesFlow
+
+__all__ = ['SelectionFlow', 'ContentFlow', 'ChangesFlow']

janito/tui/flows/changes.py

@@ -0,0 +1,65 @@
+from textual.app import ComposeResult
+from textual.containers import ScrollableContainer
+from textual.screen import Screen
+from textual.binding import Binding
+from textual.widgets import Header, Footer, Static
+from typing import List
+from ...change.viewer.styling import format_content, create_legend_items
+from ...change.viewer.panels import create_change_panel, create_new_file_panel, create_replace_panel, create_remove_file_panel
+from ...change.parser import FileChange
+
+class ChangesFlow(Screen):
+    """Screen for changes preview flow"""
+    CSS = """
+    ScrollableContainer {
+        width: 100%;
+        height: 100%;
+        border: solid green;
+        background: $surface;
+        color: $text;
+        padding: 1;
+    }
+
+    Container.panel {
+        margin: 1;
+        padding: 1;
+        border: solid $primary;
+        width: 100%;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("escape", "quit", "Quit"),
+        Binding("up", "previous", "Previous"),
+        Binding("down", "next", "Next"),
+    ]
+
+    def __init__(self, changes: List[FileChange]):
+        super().__init__()
+        self.changes = changes
+        self.current_index = 0
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with ScrollableContainer():
+            for change in self.changes:
+                if change.operation == 'create_file':
+                    yield Static(create_new_file_panel(change.name, change.content))
+                elif change.operation == 'replace_file':
+                    yield Static(create_replace_panel(change.name, change))
+                elif change.operation == 'remove_file':
+                    yield Static(create_remove_file_panel(change.name))
+                elif change.operation == 'modify_file':
+                    for mod in change.text_changes:
+                        yield Static(create_change_panel(mod.search_content, mod.replace_content, change.description, 1))
+        yield Footer()
+
+    def action_quit(self):
+        self.app.exit()
+
+    def action_previous(self):
+        self.scroll_up()
+
+    def action_next(self):
+        self.scroll_down()

janito/tui/flows/content.py

@@ -0,0 +1,128 @@
+from textual.app import ComposeResult
+from textual.containers import ScrollableContainer
+from textual.screen import Screen
+from textual.binding import Binding
+from textual.widgets import Header, Footer, Static
+from rich.panel import Panel
+from rich.text import Text
+from rich import box
+from pathlib import Path
+from typing import Dict, List
+
+class ContentFlow(Screen):
+    """Screen for content viewing flow with unified display format"""
+    CSS = """
+    ScrollableContainer {
+        width: 100%;
+        height: 100%;
+        border: solid green;
+        background: $surface;
+        color: $text;
+        padding: 1;
+    }
+
+    Container.panel {
+        margin: 1;
+        padding: 1;
+        border: solid $primary;
+        width: 100%;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("escape", "quit", "Quit"),
+        Binding("up", "previous", "Previous"),
+        Binding("down", "next", "Next"),
+    ]
+
+    def __init__(self, content: str):
+        super().__init__()
+        self.content = content
+        self.files_by_type = self._organize_content()
+
+    def _organize_content(self) -> Dict[str, List[str]]:
+        """Organize content into file groups"""
+        files = {
+            'Modified': [],
+            'New': [],
+            'Deleted': []
+        }
+
+        # Parse content to extract file information
+        for line in self.content.split('\n'):
+            if line.strip().startswith('- '):
+                file_path = line[2:].strip()
+                if '(new)' in file_path:
+                    files['New'].append(file_path)
+                elif '(removed)' in file_path:
+                    files['Deleted'].append(file_path)
+                else:
+                    files['Modified'].append(file_path)
+
+        return files
+
+    def _format_files_group(self, group_name: str, files: List[str], style: str) -> Text:
+        """Format a group of files with consistent styling"""
+        content = Text()
+        if files:
+            content.append(Text(f"\n─── {group_name} ───\n", style="cyan"))
+
+            # Group files by directory
+            files_by_dir = {}
+            for file_path in files:
+                clean_path = file_path.split(' (')[0]
+                path = Path(clean_path)
+                dir_path = str(path.parent)
+                if dir_path not in files_by_dir:
+                    files_by_dir[dir_path] = []
+                files_by_dir[dir_path].append(path)
+
+            # Display files by directory
+            for dir_path, paths in sorted(files_by_dir.items()):
+                first_in_dir = True
+                for path in sorted(paths):
+                    if first_in_dir:
+                        display_path = dir_path
+                    else:
+                        pad_left = (len(dir_path) - 3) // 2
+                        pad_right = len(dir_path) - 3 - pad_left
+                        display_path = " " * pad_left + "..." + " " * pad_right
+
+                    content.append(Text(f"• {display_path}/{path.name}\n", style=style))
+                    first_in_dir = False
+
+        return content
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with ScrollableContainer():
+            # Format content with consistent styling
+            content = Text()
+
+            # Add each file group with appropriate styling
+            content.append(self._format_files_group("Modified", self.files_by_type['Modified'], "yellow"))
+            content.append(self._format_files_group("New", self.files_by_type['New'], "green"))
+            content.append(self._format_files_group("Deleted", self.files_by_type['Deleted'], "red"))
+
+            # Create panel with formatted content
+            panel = Panel(
+                content,
+                box=box.ROUNDED,
+                border_style="cyan",
+                title="Content Changes",
+                title_align="center",
+                padding=(1, 2)
+            )
+
+            yield Static(panel)
+        yield Footer()
+
+    def action_quit(self):
+        self.app.exit()
+
+    def action_previous(self):
+        self.scroll_up()
+
+    def action_next(self):
+        self.scroll_down()

janito/tui/flows/selection.py

@@ -0,0 +1,117 @@
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.screen import Screen
+from textual.binding import Binding
+from textual.widgets import Header, Footer, Static
+from typing import Dict, Optional
+from rich.panel import Panel
+from rich import box
+from janito.change.analysis.options import AnalysisOption
+from janito.agents import agent
+from janito.common import progress_send_message
+from janito.change.parser import parse_response
+from .changes import ChangesFlow
+
+class SelectionFlow(Screen):
+    """Selection screen with direct navigation to changes preview"""
+
+    CSS = """
+    #options-container {
+        layout: horizontal;
+        height: 100%;
+        margin: 1;
+        align: center middle;
+    }
+
+    .option-panel {
+        width: 1fr;
+        height: 100%;
+        border: solid $primary;
+        margin: 0 1;
+        padding: 1;
+    }
+
+    .option-panel.selected {
+        border: double $secondary;
+        background: $boost;
+    }
+    """
+
+    BINDINGS = [
+        Binding("left", "previous", "Previous"),
+        Binding("right", "next", "Next"),
+        Binding("enter", "select", "Select"),
+        Binding("escape", "quit", "Quit"),
+    ]
+
+    def __init__(self, options: Dict[str, AnalysisOption]):
+        super().__init__()
+        self.options = options
+        self.current_index = 0
+        self.panels = []
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Container(id="options-container"):
+            for letter, option in self.options.items():
+                panel = Static(self._format_option(letter, option), classes="option-panel")
+                self.panels.append(panel)
+                yield panel
+        yield Footer()
+        # Set initial selection
+        if self.panels:
+            self.panels[0].add_class("selected")
+
+    def _format_option(self, letter: str, option: AnalysisOption) -> str:
+        """Format option content"""
+        content = [f"Option {letter}: {option.summary}\n"]
+        content.append("\nDescription:")
+        for item in option.description_items:
+            content.append(f"• {item}")
+        content.append("\nAffected files:")
+        for file in option.affected_files:
+            content.append(f"• {file}")
+        return "\n".join(content)
+
+    def action_previous(self) -> None:
+        """Handle left arrow key"""
+        if self.panels:
+            self.panels[self.current_index].remove_class("selected")
+            self.current_index = (self.current_index - 1) % len(self.panels)
+            self.panels[self.current_index].add_class("selected")
+
+    def action_next(self) -> None:
+        """Handle right arrow key"""
+        if self.panels:
+            self.panels[self.current_index].remove_class("selected")
+            self.current_index = (self.current_index + 1) % len(self.panels)
+            self.panels[self.current_index].add_class("selected")
+
+    def action_select(self) -> None:
+        """Handle enter key - request changes and show preview"""
+        if self.panels:
+            letter = list(self.options.keys())[self.current_index]
+            option = self.options[letter]
+
+            # Build and send change request
+            from janito.change import build_change_request_prompt
+            from janito.workspace import collect_files_content
+
+            files_content = collect_files_content([option.get_clean_path(f) for f in option.affected_files])
+            prompt = build_change_request_prompt(option.format_option_text(), "", files_content)
+            response = progress_send_message(prompt)
+
+            if response:
+                changes = parse_response(response)
+                if changes:
+                    # Show changes preview
+                    self.app.push_screen(ChangesFlow(changes))
+                    return
+
+            self.app.selected_option = option
+            self.app.exit()
+
+    def action_quit(self) -> None:
+        """Handle escape key"""
+        self.app.selected_option = None
+        self.app.exit()

janito/tui/screens/__init__.py

@@ -0,0 +1,3 @@
+from .selection import SelectionScreen
+
+__all__ = ['SelectionScreen']

janito/tui/screens/app.py

@@ -0,0 +1 @@
+# This file is intentionally left empty as functionality is moved to base.py and __init__.py

janito/workspace/__init__.py

@@ -0,0 +1,6 @@
+from .workset import Workset
+
+# Create and export singleton instance
+workset = Workset()
+
+__all__ = ['workset']