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

janito-0.9.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.2
+Name: janito
+Version: 0.9.0
+Summary: Janito CLI tool
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: claudine>=0.1.0

janito-0.9.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+janito/__init__.py,sha256=-e15UAOQqb5aSP4nRNSSpPOQy8y_9nRDbxmNmCSNC_k,52
+janito/__main__.py,sha256=gskP0c2f1Zu9VwZ9V5QjdGf20wginiuGWa33qeZVDyY,6867
+janito/callbacks.py,sha256=_kmoRR2lDPQzNLfWPPibilbna4W-abj6hMO1VFICmwY,5288
+janito/cli.py,sha256=Vbg8W79d-LEB2b4cc58a2HE-8jmZrTvaNoEg2J2543k,9381
+janito/config.py,sha256=SYaMg3sqWroTaByfxGASleMLxux3s6b-fYZnT-ggqFw,2097
+janito/test_file.py,sha256=c6GWGdTYG3z-Y5XBao9Tmhmq3G-v0L37OfwLgBo8zIU,126
+janito/token_report.py,sha256=qLCAPce90Pgh_Q5qssA7irRB1C9e9pOfBC01Wi-ZUug,4006
+janito/data/instructions.txt,sha256=WkPubK1wPnLG2PpsPikEf7lWQrRW8t1C5p65PV-1qC8,311
+janito/tools/__init__.py,sha256=izLbyETR5piuFjQZ6ZY6zRgS7Tlx0yXk_wzhPn_CVYc,279
+janito/tools/decorators.py,sha256=VzUHsoxtxmsd5ic1KAW42eCOT56gjjSzWbEZTcv0RZs,2617
+janito/tools/delete_file.py,sha256=5JgSFtiF8bpfo0Z15ifj_RFHEHkl9cto1BES9TxIBIA,1245
+janito/tools/find_files.py,sha256=bN97u3VbFBA78ssXCaEo_cFloni5PE1UW6cSDP9kvjw,5993
+janito/tools/search_text.py,sha256=nABJJM_vEnMpVPfuLd_tIlVwCfXHTfo1e-K31a8IyJE,7674
+janito/tools/str_replace_editor/__init__.py,sha256=kYmscmQgft3Jzt3oCNz7k2FiRbJvku6OFDDC3Q_zoAA,144
+janito/tools/str_replace_editor/editor.py,sha256=XGrBADTlKwlcXat38T5th_KOPrspb9CBCP0g9KRuqmg,1345
+janito/tools/str_replace_editor/handlers.py,sha256=-7HJinfiJP2s-XHHVAS6TtrNwoNtTH8IJHxuLlYH2pA,12423
+janito/tools/str_replace_editor/utils.py,sha256=WOkos4bZ5Pe9U_UES6bS_QNISob0GvGN8TQVaRi6RbM,2670
+janito-0.9.0.dist-info/LICENSE,sha256=6-H8LXExbBIAuT4cyiE-Qy8Bad1K4pagQRVTWr6wkhk,1096
+janito-0.9.0.dist-info/METADATA,sha256=t8R4TKZwyPRMaS2BbJMhHPwIenKxaPX-Ro7QN7988Rc,216
+janito-0.9.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+janito-0.9.0.dist-info/entry_points.txt,sha256=JMbF_1jg-xQddidpAYkzjOKdw70fy_ymJfcmerY2wIY,47
+janito-0.9.0.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
+janito-0.9.0.dist-info/RECORD,,

{janito-0.8.0.dist-info → janito-0.9.0.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

janito-0.9.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+janito = janito.__main__:app

janito-0.9.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+janito

janito/agents/__init__.py

@@ -1,22 +0,0 @@
-import os
-
-# Try to determine backend from available API keys if not explicitly set
-ai_backend = os.getenv('AI_BACKEND', '').lower()
-
-if not ai_backend:
-    if os.getenv('ANTHROPIC_API_KEY'):
-        ai_backend = 'claudeai'
-    elif os.getenv('DEEPSEEK_API_KEY'):
-        ai_backend = 'deepseekai'
-    else:
-        raise ValueError("No AI backend API keys found. Please set either ANTHROPIC_API_KEY or DEEPSEEK_API_KEY")
-
-if ai_backend == "deepseekai":
-    from .deepseekai import DeepSeekAIAgent as AIAgent
-elif ai_backend == 'claudeai':
-    from .claudeai import ClaudeAIAgent as AIAgent
-else:
-    raise ValueError(f"Unsupported AI_BACKEND: {ai_backend}")
-
-# Create a singleton instance
-agent = AIAgent()

janito/agents/agent.py

@@ -1,25 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Optional
-
-class Agent(ABC):
-    """Abstract base class for AI agents"""
-    friendly_name = "Unknown"
-    
-    def __init__(self, api_key: Optional[str] = None):
-        self.api_key = api_key
-        self.last_prompt = None
-        self.last_full_message = None
-        self.last_response = None
-
-    @abstractmethod
-    def send_message(self, message: str, system: str) -> str:
-        """Send message to the AI agent
-        
-        Args:
-            message: The message to send
-            stop_event: Optional event to signal cancellation
-            
-        Returns:
-            The response from the AI agent
-        """
-        pass

janito/agents/claudeai.py

@@ -1,41 +0,0 @@
-import anthropic
-import os
-
-from .agent import Agent
-
-class ClaudeAIAgent(Agent):
-    """Handles interaction with Claude API, including message handling"""
-    DEFAULT_MODEL = "claude-3-5-sonnet-20241022"
-    friendly_name = "Claude"
-    
-    def __init__(self):
-        self.api_key = os.getenv('ANTHROPIC_API_KEY')
-        super().__init__(self.api_key)
-        
-        if not self.api_key:
-            raise ValueError("ANTHROPIC_API_KEY environment variable is required")
-        self.client = anthropic.Client(api_key=self.api_key)
-        self.model = os.getenv('CLAUDE_MODEL', self.DEFAULT_MODEL)
-        self.last_prompt = None
-        self.last_full_message = None
-        self.last_response = None
-
-
-    def send_message(self, system_message: str, message: str) -> str:
-        """Send message to Claude API and return response"""
-        # Store the full message
-        self.last_full_message = message
-        
-        response = self.client.messages.create(
-            model=self.model,  # Use discovered model
-            system=system_message or self.system_message,
-            max_tokens=8192,
-            messages=[
-                {"role": "user", "content": message}
-            ],
-            temperature=0,
-        )
-        
-
-        # Always return the response, let caller handle cancellation
-        return response

janito/agents/deepseekai.py

@@ -1,47 +0,0 @@
-from openai import OpenAI
-import os
-from typing import Optional
-from threading import Event
-from .agent import Agent
-
-class DeepSeekAIAgent(Agent):
-    """ DeepSeek AI Agent """
-    DEFAULT_MODEL = "deepseek-chat"
-    friendly_name = "DeepSeek"
-    api_key = None
-    
-    def __init__(self, system_prompt: str = None):
-        self.api_key = os.getenv('DEEPSEEK_API_KEY')
-        super().__init__(self.api_key, system_prompt)
-        if not system_prompt:
-            raise ValueError("system_prompt is required")
-        if not self.api_key:
-            raise ValueError("DEEPSEEK_API_KEY environment variable is required")
-        self.client = OpenAI(api_key=self.api_key, base_url="https://api.deepseek.com")
-        self.model = self.DEFAULT_MODEL
-        self.system_message = system_prompt
-
-    def send_message(self, message: str, system_message: str = None) -> str:
-        """Send message to OpenAI API and return response"""
-        self.last_full_message = message
-        
-        try:
-            messages = [
-                { "role": "system", "content": system_message},
-                { "role": "user", "content": message}
-            ]
-            
-            response = self.client.chat.completions.create(
-                model=self.model,
-                messages=messages,
-                max_completion_tokens=4096,
-                temperature=0,
-            )
-            
-            response_text = response.choices[0].message.content
-            self.last_response = response_text
-            
-            return response
-            
-        except KeyboardInterrupt:
-            return ""

janito/change/applied_blocks.py

@@ -1,34 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List, Optional
-from .edit_blocks import EditType
-
-@dataclass
-class AppliedBlock:
-    filename: Path
-    edit_type: EditType
-    reason: str
-    original_content: List[str]
-    modified_content: List[str]
-    range_start: int
-    range_end: int
-    block_marker: Optional[str] = None
-    error_message: Optional[str] = None
-    has_error: bool = False
-
-@dataclass
-class AppliedBlocks:
-    blocks: List[AppliedBlock]
-    
-    def get_changes_summary(self):
-        """Get summary info for all applied blocks"""
-        return [{
-            'file': block.filename,
-            'type': block.edit_type.name,
-            'reason': block.reason,
-            'lines_original': len(block.original_content),
-            'lines_modified': len(block.modified_content),
-            'range_start': block.range_start,
-            'range_end': block.range_end,
-            'block_marker': block.block_marker
-        } for block in self.blocks]

janito/change/applier.py

@@ -1,167 +0,0 @@
-from typing import List
-from pathlib import Path
-from janito.config import config
-from .finder import find_range, EditContentNotFoundError
-from .edit_blocks import EditType, CodeChange
-from .applied_blocks import AppliedBlock, AppliedBlocks
-
-class ChangeApplier:
-    def __init__(self, target_dir: Path):
-        self.target_dir = target_dir
-        self.edits: List[CodeChange] = []
-        self._last_changed_line = 0
-        self.current_file = None
-        self.current_content: List[str] = []
-        self.applied_blocks = AppliedBlocks(blocks=[])
-
-    def add_edit(self, edit: CodeChange):
-        self.edits.append(edit)
-
-    def start_file_edit(self, filename: str, edit_type: EditType):
-        if self.current_file:
-            self.end_file_edit()
-        self._last_changed_line = 0
-        self.current_file = filename
-        self.current_edit_type = edit_type  # Store edit type for end_file_edit
-        
-        if edit_type == EditType.CREATE:
-            self.current_content = []
-        elif edit_type == EditType.DELETE:
-            if not (self.target_dir / filename).exists():
-                raise FileNotFoundError(f"Cannot delete non-existent file: {filename}")
-            self.current_content = []
-        else:
-            self.current_content = (self.target_dir / filename).read_text(encoding="utf-8").splitlines()
-    
-    def end_file_edit(self):
-        if self.current_file:
-            target_path = self.target_dir / self.current_file
-            if hasattr(self, 'current_edit_type') and self.current_edit_type == EditType.DELETE:
-                if target_path.exists():
-                    target_path.unlink()
-            else:
-                # Create parent directories if they don't exist
-                target_path.parent.mkdir(parents=True, exist_ok=True)
-                target_path.write_text("\n".join(self.current_content), encoding="utf-8")
-        self.current_file = None
-
-    def apply(self):
-        """Apply all edits and show summary of changes."""
-        # Ensure target directory exists
-        self.target_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Track changes as we apply them
-        changes = []
-        current_file = None
-        
-        # Process edits in order as they were added
-        for edit in self.edits:
-            if current_file != edit.filename:
-                self.end_file_edit()
-                self.start_file_edit(str(edit.filename), edit.edit_type)
-                current_file = edit.filename
-            self._apply_and_collect_change(edit)
-
-        self.end_file_edit()
-
-    def _apply_and_collect_change(self, edit: CodeChange) -> AppliedBlock:
-        """Apply a single edit and collect its change information."""
-        if edit.edit_type == EditType.CREATE:
-            self.current_content = edit.modified
-            applied_block = AppliedBlock(
-                filename=edit.filename,
-                edit_type=edit.edit_type,
-                reason=edit.reason,
-                original_content=[],
-                modified_content=edit.modified,
-                range_start=1,
-                range_end=len(edit.modified),
-                block_marker=edit.block_marker
-            )
-
-        elif edit.edit_type == EditType.DELETE:
-            applied_block = AppliedBlock(
-                filename=edit.filename,
-                edit_type=edit.edit_type,
-                reason=edit.reason,
-                original_content=self.current_content,
-                modified_content=[],
-                range_start=1,
-                range_end=len(self.current_content),
-                block_marker=edit.block_marker
-            )
-            self.current_content = []
-
-        elif edit.edit_type == EditType.CLEAN:
-            try:
-                start_range = find_range(self.current_content, edit.original, self._last_changed_line)
-                try:
-                    end_range = find_range(self.current_content, edit.modified, start_range[1])
-                except EditContentNotFoundError:
-                    end_range = (start_range[1], start_range[1])
-                
-                section = self.current_content[start_range[0]:end_range[1]]
-                applied_block = AppliedBlock(
-                    filename=edit.filename,
-                    edit_type=edit.edit_type,
-                    reason=edit.reason,
-                    original_content=section,
-                    modified_content=[],
-                    range_start=start_range[0] + 1,
-                    range_end=end_range[1],
-                    block_marker=edit.block_marker
-                )
-                
-                self.current_content[start_range[0]:end_range[1]] = []
-                self._last_changed_line = start_range[0]
-                
-            except ValueError as e:
-                error_msg = f"Failed to find clean section in {self.current_file}: {e}"
-                applied_block = AppliedBlock(
-                    filename=edit.filename,
-                    edit_type=edit.edit_type,
-                    reason=edit.reason,
-                    original_content=self.current_content,
-                    modified_content=[],
-                    range_start=1,
-                    range_end=len(self.current_content),
-                    block_marker=edit.block_marker,
-                    error_message=error_msg,
-                    has_error=True
-                )
-
-        else:  # EDIT operation
-            try:
-                edit_range = find_range(self.current_content, edit.original, self._last_changed_line)
-                original_section = self.current_content[edit_range[0]:edit_range[1]]
-                
-                applied_block = AppliedBlock(
-                    filename=edit.filename,
-                    edit_type=edit.edit_type,
-                    reason=edit.reason,
-                    original_content=original_section,
-                    modified_content=edit.modified,
-                    range_start=edit_range[0] + 1,
-                    range_end=edit_range[0] + len(edit.original),
-                    block_marker=edit.block_marker
-                )
-                
-                self._last_changed_line = edit_range[0] + len(edit.original)
-                self.current_content[edit_range[0]:edit_range[1]] = edit.modified
-            except EditContentNotFoundError as e:
-                error_msg = f"Failed to find edit section in {self.current_file}: {e}"
-                applied_block = AppliedBlock(
-                    filename=edit.filename,
-                    edit_type=edit.edit_type,
-                    reason=edit.reason,
-                    original_content=edit.original,
-                    modified_content=edit.modified,
-                    range_start=self._last_changed_line + 1,
-                    range_end=self._last_changed_line + len(edit.original),
-                    block_marker=edit.block_marker,
-                    error_message=error_msg,
-                    has_error=True
-                )
-
-        self.applied_blocks.blocks.append(applied_block)
-        return applied_block

janito/change/edit_blocks.py

@@ -1,148 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from enum import Enum, auto
-from typing import List, Tuple, Dict
-import string
-
-class EditType(Enum):
-    CREATE = auto()
-    EDIT = auto()
-    DELETE = auto()
-    CLEAN = auto()
-
-@dataclass
-class CodeChange:
-    filename: Path
-    reason: str
-    original: List[str]  # Changed from 'before'
-    modified: List[str]  # Changed from 'after'
-    edit_type: EditType = EditType.EDIT
-    block_marker: str = None  # Track which code block this change came from
-
-def parse_edit_command(line: str, command: str) -> tuple[Path, str]:
-    """Parse an Edit or Create command line to extract filename and reason.
-    Expected format: Command filename "reason"
-    Example: Edit path/to/file.py "Add new feature"
-    """
-    if not line or not line.startswith(command):
-        raise ValueError(f"Invalid command format in line:\n{line}\nExpected: {command} filename \"reason\"")
-        
-    # Split by quote to separate filename from reason
-    parts = line.split('"')
-    if len(parts) < 2:
-        raise ValueError(f"Missing reason in quotes in line:\n{line}")
-        
-    filename = Path(parts[0].replace(f"{command} ", "").strip())
-    reason = parts[1].strip()
-    
-    return filename, reason
-
-def get_edit_blocks(response: str) -> Tuple[List[CodeChange], str]:
-    """Parse response text into a list of CodeChange objects and annotated response.
-    
-    The format expected from the response follows the system prompt:
-    
-    Edit file "reason"
-    <<<< original
-    {original code}
-    >>>> modified
-    {modified code}
-    ====
-    
-    Clean file "reason"
-    <<<< starting
-    {start marker lines}
-    >>>> ending
-    {end marker lines}
-    ====
-    """
-    edit_blocks = []
-    modified_response = []
-    current_block = []
-    original_content = None
-    current_command = None
-    marker_index = 0
-    in_block = False
-
-    for line in response.splitlines():
-        # Handle command lines
-        if line.startswith(("Edit ", "Create ", "Delete ", "Clean ")):
-            command = line.split(" ")[0]
-            filename, reason = parse_edit_command(line, command)
-            current_command = command
-            # Reset state for new command
-            original_content = None
-            current_block = []
-            # Add marker for this edit block
-            current_marker = string.ascii_uppercase[marker_index]
-            modified_response.append(f"[Edit Block {current_marker}]")
-            marker_index += 1
-            continue
-            
-        # Add the line to modified_response unless we're in a code block or it's a block marker
-        if not in_block and not line.startswith(("<<<< ", ">>>> ", "====")):
-            modified_response.append(line)
-            
-        # Handle block markers - Update to match system prompt
-        if line.startswith("<<<< original") or line.startswith("<<<< starting"):
-            current_block = []
-            in_block = True
-            if current_command == "Clean":
-                original_content = None
-        elif line.startswith(">>>> modified") or line.startswith(">>>> ending"):
-            if current_command == "Clean":
-                original_content = current_block
-            elif not original_content and current_block:
-                original_content = current_block
-            current_block = []
-            in_block = True
-        elif line == "====":  # End of edit block
-            # Trim empty lines at start and end of blocks
-            def trim_block(block: List[str]) -> List[str]:
-                if not block:
-                    return []
-                # Remove empty lines at start and end
-                while block and not block[0].strip():
-                    block.pop(0)
-                while block and not block[-1].strip():
-                    block.pop()
-                return block
-
-            if current_command == "Delete":
-                edit_blocks.append(CodeChange(filename, reason, [], [], EditType.DELETE, current_marker))
-            elif current_command == "Clean":
-                edit_blocks.append(CodeChange(
-                    filename, reason,
-                    trim_block(original_content or []),
-                    trim_block(current_block),
-                    EditType.CLEAN,
-                    current_marker
-                ))
-            elif current_command == "Create":
-                edit_blocks.append(CodeChange(
-                    filename, reason,
-                    [],
-                    trim_block(current_block),
-                    EditType.CREATE,
-                    current_marker
-                ))
-            elif current_command == "Edit":
-                original = trim_block(original_content or [])
-                modified = trim_block(current_block)
-                edit_blocks.append(CodeChange(
-                    filename, reason,
-                    original,
-                    modified,
-                    EditType.EDIT,
-                    current_marker
-                ))
-            
-            # Reset state after block is completed
-            current_block = []
-            in_block = False
-            current_command = None
-            original_content = None
-        elif in_block:
-            current_block.append(line)
-
-    return edit_blocks, "\n".join(modified_response)

janito/change/finder.py

@@ -1,72 +0,0 @@
-from typing import List, Tuple
-from difflib import SequenceMatcher
-
-class EditContentNotFoundError(ValueError):
-    """Raised when edit content cannot be found in the target file."""
-    pass
-
-SIMILARITY_THRESHOLD = 0.8  # Minimum similarity required for a match
-
-def find_range(full_lines: List[str], changed_lines: List[str], start: int = 0) -> Tuple[int, int]:
-    """Find the range of the first occurrence of the changed_lines in the full_lines list.
-    
-    Args:
-        full_lines: The complete text content to search within
-        changed_lines: The block of lines to find
-        start: The line number to start searching from
-        
-    Returns:
-        Tuple of (start_line, end_line) where the block was found
-        
-    Raises:
-        ValueError: If no matching block is found with sufficient similarity
-    """
-    _validate_inputs(full_lines, changed_lines, start)
-    
-    if not changed_lines:
-        return (start, start)
-
-    best_match, best_score = _find_best_matching_block(full_lines, changed_lines, start)
-    
-    if not best_match or best_score < SIMILARITY_THRESHOLD:
-        _raise_no_match_error(changed_lines, start, best_score)
-        
-    return best_match
-
-def _validate_inputs(full_lines: List[str], changed_lines: List[str], start: int) -> None:
-    if start >= len(full_lines):
-        raise ValueError(f"Start position {start} is beyond content length {len(full_lines)}")
-
-def _find_best_matching_block(full_lines: List[str], changed_lines: List[str], start: int) -> Tuple[Tuple[int, int], float]:
-    best_match = None
-    best_score = 0.0
-    
-    for i in range(start, len(full_lines) - len(changed_lines) + 1):
-        window = full_lines[i:i + len(changed_lines)]
-        if len(window) != len(changed_lines):
-            continue
-            
-        similarity = _calculate_similarity(window, changed_lines)
-        
-        if similarity > best_score:
-            best_score = similarity
-            best_match = (i, i + len(changed_lines))
-            
-            if similarity == 1.0:  # Early exit on perfect match
-                break
-    
-    return best_match, best_score
-
-def _calculate_similarity(window: List[str], changed_lines: List[str]) -> float:
-    return sum(
-        SequenceMatcher(None, a, b).ratio() 
-        for a, b in zip(window, changed_lines)
-    ) / len(changed_lines)
-
-def _raise_no_match_error(changed_lines: List[str], start: int, best_score: float) -> None:
-    sample = "\n".join(changed_lines[:3]) + ("..." if len(changed_lines) > 3 else "")
-    raise EditContentNotFoundError(
-        f"Could not find matching block after line {start}. "
-        f"Looking for:\n{sample}\n"
-        f"Best match score: {best_score:.2f}"
-    )