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

janito/workspace/analysis.py

@@ -1,121 +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 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
+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}"

janito/workspace/{types.py → models.py}

@@ -1,98 +1,97 @@
-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)
+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
+
+    def __lt__(self, other: 'FileInfo') -> bool:
+        """Enable sorting by filepath."""
+        if not isinstance(other, FileInfo):
+            return NotImplemented
+        return self.name < other.name
+
+    def __eq__(self, other: object) -> bool:
+        """Enable equality comparison by filepath."""
+        if not isinstance(other, FileInfo):
+            return NotImplemented
+        return self.name == other.name
+
+    def __hash__(self) -> int:
+        """Enable using FileInfo in sets by using filepath as hash."""
+        return hash(self.name)
+
+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
+
+    @classmethod
+    def validate(cls, path: Path) -> None:
+        """Validate path is relative and exists"""
+        if path.is_absolute():
+            raise ValueError(f"Path must be relative: {path}")
+        if not path.exists():
+            raise ValueError(f"Path does not exist: {path}")
+
+@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'))
+
+
+    @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)