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

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/workspace/__init__.py

@@ -1,7 +1,6 @@
-from .manager import WorkspaceManager
-from .scan import preview_scan, collect_files_content, is_dir_empty
+from .workset import Workset
 
-# Create singleton instance
-workspace = WorkspaceManager.get_instance()
+# Create and export singleton instance
+workset = Workset()
 
-__all__ = ['workspace', 'preview_scan', 'collect_files_content', 'is_dir_empty']
+__all__ = ['workset']

janito/workspace/analysis.py

@@ -104,11 +104,11 @@ def analyze_workspace_content(content: str) -> None:
 
     content = Group(*content_sections)
 
-    # Display workspace analysis in panel
+    # Display workset analysis in panel
     console.print("\n")
     console.print(Panel(
         content,
-        title="[bold blue]Workspace Analysis[/bold blue]",
+        title="[bold blue]Workset Analysis[/bold blue]",
         title_align="center"
     ))
 

janito/workspace/show.py

@@ -0,0 +1,141 @@
+from rich.traceback import install
+install(show_locals=False)
+
+from pathlib import Path
+from typing import List, Set
+from rich.columns import Columns
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.text import Text
+from janito.config import config
+from .types import FileInfo, ScanPath
+from .stats import collect_file_stats, _format_size 
+
+
+def show_workset_analysis(
+    files: List[FileInfo],
+    scan_paths: List[ScanPath],
+    cache_blocks: List[List[FileInfo]] = None
+) -> None:
+    """Display analysis of workspace content and configuration."""
+
+    console = Console()
+    content_sections = []
+
+    # Get statistics
+    dir_counts, file_types = collect_file_stats(files)
+
+    # Calculate path stats using relative paths
+    paths_stats = []
+    total_files = 0
+    total_size = 0
+
+  
+    # Process all paths uniformly
+    for scan_path in sorted(scan_paths, key=lambda p: p.path):
+
+        path = scan_path.path
+        is_recursive = scan_path.is_recursive
+        path_str = str(path)
+
+        # Calculate stats based on scan type
+        if is_recursive:
+            path_files = sum(count for d, [count, _] in dir_counts.items()
+                           if Path(d) == path or Path(d).is_relative_to(path))
+            path_size = sum(size for d, [_, size] in dir_counts.items()
+                          if Path(d) == path or Path(d).is_relative_to(path))
+        else:
+            path_files = dir_counts.get(path_str, [0, 0])[0]
+            path_size = dir_counts.get(path_str, [0, 0])[1]
+
+        total_files += path_files
+        total_size += path_size
+
+        paths_stats.append(
+            f"[bold cyan]{path}[/bold cyan]"
+            f"[yellow]{'/**' if is_recursive else '/'}[/yellow] "
+            f"[[green]{path_files}[/green] "
+            f"{'total ' if is_recursive else ''}file(s), "
+            f"[blue]{_format_size(path_size)}[/blue]]"
+        )
+
+    # Build sections - Show paths first
+    if paths_stats or current_dir_stats:
+        content_sections.extend([
+            "[bold yellow]📌 Included Paths[/bold yellow]",
+            Rule(style="yellow"),
+        ])
+
+        # All paths are now handled in the main loop
+
+        content_sections.append(
+            Text(" | ").join(Text.from_markup(path) for path in paths_stats)
+        )
+
+        # Add total summary if there are multiple paths
+        if len(paths_stats) > 1:
+            content_sections.extend([
+                "",  # Empty line for spacing
+                f"[bold yellow]Total:[/bold yellow] [green]{total_files}[/green] files, "
+                f"[blue]{_format_size(total_size)}[/blue]"
+            ])
+        content_sections.append("\n")
+
+    # Then show directory structure if verbose
+    if config.verbose:
+        dir_stats = [
+            f"📁 {directory}/ [{count} file(s), {_format_size(size)}]"
+            for directory, (count, size) in sorted(dir_counts.items())
+        ]
+        content_sections.extend([
+            "[bold magenta]📂 Directory Structure[/bold magenta]",
+            Rule(style="magenta"),
+            Columns(dir_stats, equal=True, expand=True),
+            "\n"
+        ])
+
+    type_stats = [
+        f"[bold cyan].{ext.lstrip('.')}[/bold cyan] [[green]{count}[/green] file(s)]" 
+        if ext != 'no_ext' 
+        else f"[bold cyan]no ext[/bold cyan] [[green]{count}[/green] file(s)]"
+        for ext, count in sorted(file_types.items())
+    ]
+    content_sections.extend([
+        "[bold cyan]📑 File Types[/bold cyan]",
+        Rule(style="cyan"),
+        Text(" | ").join(Text.from_markup(stat) for stat in type_stats)
+    ])
+
+    # Finally show cache blocks if in debug mode
+    if config.debug and cache_blocks:
+        blocks = cache_blocks
+        if any(blocks):
+            content_sections.extend([
+                "\n",
+                "[bold blue]🕒 Cache Blocks[/bold blue]",
+                Rule(style="blue"),
+            ])
+            
+            block_names = ["Last 5 minutes", "Last hour", "Last 24 hours", "Older"]
+            for name, block in zip(block_names, blocks):
+                if block:  # Only show non-empty blocks
+                    content_sections.extend([
+                        f"\n[bold]{name}[/bold] ({len(block)} files):",
+                        Columns([
+                            Text.assemble(
+                                f"{f.name} - ",
+                                (f"{f.content.splitlines()[0][:50]}...", "dim")
+                            )
+                            for f in block[:5]  # Show first 5 files only
+                        ], padding=(0, 2)),
+                        "" if block == blocks[-1] else Rule(style="dim")
+                    ])
+
+    # Display analysis
+    console.print("\n")
+    console.print(Panel(
+        Group(*content_sections),
+        title="[bold blue]Workset Analysis[/bold blue]",
+        title_align="center"
+    ))

janito/workspace/stats.py

@@ -0,0 +1,43 @@
+from collections import defaultdict
+from pathlib import Path
+from typing import List, Dict, Tuple
+from .types import FileInfo
+
+def collect_file_stats(files: List[FileInfo]) -> Tuple[Dict[str, List[int]], Dict[str, int]]:
+    """Collect directory and file type statistics from files.
+
+    Args:
+        files: List of FileInfo objects to analyze
+
+    Returns:
+        Tuple containing:
+            - Dictionary of directory stats [count, size]
+            - Dictionary of file type counts
+    """
+    dir_counts = defaultdict(lambda: [0, 0])  # [count, size]
+    file_types = defaultdict(int)
+
+    for file_info in files:
+        path = Path(file_info.name)
+        dir_path = str(path.parent)
+        file_size = len(file_info.content.encode('utf-8'))
+
+        # Update directory stats
+        dir_counts[dir_path][0] += 1
+        dir_counts[dir_path][1] += file_size
+
+        # Update file type stats
+        file_types[path.suffix.lower() or 'no_ext'] += 1
+
+    return dir_counts, file_types
+
+def _format_size(size_bytes: int) -> str:
+    """Format size in bytes to human readable format."""
+    size = size_bytes
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size < 1024:
+            break
+        size //= 1024
+    return f"{size} {unit}"
+
+# Remove _group_files_by_time function as it's now handled by Workset

janito/workspace/types.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Dict, Set, Tuple
+from sys import maxsize
+from janito.config import config
+from enum import auto, Enum
+
+@dataclass
+class FileInfo:
+    """Represents a file's basic information"""
+    name: str  # Relative path from workspace root
+    content: str
+    seconds_ago: int = 0  # Seconds since last modification
+
+class ScanType(Enum):
+    """Type of path scanning"""
+    PLAIN = auto()
+    RECURSIVE = auto()
+
+@dataclass
+class ScanPath:
+    """Represents a path to be scanned"""
+    path: Path
+    scan_type: ScanType = ScanType.PLAIN
+
+    @property
+    def is_recursive(self) -> bool:
+        return self.scan_type == ScanType.RECURSIVE
+
+@dataclass
+class WorksetContent:
+    """Represents workset content and statistics."""
+    files: List[FileInfo] = field(default_factory=list)
+    scanned_paths: Set[Path] = field(default_factory=set)
+    dir_counts: Dict[str, int] = field(default_factory=dict)
+    dir_sizes: Dict[str, int] = field(default_factory=dict)
+    file_types: Dict[str, int] = field(default_factory=dict)
+    scan_completed: bool = False
+    analyzed: bool = False
+
+    def clear(self) -> None:
+        """Reset all content"""
+        self.files = []
+        self.scanned_paths = set()
+        self.dir_counts = {}
+        self.dir_sizes = {}
+        self.file_types = {}
+        self.scan_completed = False
+        self.analyzed = False
+
+    def add_file(self, file_info: FileInfo) -> None:
+        """Add a file to the content and update statistics"""
+        self.files.append(file_info)
+        
+        # Update file type stats
+        suffix = Path(file_info.name).suffix.lower() or 'no_ext'
+        self.file_types[suffix] = self.file_types.get(suffix, 0) + 1
+        
+        # Update directory stats
+        dir_path = str(Path(file_info.name).parent)
+        self.dir_counts[dir_path] = self.dir_counts.get(dir_path, 0) + 1
+        self.dir_sizes[dir_path] = self.dir_sizes.get(dir_path, 0) + len(file_info.content.encode('utf-8'))
+
+    def get_file_info(self, time_ranges: List[int] = None) -> Tuple[List[FileInfo], List[FileInfo], List[FileInfo], List[FileInfo]]:
+        """Get file information grouped into 4 blocks based on modification time ranges."""
+        if not time_ranges:
+            time_ranges = [300, 3600, 86400, maxsize]  # 5min, 1h, 24h, rest
+        else:
+            time_ranges = [int(x) for x in time_ranges[:3]] + [maxsize]
+            if len(time_ranges) < 4:
+                time_ranges.extend([maxsize] * (4 - len(time_ranges)))
+        time_ranges.sort()
+
+        blocks = [[] for _ in range(4)]
+        
+        def get_range_index(seconds: int) -> int:
+            for i, threshold in enumerate(time_ranges):
+                if seconds <= threshold:
+                    return i
+            return len(time_ranges) - 1
+
+        # Sort and group files by modification time
+        sorted_files = sorted(self.files, key=lambda f: f.seconds_ago)
+        for file_info in sorted_files:
+            block_idx = get_range_index(file_info.seconds_ago)
+            blocks[block_idx].append(file_info)
+
+        return tuple(blocks)
+
+    @property
+    def content_size(self) -> int:
+        """Get total content size in bytes"""
+        return sum(len(f.content.encode('utf-8')) for f in self.files)
+
+    @property
+    def file_count(self) -> int:
+        """Get total number of files"""
+        return len(self.files)

janito/workspace/workset.py

@@ -0,0 +1,108 @@
+from pathlib import Path
+from typing import List, Set, Tuple
+from .show import show_workset_analysis
+from rich.console import Console
+from janito.config import config
+from .types import WorksetContent, FileInfo, ScanPath, ScanType
+from .workspace import Workspace
+
+class PathNotRelativeError(Exception):
+    """Raised when a path is not relative."""
+    pass
+
+class Workset:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._init()
+        return cls._instance
+
+    def _init(self):
+        self._scan_paths: List[ScanPath] = []
+        self._content = WorksetContent()
+        self._workspace = Workspace()
+        if not config.skip_work:
+            self._scan_paths.append(ScanPath(Path("."), ScanType.PLAIN))
+
+    def add_scan_path(self, path: Path, scan_type: ScanType) -> None:
+        """Add a path with specific scan type."""
+        if path.is_absolute():
+            raise PathNotRelativeError(f"Path must be relative: {path}")
+        self._scan_paths.append(ScanPath(path, scan_type))
+        
+        if config.debug:
+            Console(stderr=True).print(
+                f"[cyan]Debug: Added {scan_type.name.lower()} scan path: {path}[/cyan]"
+            )
+
+    def refresh(self) -> None:
+        """Refresh content by scanning configured paths"""
+        self.clear()
+        paths = self.get_scan_paths()
+        
+        if config.debug:
+            Console(stderr=True).print(f"[cyan]Debug: Refreshing workset with paths: {paths}[/cyan]")
+            
+        self._workspace.scan_files(paths, self.get_recursive_paths())
+        self._content = self._workspace.content
+
+    def get_scan_paths(self) -> List[Path]:
+        """Get effective scan paths based on configuration"""
+        paths = set()
+        paths.update(p.path for p in self._scan_paths)
+        return sorted(paths)
+
+    def get_recursive_paths(self) -> Set[Path]:
+        """Get paths that should be scanned recursively"""
+        return {p.path for p in self._scan_paths if p.is_recursive}
+
+    def is_path_recursive(self, path: Path) -> bool:
+        """Check if a path is configured for recursive scanning"""
+        return any(scan_path.is_recursive and scan_path.path == path 
+                  for scan_path in self._scan_paths)
+
+    @property
+    def paths(self) -> Set[Path]:
+        return {p.path for p in self._scan_paths}
+
+    @property
+    def recursive_paths(self) -> Set[Path]:
+        return self.get_recursive_paths()
+
+    def clear(self) -> None:
+        """Clear workspace settings while maintaining current directory in scan paths"""
+        self._content = WorksetContent()
+
+    def show(self) -> None:
+        """Display analysis of current workset content."""
+        show_workset_analysis(
+            files=self._content.files,
+            scan_paths=self._scan_paths,
+            cache_blocks=self.get_cache_blocks()
+        )
+
+    def get_cache_blocks(self) -> Tuple[List[FileInfo], List[FileInfo], List[FileInfo], List[FileInfo]]:
+        """Get files grouped into time-based cache blocks.
+        
+        Returns:
+            Tuple of 4 lists containing FileInfo objects:
+            - Last 5 minutes
+            - Last hour
+            - Last 24 hours
+            - Older files
+        """
+        time_ranges = [300, 3600, 86400]  # 5min, 1h, 24h
+        blocks: List[List[FileInfo]] = [[] for _ in range(4)]
+        
+        for file_info in sorted(self._content.files, key=lambda f: f.seconds_ago):
+            # Will return 3 if file is older than all thresholds
+            block_idx = next((i for i, threshold in enumerate(time_ranges) 
+                            if file_info.seconds_ago <= threshold), 3)
+            blocks[block_idx].append(file_info)
+            
+        return tuple(blocks)
+
+# Create and export singleton instance at module level
+workset = Workset()

janito/workspace/workspace.py

@@ -0,0 +1,114 @@
+from pathlib import Path
+from typing import List, Set, Dict, Optional, Tuple
+import time
+from rich.console import Console
+from janito.config import config
+from .types import WorksetContent, FileInfo, ScanPath  # Add ScanPath import
+
+class PathNotRelativeError(Exception):
+    """Raised when a path is not relative."""
+    pass
+
+class Workspace:
+    """Handles workspace scanning and content management."""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if not self._initialized:
+            self._content = WorksetContent()
+            self._initialized = True
+
+    def scan_files(self, paths: List[Path], recursive_paths: Set[Path]) -> None:
+        """Scan files from given paths and update content.
+        
+        Args:
+            paths: List of paths to scan
+            recursive_paths: Set of paths to scan recursively
+        """
+        for path in paths:
+            if path.is_absolute():
+                raise PathNotRelativeError(f"Path must be relative: {path}")
+                
+        scan_time = time.time()
+        
+        if config.debug:
+            console = Console(stderr=True)
+            console.print(f"\n[cyan]Debug: Starting scan of {len(paths)} paths[/cyan]")
+
+        processed_files: Set[Path] = set()
+        for path in paths:
+            abs_path = config.workspace_dir / path
+            if not (config.skip_work and path == Path(".")):
+                self._scan_path(abs_path, processed_files, scan_time, recursive_paths)
+
+        self._content.scan_completed = True
+        self._content.analyzed = False
+        self._content.scanned_paths = set(paths)
+
+    def _scan_path(self, path: Path, processed_files: Set[Path], scan_time: float, 
+                  recursive_paths: Set[Path]) -> None:
+        """Scan a single path and process its contents."""
+        if path in processed_files:
+            return
+
+        # Convert recursive_paths to absolute for comparison
+        abs_recursive_paths = {config.workspace_dir / p for p in recursive_paths}
+
+        path = path.resolve()
+        processed_files.add(path)
+
+        if path.is_dir():
+            try:
+                for item in path.iterdir():
+                    if item.name.startswith(('.', '__pycache__')):
+                        continue
+                    if path in abs_recursive_paths:
+                        self._scan_path(item, processed_files, scan_time, recursive_paths)
+                    elif item.is_file():
+                        self._scan_path(item, processed_files, scan_time, recursive_paths)
+            except PermissionError:
+                if config.debug:
+                    Console(stderr=True).print(f"[red]Debug: Permission denied: {path}[/red]")
+        elif path.is_file():
+            self._process_file(path, scan_time)
+
+    def _process_file(self, path: Path, scan_time: float) -> None:
+        """Process a single file and add it to the content."""
+        try:
+            if path.suffix.lower() in {'.py', '.md', '.txt', '.json', '.yaml', '.yml', '.toml'} or not path.suffix:
+                content = path.read_text(encoding='utf-8')
+                rel_path = path.relative_to(config.workspace_dir)
+                seconds_ago = int(scan_time - path.stat().st_mtime)
+                
+                file_info = FileInfo(
+                    name=str(rel_path),
+                    content=content,
+                    seconds_ago=seconds_ago
+                )
+                self._content.add_file(file_info)
+                
+                if config.debug:
+                    Console(stderr=True).print(f"[cyan]Debug: Added file: {rel_path}[/cyan]")
+        except (UnicodeDecodeError, PermissionError) as e:
+            if config.debug:
+                Console(stderr=True).print(f"[red]Debug: Error reading file {path}: {str(e)}[/red]")
+
+    def get_file_info(self, time_ranges: Optional[List[int]] = None) -> Tuple[List[FileInfo], List[FileInfo], List[FileInfo], List[FileInfo]]:
+        """Get file information grouped by modification time."""
+        return self._content.get_file_info(time_ranges)
+
+    def clear(self) -> None:
+        """Clear all workspace content and settings."""
+        self._content = WorksetContent()
+
+    @property
+    def content(self) -> WorksetContent:
+        """Get the workspace content."""
+        return self._content