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

janito/shell/handlers.py

@@ -0,0 +1,122 @@
+"""Command handlers for Janito shell."""
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import PathCompleter
+from prompt_toolkit.shortcuts import clear as ptk_clear
+from janito.config import config
+from janito.scan import collect_files_content
+from janito.scan.analysis import analyze_workspace_content
+from .registry import CommandRegistry, 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 to clear terminal screen."""
+    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}")
+        return
+
+    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 with path completion."""
+    console = Console()
+    session = PromptSession()
+    completer = PathCompleter()
+
+    # If no args provided, prompt with completion
+    if not args:
+        try:
+            args = session.prompt("Enter 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.workdir / path
+        resolved_paths.append(path.resolve())
+
+    config.set_include(resolved_paths)
+    content = collect_files_content(resolved_paths)
+    analyze_workspace_content(content)
+
+    console.print(f"[green]Updated include paths:[/green]")
+    for path in resolved_paths:
+        console.print(f"  {path}")
+
+def handle_rinclude(args: str) -> None:
+    """Handle rinclude command with recursive path scanning."""
+    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.workdir / 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(f"[green]Updated recursive include paths:[/green]")
+    for path in resolved_paths:
+        console.print(f"  {path}")

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,52 @@
+"""Command processor for Janito shell."""
+from typing import Optional
+from rich.console import Console
+from .commands import CommandSystem, register_commands
+
+class CommandProcessor:
+    """Processes shell commands."""
+
+    def __init__(self):
+        self.console = Console()
+        self.workspace_content: Optional[str] = None
+        register_commands()
+
+    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 ""
+
+        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
+
+            command.handler(args)
+        else:
+            # Treat as request command
+            if request_cmd := system.get_command("/request"):
+                request_cmd.handler(command_line)
+            else:
+                self.console.print("[red]Error: Request command not registered[/red]")

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,7 @@
+from .manager import WorkspaceManager
+from .scan import preview_scan, collect_files_content, is_dir_empty
+
+# Create singleton instance
+workspace = WorkspaceManager.get_instance()
+
+__all__ = ['workspace', 'preview_scan', 'collect_files_content', 'is_dir_empty']