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

janito/change/applier/workspace_dir.py

@@ -1,58 +0,0 @@
-from pathlib import Path
-from typing import Set, List
-import shutil
-from rich.console import Console
-from janito.config import config
-from ..parser import FileChange, ChangeOperation
-
-def verify_changes(changes: List[FileChange]) -> tuple[bool, str]:
-    """Verify changes can be safely applied to workspace_dir.
-    Returns (is_safe, error_message)."""
-    for change in changes:
-        source_path = config.workspace_dir / change.name
-        
-        if change.operation == ChangeOperation.CREATE_FILE:
-            if source_path.exists():
-                return False, f"Cannot create {change.name} - already exists"
-                
-        elif change.operation in (ChangeOperation.MOVE_FILE, ChangeOperation.RENAME_FILE):
-            if not source_path.exists():
-                return False, f"Cannot {change.operation.name.lower()} non-existent file {change.name}"
-            target_path = config.workspace_dir / change.target
-            if target_path.exists():
-                return False, f"Cannot {change.operation.name.lower()} {change.name} to {change.target} - target already exists"
-
-            
-    return True, ""
-
-def apply_changes(changes: List[FileChange], preview_dir: Path, console: Console) -> bool:
-    """Apply all changes from preview to workspace_dir.
-    Returns success status."""
-    is_safe, error = verify_changes(changes)
-    if not is_safe:
-        console.print(f"[red]Error: {error}[/red]")
-        return False
-
-    console.print("\n[blue]Applying changes to working directory...[/blue]")
-
-    for change in changes:
-        if change.operation == ChangeOperation.REMOVE_FILE:
-            remove_from_workspace_dir(change.name, console)
-        else:
-            filepath = change.target if change.operation == ChangeOperation.RENAME_FILE else change.name
-            target_path = config.workspace_dir / filepath
-            preview_path = preview_dir / filepath
-
-            target_path.parent.mkdir(parents=True, exist_ok=True)
-            if preview_path.exists():
-                shutil.copy2(preview_path, target_path)
-                console.print(f"[dim]Applied changes to {filepath}[/dim]")
-
-    return True
-
-def remove_from_workspace_dir(filepath: Path, console: Console) -> None:
-    """Remove file from working directory"""
-    target_path = config.workspace_dir / filepath
-    if target_path.exists():
-        target_path.unlink()
-        console.print(f"[red]Removed {filepath}[/red]")

janito/change/core.py

@@ -1,124 +0,0 @@
-from pathlib import Path
-from typing import Optional, Tuple, List
-from rich.console import Console
-from rich.prompt import Confirm
-from rich.panel import Panel
-from rich.columns import Columns
-from rich import box
-
-from janito.common import progress_send_message
-from janito.change.history import save_changes_to_history
-from janito.config import config
-from janito.workspace.workset import Workset  # Update import to use Workset directly
-from .viewer import preview_all_changes
-from janito.workspace.analysis import analyze_workspace_content as show_content_stats
-
-from . import (
-    build_change_request_prompt,
-    parse_response,
-    setup_workspace_dir_preview,
-    ChangeApplier
-)
-
-from .analysis import analyze_request
-
-def process_change_request(
-    request: str,
-    preview_only: bool = False,
-    debug: bool = False
-    ) -> Tuple[bool, Optional[Path]]:
-    """
-    Process a change request through the main flow.
-    Return:
-        success: True if the request was processed successfully
-        history_file: Path to the saved history file
-    """
-    console = Console()
-    workset = Workset()  # Create workset instance
-
-    
-    # Analyze workspace content
-    workset.show()
-
-    # Get analysis of the request using workset content
-    analysis = analyze_request(request)
-    if not analysis:
-        console.print("[red]Analysis failed or interrupted[/red]")
-        return False, None
-
-    # Build and send prompt
-    prompt = build_change_request_prompt(request, analysis.format_option_text())
-    response = progress_send_message(prompt)
-    if not response:
-        console.print("[red]Failed to get response from AI[/red]")
-        return False, None
-
-    # Save to history and process response
-    history_file = save_changes_to_history(response, request)
-
-    # Parse changes
-    changes = parse_response(response)
-    if not changes:
-        console.print("[yellow]No changes found in response[/yellow]")
-        return False, None
-
-    # Show request and response info
-    response_info = extract_response_info(response)
-    console.print("\n")
-    console.print(Columns([
-        Panel(request, title="User Request", border_style="cyan", box=box.ROUNDED),
-        Panel(
-            response_info if response_info else "No additional information provided",
-            title="Response Information",
-            border_style="green",
-            box=box.ROUNDED
-        )
-    ], equal=True, expand=True))
-    console.print("\n")
-
-    if preview_only:
-        preview_all_changes(console, changes)
-        return True, history_file
-
-    # Apply changes
-    _, preview_dir = setup_workspace_dir_preview()
-    applier = ChangeApplier(preview_dir, debug=debug)
-
-    success, _ = applier.apply_changes(changes)
-    if success:
-        preview_all_changes(console, changes)
-
-        if not config.auto_apply:
-            apply_changes = Confirm.ask("[cyan]Apply changes to working dir?[/cyan]")
-        else:
-            apply_changes = True
-            console.print("[cyan]Auto-applying changes to working dir...[/cyan]")
-
-        if apply_changes:
-            applier.apply_to_workspace_dir(changes)
-            console.print("[green]Changes applied successfully[/green]")
-        else:
-            console.print("[yellow]Changes were not applied[/yellow]")
-
-    return success, history_file
-
-
-def extract_response_info(response: str) -> str:
-    """Extract information after END_OF_INSTRUCTIONS marker"""
-    if not response:
-        return ""
-
-    # Find the marker
-    marker = "END_INSTRUCTIONS"
-    marker_pos = response.find(marker)
-
-    if marker_pos == -1:
-        return ""
-
-    # Get text after marker, skipping the marker itself
-    info = response[marker_pos + len(marker):].strip()
-
-    # Remove any XML-style tags
-    info = info.replace("<Extra info about what was implemented/changed goes here>", "")
-
-    return info.strip()

janito/change/history.py

@@ -1,44 +0,0 @@
-from pathlib import Path
-from datetime import datetime
-from typing import Optional, Tuple
-from janito.config import config
-
-# Set fixed timestamp when module is loaded
-APP_TIMESTAMP = datetime.now().strftime("%Y%m%d_%H%M%S")
-
-def get_history_path() -> Path:
-    """Create and return the history directory path"""
-    history_dir = config.workspace_dir / '.janito' / 'change_history'
-    history_dir.mkdir(parents=True, exist_ok=True)
-    return history_dir
-
-def determine_history_file_type(filepath: Path) -> str:
-    """Determine the type of saved file based on its name"""
-    name = filepath.name.lower()
-    if '_changes_failed' in name:
-        return 'changes_failed'
-    elif '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) -> Path:
-    """Save change content to history folder with timestamp and request info"""
-    history_dir = get_history_path()
-    
-    # Create history entry with request and changes
-    filename = f"{APP_TIMESTAMP}_changes.txt"
-    history_file = history_dir / filename
-    history_content = f"""Request: {request}
-Timestamp: {APP_TIMESTAMP}
-
-Changes:
-{content}
-"""
-    history_file.write_text(history_content)
-    return history_file

janito/change/operations.py

@@ -1,7 +0,0 @@
-from enum import Enum, auto
-
-class TextOperation(Enum):
-    """Supported text modification operations"""
-    REPLACE = auto()
-    APPEND = auto()
-    DELETE = auto()

janito/change/parser.py

@@ -1,287 +0,0 @@
-import uuid
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import List, Optional
-from rich.console import Console
-from janito.config import config
-from janito.clear_statement_parser.parser import Statement, StatementParser
-
-console = Console(stderr=True)
-
-from .prompts import CHANGE_REQUEST_PROMPT
-
-
-import uuid
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import List, Optional, Dict, Union
-from rich.console import Console
-from enum import Enum, auto
-
-class ChangeOperation(Enum):
-    CREATE_FILE = auto()
-    REPLACE_FILE = auto()
-    RENAME_FILE = auto()
-    REMOVE_FILE = auto()
-    MODIFY_FILE = auto()
-    MOVE_FILE = auto()
-
-@dataclass
-class TextChange:
-    """Represents a search and replace/delete operation"""
-    search_content: Optional[str] = None
-    replace_content: Optional[str] = None
-    reason: Optional[str] = None
-    operation: Optional[str] = None
-
-    @property
-    def is_append(self) -> bool:
-        return self.operation == 'Append'
-
-    @property
-    def is_delete(self) -> bool:
-        return self.operation == 'Delete' or (self.search_content and not self.replace_content)
-    
-    def validate(self) -> bool:
-        """Validate the text change operation"""
-        if not self.search_content and self.replace_content is None:
-            return False
-        return True
-
-@dataclass
-class FileChange:
-    """Represents a file change operation"""
-    operation: ChangeOperation
-    name: Path  # Changed back from path to name
-    target: Optional[Path] = None
-    source: Optional[Path] = None
-    content: Optional[str] = None
-    text_changes: List[TextChange] = field(default_factory=list)
-    original_content: Optional[str] = None
-    reason: Optional[str] = None
-
-    def add_text_changes(self, changes: List[TextChange]):
-        """Add multiple text changes to the existing list"""
-        self.text_changes.extend(changes)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Union[str, Path]]) -> 'FileChange':
-        """Create FileChange instance from dictionary data"""
-        operation = ChangeOperation[data['operation'].upper()]
-        return cls(
-            operation=operation,
-            name=Path(data['name']),  # Changed back to name
-            target=Path(data['target']) if data.get('target') else None,
-            source=Path(data.get('source')) if data.get('source') else None,
-            content=data.get('content'),
-            reason=data.get('reason')
-        )
-
-    def validate_required_parameters(self) -> bool:
-        """Validate the file change operation and raise detailed errors if parameters are missing"""
-        if self.operation == ChangeOperation.RENAME_FILE:
-            if not self.source:
-                raise ValueError(f"Missing 'source' parameter for {self.operation.name}")
-            if not self.target:
-                raise ValueError(f"Missing 'target' parameter for {self.operation.name}")
-                
-        elif self.operation in (ChangeOperation.CREATE_FILE, ChangeOperation.REPLACE_FILE):
-            if not self.content:
-                raise ValueError(f"Missing 'content' parameter for {self.operation.name}")
-                
-        elif self.operation == ChangeOperation.MODIFY_FILE:
-            if not self.text_changes:
-                raise ValueError(f"No closed text changes found for {self.operation.name}")
-                
-        return True
-
-class CommandParser:
-    def __init__(self, debug: bool = False):
-        self.debug = debug
-        self.console = Console(stderr=True)
-        
-    def parse_statements(self, statements: List[Statement]) -> List[FileChange]:
-        """Parse a list of Statement objects into FileChange objects"""
-        if self.debug:
-            self.console.print("[dim]Starting to parse statements...[/dim]")
-            
-        changes = []
-
-        for statement in statements:
-            statement_key = statement.name.upper().replace(' ', '_') 
-            supported_opers = [op.name.title().upper() for op in ChangeOperation]
-            if statement_key not in supported_opers: 
-                raise Exception(f"{statement_key} not in supported statements: {supported_opers}")
-                
-            change = self.convert_statement_to_filechange(statement)
-            if not change:
-                raise Exception(f"Invalid change found: {statement.name}")
-            if not change.validate_required_parameters():
-                raise Exception(f"Missing required parameters for change: {statement.name}")
-            changes.append(change)
-        return changes
-
-    def convert_statement_to_filechange(self, statement: Statement) -> Optional[FileChange]:
-        """Convert a Statement to a FileChange object"""
-        try:
-            operation = ChangeOperation[statement.name.upper().replace(' ', '_')]
-            change = FileChange(
-                operation=operation,
-                name=Path(statement.parameters.get('name', '')),  # Changed back to name
-                reason=statement.parameters.get('reason')
-            )
-
-            if 'target' in statement.parameters:
-                change.target = Path(statement.parameters['target'])
-            if 'source' in statement.parameters:
-                change.source = Path(statement.parameters['source'])
-                change.name = Path(statement.parameters['source'])  # Changed back to name
-
-            content = statement.parameters.get('content')
-            if content:
-                change.content = self._clean_content(content)
-
-            # Handle multiple Changes blocks - combine all text changes
-            all_text_changes = []
-            for block_name, block_statements in statement.blocks:
-                # Handle both numbered (Changes#1) and unnumbered (Changes) blocks
-                base_name = block_name.split('#')[0]
-                if base_name == 'Changes':
-                    if self.debug:
-                        self.console.print(f"[dim]Processing Changes block: {block_name}[/dim]")
-                    new_changes = self.parse_modifications_from_list(block_statements)
-                    all_text_changes.extend(new_changes)
-
-            if all_text_changes:
-                change.text_changes = all_text_changes
-
-            return change
-        except Exception as e:
-            if self.debug:
-                self.console.print(f"[red]Error converting statement: {e}[/red]")
-            return None
-
-    def parse_modifications_from_list(self, mod_statements: List[Statement]) -> List[TextChange]:
-        """Convert parsed modifications list to TextChange objects"""
-        modifications = []
-
-        for statement in mod_statements:
-            try:
-                if statement.name == 'Replace':
-                    mod = TextChange(
-                        search_content=self._clean_content(statement.parameters.get('search', '')),
-                        replace_content=self._clean_content(statement.parameters.get('with', '')),
-                        reason=statement.parameters.get('reason'),
-                        operation='Replace'
-                    )
-                elif statement.name == 'Delete':
-                    mod = TextChange(
-                        search_content=self._clean_content(statement.parameters.get('search', '')),
-                        reason=statement.parameters.get('reason'),
-                        operation='Delete'
-                    )
-                elif statement.name == 'Append':
-                    mod = TextChange(
-                        search_content='',
-                        replace_content=self._clean_content(statement.parameters.get('content', '')),
-                        reason=statement.parameters.get('reason'),
-                        operation='Append'
-                    )
-                else:
-                    continue
-
-                if mod.validate():
-                    modifications.append(mod)
-            except Exception as e:
-                if self.debug:
-                    self.console.print(f"[red]Error processing modification: {e}[/red]")
-                continue
-
-        return modifications
-
-    @staticmethod
-    def _clean_content(content: str) -> str:
-        """Clean content by removing leading dots and normalizing line endings"""
-        if not content:
-            return ''
-        lines = content.splitlines()
-        cleaned_lines = [line[1:] if line.startswith('.') else line for line in lines]
-        return '\n'.join(cleaned_lines)
-
-def extract_instructions_section(response_text: str) -> Optional[str]:
-    """Extract text between BEGIN_INSTRUCTIONS and END_INSTRUCTIONS markers using exact line matching"""
-    try:
-        lines = response_text.splitlines()
-        start_marker = "BEGIN_INSTRUCTIONS"
-        end_marker = "END_INSTRUCTIONS"
-        
-        # Find exact line matches for markers
-        start_idx = None
-        end_idx = None
-        
-        for i, line in enumerate(lines):
-            line = line.strip()
-            if line == start_marker and start_idx is None:
-                start_idx = i
-                continue
-            if line == end_marker and start_idx is not None:
-                end_idx = i
-                break
-                
-        if start_idx is None or end_idx is None:
-            if config.debug:
-                if start_idx is None:
-                    console.print("[yellow]BEGIN_CHANGES marker not found[/yellow]")
-                else:
-                    console.print("[yellow]END_CHANGES marker not found[/yellow]")
-            return None
-            
-        # Extract lines between markers (exclusive)
-        changes_text = '\n'.join(lines[start_idx + 1:end_idx])
-        if not changes_text.strip():
-            if config.debug:
-                console.print("[yellow]Empty changes section found[/yellow]")
-            return None
-            
-        return changes_text.strip()
-        
-    except Exception as e:
-        console.print(f"[red]Error extracting changes section: {e}[/red]")
-        return None
-
-def parse_response(response_text: str) -> List[FileChange]:
-    """Parse a response string into FileChange objects"""
-    parser = CommandParser()
-    statement_parser = StatementParser()
-
-    # First extract the changes section
-    instructions = extract_instructions_section(response_text)
-    if not instructions:
-        if config.debug:
-            console.print("[yellow]No changes section found in response[/yellow]")
-        return []
-
-    statements = statement_parser.parse(instructions)
-    return parser.parse_statements(statements)
-
-def build_change_request_prompt(
-    option_text: str,
-    request: str,
-) -> str:
-    """Build prompt for change request details
-    
-    Args:
-        option_text: Formatted text describing the selected option
-        request: The original user request
-        files_content_xml: Content of relevant files in XML format
-    
-    Returns:
-        Formatted prompt string
-    """
-    short_uuid = str(uuid.uuid4())[:8]
-    
-    return CHANGE_REQUEST_PROMPT.format(
-        option_text=option_text,
-        request=request,
-        uuid=short_uuid
-    )

janito/change/play.py

@@ -1,54 +0,0 @@
-from pathlib import Path
-from typing import Tuple, Optional
-from rich.console import Console
-from rich.prompt import Confirm
-from .parser import parse_response
-from .preview import setup_workspace_dir_preview
-from .applier.main import ChangeApplier
-from .viewer import preview_all_changes  # Add this import
-from ..config import config  # Add this import
-
-
-def play_saved_changes(history_file: Path) -> Tuple[bool, Optional[Path]]:
-    """
-    Replay changes from a saved history file
-    Returns:
-        success: True if changes were applied successfully
-        history_file: Path to the history file that was played
-    """
-    console = Console()
-
-    if not history_file.exists():
-        console.print(f"[red]History file not found: {history_file}[/red]")
-        return False, None
-
-    content = history_file.read_text()
-    changes = parse_response(content)
-
-    if not changes:
-        console.print("[yellow]No changes found in history file[/yellow]")
-        return False, None
-
-
-    # Create preview directory and apply changes
-    _, preview_dir = setup_workspace_dir_preview()
-    applier = ChangeApplier(preview_dir)
-
-    success, _ = applier.apply_changes(changes, debug=True)
-    if success:
-        preview_all_changes(console, changes)
-
-        if not config.auto_apply:
-            apply_changes = Confirm.ask("[cyan]Apply changes to working dir?[/cyan]", default=False)
-        else:
-            apply_changes = True
-            console.print("[cyan]Auto-applying changes to working dir...[/cyan]")
-
-        if apply_changes:
-            applier.apply_to_workspace_dir(changes)
-            console.print("[green]Changes applied successfully[/green]")
-        else:
-            console.print("[yellow]Changes were not applied[/yellow]")
-            return False, history_file
-
-        return success, history_file

janito/change/preview.py

@@ -1,82 +0,0 @@
-from pathlib import Path
-import shutil
-import tempfile
-from typing import List, Set, Tuple
-from datetime import datetime
-from rich.console import Console
-from rich.panel import Panel
-
-from janito.config import config
-
-def create_backup() -> Path:
-    """Create backup directory and restore script.
-    Returns the path to the backup directory."""
-    backup_dir = config.workspace_dir / '.janito' / 'backups' / datetime.now().strftime('%Y%m%d_%H%M%S')
-    backup_dir.parent.mkdir(parents=True, exist_ok=True)
-
-    # Copy existing files to backup directory
-    if config.workspace_dir.exists():
-        shutil.copytree(config.workspace_dir, backup_dir, ignore=shutil.ignore_patterns('.janito', '.git'))
-        
-        # Create restore script
-        restore_script = config.workspace_dir / '.janito' / 'restore.sh'
-        restore_script.parent.mkdir(parents=True, exist_ok=True)
-        script_content = f"""#!/bin/bash
-# Restore script generated by Janito
-# Restores files from backup created at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
-# Exit on error
-set -e
-
-# Get backup directory from argument or use latest
-BACKUP_DIR="$1"
-if [ -z "$BACKUP_DIR" ]; then
-    BACKUP_DIR="{backup_dir}"
-    echo "No backup directory specified, using latest: $BACKUP_DIR"
-fi
-
-# Show usage if --help is provided
-if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-    echo "Usage: $0 [backup_directory]"
-    echo ""
-    echo "If no backup directory is provided, uses the latest backup at:"
-    echo "{backup_dir}"
-    exit 0
-fi
-
-# Check if backup directory exists
-if [ ! -d "$BACKUP_DIR" ]; then
-    echo "Error: Backup directory not found at $BACKUP_DIR"
-    exit 1
-fi
-
-# Restore files from backup
-echo "Restoring files from backup..."
-cp -r "$BACKUP_DIR"/* "{config.workspace_dir}/"
-
-echo "Files restored successfully from $BACKUP_DIR"
-"""
-        restore_script.write_text(script_content)
-        restore_script.chmod(0o755)
-
-    return backup_dir
-
-def setup_preview_directory() -> Path:
-    """Creates and sets up preview directory with working directory contents.
-    Returns the path to the preview directory."""
-    preview_dir = Path(tempfile.mkdtemp())
-    
-    # Copy existing files to preview directory if workspace_dir exists
-    if config.workspace_dir.exists():
-        shutil.copytree(config.workspace_dir, preview_dir, dirs_exist_ok=True, 
-                       ignore=shutil.ignore_patterns('.janito', '.git'))
-        
-    return preview_dir
-
-def setup_workspace_dir_preview() -> tuple[Path, Path]:
-    """Sets up both backup and preview directories.
-    Returns (backup_dir, preview_dir) tuple."""
-    backup_dir = create_backup()
-    preview_dir = setup_preview_directory()
-    return backup_dir, preview_dir
-