janito 0.1.0__py3-none-any.whl

janito/workspace.py

@@ -0,0 +1,169 @@
+from pathlib import Path
+from typing import List, Dict
+
+class Workspace:
+    def __init__(self, base_path: Path = None):
+        self.base_path = base_path or Path().absolute()
+        self.default_exclude = [".janito", "__pycache__", ".git", ".janito/history"]  # Added .janito/history
+        self.default_patterns = ["*.py", "*.txt", "*.md", "*.toml", "**/.gitignore"]
+        self.history_file = self.base_path / ".janito" / "history"
+        # Create .janito directory if it doesn't exist
+        (self.base_path / ".janito").mkdir(exist_ok=True)
+
+    def generate_file_structure(self, pattern: str = None, exclude_patterns: List[str] = None) -> Dict:
+        """Generate a tree structure of files in the workspace directory."""
+        exclude_patterns = exclude_patterns or self.default_exclude
+        patterns = [pattern] if pattern else self.default_patterns
+        
+        tree = {}
+        try:
+            base_path = self.base_path.resolve()
+            
+            for pattern in patterns:
+                for file in sorted(base_path.rglob(pattern)):
+                    try:
+                        import fnmatch
+
+                        if any(fnmatch.fnmatch(str(file), pat) for pat in exclude_patterns):
+                            continue
+                        
+                        try:
+                            file.relative_to(base_path)
+                        except ValueError:
+                            continue
+                        
+                        rel_path = file.relative_to(base_path)
+                        current = tree
+                        
+                        for part in rel_path.parts[:-1]:
+                            if part not in current:
+                                current[part] = {}
+                            current = current[part]
+                        current[rel_path.parts[-1]] = None
+                        
+                    except Exception as e:
+                        print(f"Error processing file {file}: {e}")
+                        continue
+                
+        except Exception as e:
+            print(f"Error generating file structure: {e}")
+            return {}
+            
+        return tree
+
+    def get_files_content(self, exclude_patterns: List[str] = None) -> str:
+        """Get content of files in workspace directory in XML format"""
+        content = ['<workspaceFiles>']
+        exclude_patterns = exclude_patterns or self.default_exclude
+        base_path = self.base_path.resolve()
+        
+        for pattern in self.default_patterns:
+            for file in sorted(base_path.rglob(pattern)):
+                if any(pat in str(file) for pat in exclude_patterns):
+                    continue
+                
+                try:
+                    rel_path = file.relative_to(base_path)
+                    content.append(f'  <file path="{rel_path}">')
+                    content.append('    <content>')
+                    content.append(file.read_text())  # Remove .strip() to preserve original content
+                    content.append('    </content>')
+                    content.append('  </file>')
+                except ValueError:
+                    continue
+                    
+        content.append('</workspaceFiles>')
+        return "\n".join(content)
+
+    def format_tree(self, tree: Dict, prefix: str = "", is_last: bool = True) -> List[str]:
+        """Format a tree dictionary into a list of strings showing the structure."""
+        lines = []
+        
+        if not tree:
+            return lines
+            
+        for i, (name, subtree) in enumerate(tree.items()):
+            is_last_item = i == len(tree) - 1
+            connector = "└── " if is_last_item else "├── "
+            
+            if subtree is None:  # File
+                lines.append(f"{prefix}{connector}{name}")
+            else:  # Directory
+                lines.append(f"{prefix}{connector}{name}/")
+                next_prefix = prefix + ("    " if is_last_item else "│   ")
+                lines.extend(self.format_tree(subtree, next_prefix))
+                
+        return lines
+
+    def get_workspace_status(self) -> str:
+        """Get a formatted string of the workspace structure"""
+        tree = self.generate_file_structure()
+        if not tree:
+            return "No files found in the current workspace."
+        tree_lines = self.format_tree(tree)
+        return "Files in workspace:\n" + "\n".join(tree_lines)
+
+    def get_excluded_files(self) -> List[str]:
+        """Get a list of files and directories that are excluded from the workspace"""
+        exclude_patterns = self.default_exclude
+        gitignore_paths = list(self.base_path.rglob(".gitignore"))
+        for p in gitignore_paths:
+            with open(p) as f:
+                ignore_patterns = [line.strip() for line in f if line.strip() and not line.strip().startswith("#")]
+            exclude_patterns.extend(ignore_patterns)
+        
+        excluded_files = []
+        base_path = self.base_path.resolve()
+        
+        for file in base_path.rglob('*'):
+            if any(fnmatch.fnmatch(str(file), pat) for pat in exclude_patterns):
+                try:
+                    rel_path = file.relative_to(base_path)
+                    excluded_files.append(str(rel_path))
+                except ValueError:
+                    continue
+        
+        return excluded_files
+
+    def print_excluded_files(self):
+        """Print files and patterns excluded from workspace"""
+        excluded_files = self.get_excluded_files()
+        if not excluded_files:
+            self.console.print("No excluded files or directories found.")
+            return
+        
+        self.console.print("\nExcluded files and directories:")
+        for path in excluded_files:
+            self.console.print(f"  {path}")
+
+    def calculate_stats(self) -> Dict[str, int]:
+        """Calculate statistics about the current directory contents."""
+        stats = {
+            "total_files": 0,
+            "total_dirs": 0,
+            "total_size": 0
+        }
+        for path in self.base_path.rglob('*'):
+            if path.is_file():
+                stats["total_files"] += 1
+                stats["total_size"] += path.stat().st_size
+            elif path.is_dir():
+                stats["total_dirs"] += 1
+        return stats
+
+
+    def print_workspace_structure(self):
+        """Print the workspace structure with statistics"""
+        stats = self.calculate_stats()
+        tree = self.generate_file_structure()
+        if not tree:
+            print("No files found in the current workspace.")
+            return
+        tree_lines = self.format_tree(tree)
+        print("Workspace structure:")
+        print("=" * 80)
+        print(f"Total files: {stats['total_files']}")
+        print(f"Total directories: {stats['total_dirs']}")
+        print(f"Total size: {stats['total_size']} bytes")
+        print("=" * 80)
+        print("\n".join(tree_lines))

janito/xmlchangeparser.py

@@ -0,0 +1,202 @@
+from typing import List
+from pathlib import Path
+import re
+from dataclasses import dataclass
+from rich.console import Console
+
+@dataclass
+class XMLBlock:
+    """Simple container for parsed XML blocks"""
+    description: str = ""
+    old_content: List[str] = None
+    new_content: List[str] = None
+    
+    def __post_init__(self):
+        if self.old_content is None:
+            self.old_content = []
+        if self.new_content is None:
+            self.new_content = []
+
+@dataclass
+class XMLChange:
+    """Simple container for parsed XML changes"""
+    path: Path
+    operation: str
+    blocks: List[XMLBlock] = None
+    content: str = ""
+
+    def __post_init__(self):
+        if self.blocks is None:
+            self.blocks = []
+
+class XMLChangeParser:
+    """XML parser for file changes"""
+    def __init__(self):
+        self.console = Console()
+        self.current_operation = None
+        self.has_invalid_tags = False  # Track invalid tag occurrences
+
+    def _validate_tag_format(self, line: str) -> bool:
+        """Validate that a line contains only a single XML tag and nothing else"""
+        stripped = line.strip()
+        if not stripped:
+            return True
+        if stripped.startswith('<?xml'):
+            return True
+            
+        # Allow empty content tags in one line
+        if stripped in ('<oldContent></oldContent>', '<newContent></newContent>'):
+            return True
+            
+        # Check if line contains exactly one XML tag and nothing else
+        return bool(re.match(r'^\s*<[^>]+>\s*$', line))
+
+    def _validate_path(self, path_str: str) -> bool:
+        """Validate that path is relative and does not try to escape workspace"""
+        try:
+            path = Path(path_str)
+            # Check if path is absolute
+            if path.is_absolute():
+                self.console.print(f"[red]Error: Path must be relative: {path_str}[/]")
+                return False
+            # Check for path traversal attempts
+            if '..' in path.parts:
+                self.console.print(f"[red]Error: Path cannot contain '..': {path_str}[/]")
+                return False
+            return True
+        except Exception:
+            self.console.print(f"[red]Error: Invalid path format: {path_str}[/]")
+            return False
+
+    def parse_response(self, response: str) -> List[XMLChange]:
+        """Parse XML response according to format specification:
+        <fileChanges>
+            <change path="file.py" operation="create|modify">
+                <block description="Description of changes">
+                    <oldContent>
+                        // Exact content to be replaced (empty for create/append)
+                        // Must match existing indentation exactly
+                    </oldContent>
+                    <newContent>
+                        // New content to replace the old content
+                        // Must include desired indentation
+                    </newContent>
+                </block>
+            </change>
+        </fileChanges>
+        """
+        changes = []
+        current_change = None
+        current_block = None
+        current_section = None
+        content_buffer = []
+        in_content = False
+        self.current_operation = None
+        self.has_invalid_tags = False  # Reset at start of parsing
+        
+        try:
+            lines = response.splitlines()
+            for i, line in enumerate(lines):
+                stripped = line.strip()
+                
+                # Update operation tracking when encountering a change tag
+                if match := re.match(r'<change\s+path="([^"]+)"\s+operation="([^"]+)">', stripped):
+                    _, operation = match.groups()
+                    self.current_operation = operation
+                    self.has_invalid_tags = False  # Reset for new change
+
+                # Reset operation on change end
+                elif stripped == '</change>':
+                    if current_change and not self.has_invalid_tags:
+                        changes.append(current_change)
+                    current_change = None
+                    self.current_operation = None
+                    continue
+
+                # Validate tag format
+                if not self._validate_tag_format(line) and not in_content:
+                    self.console.print(f"[red]Invalid tag format at line {i+1}: {line}[/]")
+                    self.has_invalid_tags = True
+                    continue
+
+                if not stripped and not in_content:
+                    continue
+
+                if stripped.startswith('<fileChanges>'):
+                    continue
+                elif stripped.startswith('</fileChanges>'):
+                    break
+                    
+                elif match := re.match(r'<change\s+path="([^"]+)"\s+operation="([^"]+)">', stripped):
+                    path, operation = match.groups()
+                    # Validate path before creating change object
+                    if not self._validate_path(path):
+                        self.has_invalid_tags = True
+                        continue
+                    if operation not in ('create', 'modify'):
+                        self.console.print(f"[red]Invalid operation '{operation}' - skipping change[/]")
+                        continue
+                    current_change = XMLChange(Path(path), operation)
+                    current_block = None
+                elif stripped == '</change>':
+                    if current_change:
+                        changes.append(current_change)
+                        current_change = None
+                    continue
+
+                elif match := re.match(r'<block\s+description="([^"]+)">', stripped):
+                    if current_change:
+                        current_block = XMLBlock(description=match.group(1))
+                elif stripped == '</block>':
+                    if current_change and current_block:
+                        current_change.blocks.append(current_block)
+                        current_block = None
+                    continue
+
+                elif stripped in ('<oldContent>', '<newContent>'):
+                    if current_block:
+                        current_section = 'old' if 'old' in stripped else 'new'
+                        content_buffer = []
+                        in_content = True
+                elif stripped in ('</oldContent>', '</newContent>'):
+                    if current_block and in_content:
+                        # Find the common indentation of non-empty lines
+                        non_empty_lines = [line for line in content_buffer if line.strip()]
+                        if non_empty_lines:
+                            # Find minimal indent by looking at first real line
+                            first_line = next(line for line in content_buffer if line.strip())
+                            indent = len(first_line) - len(first_line.lstrip())
+                            # Remove only the common indentation from XML
+                            content = []
+                            for line in content_buffer:
+                                if line.strip():
+                                    # Remove only the XML indentation
+                                    content.append(line[indent:])
+                                elif content:  # Keep empty lines only if we have previous content
+                                    content.append('')
+                        else:
+                            content = []
+
+                        if current_section == 'old':
+                            current_block.old_content = content
+                        else:
+                            current_block.new_content = content
+                        in_content = False
+                        current_section = None
+                    continue
+                
+                elif in_content:
+                    # Store lines with their original indentation
+                    content_buffer.append(line)
+                elif current_change and not current_block and not stripped.startswith('<'):
+                    if stripped:
+                        current_change.content += line + '\n'
+
+            return [c for c in changes if not self.has_invalid_tags]
+            
+        except Exception as e:
+            self.console.print(f"[red]Error parsing XML: {str(e)}[/]")
+            self.console.print(f"[red]Error occurred at line {i + 1}:[/]")
+            self.console.print("\nOriginal response:")
+            self.console.print(response)
+            return []

janito-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

janito-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: janito
+Version: 0.1.0
+Summary: Language-Driven Software Development Assistant powered by Claude AI
+Home-page: https://github.com/joaompinto/janito
+Author: João M. Pinto
+Author-email: "João M. Pinto" <lamego.pinto@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/joaompinto/janito
+Project-URL: Documentation, https://github.com/joaompinto/janito#readme
+Project-URL: Repository, https://github.com/joaompinto/janito.git
+Keywords: ai,development,claude,assistant,code
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic
+Requires-Dist: prompt_toolkit
+Requires-Dist: rich
+Requires-Dist: typer
+Requires-Dist: watchdog
+Requires-Dist: pytest
+
+
+Janito is an open source Language-Driven Software Development Assistant powered by Claude AI. It helps developers understand, modify, and improve their Python code through natural language interaction.
+
+## Features
+
+- Natural language code interactions
+- File system monitoring and auto-restart
+- Interactive command-line interface 
+- Workspace management and visualization
+- History and session management
+- Debug mode for troubleshooting
+- Syntax error detection and fixing
+- Python file execution
+- File editing with system editor
+
+## Installation
+
+```bash
+# Install package
+pip install janito
+```
+
+## Usage
+
+Start Janito in your project directory:
+
+```bash
+python -m janito
+```
+
+Or launch with options:
+
+```bash 
+python -m janito --debug  # Enable debug mode
+python -m janito --no-watch  # Disable file watching
+```
+
+### Commands
+
+- `.help` - Show help information 
+- `.exit` - Exit the console
+- `.clear` - Clear console output
+- `.debug` - Toggle debug mode  
+- `.workspace` - Show workspace structure
+- `.last` - Show last Claude response
+- `.show <file>` - Show file content with syntax highlighting
+- `.check` - Check workspace Python files for syntax errors
+- `.p <file>` - Run a Python file
+- `.python <file>` - Run a Python file (alias for .p)
+- `.edit <file>` - Open file in system editor
+
+### Input Formats
+
+- `!request` - Request file changes (e.g. '!add logging to utils.py')  
+- `request?` - Get information and analysis without changes
+- `request` - General discussion and queries
+- `$command` - Execute shell commands
+
+## Configuration
+
+Requires an Anthropic API key set via environment variable:
+
+```bash
+export ANTHROPIC_API_KEY='your_api_key_here'
+```
+
+## Development
+
+The package consists of several modules:
+
+- `janito.py` - Core functionality and CLI interface
+- `change.py` - File modification and change tracking 
+- `claude.py` - Claude API interaction
+- `console.py` - Interactive console and command handling
+- `commands.py` - Command implementations
+- `prompts.py` - Prompt templates and builders
+- `watcher.py` - File system monitoring
+- `workspace.py` - Workspace analysis and management
+- `xmlchangeparser.py` - XML parser for file changes
+- `watcher.py` - File system monitoring
+
+## License
+
+MIT License

janito-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+janito/__init__.py,sha256=y6hOI0whYLZTk73Uoq-dxcCGKdPmAH9Fa5ywXV4CIaM,87
+janito/__main__.py,sha256=e_8IHo0JtPt8lgS43UTUzkaIu47SZ8PjhOomNqrt6Q4,173
+janito/change.py,sha256=4GueUiqKx6fqzmwaxTyj9n-rifyc54IUdoxmJHxnnBc,17898
+janito/claude.py,sha256=KFyhAqRKY0iUMiuazlpvPlR6uufJCkkxZx_Jxeqdu1w,4294
+janito/commands.py,sha256=CqP0oOA9Rl6siQT0mNo3jeB7ubZwSCxsmXLTA0ostAM,15305
+janito/console.py,sha256=-SqCPFBt-7gqROCWlkGUcmOAJGC1_YnS5cuwXZITHAk,14909
+janito/janito.py,sha256=bgddRXQNQj28scRYNhXPeA3T3Jh84A9EOZApZ_OD0us,13311
+janito/prompts.py,sha256=4TkFnam7Ya8sBUQ9k5iAt72Ca7-k9KPmKjaqilfCX6U,5879
+janito/watcher.py,sha256=8icD9XnHnYpy_XI_i5Dg6tHpw27ecJie2ZqpEo66COY,3363
+janito/workspace.py,sha256=do66QRQ2VIpMofJuyVUyS_Gp5WMDG-5XoNYm270Zv0s,6979
+janito/xmlchangeparser.py,sha256=kfMa9AntsPBhG_R2NHFU3DZsaRh5BXRREZCnCfR1SDs,8576
+tests/__init__.py,sha256=EjWgRAmKaumanB8t00SWGaTu2b7AuZNDiMxqYoAhVJI,26
+tests/conftest.py,sha256=_8lI6aTT2s1A14ggojPW-bI0imOj1JmXwdR1_2BPuCw,185
+tests/test_change.py,sha256=wqufymSOo4ypMorMpQk9oyJYeYgO6Zn1H2GhU1Wx2ls,12482
+janito-0.1.0.dist-info/LICENSE,sha256=pAZXnNE2dxxwXFIduGyn1gpvPefJtUYOYZOi3yeGG94,1068
+janito-0.1.0.dist-info/METADATA,sha256=ROEPyzYWR3q8ibD4bpLGQGTyQBGEkpRx0IyKxVFHfc0,2979
+janito-0.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+janito-0.1.0.dist-info/top_level.txt,sha256=b9vGz4twQlT5Sx2aD5wtd9NbXg3N40FjXgGRpcbKGVQ,13
+janito-0.1.0.dist-info/RECORD,,

janito-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

janito-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+janito
+tests

tests/__init__.py

@@ -0,0 +1,4 @@
+
+"""
+Janito test suite
+"""

tests/conftest.py

@@ -0,0 +1,9 @@
+
+import pytest
+import os
+import sys
+from pathlib import Path
+
+# Add the project root to the Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))