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

janito/workspace/show.py

@@ -1,141 +1,115 @@
-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"
-    ))
+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 .models 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:
+        content_sections.extend([
+            "[bold yellow]📌 Included Paths[/bold yellow]",
+            Rule(style="yellow"),
+        ])
+
+        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)
+    ])
+
+
+    # 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

@@ -1,43 +1,42 @@
-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
+from collections import defaultdict
+from pathlib import Path
+from typing import List, Dict, Tuple
+from .models 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}"
+

janito/workspace/workset.py

@@ -1,108 +1,135 @@
-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()
+from pathlib import Path
+from typing import List, Set
+from .show import show_workset_analysis
+from rich.console import Console
+from janito.config import config
+from .models import WorksetContent, 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.add_scan_path(Path("."))
+
+    def add_scan_path(self, path: Path, scan_type: ScanType = ScanType.PLAIN) -> None:
+        """Add a path with specific scan type.
+
+        Args:
+            path: Relative path to add for scanning
+            scan_type: Type of scanning (PLAIN or RECURSIVE)
+
+        Raises:
+            PathNotRelativeError: If path is absolute
+        """
+        if path.is_absolute():
+            raise PathNotRelativeError(f"Path must be relative: {path}")
+
+        scan_path = ScanPath(path, scan_type)
+        ScanPath.validate(path)
+        self._scan_paths.append(scan_path)
+
+        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=None
+        )
+
+    @property
+    def content(self) -> str:
+        """Return the workset content as a string.
+        
+        Format:
+        <workspace_base_directories>
+        dirname1
+        dirname2
+        ...
+        <workset_files>
+        <file name=filename1>
+        ```
+        file1_content
+        ```
+        </file>
+        <file name=filename2>
+        ```
+        file2_content
+        ```
+        </file>
+        ...
+        """
+        content = "<workspace_base_directories>\n"
+        # Only include root directories if not skipping workspace
+        if not config.skip_work:
+            for dir in sorted(self._workspace.root_directories):
+                content += f"{dir}\n"
+        
+        content += "<workset_files>\n"
+        for file in sorted(self._content.files):
+            content += f"<file name={file.name}>\n"
+            content += "```\n"
+            content += file.content
+            content += "\n```\n"
+            content += "</file>\n"
+        
+        return content
+