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

janito/cli/handlers/request.py

@@ -1,24 +0,0 @@
-from pathlib import Path
-from rich.console import Console
-from janito.config import config
-from janito.workspace import is_dir_empty
-from janito.change.core import process_change_request
-from ..base import BaseCLIHandler
-
-class RequestHandler(BaseCLIHandler):
-    def handle(self, request: str, preview_only: bool = False):
-        """Process a modification request"""
-        is_empty = is_dir_empty(config.workspace_dir)
-        if is_empty and not config.include:
-            self.console.print("\n[bold blue]Empty directory - will create new files as needed[/bold blue]")
-
-        success, history_file = process_change_request(request, preview_only)
-
-        if success and history_file and config.verbose:
-            try:
-                rel_path = history_file.relative_to(config.workspace_dir)
-                self.console.print(f"\nChanges saved to: ./{rel_path}")
-            except ValueError:
-                self.console.print(f"\nChanges saved to: {history_file}")
-        elif not success:
-            self.console.print("[red]Failed to process change request[/red]")

janito/cli/handlers/scan.py

@@ -1,9 +0,0 @@
-from pathlib import Path
-from typing import List
-from janito.workspace import preview_scan
-from ..base import BaseCLIHandler
-
-class ScanHandler(BaseCLIHandler):
-    def handle(self, paths_to_scan: List[Path]):
-        """Preview files that would be analyzed"""
-        preview_scan(paths_to_scan)

janito/cli/history.py

@@ -1,61 +0,0 @@
-from pathlib import Path
-from datetime import datetime, timezone
-from typing import List
-from rich.console import Console
-from rich.table import Table
-from janito.config import config
-
-def get_history_path() -> Path:
-    """Get the path to the history directory"""
-    history_dir = config.workspace_dir / '.janito' / 'history'
-    history_dir.mkdir(parents=True, exist_ok=True)
-    return history_dir
-
-def save_to_history(request: str, response: str) -> None:
-    """Save a request and its response to the history file"""
-    history_dir = get_history_path()
-    timestamp = datetime.now(timezone.utc).strftime('%Y-%m-%d_%H%M%S')
-    history_file = history_dir / f"{timestamp}_request.txt"
-
-    content = f"""Request: {request}
-Timestamp: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}
-
-Response:
-{response}
-"""
-    history_file.write_text(content)
-
-def display_history() -> None:
-    """Display the history of requests"""
-    console = Console()
-    history_dir = get_history_path()
-
-    if not history_dir.exists():
-        console.print("[yellow]No history found[/yellow]")
-        return
-
-    table = Table(title="Request History")
-    table.add_column("Timestamp", style="cyan")
-    table.add_column("Request", style="white")
-    table.add_column("File", style="dim")
-
-    history_files = sorted(history_dir.glob("*_request.txt"), reverse=True)
-
-    if not history_files:
-        console.print("[yellow]No history found[/yellow]")
-        return
-
-    for history_file in history_files:
-        try:
-            content = history_file.read_text()
-            request_line = next(line for line in content.splitlines() if line.startswith("Request:"))
-            timestamp_line = next(line for line in content.splitlines() if line.startswith("Timestamp:"))
-
-            request = request_line.replace("Request:", "").strip()
-            timestamp = timestamp_line.replace("Timestamp:", "").strip()
-
-            table.add_row(timestamp, request, history_file.name)
-        except Exception as e:
-            console.print(f"[red]Error reading {history_file}: {e}[/red]")
-
-    console.print(table)

janito/cli/registry.py

@@ -1,26 +0,0 @@
-from typing import Callable, Dict
-from dataclasses import dataclass
-
-@dataclass
-class Command:
-    name: str
-    handler: Callable
-    help_text: str
-
-class CommandRegistry:
-    def __init__(self):
-        self._commands: Dict[str, Command] = {}
-        
-    def register(self, name: str, help_text: str):
-        def decorator(handler: Callable):
-            self._commands[name] = Command(name, handler, help_text)
-            return handler
-        return decorator
-        
-    def get_command(self, name: str) -> Command:
-        return self._commands.get(name)
-        
-    def get_all_commands(self) -> Dict[str, Command]:
-        return self._commands
-
-registry = CommandRegistry()

janito/demo/__init__.py

@@ -1,4 +0,0 @@
-from .runner import DemoRunner
-from .scenarios import DemoScenario
-
-__all__ = ['DemoRunner', 'DemoScenario']

janito/demo/data.py

@@ -1,13 +0,0 @@
-from typing import Dict, List
-from .scenarios import DemoScenario
-from .mock_data import get_mock_changes
-
-def get_demo_scenarios() -> List[DemoScenario]:
-    """Get list of predefined demo scenarios"""
-    return [
-        DemoScenario(
-            name="File Operations Demo",
-            description="Demonstrate various file operations with change viewer",
-            changes=get_mock_changes()
-        )
-    ]

janito/demo/mock_data.py

@@ -1,20 +0,0 @@
-from typing import List
-from .operations import CreateOperation, ModifyOperation, RemoveOperation, MockOperation
-
-def get_mock_changes() -> List[MockOperation]:
-    """Get predefined mock changes for demo"""
-    return [
-        CreateOperation(
-            name="example/hello.py",
-            content="def greet():\n    print('Hello, World!')\n"
-        ),
-        ModifyOperation(
-            name="example/utils.py",
-            content="def process():\n    return 'Processed'\n",
-            original_content="def old_process():\n    return 'Old'\n"
-        ),
-        RemoveOperation(
-            name="example/obsolete.py",
-            original_content="# Obsolete code\n"
-        )
-    ]

janito/demo/operations.py

@@ -1,45 +0,0 @@
-from dataclasses import dataclass
-from typing import List, Optional
-from enum import Enum, auto
-from pathlib import Path
-
-class MockOperationType(Enum):
-    CREATE = auto()
-    MODIFY = auto()
-    REMOVE = auto()
-
-@dataclass
-class MockOperation:
-    """Base class for mock operations"""
-    operation_type: MockOperationType
-    name: str
-    reason: str
-
-@dataclass
-class CreateOperation(MockOperation):
-    """Operation for creating new files"""
-    content: str
-
-    def __init__(self, name: str, content: str, reason: str = "Create new file"):
-        super().__init__(MockOperationType.CREATE, name, reason)
-        self.content = content
-
-@dataclass
-class ModifyOperation(MockOperation):
-    """Operation for modifying existing files"""
-    content: str
-    original_content: str
-
-    def __init__(self, name: str, content: str, original_content: str, reason: str = "Modify existing file"):
-        super().__init__(MockOperationType.MODIFY, name, reason)
-        self.content = content
-        self.original_content = original_content
-
-@dataclass
-class RemoveOperation(MockOperation):
-    """Operation for removing files"""
-    original_content: Optional[str] = None
-
-    def __init__(self, name: str, original_content: Optional[str] = None, reason: str = "Remove file"):
-        super().__init__(MockOperationType.REMOVE, name, reason)
-        self.original_content = original_content

janito/demo/runner.py

@@ -1,59 +0,0 @@
-from typing import List, Optional
-from pathlib import Path
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from .scenarios import DemoScenario
-from .operations import MockOperationType
-from ..change.viewer import preview_all_changes
-from ..change.parser import FileChange, ChangeOperation
-
-class DemoRunner:
-    def __init__(self):
-        self.console = Console()
-        self.scenarios: List[DemoScenario] = []
-
-    def add_scenario(self, scenario: DemoScenario) -> None:
-        """Add a demo scenario to the runner"""
-        self.scenarios.append(scenario)
-
-    def run_all(self) -> None:
-        """Run all registered demo scenarios"""
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            console=self.console
-        ) as progress:
-            for scenario in self.scenarios:
-                task = progress.add_task(f"Running scenario: {scenario.name}")
-                self.preview_changes(scenario)
-                progress.update(task, completed=True)
-
-    def preview_changes(self, scenario: Optional[DemoScenario] = None) -> None:
-        """Preview changes for a scenario using change viewer"""
-        if scenario is None:
-            if not self.scenarios:
-                self.console.print("[yellow]No scenarios to preview[/yellow]")
-                return
-            scenario = self.scenarios[0]
-
-        # Convert mock changes to FileChange objects
-        changes = []
-        for mock in scenario.changes:
-            # Map mock operation type to ChangeOperation
-            operation_map = {
-                MockOperationType.CREATE: ChangeOperation.CREATE_FILE,
-                MockOperationType.MODIFY: ChangeOperation.MODIFY_FILE,
-                MockOperationType.REMOVE: ChangeOperation.REMOVE_FILE
-            }
-            operation = operation_map[mock.operation_type]
-            change = FileChange(
-                operation=operation,
-                name=Path(mock.name),
-                content=mock.content if hasattr(mock, 'content') else None,
-                original_content=mock.original_content if hasattr(mock, 'original_content') else None
-            )
-            changes.append(change)
-
-        # Show changes using change viewer
-        preview_all_changes(self.console, changes)

janito/demo/scenarios.py

@@ -1,32 +0,0 @@
-from dataclasses import dataclass
-from typing import List, Dict, Optional
-from rich.text import Text
-from pathlib import Path
-from .operations import MockOperation
-from .mock_data import get_mock_changes
-
-@dataclass
-class DemoScenario:
-    name: str
-    description: str
-    changes: List[MockOperation]
-
-    def get_preview(self) -> Text:
-        """Get a preview of the changes"""
-        text = Text()
-        text.append(f"Description: {self.description}\n\n", style="cyan")
-
-        # Group changes by operation
-        by_operation = {}
-        for change in self.changes:
-            if change.operation not in by_operation:
-                by_operation[change.operation] = []
-            by_operation[change.operation].append(change)
-
-        # Show changes grouped by operation
-        for operation_type, changes in by_operation.items():
-            text.append(f"\n{operation_type.name.title()} Operations:\n", style="yellow")
-            for change in changes:
-                text.append(f"• {change.name}\n", style="white")
-
-        return text

janito/prompts.py

@@ -1,2 +0,0 @@
-# Core system prompt focused on role and purpose
-SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. I help you with coding tasks while being clear and concise in my responses."""

janito/review.py

@@ -1,13 +0,0 @@
-from rich.console import Console
-from rich.markdown import Markdown
-from janito.common import progress_send_message
-from janito.agents import AIAgent
-
-def review_text(text: str, raw: bool = False) -> None:
-    """Review the provided text using Claude"""
-    console = Console()
-    response = progress_send_message(f"Please review this text and provide feedback:\n\n{text}")
-    if raw:
-        console.print(response)
-    else:
-        console.print(Markdown(response))

janito/search_replace/README.md

@@ -1,146 +0,0 @@
-# Search/Replace Module
-
-A smart search and replace module that handles code indentation and provides debugging capabilities for failed searches.
-
-## Usage
-
-### As a Module
-
-```python
-from janito.search_replace import SearchReplacer
-
-# Basic search/replace
-source_code = """
-def hello():
-    print("Hello")
-    print("World")
-"""
-
-search = """    print("Hello")
-    print("World")"""
-
-replacement = """    print("Hi")
-    print("Universe")"""
-
-replacer = SearchReplacer(source_code, search, replacement)
-modified = replacer.replace()
-```
-
-### Command Line Debugging
-
-When a search fails, a debug file is automatically created in `.janito/change_history/`. You can debug these files using:
-
-```bash
-python -m janito.search_replace <debug_file>
-```
-
-Example debug file format:
-```
-Test: Failed search in example.py
-========================================
-Original:
-def hello():
-    print("Hello")
-    print("World")
-========================================
-Search pattern:
-    print("Hi")
-    print("World")
-========================================
-```
-
-## Features
-
-- Indentation-aware searching
-- Multiple search strategies:
-  - ExactMatch: Matches content with exact indentation
-  - ExactContent: Matches content ignoring indentation
-  - IndentAware: Matches preserving relative indentation
-- Debug mode with detailed indentation analysis
-- File extension specific behavior
-- Automatic debug file generation for failed searches
-
-## Search Strategies
-
-The module uses multiple search strategies in a fallback chain to find the best match:
-
-### ExactMatch Strategy
-- Matches content exactly, including all whitespace and indentation
-- Strictest matching strategy
-- Example:
-  ```python
-  # Pattern:
-      def hello():
-          print("Hi")
-  
-  # Will only match exact indentation:
-      def hello():
-          print("Hi")
-  ```
-
-### IndentAware Strategy
-- Preserves relative indentation between lines
-- Allows different base indentation levels
-- Example:
-  ```python
-  # Pattern:
-      print("Hello")
-      print("World")
-  
-  # Matches with different base indentation:
-  def test():
-      print("Hello")
-      print("World")
-  
-  def other():
-          print("Hello")
-          print("World")
-  ```
-
-### ExactContent Strategy
-- Ignores all indentation
-- Matches content after stripping whitespace
-- Most flexible strategy
-- Example:
-  ```python
-  # Pattern:
-  print("Hello")
-      print("World")
-  
-  # Matches regardless of indentation:
-        print("Hello")
-    print("World")
-  ```
-
-### ExactContentNoComments Strategy
-- Ignores indentation, comments, and empty lines
-- Most flexible strategy
-- Example:
-  ```python
-  # Pattern:
-  print("Hello")  # greeting
-  
-  print("World")  # message
-
-  # Matches:
-  def test():
-        print("Hello")   # different comment
-        # some comment
-        print("World")
-  ```
-
-### Strategy Selection
-- Strategies are tried in order: ExactMatch → IndentAware → ExactContent → ExactContentNoComments
-- File extension specific behavior:
-  - Python files (.py): All strategies
-  - Java files (.java): All strategies
-  - JavaScript/TypeScript (.js/.ts): All strategies
-  - Other files: ExactMatch, ExactContent, and ExactContentNoComments
-
-## Debug Output
-
-When debugging failed searches, the module provides:
-- Visual whitespace markers (· for spaces, → for tabs)
-- Indentation analysis
-- Line-by-line matching attempts
-- Strategy selection information

janito/search_replace/__init__.py

@@ -1,6 +0,0 @@
-from .core import SearchReplacer, PatternNotFoundException
-from .searcher import Searcher
-from .replacer import Replacer
-from .parser import parse_test_file
-
-__all__ = ['SearchReplacer', 'PatternNotFoundException', 'Searcher', 'Replacer', 'parse_test_file']

janito/search_replace/__main__.py

@@ -1,21 +0,0 @@
-"""Main entry point for search/replace module."""
-
-from pathlib import Path
-import sys
-import argparse
-from .play import play_file
-
-def main():
-    parser = argparse.ArgumentParser(description="Debug search/replace patterns")
-    parser.add_argument('file', type=Path, help='Test file to analyze')
-    
-    args = parser.parse_args()
-    
-    if not args.file.exists():
-        print(f"Error: Test file not found: {args.file}")
-        sys.exit(1)
-        
-    play_file(args.file)
-
-if __name__ == "__main__":
-    main()

janito/search_replace/core.py

@@ -1,119 +0,0 @@
-from typing import Optional, List
-from pathlib import Path
-from .searcher import Searcher
-from .replacer import Replacer
-
-class PatternNotFoundException(Exception):
-    """Raised when the search pattern is not found in the source code."""
-    pass
-
-class SearchReplacer:
-    """Handles indentation-aware search and replace operations on Python source code."""
-
-    def __init__(self, source_code: str, search_pattern: str, replacement: Optional[str] = None, 
-                 file_ext: Optional[str] = None, debug: bool = False):
-        """Initialize with source code and patterns."""
-        self.source_code = source_code.rstrip()
-        self.search_pattern = search_pattern.rstrip()
-        self.replacement = replacement.rstrip() if replacement else None
-        self.file_ext = file_ext.lower() if file_ext else None
-        self.pattern_found = False
-        self.searcher = Searcher(debug=debug)
-        self.replacer = Replacer(debug=debug)
-
-        # Initialize pattern base indent
-        first_line, _ = self.searcher.get_first_non_empty_line(self.search_pattern)
-        self.pattern_base_indent = len(self.searcher.get_indentation(first_line)) if first_line else 0
-
-    def find_pattern(self) -> bool:
-        """Search for pattern with indentation awareness."""
-        try:
-            # Try exact matching first
-            exact_matches = self.searcher.exact_match(self.source_code, self.search_pattern)
-            if exact_matches:
-                if self.searcher.debug_mode:
-                    print("[DEBUG] Found pattern using exact match")
-                return True
-
-            # Fall back to flexible matching
-            if self.searcher.debug_mode:
-                print("[DEBUG] No exact match found, trying flexible matching")
-            search_first, _ = self.searcher.get_first_non_empty_line(self.search_pattern)
-            search_indent = self.searcher.get_indentation(search_first)
-            normalized_pattern = self.searcher.normalize_pattern(self.search_pattern, search_indent)
-
-            source_lines = self.source_code.splitlines()
-            matches = self._find_matches(source_lines, normalized_pattern)
-
-            return bool(self.searcher._find_best_match_position(matches, source_lines, self.pattern_base_indent))
-        except Exception:
-            return False
-
-    def replace(self) -> str:
-        """Perform the search and replace operation."""
-        if self.replacement is None:
-            if not self.find_pattern():
-                raise PatternNotFoundException("Pattern not found")
-            return self.source_code
-
-        source_lines = self.source_code.splitlines()
-        search_first, _ = self.searcher.get_first_non_empty_line(self.search_pattern)
-        search_indent = self.searcher.get_indentation(search_first)
-        normalized_pattern = self.searcher.normalize_pattern(self.search_pattern, search_indent)
-
-        matches = self._find_matches(source_lines, normalized_pattern)
-        best_pos = self.searcher._find_best_match_position(matches, source_lines, self.pattern_base_indent)
-
-        if best_pos is None:
-            raise PatternNotFoundException("Pattern not found")
-
-        if self.searcher.debug_mode:
-            pattern_lines = len(normalized_pattern.splitlines())
-            replacement_lines = len(self.replacement.splitlines()) if self.replacement else 0
-            print(f"\n[DEBUG] Replacing {pattern_lines} lines with {replacement_lines} lines")
-            context_start = max(0, best_pos - 2)
-            context_end = min(len(source_lines), best_pos + len(normalized_pattern.splitlines()) + 2)
-            print("\n[DEBUG] Context before replacement:")
-            for i in range(context_start, context_end):
-                prefix = ">>> " if context_start <= i < best_pos + len(normalized_pattern.splitlines()) else "    "
-                print(f"[DEBUG] {prefix}Line {i + 1}: {source_lines[i]}")
-
-        result = self._apply_replacement(source_lines, best_pos, normalized_pattern)
-
-        if self.searcher.debug_mode:
-            print("\n[DEBUG] Context after replacement:")
-            result_lines = result.splitlines()
-            for i in range(context_start, context_end):
-                prefix = ">>> " if context_start <= i < best_pos + len(self.replacement.splitlines()) else "    "
-                print(f"[DEBUG] {prefix}Line {i + 1}: {result_lines[i]}")
-
-        return result
-
-    def _find_matches(self, source_lines, normalized_pattern):
-        """Find all possible matches in source."""
-        pattern_lines = normalized_pattern.splitlines()
-        return self.searcher._find_matches(source_lines, pattern_lines, self.file_ext)
-
-    def _apply_replacement(self, source_lines, match_pos, normalized_pattern):
-        """Apply replacement at the matched position."""
-        result_lines = []
-        i = 0
-        while i < len(source_lines):
-            if i == match_pos:
-                self.pattern_found = True
-                match_indent = self.searcher.get_indentation(source_lines[i])
-                replacement_lines = self.replacer.create_indented_replacement(
-                    match_indent, self.search_pattern, self.replacement
-                )
-                result_lines.extend(replacement_lines)
-                i += len(normalized_pattern.splitlines())
-            else:
-                result_lines.append(source_lines[i])
-                i += 1
-        return '\n'.join(result_lines)
-
-    def _try_match_at_position(self, pos, source_lines, normalized_pattern):
-        """Check if pattern matches at given position."""
-        pattern_lines = normalized_pattern.splitlines()
-        strategies = self.searcher.get_strategies(self.file_ext)
-        return self.searcher.try_match_with_strategies(source_lines, pattern_lines, pos, strategies)

janito/search_replace/parser.py

@@ -1,52 +0,0 @@
-from pathlib import Path
-from typing import List, Dict
-
-def parse_test_file(filepath: Path) -> List[Dict]:
-    """Parse a test file containing test cases. Replacement section is optional."""
-    test_cases = []
-    current_test = {}
-    current_section = None
-    current_content = []
-
-    try:
-        content = filepath.read_text()
-        lines = content.splitlines()
-
-        for line in lines:
-            if line.startswith("Test: "):
-                if current_test:
-                    if current_section and current_content:
-                        current_test[current_section] = "\n".join(current_content)
-                    test_cases.append(current_test)
-                current_test = {"name": line[6:].strip(), "expect_success": True}
-                current_section = None
-                current_content = []
-            elif line.startswith("Original:"):
-                if current_section and current_content:
-                    current_test[current_section] = "\n".join(current_content)
-                current_section = "source"
-                current_content = []
-            elif line.startswith("Search pattern:"):
-                if current_section and current_content:
-                    current_test[current_section] = "\n".join(current_content)
-                current_section = "search"
-                current_content = []
-            elif line.startswith("Replacement:"):
-                if current_section and current_content:
-                    current_test[current_section] = "\n".join(current_content)
-                current_section = "replacement"
-                current_content = []
-            elif not line.startswith("="):  # Skip separator lines
-                if current_section:
-                    current_content.append(line)
-
-        # Add last test case
-        if current_test:
-            if current_section and current_content:
-                current_test[current_section] = "\n".join(current_content)
-            test_cases.append(current_test)
-
-        return test_cases
-    except Exception as e:
-        print(f"Error parsing test file: {e}")
-        return []