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

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/prompt.py

@@ -0,0 +1,36 @@
+from .workspace import workset
+
+SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. 
+
+I help you with coding tasks while being clear and concise in my responses.
+
+I have received the following workset for analysis:
+
+{workset}
+
+"""
+
+def build_system_prompt() -> dict:
+
+    system_prompt = [
+        {
+            "type": "text",
+            "text": "You Janito, an AI assistant tasked with analyzing worksets of code. You have received the following workset for analysis:",
+        }
+    ]
+
+    blocks = workset.get_cache_blocks()
+    for block in blocks:
+        if not block:
+            continue
+        block_content = ""
+        for file in block:
+            block_content += f'<file name="{file.name}"\n"'
+            block_content += f'<content>\n"{file.content}"\n</content>\n</file>\n'
+        system_prompt.append( {
+            "type": "text",
+            "text": block_content,
+            "cache_control": {"type": "ephemeral"}
+            }
+        )
+    return system_prompt

janito/qa.py

@@ -1,34 +1,26 @@
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
-from rich.syntax import Syntax
-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 workset  # Updated import
 
-QA_PROMPT = """Please provide a clear and concise answer to the following question about the codebase:
 
-Question: {question}
+QA_PROMPT = """Please provide a clear and concise answer to the following question about the workset you received above.
 
-Current files:
-<files>
-{files_content}
-</files>
+Question: {question}
 
 Focus on providing factual information and explanations. Do not suggest code changes.
 Format your response using markdown with appropriate headers and code blocks.
 """
 
-def ask_question(question: str, files_content: str) -> str:
+def ask_question(question: str) -> str:
     """Process a question about the codebase and return the answer"""
-    # Show content stats before processing
-    show_content_stats(files_content)
+    # Ensure content is refreshed and analyzed
+    workset.show()
     
     prompt = QA_PROMPT.format(
         question=question,
-        files_content=files_content
     )
     return progress_send_message(prompt)
 

janito/search_replace/README.md

@@ -0,0 +1,192 @@
+# 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 employs multiple search strategies in a fallback chain to find the best match. Each strategy has specific behaviors and use cases:
+
+### ExactMatch Strategy
+- Matches content exactly, including all whitespace and indentation
+- Strictest matching strategy
+- Best for precise replacements where indentation matters
+- Example:
+  ```python
+  # Pattern:
+      def hello():
+          print("Hi")
+
+  # Will only match exact indentation:
+      def hello():
+          print("Hi")
+
+  # Won't match different indentation:
+  def hello():
+      print("Hi")
+  ```
+
+### IndentAware Strategy
+- Preserves relative indentation between lines
+- Allows different base indentation levels
+- Ideal for matching code blocks inside functions/classes
+- Example:
+  ```python
+  # Pattern:
+      print("Hello")
+      print("World")
+
+  # Matches with different base indentation:
+  def test():
+      print("Hello")
+      print("World")
+
+  def other():
+          print("Hello")
+          print("World")
+
+  # Won't match if relative indentation differs:
+  def wrong():
+      print("Hello")
+          print("World")
+  ```
+
+### ExactContent Strategy
+- Ignores all indentation
+- Matches content after stripping whitespace
+- Useful for matching code regardless of formatting
+- Example:
+  ```python
+  # Pattern:
+  print("Hello")
+      print("World")
+
+  # Matches any indentation:
+        print("Hello")
+    print("World")
+
+  # Also matches:
+  print("Hello")
+print("World")
+  ```
+
+### ExactContentNoComments Strategy
+- Ignores indentation, comments, and empty lines
+- Most flexible strategy
+- Perfect for matching code with varying comments/formatting
+- Example:
+  ```python
+  # Pattern:
+  print("Hello")  # greeting
+
+  print("World")  # message
+
+  # Matches all these variations:
+  def test():
+        print("Hello")   # different comment
+        # some comment
+        print("World")
+
+  # Or:
+  print("Hello")  # no comment
+  print("World")  # different note
+  ```
+
+### ExactContentNoCommentsFirstLinePartial Strategy
+- Matches first line partially, ignoring comments
+- Useful for finding code fragments or partial matches
+- Example:
+  ```python
+  # Pattern:
+  print("Hello")
+
+  # Matches partial content:
+  message = print("Hello") + "extra"
+  result = print("Hello, World")
+  ```
+
+### Strategy Selection and File Types
+
+Strategies are tried in the following order:
+1. ExactMatch
+2. IndentAware
+3. ExactContent
+4. ExactContentNoComments
+5. ExactContentNoCommentsFirstLinePartial
+
+File extension specific behavior:
+
+| File Type | Available Strategies |
+|-----------|---------------------|
+| Python (.py) | All strategies |
+| Java (.java) | All strategies |
+| JavaScript (.js) | All strategies |
+| TypeScript (.ts) | All strategies |
+| Other files | ExactMatch, ExactContent, ExactContentNoComments, ExactContentNoCommentsFirstLinePartial |
+
+The module automatically selects the appropriate strategies based on the file type and tries them in order until a match is found.
+
+## 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,7 @@
+from .core import SearchReplacer, PatternNotFoundException
+from .searcher import Searcher
+from .replacer import Replacer
+from .parser import parse_test_file
+from .strategy_result import StrategyResult
+
+__all__ = ['SearchReplacer', 'PatternNotFoundException', 'Searcher', 'Replacer', 'parse_test_file', 'StrategyResult']

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,120 @@
+from typing import Optional, List
+from pathlib import Path
+import os
+from datetime import datetime
+from .logger import log_match, log_failure
+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:
+            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)
+            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:
+            # Log failed match if not in debug mode
+            if not self.searcher.debug_mode:
+                log_failure(self.file_ext)
+            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
+                # Log successful match if not in debug mode
+                # get the 
+                if not self.searcher.debug_mode:
+                    log_match("Strategy", self.file_ext)
+                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)
+        result = self.searcher.try_match_with_strategies(source_lines, pattern_lines, pos, strategies)
+        if result.success and not self.searcher.debug_mode:
+            log_match(result.strategy_name, self.file_ext)
+        return result.success

janito/search_replace/logger.py

@@ -0,0 +1,35 @@
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+# Configure logging
+logger = logging.getLogger("janito.search_replace")
+logger.setLevel(logging.INFO)
+
+# Create formatter
+formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+
+# Create file handler
+def setup_file_handler():
+    """Setup file handler for logging if .janito directory exists"""
+    if Path(".janito").exists():
+        fh = logging.FileHandler(".janito/search_logs.txt")
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+
+setup_file_handler()
+
+def log_match(strategy_name: str, file_type: Optional[str] = None):
+    """Log successful match with strategy info"""
+    msg = f"Match found using {strategy_name}"
+    if file_type:
+        msg += f" for file type {file_type}"
+    logger.info(msg)
+
+def log_failure(file_type: Optional[str] = None):
+    """Log failed match attempt"""
+    msg = "Failed to match pattern"
+    if file_type:
+        msg += f" for file type {file_type}"
+    logger.warning(msg)

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 []