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

janito/config.py

@@ -1,36 +1,57 @@
-from typing import Optional, List
+from typing import Optional
 import os
 from pathlib import Path
 
 class ConfigManager:
+    """Singleton configuration manager for the application."""
+    
     _instance = None
 
     def __init__(self):
+        """Initialize configuration with default values."""
         self.debug = False
         self.verbose = False
         self.debug_line = None
         self.test_cmd = os.getenv('JANITO_TEST_CMD')
         self.workspace_dir = Path.cwd()
         self.raw = False
-        self.include: List[Path] = []
-        self.recursive: List[Path] = []
         self.auto_apply: bool = False
         self.tui: bool = False
-        self.skipwork: bool = False
+        self.skip_work: bool = False
 
     @classmethod
     def get_instance(cls) -> "ConfigManager":
+        """Return the singleton instance of ConfigManager.
+        
+        Returns:
+            ConfigManager: The singleton instance
+        """
         if cls._instance is None:
             cls._instance = cls()
         return cls._instance
 
     def set_debug(self, enabled: bool) -> None:
+        """Set debug mode.
+        
+        Args:
+            enabled: True to enable debug mode, False to disable
+        """
         self.debug = enabled
 
     def set_verbose(self, enabled: bool) -> None:
+        """Set verbose output mode.
+        
+        Args:
+            enabled: True to enable verbose output, False to disable
+        """
         self.verbose = enabled
 
     def set_debug_line(self, line: Optional[int]) -> None:
+        """Set specific line number for debug output.
+        
+        Args:
+            line: Line number to debug, or None for all lines
+        """
         self.debug_line = line
 
     def should_debug_line(self, line: int) -> bool:
@@ -46,57 +67,36 @@ class ConfigManager:
         self.workspace_dir = path if path is not None else Path.cwd()
 
     def set_raw(self, enabled: bool) -> None:
-        """Set raw output mode"""
-        self.raw = enabled
-
-    def set_include(self, paths: Optional[List[Path]]) -> None:
-        """
-        Set additional paths to include.
-
+        """Set raw output mode.
+        
         Args:
-            paths: List of paths to include
-
-        Raises:
-            ValueError: If duplicate paths are provided
+            enabled: True to enable raw output mode, False to disable
         """
-        if paths is None:
-            self.include = []
-            return
-
-        # Convert paths to absolute and resolve symlinks
-        resolved_paths = [p.absolute().resolve() for p in paths]
-
-        # Check for duplicates
-        seen_paths = set()
-        unique_paths = []
-
-        for path in resolved_paths:
-            if path in seen_paths:
-                raise ValueError(f"Duplicate path provided: {path}")
-            seen_paths.add(path)
-            unique_paths.append(path)
-
-        self.include = unique_paths
+        self.raw = enabled
 
     def set_auto_apply(self, enabled: bool) -> None:
-        """Set auto apply mode"""
+        """Set auto apply mode for changes.
+        
+        Args:
+            enabled: True to enable auto apply mode, False to disable
+        """
         self.auto_apply = enabled
 
     def set_tui(self, enabled: bool) -> None:
-        """Set TUI mode"""
+        """Set Text User Interface mode.
+        
+        Args:
+            enabled: True to enable TUI mode, False to disable
+        """
         self.tui = enabled
 
-    def set_recursive(self, paths: Optional[List[Path]]) -> None:
-        """Set paths to scan recursively
-
+    def set_skip_work(self, enabled: bool) -> None:
+        """Set whether to skip scanning the workspace directory.
+        
         Args:
-            paths: List of directory paths to scan recursively, or None to disable recursive scanning
+            enabled: True to skip workspace directory, False to include it
         """
-        self.recursive = paths
-
-    def set_skipwork(self, enabled: bool) -> None:
-        """Set skipwork flag to skip scanning workspace_dir"""
-        self.skipwork = enabled
+        self.skip_work = enabled
 
 # Create a singleton instance
 config = ConfigManager.get_instance()

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,35 +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.workspace import workspace
+from janito.workspace import workset  # Updated import
 
 
-QA_PROMPT = """Please provide a clear and concise answer to the following question about the codebase:
+QA_PROMPT = """Please provide a clear and concise answer to the following question about the workset you received above.
 
 Question: {question}
 
-Current files:
-<files>
-{files_content}
-</files>
-
 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"""
-    # Analyze workspace content if needed
-    workspace.analyze()
+    # 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

@@ -62,80 +62,126 @@ Search pattern:
 
 ## Search Strategies
 
-The module uses multiple search strategies in a fallback chain to find the best match:
+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
-- Most flexible strategy
+- Useful for matching code regardless of formatting
 - Example:
   ```python
   # Pattern:
   print("Hello")
       print("World")
-  
-  # Matches regardless of indentation:
+
+  # 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:
+  # 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
-- 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
+### 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
 
@@ -143,4 +189,4 @@ When debugging failed searches, the module provides:
 - Visual whitespace markers (· for spaces, → for tabs)
 - Indentation analysis
 - Line-by-line matching attempts
-- Strategy selection information
+- Strategy selection information

janito/search_replace/__init__.py

@@ -2,5 +2,6 @@ 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']
+__all__ = ['SearchReplacer', 'PatternNotFoundException', 'Searcher', 'Replacer', 'parse_test_file', 'StrategyResult']

janito/search_replace/core.py

@@ -1,5 +1,8 @@
 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
 
@@ -28,23 +31,11 @@ class SearchReplacer:
     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")
+            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)
-
-            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
@@ -65,6 +56,9 @@ class SearchReplacer:
         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:
@@ -101,6 +95,10 @@ class SearchReplacer:
         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
@@ -116,4 +114,7 @@ class SearchReplacer:
         """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)
+        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)