janito 0.6.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 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
+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/models.py

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

janito/workspace/show.py

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

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

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