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

janito/contentchange.py

@@ -1,84 +0,0 @@
-from pathlib import Path
-from typing import Dict, Tuple
-from rich.console import Console
-from datetime import datetime
-from janito.fileparser import FileChange, parse_block_changes
-from janito.changeapplier import preview_and_apply_changes
-
-def get_file_type(filepath: Path) -> str:
-    """Determine the type of saved file based on its name"""
-    name = filepath.name.lower()
-    if 'changes' in name:
-        return 'changes'
-    elif 'selected' in name:
-        return 'selected'
-    elif 'analysis' in name:
-        return 'analysis'
-    elif 'response' in name:
-        return 'response'
-    return 'unknown'
-
-def save_changes_to_history(content: str, request: str, workdir: Path) -> Path:
-    """Save change content to history folder with timestamp and request info"""
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")  # Already in the correct format
-    history_dir = workdir / '.janito' / 'history'
-    history_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Create history entry with request and changes
-    history_file = history_dir / f"changes_{timestamp}.txt"
-    
-    history_content = f"""Request: {request}
-Timestamp: {timestamp}
-
-Changes:
-{content}
-"""
-    history_file.write_text(history_content)
-    return history_file
-
-def process_and_save_changes(content: str, request: str, workdir: Path) -> Tuple[Dict[Path, Tuple[str, str]], Path]:
-    """Parse changes and save to history, returns (changes_dict, history_file)"""
-    changes = parse_block_changes(content)
-    history_file = save_changes_to_history(content, request, workdir)
-    return changes, history_file
-
-def validate_python_syntax(content: str, filepath: Path) -> Tuple[bool, str]:
-    """Validate Python syntax and return (is_valid, error_message)"""
-    try:
-        ast.parse(content)
-        return True, ""
-    except SyntaxError as e:
-        return False, f"Line {e.lineno}: {e.msg}"
-
-def format_parsed_changes(changes: Dict[Path, Tuple[str, str]]) -> str:
-    """Format parsed changes to show only file change descriptions"""
-    result = []
-    for filepath, (_, description) in changes.items():  # Updated tuple unpacking
-        result.append(f"=== {filepath} ===\n{description}\n")
-    return "\n".join(result)
-
-def apply_content_changes(content: str, request: str, workdir: Path, test_cmd: str = None) -> Tuple[bool, Path]:
-    """Regular flow: Parse content, save to history, and apply changes."""
-    console = Console()
-    changes = parse_block_changes(content)
-    
-    if not changes:
-        console.print("\n[yellow]No file changes were found in the response[/yellow]")
-        return False, None
-
-    history_file = save_changes_to_history(content, request, workdir)
-    success = preview_and_apply_changes(changes, workdir, test_cmd)
-    return success, history_file
-
-def handle_changes_file(filepath: Path, workdir: Path, test_cmd: str = None) -> Tuple[bool, Path]:
-    """Replay flow: Load changes from file and apply them."""
-    content = filepath.read_text()
-    changes = parse_block_changes(content)
-    
-    if not changes:
-        console = Console()
-        console.print("\n[yellow]No file changes were found in the file[/yellow]")
-        return False, None
-
-    success = preview_and_apply_changes(changes, workdir, test_cmd)
-    return success, filepath

janito/contextparser.py

@@ -1,113 +0,0 @@
-from typing import List, Tuple, Optional, NamedTuple
-from difflib import SequenceMatcher
-from janito.config import config
-from rich.console import Console
-
-class ContextError(NamedTuple):
-    """Contains error details for context matching failures"""
-    pre_context: List[str]
-    post_context: List[str]
-    content: str
-
-def parse_change_block(content: str) -> Tuple[List[str], List[str], List[str]]:
-    """Parse a change block into pre-context, post-context and change lines.
-    Returns (pre_context_lines, post_context_lines, change_lines)"""
-    pre_context_lines = []
-    post_context_lines = []
-    change_lines = []
-    in_pre_context = True
-    
-    for line in content.splitlines():
-        if line.startswith('='):
-            if in_pre_context:
-                pre_context_lines.append(line[1:])
-            else:
-                post_context_lines.append(line[1:])
-        elif line.startswith('>'):
-            in_pre_context = False
-            change_lines.append(line[1:])
-            
-    return pre_context_lines, post_context_lines, change_lines
-
-def find_context_match(file_content: str, pre_context: List[str], post_context: List[str], min_context: int = 2) -> Optional[Tuple[int, int]]:
-    """Find exact matching location using line-by-line matching.
-    Returns (start_index, end_index) or None if no match found."""
-    if not (pre_context or post_context) or (len(pre_context) + len(post_context)) < min_context:
-        return None
-
-    file_lines = file_content.splitlines()
-    
-    # Function to check if lines match at a given position
-    def lines_match_at(pos: int, target_lines: List[str]) -> bool:
-        if pos + len(target_lines) > len(file_lines):
-            return False
-        return all(a == b for a, b in zip(file_lines[pos:pos + len(target_lines)], target_lines))
-
-    # For debug output
-    debug_matches = []
-    
-    # Try to find pre_context match
-    pre_match_pos = None
-    if pre_context:
-        for i in range(len(file_lines) - len(pre_context) + 1):
-            if lines_match_at(i, pre_context):
-                pre_match_pos = i
-                break
-            if config.debug:
-                # Record first 20 non-matches for debug output
-                if len(debug_matches) < 20:
-                    debug_matches.append((i, file_lines[i:i + len(pre_context)]))
-
-    # Try to find post_context match after pre_context if found
-    if pre_match_pos is not None and post_context:
-        expected_post_pos = pre_match_pos + len(pre_context)
-        if not lines_match_at(expected_post_pos, post_context):
-            pre_match_pos = None
-
-    if pre_match_pos is None and config.debug:
-        console = Console()
-        console.print("\n[bold red]Context Match Debug:[/bold red]")
-        
-        if pre_context:
-            console.print("\n[yellow]Expected pre-context:[/yellow]")
-            for i, line in enumerate(pre_context):
-                console.print(f"  {i+1:2d} | '{line}'")
-
-        if post_context:
-            console.print("\n[yellow]Expected post-context:[/yellow]")
-            for i, line in enumerate(post_context):
-                console.print(f"  {i+1:2d} | '{line}'")
-
-        console.print("\n[yellow]First 20 attempted matches in file:[/yellow]")
-        for pos, lines in debug_matches:
-            console.print(f"\n[cyan]At line {pos+1}:[/cyan]")
-            for i, line in enumerate(lines):
-                match_status = "≠" if i < len(pre_context) and line != pre_context[i] else "="
-                console.print(f"  {i+1:2d} | '{line}' {match_status}")
-
-        return None
-
-    if pre_match_pos is None:
-        return None
-
-    end_pos = pre_match_pos + len(pre_context)
-    
-    return pre_match_pos, end_pos
-
-def apply_changes(content: str, 
-                 pre_context_lines: List[str], 
-                 post_context_lines: List[str], 
-                 change_lines: List[str]) -> Optional[Tuple[str, Optional[ContextError]]]:
-    """Apply changes with context matching, returns (new_content, error_details)"""
-    if not content.strip() and not pre_context_lines and not post_context_lines:
-        return '\n'.join(change_lines), None
-
-    pre_context = '\n'.join(pre_context_lines)
-    post_context = '\n'.join(post_context_lines)
-    
-    if pre_context and pre_context not in content:
-        return None, ContextError(pre_context_lines, post_context_lines, content)
-    
-    if post_context and post_context not in content:
-        return None, ContextError(pre_context_lines, post_context_lines, content)
-

janito/fileparser.py

@@ -1,125 +0,0 @@
-from pathlib import Path
-from typing import Dict, Tuple, List, Optional
-from dataclasses import dataclass
-import re
-import ast
-import sys  # Add this import
-from rich.console import Console
-from rich.panel import Panel  # Add this import
-from janito.config import config  # Add this import
-
-@dataclass
-class FileChange:
-    """Represents a file change with search/replace, search/delete or create instructions"""
-    description: str
-    is_new_file: bool
-    content: str = ""  # For new files
-    search_blocks: List[Tuple[str, Optional[str], Optional[str]]] = None  # (search, replace, description)
-
-    def add_search_block(self, search: str, replace: Optional[str], description: Optional[str] = None) -> None:
-        """Add a search/replace or search/delete block with optional description"""
-        if self.search_blocks is None:
-            self.search_blocks = []
-        self.search_blocks.append((search, replace, description))
-
-def validate_python_syntax(content: str, filepath: Path) -> Tuple[bool, str]:
-    """Validate Python syntax and return (is_valid, error_message)"""
-    try:
-        ast.parse(content)
-        console = Console()
-        console.print(f"[green]✓ Python syntax validation passed:[/green] {filepath.absolute()}")
-        return True, ""
-    except SyntaxError as e:
-        error_msg = f"Line {e.lineno}: {e.msg}"
-        console = Console()
-        console.print(f"[red]✗ Python syntax validation failed:[/red] {filepath.absolute()}")
-        console.print(f"[red]  {error_msg}[/red]")
-        return False, error_msg
-
-
-def parse_block_changes(response_text: str) -> Dict[Path, FileChange]:
-    """Parse file changes from response blocks"""
-    changes = {}
-    console = Console()
-    # Match file blocks with UUID
-    file_pattern = r'## ([a-f0-9]{8}) file (.*?) (modify|create) "(.*?)" ##\n?(.*?)## \1 file end ##'
-    
-    for match in re.finditer(file_pattern, response_text, re.DOTALL):
-        uuid, filepath, action, description, content = match.groups()
-        path = Path(filepath.strip())
-        
-        if action == 'create':
-            changes[path] = FileChange(
-                description=description,
-                is_new_file=True,
-                content=content[1:] if content.startswith('\n') else content,
-                search_blocks=[]
-            )
-            continue
-            
-        # For modifications, find all search/replace and search/delete blocks
-        search_blocks = []
-        block_patterns = [
-            # Match search/replace blocks with description - updated pattern
-            (r'## ' + re.escape(uuid) + r' search/replace "(.*?)" ##\n?(.*?)## ' + 
-             re.escape(uuid) + r' replace with ##\n?(.*?)(?=## ' + re.escape(uuid) + r'|$)', False),
-            # Match search/delete blocks with description
-            (r'## ' + re.escape(uuid) + r' search/delete "(.*?)" ##\n?(.*?)(?=## ' + re.escape(uuid) + r'|$)', True)
-        ]
-        
-        if config.debug:
-            console.print("\n[blue]Updated regex patterns:[/blue]")
-            for pattern, is_delete in block_patterns:
-                console.print(Panel(pattern, title="Search/Replace Pattern" if not is_delete else "Search/Delete Pattern", border_style="blue"))
-                
-        for pattern, is_delete in block_patterns:
-            if config.debug:
-                console.print(f"\n[blue]Looking for pattern:[/blue]")
-                console.print(Panel(pattern, title="Pattern", border_style="blue"))
-                console.print(f"\n[blue]In content:[/blue]")
-                console.print(Panel(content, title="Content", border_style="blue"))
-                
-            for block_match in re.finditer(pattern, content, re.DOTALL):
-                if is_delete:
-                    description, search = block_match.groups()
-                    search = search.rstrip('\n') + '\n'  # Ensure single trailing newline
-                    replace = None
-                else:
-                    description, search, replace = block_match.groups()
-                    search = search.rstrip('\n') + '\n'  # Ensure single trailing newline
-                    replace = (replace.rstrip('\n') + '\n') if replace else None
-                    
-                    # Abort parsing if replace content is empty
-                    if not is_delete and (replace is None or replace.strip() == ''):
-                        console.print(f"\n[red]Error: Empty replace content found![/red]")
-                        console.print(f"[red]File:[/red] {filepath}")
-                        console.print(f"[red]Description:[/red] {description}")
-                        console.print("[yellow]Search block:[/yellow]")
-                        console.print(Panel(search, title="Search Content", border_style="yellow"))
-                        console.print("[red]Replace block is empty or contains only whitespace![/red]")
-                        console.print("[red]Aborting due to empty replace content.[/red]")
-                        sys.exit(1)
-                    
-                    # Enhanced debug info
-                    if config.debug or (not is_delete and (replace is None or replace.strip() == '')):
-                        console.print(f"\n[yellow]Search/Replace block analysis:[/yellow]")
-                        console.print(f"[yellow]File:[/yellow] {filepath}")
-                        console.print(f"[yellow]Description:[/yellow] {description}")
-                        console.print("[yellow]Search block:[/yellow]")
-                        console.print(Panel(search, title="Search Content", border_style="yellow"))
-                        console.print("[yellow]Replace block:[/yellow]")
-                        console.print(Panel(replace if replace else "<empty>", title="Replace Content", border_style="yellow"))
-                        console.print("\n[blue]Match groups:[/blue]")
-                        for i, group in enumerate(block_match.groups()):
-                            console.print(Panel(str(group), title=f"Group {i}", border_style="blue"))
-                    
-                search_blocks.append((search, replace, description))
-        
-        # Add debug info if no blocks were found
-        if config.debug and not search_blocks:
-            console.print(f"\n[red]No search/replace blocks found for file:[/red] {filepath}")
-            console.print("[red]Check if the content format matches the expected patterns[/red]")
-        
-        changes[path] = FileChange(description=description, is_new_file=False, search_blocks=search_blocks)
-    
-    return changes

janito/scan.py

@@ -1,137 +0,0 @@
-from pathlib import Path
-from typing import List, Tuple
-from rich.console import Console
-from rich.columns import Columns
-from janito.config import config
-from pathspec import PathSpec
-from pathspec.patterns import GitWildMatchPattern
-
-
-SPECIAL_FILES = ["README.md", "__init__.py", "__main__.py"]
-
-def _scan_paths(paths: List[Path], workdir: Path = None) -> Tuple[List[str], List[str]]:
-    """Common scanning logic used by both preview and content collection"""
-    content_parts = []
-    file_items = []
-    skipped_files = []
-    console = Console()
-    
-    # Load gitignore if it exists
-    gitignore_path = workdir / '.gitignore' if workdir else None
-    gitignore_spec = None
-    if (gitignore_path and gitignore_path.exists()):
-        with open(gitignore_path) as f:
-            gitignore = f.read()
-        gitignore_spec = PathSpec.from_lines(GitWildMatchPattern, gitignore.splitlines())
-    
-
-    def scan_path(path: Path, level: int) -> None:
-        """
-        Scan a path and add it to the content_parts list
-        level 0 means we are scanning the root directory
-        level 1 we provide both directory directory name and file content
-        level > 1 we just return
-        """
-        if level > 1:
-            return
-
-        relative_base = workdir
-        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}/")
-            # Check for special files
-            special_found = []
-            for special_file in SPECIAL_FILES:
-                if (path / special_file).exists():
-                    special_found.append(special_file)
-            if special_found:
-                file_items[-1] = f"[blue]•[/blue] {relative_path}/ [cyan]({', '.join(special_found)})[/cyan]"
-                for special_file in special_found:
-                    special_path = path / special_file
-                    try:
-                        relative_path = special_path.relative_to(relative_base)
-                        file_content = special_path.read_text(encoding='utf-8')
-                        content_parts.append(f"<file>\n<path>{relative_path}</path>\n<content>\n{file_content}\n</content>\n</file>")
-                    except UnicodeDecodeError:
-                        skipped_files.append(str(relative_path))
-                        console.print(f"[yellow]Warning: Skipping file due to encoding issues: {relative_path}[/yellow]")
-
-            for item in path.iterdir():
-                # Skip if matches gitignore patterns
-                if gitignore_spec:
-                    rel_path = str(item.relative_to(workdir))
-                    if gitignore_spec.match_file(rel_path):
-                        continue
-                scan_path(item, level+1)
-
-        else:
-            relative_path = path.relative_to(relative_base)
-            # check if file is binary
-            try:
-                if path.is_file() and path.read_bytes().find(b'\x00') != -1:
-                    console.print(f"[red]Skipped binary file found: {relative_path}[/red]")
-                    return
-                file_content = path.read_text(encoding='utf-8')
-                content_parts.append(f"<file>\n<path>{relative_path}</path>\n<content>\n{file_content}\n</content>\n</file>")
-                file_items.append(f"[cyan]•[/cyan] {relative_path}")
-            except UnicodeDecodeError:
-                skipped_files.append(str(relative_path))
-                console.print(f"[yellow]Warning: Skipping file due to encoding issues: {relative_path}[/yellow]")
-
-    for path in paths:
-        scan_path(path, 0)
-        
-    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
-
-def collect_files_content(paths: List[Path], workdir: Path = None) -> str:
-    """Collect content from all files in XML format"""
-    console = Console()
-    content_parts, file_items = _scan_paths(paths, workdir)
-
-    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))
-    
-    return "\n".join(content_parts)
-
-
-def preview_scan(paths: List[Path], workdir: Path = None) -> None:
-    """Preview what files and directories would be scanned"""
-    console = Console()
-    _, file_items = _scan_paths(paths, workdir)
-    
-    # Display working directory status
-    console.print("\n[bold blue]Analysis Paths:[/bold blue]")
-    console.print(f"[cyan]Working Directory:[/cyan] {workdir.absolute()}")
-    
-    # Show if working directory is being scanned
-    is_workdir_scanned = any(p.resolve() == workdir.resolve() for p in paths)
-    if is_workdir_scanned:
-        console.print("[green]✓ Working directory will be scanned[/green]")
-    else:
-        console.print("[yellow]! Working directory will not be scanned[/yellow]")
-    
-    # Show included paths relative to working directory
-    if len(paths) > (1 if is_workdir_scanned else 0):
-        console.print("\n[cyan]Additional Included Paths:[/cyan]")
-        for path in paths:
-            if path.resolve() != workdir.resolve():
-                try:
-                    rel_path = path.relative_to(workdir)
-                    console.print(f"  • ./{rel_path}")
-                except ValueError:
-                    # Path is outside working directory
-                    console.print(f"  • {path.absolute()}")
-    
-    console.print("\n[bold blue]Files that will be analyzed:[/bold blue]")
-    console.print(Columns(file_items, padding=(0, 4), expand=True))
-
-def is_dir_empty(path: Path) -> bool:
-    """Check if directory is empty, ignoring hidden files"""
-    return not any(item for item in path.iterdir() if not item.name.startswith('.'))

janito-0.4.0.dist-info/METADATA

@@ -1,164 +0,0 @@
-Metadata-Version: 2.3
-Name: janito
-Version: 0.4.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
-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 CLI
-
-A CLI tool for software development tasks powered by AI.
-
-Meet Janito, your friendly AI-powered software development buddy! Janito helps you with coding tasks like refactoring, documentation updates, and code optimization while being clear and concise in its responses.
-
-## 📥 Installation
-
-```bash
-# Install from PyPI
-pip install janito
-
-# Install from source
-git clone https://github.com/joaompinto/janito.git
-cd janito
-pip install -e .
-```
-
-## ⚡ Requirements
-
-- Python 3.8+
-- Anthropic API key
-- Required packages (automatically installed):
-  - typer
-  - pathspec
-  - rich
-
-## ⚙️ Configuration
-
-### 🔑 API Key Setup
-Janito requires an Anthropic API key to function. Set it as an environment variable:
-
-```bash
-export ANTHROPIC_API_KEY='your-api-key-here'
-```
-
-You can also add this to your shell profile (~/.bashrc, ~/.zshrc, etc.) for persistence.
-
-### ⚙️ Test Command Setup
-You can configure a test command to run before applying changes:
-
-```bash
-export JANITO_TEST_CMD='your-test-command'
-```
-
-This command will be executed in the preview directory before applying changes to verify they don't break anything.
-
-## 📖 Usage
-
-Janito can be used in two modes: Command Line or Interactive Console.
-
-### 💻 Command Line Mode
-
-```bash
-janito REQUEST [OPTIONS]
-```
-
-#### Arguments
-- `REQUEST`: The modification request to process (optional)
-
-#### Options
-##### General Options
-- `--version`: Show version and exit
-- `-w, --workdir PATH`: Working directory (defaults to current directory)
-- `-i, --include PATH`: Additional paths to include in analysis (can be used multiple times)
-
-##### Operation Modes
-- `--ask TEXT`: Ask a question about the codebase instead of making changes
-- `--scan`: Preview files that would be analyzed without making changes
-- `--play PATH`: Replay a saved prompt file
-
-##### Output Control
-- `--raw`: Print raw response instead of markdown format
-- `-v, --verbose`: Show verbose output
-- `--debug`: Show debug information
-
-##### Testing
-- `-t, --test COMMAND`: Test command to run before applying changes (overrides JANITO_TEST_CMD)
-
-### 🖥️ Interactive Console Mode
-
-Start the interactive console by running `janito` without arguments:
-
-```bash
-janito
-```
-
-In console mode, you can:
-- Enter requests directly
-- Navigate history with up/down arrows
-- Use special commands starting with /
-
-### 📝 Examples
-
-```bash
-# Command Line Mode Examples
-janito "create docstrings for all functions"
-janito "add error handling" -w ./myproject
-janito "update tests" -i ./tests -i ./lib
-janito --ask "explain the authentication flow"
-janito --scan  # Preview files to be analyzed
-
-# Test Command Examples
-janito "update code" --test "pytest"  # Run pytest before applying changes
-janito "refactor module" -t "make test"  # Run make test before applying
-export JANITO_TEST_CMD="python -m unittest"  # Set default test command
-janito "optimize function"  # Will use JANITO_TEST_CMD
-
-# Console Mode
-janito  # Starts interactive session
-```
-
-## ✨ Features
-
-- 🤖 AI-powered code analysis and modifications
-- 💻 Interactive console mode for continuous interaction
-- 📁 Support for multiple file types
-- ✅ Syntax validation for Python files
-- 👀 Interactive change preview and confirmation
-- 📜 History tracking of all changes
-- 🐛 Debug and verbose output modes
-- ❓ Question-answering about codebase
-- 🔍 File scanning preview
-- 🧪 Test command execution before applying changes
-
-## 📚 History and Debugging
-
-Changes are automatically saved in `.janito/history/` with timestamps:
-- `*_analysis.txt`: Initial analysis
-- `*_selected.txt`: Selected implementation
-- `*_changes.txt`: Actual changes
-
-Enable debug mode for detailed logging:
-```bash
-janito "request" --debug
-```
-
-## 📄 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

janito-0.4.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-janito/__init__.py,sha256=CLeVFqpY9Ki3R3MgLAiTjNsJjsj1BD3_9CzP2kgCj-k,52
-janito/__main__.py,sha256=DqbMlHNWCX-XwiZz1qEYP3qAADKtfmlDhhbTgpXB5_M,14158
-janito/analysis.py,sha256=dAzMARAcDZ1LN6KC2-Xb0bIB0p5VsaT2lhurtPLLIKk,9368
-janito/changeapplier.py,sha256=fDP87Hh3uY8qoSv3-SSnafLCRJHLPQZ5U8GIMkdVZ9Y,17697
-janito/changeviewer.py,sha256=51J0pvGe1rfYpiYo0mhZMonsYJmyAN44mg1TfKRxdM4,12716
-janito/claude.py,sha256=N7ZX6WCrLKcj9na3o2MMPqH8tlobHYtIG1HnhgMVUKw,2272
-janito/common.py,sha256=1blM7rY55-mLPXD4L3xwS-RaJ2tBZx8xHhaLYQku3Rk,801
-janito/config.py,sha256=ocg0lyab9ysgczKaqJTAtv0ZRa2VDMwclTJBgps7Vxw,1171
-janito/console.py,sha256=E2mLPoBw7Gh1K1hPuCoRDBEFE-klIERt5KFgE3fHqUg,11100
-janito/contentchange.py,sha256=2HkNhqA_ZIXDHfiv3xRcwfoxMzFUNMuFfbMtf-4jhRM,3282
-janito/contextparser.py,sha256=iDX6nlqUQr-lj7lkEI4B6jHLci_Kxl-XWOaEiAQtVxA,4531
-janito/fileparser.py,sha256=8nngFmR9s6NVv2YuMcNKO4udNh-ZcKN4_Jo11vKzLhI,6586
-janito/prompts.py,sha256=aUDDx16L2ygPJZwrWn4FmrXt1KGNfLeYRcDSPD9BzIA,1879
-janito/qa.py,sha256=qrAXbsGPCRSW378V88w8e19uU3hfbDnx6lsiRYhq324,1927
-janito/scan.py,sha256=c_IKSuWx1_525RlIgPtP-tFoH7lManVGGNFMxVg1hMk,6014
-janito/version.py,sha256=ylfPwGtdY8dEOFJ-DB9gKUQLggqRCvoLxhpnwjzCM94,739
-janito-0.4.0.dist-info/METADATA,sha256=uUCven38ndkbyLrrLw3B42P7AGyijqTGICKRzLJkDDE,4705
-janito-0.4.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-janito-0.4.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
-janito-0.4.0.dist-info/licenses/LICENSE,sha256=xLIUXRPjtsgQml2zD1Pn4LpgiyZ49raw6jZDlO_gZdo,1062
-janito-0.4.0.dist-info/RECORD,,