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

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']

janito/workspace/analysis.py

@@ -0,0 +1,121 @@
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List
+
+from rich.columns import Columns
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.rule import Rule
+from janito.config import config
+
+def analyze_workspace_content(content: str) -> None:
+    """Show statistics about the scanned content"""
+    if not content:
+        return
+
+    # Collect include paths
+    paths = []
+    if config.include:
+        for path in config.include:
+            is_recursive = path in config.recursive
+            path_str = str(path.relative_to(config.workspace_dir))
+            paths.append(f"{path_str}/*" if is_recursive else f"{path_str}/")
+    else:
+        # Use workspace_dir as fallback when no include paths specified
+        paths.append("./")
+
+    console = Console()
+
+    dir_counts: Dict[str, int] = defaultdict(int)
+    dir_sizes: Dict[str, int] = defaultdict(int)
+    file_types: Dict[str, int] = defaultdict(int)
+    current_path = None
+    current_content = []
+
+    for line in content.split('\n'):
+        if line.startswith('<path>'):
+            path = Path(line.replace('<path>', '').replace('</path>', '').strip())
+            current_path = str(path.parent)
+            dir_counts[current_path] += 1
+            file_types[path.suffix.lower() or 'no_ext'] += 1
+        elif line.startswith('<content>'):
+            current_content = []
+        elif line.startswith('</content>'):
+            content_size = sum(len(line.encode('utf-8')) for line in current_content)
+            if current_path:
+                dir_sizes[current_path] += content_size
+            current_content = []
+        elif current_content is not None:
+            current_content.append(line)
+
+    console = Console()
+
+    # Directory statistics
+    dir_stats = [
+        f"📁 {directory}/ [{count} file(s), {_format_size(size)}]"
+        for directory, (count, size) in (
+            (d, (dir_counts[d], dir_sizes[d]))
+            for d in sorted(dir_counts.keys())
+        )
+    ]
+
+    # File type statistics
+    type_stats = [
+        f"📄 .{ext.lstrip('.')} [{count} file(s)]" if ext != 'no_ext' else f"📄 {ext} [{count} file(s)]"
+        for ext, count in sorted(file_types.items())
+    ]
+
+    # Create grouped content with styled separators
+    content_sections = []
+
+    if paths:
+        # Group paths with their stats
+        path_stats = []
+        for path in sorted(set(paths)):
+            base_path = Path(path.rstrip("/*"))
+            total_files = sum(1 for d, count in dir_counts.items()
+                             if Path(d).is_relative_to(base_path))
+            total_size = sum(size for d, size in dir_sizes.items()
+                            if Path(d).is_relative_to(base_path))
+            path_stats.append(f"{path} [{total_files} file(s), {_format_size(total_size)}]")
+
+        content_sections.extend([
+            "[bold yellow]📌 Included Paths[/bold yellow]",
+            Rule(style="yellow"),
+            Columns(path_stats, equal=True, expand=True),
+            "\n"
+        ])
+
+    # Add directory structure section only in verbose mode
+    if config.verbose:
+        content_sections.extend([
+            "[bold magenta]📂 Directory Structure[/bold magenta]",
+            Rule(style="magenta"),
+            Columns(dir_stats, equal=True, expand=True),
+            "\n"
+        ])
+
+    # Always show file types section
+    content_sections.extend([
+        "[bold cyan]📑 File Types[/bold cyan]",
+        Rule(style="cyan"),
+        Columns(type_stats, equal=True, expand=True)
+    ])
+
+    content = Group(*content_sections)
+
+    # Display workspace analysis in panel
+    console.print("\n")
+    console.print(Panel(
+        content,
+        title="[bold blue]Workspace Analysis[/bold blue]",
+        title_align="center"
+    ))
+
+def _format_size(size_bytes: int) -> str:
+    """Format size in bytes to human readable format"""
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size_bytes < 1024.0:
+            break
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} {unit}"

janito/workspace/manager.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+from collections import defaultdict
+
+class WorkspaceManager:
+    """Manages workspace state and operations using singleton pattern."""
+    _instance = None
+
+    def __init__(self):
+        if WorkspaceManager._instance is not None:
+            raise RuntimeError("Use WorkspaceManager.get_instance() instead")
+        self.content: str = ""
+        self.scan_completed: bool = False
+        self._analyzed: bool = False
+
+    @classmethod
+    def get_instance(cls) -> "WorkspaceManager":
+        """Get singleton instance of WorkspaceManager."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def collect_content(self, paths: List[Path]) -> None:
+        """Collect and store content from specified paths."""
+        from .scan import _scan_paths
+        content_parts, _, _, _ = _scan_paths(paths)
+        self.content = "\n".join(content_parts)
+        self.scan_completed = True
+        self._analyzed = False
+
+    def analyze(self) -> None:
+        """Analyze workspace content and update statistics."""
+        from .analysis import analyze_workspace_content
+        if not self.scan_completed:
+            return
+        if not self._analyzed and self.content:
+            analyze_workspace_content(self.content)
+            self._analyzed = True
+
+    def get_content(self) -> str:
+        """Get collected workspace content."""
+        return self.content
+
+    def clear(self) -> None:
+        """Clear workspace content and stats."""
+        self.content = ""
+        self.scan_completed = False
+        self._analyzed = False