janito 0.3.0__tar.gz → 0.5.0__tar.gz

janito-0.5.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.3
+Name: janito
+Version: 0.5.0
+Summary: A CLI tool for software development tasks powered by AI
+Project-URL: Homepage, https://github.com/joaompinto/janito
+Project-URL: Repository, https://github.com/joaompinto/janito.git
+Author-email: João Pinto <lamego.pinto@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Requires-Dist: anthropic
+Requires-Dist: pathspec
+Requires-Dist: rich
+Requires-Dist: tomli
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# 🤖 Janito CLI
+
+A CLI tool for software development tasks powered by AI. Janito is your friendly AI-powered software development buddy that helps with coding tasks like refactoring, documentation updates, and code optimization.
+
+## 📥 Installation
+
+1. Install using pip:
+```bash
+pip install janito
+```
+
+2. Verify installation:
+```bash
+janito --version
+```
+
+## ⚙️ Setup
+
+1. Get your Anthropic API key from [Anthropic's website](https://www.anthropic.com/)
+
+2. Set your API key:
+```bash
+# Linux/macOS
+export ANTHROPIC_API_KEY='your-api-key-here'
+
+# Windows (Command Prompt)
+set ANTHROPIC_API_KEY=your-api-key-here
+
+# Windows (PowerShell)
+$env:ANTHROPIC_API_KEY='your-api-key-here'
+```
+
+3. (Optional) Configure default test command:
+```bash
+export JANITO_TEST_CMD='pytest'  # or your preferred test command
+```
+
+## 🚀 Quick Start
+
+### Basic Usage
+
+```bash
+# Add docstrings to your code
+janito "add docstrings to this file"
+
+# Optimize a function
+janito "optimize the main function"
+
+# Get code explanations
+janito --ask "explain this code"
+```
+
+### Common Scenarios
+
+1. **Code Refactoring**
+```bash
+# Refactor with test validation
+janito "refactor this code to use list comprehension" --test "pytest"
+
+# Refactor specific directory
+janito "update imports" -i ./src
+```
+
+2. **Documentation Updates**
+```bash
+# Add or update docstrings
+janito "add type hints and docstrings"
+
+# Generate README
+janito "create a README for this project"
+```
+
+3. **Code Analysis**
+```bash
+# Get code explanations
+janito --ask "what does this function do?"
+
+# Find potential improvements
+janito --ask "suggest optimizations for this code"
+```
+
+## 🛠️ Command Reference
+
+### Syntax
+```bash
+janito [OPTIONS] [REQUEST]
+```
+
+### Key Options
+
+| Option | Description |
+|--------|-------------|
+| `REQUEST` | The AI request/instruction (in quotes) |
+| `-w, --working-dir PATH` | Working directory [default: current] |
+| `-i, --include PATH` | Include directory int the working context (can be multiple)|
+| `--ask QUESTION` | Ask questions without making changes |
+| `--test COMMAND` | Run tests before applying changes |
+| `--debug` | Enable debug logging |
+| `--verbose` | Enable verbose mode |
+| `--version` | Show version information |
+| `--help` | Show help message |
+
+## 🔑 Key Features
+
+- 🤖 AI-powered code analysis and modifications
+- 💻 Interactive console mode
+- ✅ Syntax validation for Python files
+- 👀 Change preview and confirmation
+- 🧪 Test command execution
+- 📜 Change history tracking
+
+## 📚 Additional Information
+
+- Requires Python 3.8+
+- Changes are backed up in `.janito/changes_history/`
+- Environment variables:
+  - `ANTHROPIC_API_KEY`: Required for API access
+  - `JANITO_TEST_CMD`: Default test command (optional)
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.

janito-0.5.0/README.md

@@ -0,0 +1,122 @@
+# 🤖 Janito CLI
+
+A CLI tool for software development tasks powered by AI. Janito is your friendly AI-powered software development buddy that helps with coding tasks like refactoring, documentation updates, and code optimization.
+
+## 📥 Installation
+
+1. Install using pip:
+```bash
+pip install janito
+```
+
+2. Verify installation:
+```bash
+janito --version
+```
+
+## ⚙️ Setup
+
+1. Get your Anthropic API key from [Anthropic's website](https://www.anthropic.com/)
+
+2. Set your API key:
+```bash
+# Linux/macOS
+export ANTHROPIC_API_KEY='your-api-key-here'
+
+# Windows (Command Prompt)
+set ANTHROPIC_API_KEY=your-api-key-here
+
+# Windows (PowerShell)
+$env:ANTHROPIC_API_KEY='your-api-key-here'
+```
+
+3. (Optional) Configure default test command:
+```bash
+export JANITO_TEST_CMD='pytest'  # or your preferred test command
+```
+
+## 🚀 Quick Start
+
+### Basic Usage
+
+```bash
+# Add docstrings to your code
+janito "add docstrings to this file"
+
+# Optimize a function
+janito "optimize the main function"
+
+# Get code explanations
+janito --ask "explain this code"
+```
+
+### Common Scenarios
+
+1. **Code Refactoring**
+```bash
+# Refactor with test validation
+janito "refactor this code to use list comprehension" --test "pytest"
+
+# Refactor specific directory
+janito "update imports" -i ./src
+```
+
+2. **Documentation Updates**
+```bash
+# Add or update docstrings
+janito "add type hints and docstrings"
+
+# Generate README
+janito "create a README for this project"
+```
+
+3. **Code Analysis**
+```bash
+# Get code explanations
+janito --ask "what does this function do?"
+
+# Find potential improvements
+janito --ask "suggest optimizations for this code"
+```
+
+## 🛠️ Command Reference
+
+### Syntax
+```bash
+janito [OPTIONS] [REQUEST]
+```
+
+### Key Options
+
+| Option | Description |
+|--------|-------------|
+| `REQUEST` | The AI request/instruction (in quotes) |
+| `-w, --working-dir PATH` | Working directory [default: current] |
+| `-i, --include PATH` | Include directory int the working context (can be multiple)|
+| `--ask QUESTION` | Ask questions without making changes |
+| `--test COMMAND` | Run tests before applying changes |
+| `--debug` | Enable debug logging |
+| `--verbose` | Enable verbose mode |
+| `--version` | Show version information |
+| `--help` | Show help message |
+
+## 🔑 Key Features
+
+- 🤖 AI-powered code analysis and modifications
+- 💻 Interactive console mode
+- ✅ Syntax validation for Python files
+- 👀 Change preview and confirmation
+- 🧪 Test command execution
+- 📜 Change history tracking
+
+## 📚 Additional Information
+
+- Requires Python 3.8+
+- Changes are backed up in `.janito/changes_history/`
+- Environment variables:
+  - `ANTHROPIC_API_KEY`: Required for API access
+  - `JANITO_TEST_CMD`: Default test command (optional)
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.

janito-0.5.0/janito/__init__.py

@@ -0,0 +1,49 @@
+"""Core package initialization for Janito."""
+
+from .analysis import (
+    AnalysisOption,
+    parse_analysis_options,
+    format_analysis,
+    get_history_file_type,
+    get_history_path,
+    get_timestamp,
+    save_to_file,
+    build_request_analysis_prompt,
+    get_option_selection,
+    prompt_user,
+    validate_option_letter
+)
+
+from .change import (
+    apply_single_change,
+    parse_and_apply_changes_sequence,
+    get_file_type,
+    process_and_save_changes,
+    format_parsed_changes,
+    apply_content_changes,
+    handle_changes_file
+)
+
+__all__ = [
+    # Analysis exports
+    'AnalysisOption',
+    'parse_analysis_options',
+    'format_analysis',
+    'get_history_file_type',
+    'get_history_path',
+    'get_timestamp',
+    'save_to_file',
+    'build_request_analysis_prompt',
+    'get_option_selection',
+    'prompt_user',
+    'validate_option_letter',
+    
+    # Change exports
+    'apply_single_change',
+    'parse_and_apply_changes_sequence',
+    'get_file_type',
+    'process_and_save_changes',
+    'format_parsed_changes',
+    'apply_content_changes',
+    'handle_changes_file'
+]

janito-0.5.0/janito/__main__.py

@@ -0,0 +1,54 @@
+import typer
+from typing import Optional, List
+from pathlib import Path
+from rich.console import Console
+from .version import get_version
+
+from janito.agents import AgentSingleton
+from janito.config import config
+
+from .cli.commands import handle_request, handle_ask, handle_play, handle_scan
+
+app = typer.Typer(add_completion=False)
+
+def typer_main(
+    change_request: str = typer.Argument(None, help="Change request or command"),
+    workdir: Optional[Path] = typer.Option(None, "-w", "--workdir", help="Working directory", file_okay=False, dir_okay=True),
+    debug: bool = typer.Option(False, "--debug", help="Show debug information"),
+    verbose: bool = typer.Option(False, "--verbose", help="Show verbose output"),
+    include: Optional[List[Path]] = typer.Option(None, "-i", "--include", help="Additional paths to include"),
+    ask: Optional[str] = typer.Option(None, "--ask", help="Ask a question about the codebase"),
+    play: Optional[Path] = typer.Option(None, "--play", help="Replay a saved prompt file"),
+    version: bool = typer.Option(False, "--version", help="Show version information"),
+):
+    """Janito - AI-powered code modification assistant"""
+    if version:
+        console = Console()
+        console.print(f"Janito version {get_version()}")
+        return
+
+    workdir = workdir or Path.cwd()
+    config.set_debug(debug)
+    config.set_verbose(verbose)
+
+    agent = AgentSingleton.get_agent()
+
+    if ask:
+        handle_ask(ask, workdir, include, False, agent)
+    elif play:
+        handle_play(play, workdir, False)
+    elif change_request == "scan":
+        paths_to_scan = include if include else [workdir]
+        handle_scan(paths_to_scan, workdir)
+    elif change_request:
+        handle_request(change_request, workdir, include, False, agent)
+    else:
+        console = Console()
+        console.print("Error: Please provide a change request or use --ask/--play options")
+        raise typer.Exit(1)
+
+def main():
+    typer.run(typer_main)
+
+if __name__ == "__main__":
+    main()

janito-0.5.0/janito/_contextparser.py

@@ -0,0 +1,113 @@
+from typing import List, Tuple, Optional, NamedTuple
+from difflib import SequenceMatcher
+from janito.config import config
+from rich.console import Console
+
+class ContextError(NamedTuple):
+    """Contains error details for context matching failures"""
+    pre_context: List[str]
+    post_context: List[str]
+    content: str
+
+def parse_change_block(content: str) -> Tuple[List[str], List[str], List[str]]:
+    """Parse a change block into pre-context, post-context and change lines.
+    Returns (pre_context_lines, post_context_lines, change_lines)"""
+    pre_context_lines = []
+    post_context_lines = []
+    change_lines = []
+    in_pre_context = True
+    
+    for line in content.splitlines():
+        if line.startswith('='):
+            if in_pre_context:
+                pre_context_lines.append(line[1:])
+            else:
+                post_context_lines.append(line[1:])
+        elif line.startswith('>'):
+            in_pre_context = False
+            change_lines.append(line[1:])
+            
+    return pre_context_lines, post_context_lines, change_lines
+
+def find_context_match(file_content: str, pre_context: List[str], post_context: List[str], min_context: int = 2) -> Optional[Tuple[int, int]]:
+    """Find exact matching location using line-by-line matching.
+    Returns (start_index, end_index) or None if no match found."""
+    if not (pre_context or post_context) or (len(pre_context) + len(post_context)) < min_context:
+        return None
+
+    file_lines = file_content.splitlines()
+    
+    # Function to check if lines match at a given position
+    def lines_match_at(pos: int, target_lines: List[str]) -> bool:
+        if pos + len(target_lines) > len(file_lines):
+            return False
+        return all(a == b for a, b in zip(file_lines[pos:pos + len(target_lines)], target_lines))
+
+    # For debug output
+    debug_matches = []
+    
+    # Try to find pre_context match
+    pre_match_pos = None
+    if pre_context:
+        for i in range(len(file_lines) - len(pre_context) + 1):
+            if lines_match_at(i, pre_context):
+                pre_match_pos = i
+                break
+            if config.debug:
+                # Record first 20 non-matches for debug output
+                if len(debug_matches) < 20:
+                    debug_matches.append((i, file_lines[i:i + len(pre_context)]))
+
+    # Try to find post_context match after pre_context if found
+    if pre_match_pos is not None and post_context:
+        expected_post_pos = pre_match_pos + len(pre_context)
+        if not lines_match_at(expected_post_pos, post_context):
+            pre_match_pos = None
+
+    if pre_match_pos is None and config.debug:
+        console = Console()
+        console.print("\n[bold red]Context Match Debug:[/bold red]")
+        
+        if pre_context:
+            console.print("\n[yellow]Expected pre-context:[/yellow]")
+            for i, line in enumerate(pre_context):
+                console.print(f"  {i+1:2d} | '{line}'")
+
+        if post_context:
+            console.print("\n[yellow]Expected post-context:[/yellow]")
+            for i, line in enumerate(post_context):
+                console.print(f"  {i+1:2d} | '{line}'")
+
+        console.print("\n[yellow]First 20 attempted matches in file:[/yellow]")
+        for pos, lines in debug_matches:
+            console.print(f"\n[cyan]At line {pos+1}:[/cyan]")
+            for i, line in enumerate(lines):
+                match_status = "≠" if i < len(pre_context) and line != pre_context[i] else "="
+                console.print(f"  {i+1:2d} | '{line}' {match_status}")
+
+        return None
+
+    if pre_match_pos is None:
+        return None
+
+    end_pos = pre_match_pos + len(pre_context)
+    
+    return pre_match_pos, end_pos
+
+def apply_changes(content: str, 
+                 pre_context_lines: List[str], 
+                 post_context_lines: List[str], 
+                 change_lines: List[str]) -> Optional[Tuple[str, Optional[ContextError]]]:
+    """Apply changes with context matching, returns (new_content, error_details)"""
+    if not content.strip() and not pre_context_lines and not post_context_lines:
+        return '\n'.join(change_lines), None
+
+    pre_context = '\n'.join(pre_context_lines)
+    post_context = '\n'.join(post_context_lines)
+    
+    if pre_context and pre_context not in content:
+        return None, ContextError(pre_context_lines, post_context_lines, content)
+    
+    if post_context and post_context not in content:
+        return None, ContextError(pre_context_lines, post_context_lines, content)
+

janito-0.5.0/janito/agents/__init__.py

@@ -0,0 +1,22 @@
+import os
+
+SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. I help you with coding tasks while being clear and concise in my responses."""
+
+ai_backend = os.getenv('AI_BACKEND', 'claudeai').lower()
+
+if ai_backend == 'openai':
+    from .openai import OpenAIAgent as AIAgent
+elif ai_backend == 'claudeai':
+    from .claudeai import ClaudeAIAgent as AIAgent
+else:
+    raise ValueError(f"Unsupported AI_BACKEND: {ai_backend}")
+
+class AgentSingleton:
+    _instance = None
+
+    @classmethod
+    def get_agent(cls):
+        if cls._instance is None:
+            cls._instance = AIAgent(SYSTEM_PROMPT)
+        return cls._instance
+

janito-0.5.0/janito/agents/agent.py

@@ -0,0 +1,21 @@
+
+from abc import ABC, abstractmethod
+from threading import Event
+from typing import Optional, List, Tuple
+
+class Agent(ABC):
+    """Abstract base class for AI agents"""
+    def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
+        self.api_key = api_key
+        self.system_message = system_prompt
+        self.last_prompt = None
+        self.last_full_message = None
+        self.last_response = None
+        self.messages_history: List[Tuple[str, str]] = []
+        if system_prompt:
+            self.messages_history.append(("system", system_prompt))
+
+    @abstractmethod
+    def send_message(self, message: str, stop_event: Event = None) -> str:
+        """Send message to AI service and return response"""
+        pass

janito-0.5.0/janito/agents/claudeai.py

@@ -0,0 +1,64 @@
+import anthropic
+import os
+from typing import Optional
+from threading import Event
+from .agent import Agent
+
+class ClaudeAIAgent(Agent):
+    """Handles interaction with Claude API, including message handling"""
+    DEFAULT_MODEL = "claude-3-5-sonnet-20241022"
+    
+    def __init__(self, system_prompt: str = None):
+        self.api_key = os.getenv('ANTHROPIC_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("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.system_message = system_prompt
+        self.last_prompt = None
+        self.last_full_message = None
+        self.last_response = None
+        self.messages_history = []
+        if system_prompt:
+            self.messages_history.append(("system", system_prompt))
+
+    def send_message(self, message: str, stop_event: Event = None) -> str:
+        """Send message to Claude API and return response"""
+        self.messages_history.append(("user", message))
+        # Store the full message
+        self.last_full_message = message
+        
+        try:
+            # Check if already cancelled
+            if stop_event and stop_event.is_set():
+                return ""
+            
+            response = self.client.messages.create(
+                model=self.model,  # Use discovered model
+                system=self.system_message,
+                max_tokens=8192,
+                messages=[
+                    {"role": "user", "content": message}
+                ],
+                temperature=0,
+            )
+            
+            # Handle response
+            response_text = response.content[0].text
+            
+            # Only store and process response if not cancelled
+            if not (stop_event and stop_event.is_set()):
+                self.last_response = response_text
+                self.messages_history.append(("assistant", response_text))
+            
+            # Always return the response, let caller handle cancellation
+            return response_text
+            
+        except KeyboardInterrupt:
+            if stop_event:
+                stop_event.set()
+            return ""

janito-0.5.0/janito/agents/openai.py

@@ -0,0 +1,53 @@
+import openai  # updated import
+import os
+from typing import Optional
+from threading import Event
+from .agent import Agent
+
+class OpenAIAgent(Agent):
+    """Handles interaction with OpenAI API, including message handling"""
+    DEFAULT_MODEL = "o1-mini-2024-09-12"
+    
+    def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
+        super().__init__(api_key, system_prompt)
+        if not system_prompt:
+            raise ValueError("system_prompt is required")
+        self.api_key = api_key or os.getenv('OPENAI_API_KEY')
+        if not self.api_key:
+            raise ValueError("OPENAI_API_KEY environment variable is required")
+        openai.api_key = self.api_key
+        openai.organization = os.getenv("OPENAI_ORG")
+        self.client = openai.Client()  # initialized client
+        self.model = os.getenv('OPENAI_MODEL', "o1-mini-2024-09-12")  # reverted to original default model
+
+    def send_message(self, message: str, stop_event: Event = None) -> str:
+        """Send message to OpenAI API and return response"""
+        self.messages_history.append(("user", message))
+        self.last_full_message = message
+        
+        try:
+            if stop_event and stop_event.is_set():
+                return ""
+            
+            #messages = [{"role": "system", "content": self.system_message}]
+            messages = [{"role": "user", "content": message}]
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                max_completion_tokens=4000,
+                temperature=1,
+            )
+            
+            response_text = response.choices[0].message.content
+            
+            if not (stop_event and stop_event.is_set()):
+                self.last_response = response_text
+                self.messages_history.append(("assistant", response_text))
+            
+            return response_text
+            
+        except KeyboardInterrupt:
+            if stop_event:
+                stop_event.set()
+            return ""

janito-0.5.0/janito/agents/test.py

@@ -0,0 +1,34 @@
+import unittest
+import os
+from unittest.mock import patch, MagicMock
+from .openai import OpenAIAgent
+from .claudeai import AIAgent
+
+class TestAIAgents(unittest.TestCase):
+    def setUp(self):
+        self.system_prompt = "You are a helpful assistant."
+        self.test_message = "Hello, how are you?"
+        
+    def test_openai_agent_initialization(self):
+        with patch.dict(os.environ, {'OPENAI_API_KEY': 'test_key'}):
+            agent = OpenAIAgent(system_prompt=self.system_prompt)
+
+    def test_claudeai_agent_initialization(self):
+        with patch.dict(os.environ, {'ANTHROPIC_API_KEY': 'test_key'}):
+            agent = AIAgent(system_prompt=self.system_prompt)
+
+    def test_openai_agent_send_message(self):
+        with patch('openai.OpenAI.chat.completions.create') as mock_create:
+            mock_response = MagicMock()
+            mock_response.choices[0].message.content = "I'm good, thank you!"
+            mock_create.return_value = mock_response
+            response = self.openai_agent.send_message(self.test_message)
+            self.assertEqual(response, "I'm good, thank you!")
+
+    def test_claudeai_agent_send_message(self):
+        with patch('anthropic.Client.messages.create') as mock_create:
+            mock_response = MagicMock()
+            mock_response.content[0].text = "I'm Claude, how can I assist you?"
+            mock_create.return_value = mock_response
+            response = self.claudeai_agent.send_message(self.test_message)
+            self.assertEqual(response, "I'm Claude, how can I assist you?")