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

janito/workspace/analysis.py

@@ -0,0 +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
+    return f"{size_bytes:.1f} {unit}"

janito/workspace/manager.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+from collections import defaultdict
+
+class WorkspaceManager:
+    """Manages workspace state and operations using singleton pattern."""
+    _instance = None
+
+    def __init__(self):
+        if WorkspaceManager._instance is not None:
+            raise RuntimeError("Use WorkspaceManager.get_instance() instead")
+        self.content: str = ""
+        self.scan_completed: bool = False
+        self._analyzed: bool = False
+
+    @classmethod
+    def get_instance(cls) -> "WorkspaceManager":
+        """Get singleton instance of WorkspaceManager."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def collect_content(self, paths: List[Path]) -> None:
+        """Collect and store content from specified paths."""
+        from .scan import _scan_paths
+        content_parts, _, _, _ = _scan_paths(paths)
+        self.content = "\n".join(content_parts)
+        self.scan_completed = True
+        self._analyzed = False
+
+    def analyze(self) -> None:
+        """Analyze workspace content and update statistics."""
+        from .analysis import analyze_workspace_content
+        if not self.scan_completed:
+            return
+        if not self._analyzed and self.content:
+            analyze_workspace_content(self.content)
+            self._analyzed = True
+
+    def get_content(self) -> str:
+        """Get collected workspace content."""
+        return self.content
+
+    def clear(self) -> None:
+        """Clear workspace content and stats."""
+        self.content = ""
+        self.scan_completed = False
+        self._analyzed = False

janito/workspace/scan.py

@@ -0,0 +1,232 @@
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Set, Tuple
+
+from pathspec import PathSpec
+from pathspec.patterns import GitWildMatchPattern
+from rich.columns import Columns
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.rule import Rule
+from rich.console import Group
+from janito.config import config
+
+
+SPECIAL_FILES = ["README.md", "__init__.py", "__main__.py"]
+
+
+def _get_gitignore_spec() -> PathSpec:
+    """Load gitignore patterns if available"""
+    gitignore_path = config.workspace_dir / '.gitignore' if config.workspace_dir else None
+    if gitignore_path and gitignore_path.exists():
+        with gitignore_path.open() as f:
+            lines = f.readlines()
+        return PathSpec.from_lines(GitWildMatchPattern, lines)
+
+
+def _process_file(path: Path, relative_base: Path) -> Tuple[str, str, bool]:
+    """Process a single file and return its XML content, display item and success status"""
+    relative_path = path.relative_to(relative_base)
+    try:
+        # Skip binary files
+        if path.read_bytes().find(b'\x00') != -1:
+            return "", "", False
+
+        file_content = path.read_text(encoding='utf-8')
+        xml_content = f"<file>\n<path>{relative_path}</path>\n<content>\n{file_content}\n</content>\n</file>"
+        display_item = f"[cyan]•[/cyan] {relative_path}"
+        return xml_content, display_item, True
+    except UnicodeDecodeError:
+        return "", str(relative_path), False
+
+def _scan_paths(paths: List[Path] = None) -> Tuple[List[str], List[str], List[str], List[str]]:
+    """Common scanning logic for both preview and content collection"""
+    content_parts = []
+    file_items = []
+    skipped_files = []
+    ignored_items = []
+    processed_files: Set[Path] = set()
+    console = Console()
+    gitignore_spec = _get_gitignore_spec()
+
+    def scan_path(path: Path, depth: int, is_recursive: bool) -> None:
+        if depth > 1 and not is_recursive:
+            return
+
+        path = path.resolve()
+        if '.janito' in path.parts or '.git' in path.parts or '.pytest_cache' in path.parts:
+            return
+
+        relative_base = config.workspace_dir
+        if path.is_dir():
+            relative_path = path.relative_to(relative_base)
+            content_parts.append(f'<directory><path>{relative_path}</path>not sent</directory>')
+            file_items.append(f"[blue]•[/blue] {relative_path}/")
+
+            # Process special files
+            special_found = []
+            for special_file in SPECIAL_FILES:
+                special_path = path / special_file
+                if special_path.exists() and special_path.resolve() not in processed_files:
+                    special_found.append(special_file)
+                    processed_files.add(special_path.resolve())
+                    xml_content, _, success = _process_file(special_path, relative_base)
+                    if success:
+                        content_parts.append(xml_content)
+                    else:
+                        skipped_files.append(str(special_path.relative_to(relative_base)))
+
+            if special_found:
+                file_items[-1] = f"[blue]•[/blue] {relative_path}/ [cyan]({', '.join(special_found)})[/cyan]"
+
+            for item in path.iterdir():
+                # Skip ignored files/directories
+                if gitignore_spec and gitignore_spec.match_file(str(item.relative_to(config.workspace_dir))):
+                    rel_path = item.relative_to(config.workspace_dir)
+                    ignored_items.append(f"[dim red]•[/dim red] {rel_path}")
+                    continue
+                scan_path(item, depth+1, is_recursive)
+        else:
+            if path.resolve() in processed_files:
+                return
+
+            processed_files.add(path.resolve())
+            xml_content, display_item, success = _process_file(path, relative_base)
+            if success:
+                content_parts.append(xml_content)
+                file_items.append(display_item)
+            else:
+                skipped_files.append(display_item)
+                if display_item:
+                    console.print(f"[yellow]Warning: Skipping file due to encoding issues: {display_item}[/yellow]")
+
+    for path in paths:
+        is_recursive = Path(path) in config.recursive
+        scan_path(path, 0, is_recursive)
+
+    if skipped_files and config.verbose:
+        console.print("\n[yellow]Files skipped due to encoding issues:[/yellow]")
+        for file in skipped_files:
+            console.print(f"  • {file}")
+
+    return content_parts, file_items, skipped_files, ignored_items
+
+def collect_files_content(paths: List[Path] = None) -> str:
+    """Collect content from all files in XML format"""
+    console = Console()
+
+    # If no paths specified and skipwork not set, use workspace_dir
+    if not paths and not config.skipwork:
+        paths = [config.workspace_dir]
+    # If paths specified and skipwork not set, include workspace_dir
+    elif paths and not config.skipwork:
+        paths = [config.workspace_dir] + paths
+    # If skipwork set, use only specified paths
+    elif not paths and config.skipwork:
+        console.print("[yellow]Warning: No paths to scan - skipwork enabled but no include paths specified[/yellow]")
+        return ""
+
+    content_parts, file_items, skipped_files, ignored_items = _scan_paths(paths)
+
+    if file_items and config.verbose:
+        console.print("\n[bold blue]Contents being analyzed:[/bold blue]")
+        console.print(Columns(file_items, padding=(0, 4), expand=True))
+        console.print("\n[bold green]Scan completed successfully[/bold green]")
+
+    return "\n".join(content_parts)
+
+def preview_scan(paths: List[Path] = None) -> None:
+    """Preview what files and directories would be scanned with structured output."""
+    console = Console()
+    _, file_items, skipped_files, ignored_items = _scan_paths(paths)
+
+    # Create sections list for structured output
+    sections = []
+
+    # Section 1: Paths Information
+    paths_section = []
+    is_workspace_dir_scanned = any(p.resolve() == config.workspace_dir.resolve() for p in paths)
+
+    # Show workspace_dir unless skipwork is set
+    if not config.skipwork:
+        paths_section.append(Panel(
+            f"📂 {config.workspace_dir.absolute()}",
+            title="[bold cyan]Working Directory[/bold cyan]",
+            border_style="cyan",
+            padding=(1, 2)
+        ))
+
+    # Show included paths
+    if paths:
+        included_paths = []
+        for path in paths:
+            try:
+                rel_path = path.relative_to(config.workspace_dir)
+                is_recursive = path in config.recursive
+                included_paths.append(f"📁 ./{rel_path}" + ("/*" if is_recursive else "/"))
+            except ValueError:
+                included_paths.append(f"📁 {path.absolute()}")
+
+        paths_section.append(Panel(
+            Group(*[Text(p) for p in included_paths]),
+            title="[bold green]Included Paths[/bold green]",
+            border_style="green",
+            padding=(1, 2)
+        ))
+
+    sections.extend(paths_section)
+    sections.append(Rule(style="blue"))
+
+    # Section 2: Files to be scanned
+    if file_items:
+        sections.append(Panel(
+            Columns(file_items, padding=(0, 2), expand=True),
+            title="[bold blue]Files to be Scanned[/bold blue]",
+            border_style="blue",
+            padding=(1, 2)
+        ))
+
+    # Section 3: Ignored items
+    if ignored_items:
+        sections.append(Panel(
+            Columns(ignored_items, padding=(0, 2), expand=True),
+            title="[bold red]Ignored Items[/bold red]",
+            border_style="red",
+            padding=(1, 2)
+        ))
+
+    # Section 4: Skipped files (only in verbose mode)
+    if skipped_files and config.verbose:
+        sections.append(Panel(
+            Columns([f"[yellow]•[/yellow] {f}" for f in skipped_files], padding=(0, 2), expand=True),
+            title="[bold yellow]Skipped Files[/bold yellow]",
+            border_style="yellow",
+            padding=(1, 2)
+        ))
+
+    # Display all sections with separators
+    console.print("\n")
+    for section in sections:
+        console.print(section)
+        console.print("\n")
+
+
+def is_dir_empty(path: Path) -> bool:
+    """
+    Check if directory is empty (ignoring hidden files/directories).
+    
+    Args:
+        path: Directory path to check
+        
+    Returns:
+        True if directory has no visible files/directories, False otherwise
+    """
+    if not path.is_dir():
+        return False
+        
+    # List all non-hidden files and directories
+    visible_items = [item for item in path.iterdir() 
+                    if not item.name.startswith('.')]
+    
+    return len(visible_items) == 0

janito-0.6.0.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 0.6.0
+Summary: A CLI tool for software development tasks powered by AI
+Project-URL: Homepage, https://github.com/joaompinto/janito
+Project-URL: Repository, https://github.com/joaompinto/janito.git
+Author-email: João Pinto <lamego.pinto@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Requires-Dist: anthropic
+Requires-Dist: pathspec
+Requires-Dist: rich
+Requires-Dist: tomli
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# Janito
+
+[![PyPI version](https://badge.fury.io/py/janito.svg)](https://badge.fury.io/py/janito)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+AI-powered CLI tool for code modifications and analysis. Janito helps you modify, analyze, and understand your codebase using natural language commands.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+  - [Prerequisites](#prerequisites)
+  - [Steps](#steps)
+- [Usage](#usage)
+  - [Basic Commands](#basic-commands)
+  - [Common Use Cases](#common-use-cases)
+- [Configuration](#configuration)
+  - [Environment Variables](#environment-variables)
+  - [Command Line Options](#command-line-options)
+- [Troubleshooting](#troubleshooting)
+  - [Common Issues](#common-issues)
+  - [Error Messages](#error-messages)
+- [Contributing](#contributing)
+- [License](#license)
+
+## ✨ Features
+
+- Natural language code modifications
+- Codebase analysis and question answering
+- Smart search and replace with indentation awareness
+- Git-aware operations
+- Interactive shell mode
+- Change preview and validation
+- Automatic backup and restore
+
+## 🚀 Installation
+
+### Prerequisites
+
+- Python 3.8 or higher
+- pip package manager
+- An Anthropic API key (default) or OpenAI API key
+
+### Steps
+
+1. Install using pip:
+```bash
+pip install janito
+```
+
+2. Configure your API key:
+
+For Anthropic Claude (default):
+```bash
+export ANTHROPIC_API_KEY=your_api_key_here
+```
+
+For OpenAI:
+```bash
+export OPENAI_API_KEY=your_api_key_here
+export AI_BACKEND=openai
+```
+
+## 💡 Usage
+
+### Basic Commands
+
+```bash
+# Modify code
+janito "add docstrings to this file"
+
+# Ask questions about the codebase
+janito --ask "explain the main function in this file"
+
+# Preview files that would be analyzed
+janito --scan
+
+# Start interactive shell
+janito
+```
+
+### Common Use Cases
+
+1. Code Documentation:
+```bash
+janito "add type hints to all functions"
+janito "improve docstrings with more details"
+```
+
+2. Code Analysis:
+```bash
+janito --ask "what are the main classes in this project?"
+janito --ask "explain the error handling flow"
+```
+
+3. Code Refactoring:
+```bash
+janito "convert this class to use dataclasses"
+janito "split this large function into smaller ones"
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+- `ANTHROPIC_API_KEY`: Anthropic API key
+- `OPENAI_API_KEY`: OpenAI API key (if using OpenAI backend)
+- `AI_BACKEND`: AI provider ('claudeai' or 'openai')
+- `JANITO_TEST_CMD`: Default test command to run after changes
+
+### Command Line Options
+
+- `-w, --workspace_dir`: Set working directory
+- `-i, --include`: Additional paths to include
+- `--debug`: Show debug information
+- `--verbose`: Show verbose output
+- `--auto-apply`: Apply changes without confirmation
+- `--history`: Display history of requests
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+1. API Key Issues:
+```bash
+# Verify API key is set
+echo $ANTHROPIC_API_KEY
+
+# Temporarily set API key for single command
+ANTHROPIC_API_KEY=your_key janito "your request"
+```
+
+2. Path Issues:
+```bash
+# Use absolute paths if having issues with relative paths
+janito -w /full/path/to/project "your request"
+
+# Specify additional paths explicitly
+janito -i ./src -i ./tests "your request"
+```
+
+3. Debug Mode:
+```bash
+# Enable debug output for troubleshooting
+janito --debug "your request"
+```
+
+### Error Messages
+
+- "No command given": Provide a change request or command
+- "No input provided": Check if using --input mode correctly
+- "Duplicate path provided": Remove duplicate paths from includes
+
+## 👥 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE)

janito-0.6.0.dist-info/RECORD

@@ -0,0 +1,95 @@
+janito/__init__.py,sha256=Svp3i5NGeapDV4xB-CDu9TjqEzvsnjQwSzdmDT9DDqc,47
+janito/__main__.py,sha256=MChFWxE8OPLe8QsdG1nxS1l5s0oZkJoJUlX3IRqEklk,5069
+janito/common.py,sha256=jGoA1RyglPBpTQJcDdCj6Ar-h8Eh6U7ZOlgJjvdm91M,2076
+janito/config.py,sha256=B5S6mmnQi2HMA_F6FuGREdbHTj_vdi2cl1WzfFBaiJc,3134
+janito/prompts.py,sha256=VNC_1orab53YbdKIfnDub_r2PGQbwLn3hUZL0TcSvJQ,201
+janito/qa.py,sha256=4zXuEg48ogyXmL_jZpJWo4xT0cPY7LG4dUvF-_mvGIc,1959
+janito/review.py,sha256=5Oc6BfxMGNmKbIeDP5_EiAKUDeQwVOD0YL7iqfgJLRE,471
+janito/version.py,sha256=ylfPwGtdY8dEOFJ-DB9gKUQLggqRCvoLxhpnwjzCM94,739
+janito/agents/__init__.py,sha256=I_N-11HvV76yUfDOV_43U5tXz5e5kSnQamCQJE9OXXQ,510
+janito/agents/agent.py,sha256=3uGiUrvj9oCW6_oK-oMQQJ77K8jZFv7mAdXlIG1dxNY,751
+janito/agents/claudeai.py,sha256=zPySDG70ATKWPvzB4CKpaK9E8pbmzOhCE1i8ESwaE0o,1908
+janito/agents/openai.py,sha256=tNtlzFJMWFv38Z62opR23u6xXlZ9L4xX_mf2f3wjrLU,2082
+janito/agents/test.py,sha256=xoN1q9DUSYpUbnvTP1qZsEfxYrZfocJlt9DkIuMDvvY,1552
+janito/change/__init__.py,sha256=vGn9qudqiusp4LsR2zzr3mbb4dhXvcGBY2NNzl1JC5M,955
+janito/change/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+janito/change/core.py,sha256=TGlNQBZm2TdEPtWZSUV5kldxv1y4urL2YkeOn1wDxTk,4070
+janito/change/history.py,sha256=rbprE1lnOl5We85c-VsDnHAiGphW0t2fA7zu4N9uulw,1405
+janito/change/operations.py,sha256=5HeUvFa503Foemngu-ShomPn9W82XH-gLlTfXxAZoEw,165
+janito/change/parser.py,sha256=hrwJXn318mfiw1zWiLN9Frdsp5BKpg83YToCkSyHtQw,11242
+janito/change/play.py,sha256=ZzYp-eaIBn578EiPB9uVR-G-mxXiK_hD_GI15htb0DU,1835
+janito/change/preview.py,sha256=xfwo0q7jAx-U92U3iEwDDlsZnzndj7fshq8OLgjv3Vw,2720
+janito/change/prompts.py,sha256=e0uxXRRz1U1AJS-6pDcoOGJjothJNBhvixtGGYkPyWc,4372
+janito/change/test.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+janito/change/validator.py,sha256=WxGruFjH9yAsHTOWWIJFpPurrWHNNXE69JogDmraF9A,10310
+janito/change/analysis/__init__.py,sha256=yg9LhcC1nCvleGt4cnQMuJYCARXBZNvmXaT23S3szJo,593
+janito/change/analysis/__main__.py,sha256=M6JmJnZfOKB0OB29EpzzfbNZu7cusKT92KQhmnaWd5c,196
+janito/change/analysis/analyze.py,sha256=eAmqn492W_M9TwizMMlRETq3S9XiDSdXL9alKURgtBw,1655
+janito/change/analysis/formatting.py,sha256=VqDL6fBzvVm5pdDN4fX9nQQP1wZwhlxDKyaMlDj9ju4,2602
+janito/change/analysis/options.py,sha256=JNyXCFjOxS1Qm1oqqn8JSXrF4KQ9MotclfKMLD7dZFc,2957
+janito/change/analysis/prompts.py,sha256=672fztoXENLMms2_wdjaMSczIOzJe9J7tMInDQQh7Bo,3303
+janito/change/analysis/view/__init__.py,sha256=oQd_ClbL7sWmb8jbie74qRrn09CIUTxLH18b02PJFLk,204
+janito/change/analysis/view/terminal.py,sha256=7_pjYehUgzo7kOY15AgNyf1JClEy85YtgCr54VxJiOg,6105
+janito/change/applier/__init__.py,sha256=KdViLadNAWcSUbJcsfAt66cDJpaqYGIHdzSDKZjzsEw,183
+janito/change/applier/file.py,sha256=NQnoywcVXAxLU0xipsByajs2SCRtsSqFPO8tlJl1J2w,2420
+janito/change/applier/main.py,sha256=Ua-0tmOHYImSlYzmRPppz9stg50bGM1AFFUdQEFMxhY,6644
+janito/change/applier/text.py,sha256=l4vmFh1UVnzvm0W09w_m3HrbfYHIIgcNrqUw7Xld2SI,10868
+janito/change/applier/workspace_dir.py,sha256=whiuIIYyDHh2m-K_ZRMZGvMMQ1nh6lzXaWGhnFK1B1o,2443
+janito/change/viewer/__init__.py,sha256=tj-rIVbuAm80B7-no-YgdxbtkDlwRK_0hqUfIDtDOAc,250
+janito/change/viewer/content.py,sha256=SwYkLtsQXI0SCuHKD033XzxwnGQ_MmYckoDpnvJzA0s,2010
+janito/change/viewer/diff.py,sha256=OzaocnrnH4RCdzZPjT05pEmFJLcd_EgpKhRiAXJrvpc,1815
+janito/change/viewer/pager.py,sha256=oJFk1ulswrTs7Az09hHSS37SxyN2cvSVFZ_OxA2Z7os,1738
+janito/change/viewer/panels.py,sha256=1T9gZTmNud_LI2QmtYLL2xYUNeb0CpzL8xJRusmrX5U,22421
+janito/change/viewer/styling.py,sha256=vpOT0noD4Br-veZ8SuNihg_4RB55TZen-h3L7lX4IhM,3715
+janito/change/viewer/themes.py,sha256=HISrK7-qR0m4dGZqFmC5loW2E1RSwAicP0mnpZvbSv0,1470
+janito/clear_statement_parser/clear_statement_format.txt,sha256=_5iQylnCqgBaMVFVgx33QvEColV16oOwl1W4scu_-zc,13497
+janito/clear_statement_parser/examples.txt,sha256=NnxDraTpCPZCjJjL2HvCMtA1NxBY7C0l3b5v61Y-5iY,8547
+janito/clear_statement_parser/models.py,sha256=b7-lLHfQLI4q5dtaF4BVCwE9DI2xWwVQAHQqAl1c6s0,3640
+janito/clear_statement_parser/parser.py,sha256=KO7Bj0pEl7iPH3FQ3knTGSLMGqKS_pXe3_eqfEHBtXw,20847
+janito/cli/__init__.py,sha256=3gyMSaEAH2N4mXfZTLsHXKxXDxdhlYUeAPYQuhnOVBE,77
+janito/cli/base.py,sha256=WKFSxX5FKk5Se5QUZ0X3_fAQVIWG6OEGKAXKebWiRaM,1188
+janito/cli/commands.py,sha256=RP9VZYfW7vLK6xitLvp0kBQFdyEWfxHOCh91FaakRwI,1491
+janito/cli/functions.py,sha256=7DSFQaxKJ7JvkA8-wPuifogGk9NvqTUqC24nU2UUbVM,4143
+janito/cli/history.py,sha256=UIP_6UiGnJXmBke5hYqKXQVsOPrtKeyfBXW8vDxIoHQ,2114
+janito/cli/registry.py,sha256=R1sI45YonxjMSLhAle7Dt18X_devrMsLt0ljb-rNza4,690
+janito/cli/handlers/ask.py,sha256=jmD-XoP1-ldKlfNNu1WCja9NM7zJgPB3eOaglKOa7dE,829
+janito/cli/handlers/demo.py,sha256=TCjN2nVUTivUDvlRxJDhx-rZnfQDR0H_6Yuteq-zkQ0,725
+janito/cli/handlers/request.py,sha256=ytmmTSFzHoDPmOm-fWUEa6lkZRwL7e1VjcfJntoyvW8,1083
+janito/cli/handlers/scan.py,sha256=zg4AVsFTYkNtUrLA5uCi1Gr6gxDD8PbnFP0eozPtRVw,296
+janito/demo/__init__.py,sha256=vIGC6fs44yzuSK3-RgYnnanBtZwnW52ivdVbA8Yc8Lk,108
+janito/demo/data.py,sha256=t208Kixcc3J6xbn43P2OSpqkpcRrrFoEXZ44oOQMcCE,415
+janito/demo/mock_data.py,sha256=mBg-qF8GcRx7M40IGXGytQJOWihEUm51CJqcez1BKIk,695
+janito/demo/operations.py,sha256=6QXFsrMVJqX30Y19nBD8fxTj5I6MJN4duQ2qwVG_lHY,1392
+janito/demo/runner.py,sha256=Xv6v8QVlIkEnlSaNU-Jt6Yjl_NbNg_g8DMZnp8kiFGQ,2385
+janito/demo/scenarios.py,sha256=xKW6cAL3tSHWP76fvbKHf2HyruhamAzHY1VaTVCkM8o,1060
+janito/search_replace/README.md,sha256=Hat8Auac9dQY21Q1y3YVy97pqTwhBCaLTDZ64cI5hrg,3402
+janito/search_replace/__init__.py,sha256=apCtIPg44VVzGOKxCievdYAma6nfDGMl1ky-ZBQqjUc,257
+janito/search_replace/__main__.py,sha256=i0Wz387fqgiHq46QXCXpU9wnwdJYinjyY6HyoJJr_xw,520
+janito/search_replace/core.py,sha256=6xy1K9aq3-rddXS2ae158cAXP_B2-QWRbrSalTkjscw,5811
+janito/search_replace/parser.py,sha256=wFr5Dc7Im6oh4AcVUkpwKIc0Gf5oNBCYKT2lhexmyQg,2123
+janito/search_replace/play.py,sha256=vmEqbna8CAEYk4B6Og0eETCRAYRmrBSnFTdiXopsH3M,1820
+janito/search_replace/replacer.py,sha256=7MKO9PpbAMUqmnxDk1mqkZ_yWE13QwjDfvjT0uU4ypA,1556
+janito/search_replace/searcher.py,sha256=M9vzcWlfQV7ZoKQ83tLQWUtW1KPP4MOlBIEBISEh_jU,13004
+janito/shell/__init__.py,sha256=Rb6AKmUZpjsYT9bO5spU3_SdPoOoNInPKCl-Ei_qHUc,1272
+janito/shell/bus.py,sha256=xRl2-zlJsa0KPL2aSVtVJy9xH6GLw_7tEplvMIY5eCk,1041
+janito/shell/commands.py,sha256=b0J0lh2Q8HMcIldNThOnqIFAVUGAKwURThHBlP-K5tc,6797
+janito/shell/handlers.py,sha256=aiS1ASNyhZNEuzUCkhqeH1_eIpBX6R3yKjYiBmG8jQI,3978
+janito/shell/history.py,sha256=EMSbdW9ccHQ__WA-WM5VHjnu_ihTk-4sCpQXmi7e8iI,706
+janito/shell/processor.py,sha256=ueT-x4bGM7XiblweaGD5KnnQEPc5kU9cHw8LWwHpZaI,1988
+janito/tui/__init__.py,sha256=5u1TfGO99LmCtC8ilpXahkXWVJSWtBACqU_O8VtJewI,773
+janito/tui/base.py,sha256=qU_8i0aQ3sWIkgnKQDUGr3bhypDzSdqYCkNGFfRbIos,692
+janito/tui/flows/__init__.py,sha256=uI8MtTdIe2BWqbqcfJNnBdhxZcwc207wVjIWusGuDq4,161
+janito/tui/flows/changes.py,sha256=e-zHzmY8kbrbPRyyfcecFW21mH0xnn9AXnr7gsYI82s,2153
+janito/tui/flows/content.py,sha256=mAi4R0ncpC_PzjETqqH9kvy2n1xRKWLhNX5xqPgQjoM,4197
+janito/tui/flows/selection.py,sha256=PcrcY8hTl3ljZOmLYA_I3r3CVRdqKfqFlRxZSgS9rDo,4031
+janito/tui/screens/__init__.py,sha256=YZ8NVoXMs7c_aT1NuIBiZrkLfXCzaQ85yMKZ_Uh6wlE,69
+janito/tui/screens/app.py,sha256=XEiADppmDOYkjR1p7sH6N7Zqqm7RWvXSd5_udlAdvbA,92
+janito/workspace/__init__.py,sha256=vNDbXn36jSTp2OuMwLjil8eQJwXgorlBqHapOTPwnRg,260
+janito/workspace/analysis.py,sha256=Ag4mbOZPyRtm2BvbP7b9c5ZuGLs0vUBWFjormKf-jRc,4088
+janito/workspace/manager.py,sha256=GN3mGBO9-758vBsg9QBuEPu5N2QDkK4vZxD1dAGeBgg,1658
+janito/workspace/scan.py,sha256=BCYoTjEErbH9nULwFDPCqSGOvR13H01l08ZgNq7jJiY,8804
+janito-0.6.0.dist-info/METADATA,sha256=XH8_sffSXi-YqQxVeYgNoT1Yy8HtFIK26KM7AoxAiUE,4574
+janito-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+janito-0.6.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-0.6.0.dist-info/licenses/LICENSE,sha256=xLIUXRPjtsgQml2zD1Pn4LpgiyZ49raw6jZDlO_gZdo,1062
+janito-0.6.0.dist-info/RECORD,,

{janito-0.5.0.dist-info → janito-0.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any