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

janito/shell/prompt.py

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

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

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

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

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

janito/tui/flows/changes.py

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

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

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

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

janito/tui/screens/app.py

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

janito/version.py

@@ -1,23 +0,0 @@
-"""Version management module for Janito."""
-from pathlib import Path
-from typing import Optional
-import tomli
-from importlib.metadata import version as pkg_version
-
-def get_version() -> str:
-    """
-    Get Janito version from package metadata or pyproject.toml.
-    
-    Returns:
-        str: The version string
-    """
-    try:
-        return pkg_version("janito")
-    except Exception:
-        # Fallback to pyproject.toml
-        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
-        if pyproject_path.exists():
-            with open(pyproject_path, "rb") as f:
-                pyproject_data = tomli.load(f)
-                return pyproject_data.get("project", {}).get("version", "unknown")
-        return "unknown"

janito/workspace/__init__.py

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

janito/workspace/analysis.py

@@ -1,121 +0,0 @@
-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 workset analysis in panel
-    console.print("\n")
-    console.print(Panel(
-        content,
-        title="[bold blue]Workset 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}"