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

janito/prompts.py

@@ -1,66 +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 revmoing 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
-
-Please provide the changes in this format:
-
-## {uuid} file <filepath> modify "short file change description" ##
-## {uuid} search/replace "short change description" ##
-<search_content>
-## {uuid} replace with ##
-<replace_content>
-## {uuid} file end ##
-
-Or to delete content:
-## {uuid} file <filepath> modify ##
-## {uuid} search/delete "short change description" ##
-<content_to_delete>
-## {uuid} file end ##
-
-For new files:
-## {uuid} file <filepath> create "short description" ##
-<full_file_content>
-## {uuid} file end ##
-
-RULES:
-1. search_content MUST preserve the original identation/whitespace 
-"""
-
-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

@@ -4,10 +4,10 @@ from rich.panel import Panel
 from rich.syntax import Syntax
 from rich.table import Table
 from rich.rule import Rule
-from janito.claude import ClaudeAPIAgent
+from janito.agents import AIAgent
 from janito.common import progress_send_message
-from typing import Dict, List
-import re
+from janito.workspace import workspace
+
 
 QA_PROMPT = """Please provide a clear and concise answer to the following question about the codebase:
 
@@ -22,13 +22,16 @@ Focus on providing factual information and explanations. Do not suggest code cha
 Format your response using markdown with appropriate headers and code blocks.
 """
 
-def ask_question(question: str, files_content: str, claude: ClaudeAPIAgent) -> str:
+def ask_question(question: str, files_content: str) -> str:
     """Process a question about the codebase and return the answer"""
+    # Analyze workspace content if needed
+    workspace.analyze()
+    
     prompt = QA_PROMPT.format(
         question=question,
         files_content=files_content
     )
-    return progress_send_message(claude, prompt)
+    return progress_send_message(prompt)
 
 
 def display_answer(answer: str, raw: bool = False) -> None:

janito/review.py

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

@@ -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)

janito/search_replace/replacer.py

@@ -0,0 +1,36 @@
+from typing import List
+from .searcher import Searcher
+
+class Replacer:
+    """Handles replacement operations with proper indentation."""
+
+    def __init__(self, debug: bool = False):
+        """Initialize replacer with debug mode."""
+        self.searcher = Searcher(debug=debug)
+        self.debug_mode = debug
+
+    def create_indented_replacement(self, match_indent: str, search_pattern: str, replacement: str) -> List[str]:
+        """Create properly indented replacement lines."""
+        search_first, search_start_idx = self.searcher.get_first_non_empty_line(search_pattern)
+        replace_first, replace_start_idx = self.searcher.get_first_non_empty_line(replacement)
+
+        search_indent = self.searcher.get_indentation(search_first)
+        replace_indent = self.searcher.get_indentation(replace_first)
+
+        replace_lines = replacement.splitlines()
+        indented_replacement = []
+
+        # Calculate indentation shifts
+        context_shift = len(match_indent) - len(search_indent)
+        pattern_shift = len(replace_indent) - len(search_indent)
+
+        for i, line in enumerate(replace_lines):
+            if i < replace_start_idx or not line.strip():
+                indented_replacement.append('')
+            else:
+                line_indent = self.searcher.get_indentation(line)
+                rel_indent = len(line_indent) - len(replace_indent)
+                final_indent = ' ' * (len(match_indent) + rel_indent)
+                indented_replacement.append(final_indent + line.lstrip())
+
+        return indented_replacement