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

janito/demo/mock_data.py

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,32 @@
+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,81 +1,2 @@
-import re
-import uuid
-from typing import List, Union
-from dataclasses import dataclass
-from .analysis import parse_analysis_options, AnalysisOption
-
 # 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."""
-
-
-SELECTED_OPTION_PROMPT = """
-Original request: {request}
-
-Please provide detailed implementation using the following guide:
-{option_text}
-
-Current files:
-<files>
-{files_content}
-</files>
-
-RULES:
-- When removing constants, ensure they are not used elsewhere
-- When adding new features to python files, add the necessary imports
-- Python imports should be inserted at the top of the file
-- For complete file replacements, only use for existing files marked as modified
-- File replacements must preserve the essential functionality
-- When multiple changes affect the same code block, combine them into a single change
-- if no changes are required answer only the reason in the format: <no_changes_required>reason for no changes<no_changes_required>
-
-Please provide the changes in this format:
-
-For incremental changes:
-## {uuid} file <filepath> modify "short file change description" ##
-## {uuid} search/replace "short change description" ##
-<search_content>
-## {uuid} replace with ##
-<replace_content>
-## {uuid} file end ##
-
-For complete file replacement (only for existing modified files):
-## {uuid} file <filepath> replace "short file description" ##
-<full_file_content>
-## {uuid} file end ##
-
-For new files:
-## {uuid} file <filepath> create "short file description" ##
-<full_file_content>
-## {uuid} file end ##
-
-For content deletion:
-## {uuid} file <filepath> modify ##
-## {uuid} search/delete "short change description" ##
-<content_to_delete>
-## {uuid} file end ##
-
-For file removal:
-## {uuid} file <filepath> remove "short removal reason" ##
-## {uuid} file end ##
-
-RULES:
-1. search_content MUST preserve the original indentation/whitespace
-2. file replacement can only be used for existing files marked as 
-"""
-
-def build_selected_option_prompt(option_text: str, request: str, files_content: str = "") -> str:
-    """Build prompt for selected option details
-    
-    Args:
-        option_text: Formatted text describing the selected option
-        request: The original user request
-        files_content: Content of relevant files
-    """
-    short_uuid = str(uuid.uuid4())[:8]
-    
-    return SELECTED_OPTION_PROMPT.format(
-        option_text=option_text,
-        request=request,
-        files_content=files_content,
-        uuid=short_uuid
-    )
+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/qa.py

@@ -6,7 +6,8 @@ from rich.table import Table
 from rich.rule import Rule
 from janito.agents import AIAgent
 from janito.common import progress_send_message
-from janito.scan import show_content_stats
+from janito.workspace import workspace
+
 
 QA_PROMPT = """Please provide a clear and concise answer to the following question about the codebase:
 
@@ -23,8 +24,8 @@ Format your response using markdown with appropriate headers and code blocks.
 
 def ask_question(question: str, files_content: str) -> str:
     """Process a question about the codebase and return the answer"""
-    # Show content stats before processing
-    show_content_stats(files_content)
+    # Analyze workspace content if needed
+    workspace.analyze()
     
     prompt = QA_PROMPT.format(
         question=question,

janito/search_replace/README.md

@@ -0,0 +1,146 @@
+# 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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,21 @@
+"""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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,52 @@
+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 []

janito/search_replace/play.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from typing import Optional
+from .parser import parse_test_file
+from .core import SearchReplacer
+import re
+
+def _extract_file_ext(test_info: str) -> Optional[str]:
+    """Extract file extension from test description."""
+    # Try to find filename or extension in the test info
+    ext_match = re.search(r'\.([a-zA-Z0-9]+)\b', test_info)
+    if (ext_match):
+        return f".{ext_match.group(1).lower()}"
+    
+    # Look for language mentions
+    lang_map = {
+        'python': '.py',
+        'javascript': '.js',
+        'typescript': '.ts',
+        'java': '.java'
+    }
+    
+    for lang, ext in lang_map.items():
+        if lang.lower() in test_info.lower():
+            return ext
+            
+    return None
+
+def play_file(filepath: Path):
+    """Play back a test file and show detailed debugging info."""
+    test_cases = parse_test_file(filepath)
+    
+    for test in test_cases:
+        print(f"\nTest: {test['name']}")
+        print("=" * 50)
+        
+        if 'source' not in test or 'search' not in test:
+            print("Invalid test case - missing source or search pattern")
+            continue
+            
+        file_ext = _extract_file_ext(test['name'])
+        print(f"\nFile type: {file_ext or 'unknown'}")
+        
+        replacer = SearchReplacer(
+            source_code=test['source'],
+            search_pattern=test['search'],
+            replacement=test.get('replacement'),
+            file_ext=file_ext,
+            debug=True
+        )
+        
+        try:
+            print("\nAttempting search/replace...")
+            result = replacer.replace()
+            print("\nResult:")
+            print("-" * 50)
+            print(result)
+            
+        except Exception as e:
+            print(f"\nError: {str(e)}")
+        
+        print("\n" + "="*50)