janito 0.4.0__tar.gz → 0.6.0__tar.gz

janito-0.6.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 0.6.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
+License-File: LICENSE
+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
+
+[![PyPI version](https://badge.fury.io/py/janito.svg)](https://badge.fury.io/py/janito)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+AI-powered CLI tool for code modifications and analysis. Janito helps you modify, analyze, and understand your codebase using natural language commands.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+  - [Prerequisites](#prerequisites)
+  - [Steps](#steps)
+- [Usage](#usage)
+  - [Basic Commands](#basic-commands)
+  - [Common Use Cases](#common-use-cases)
+- [Configuration](#configuration)
+  - [Environment Variables](#environment-variables)
+  - [Command Line Options](#command-line-options)
+- [Troubleshooting](#troubleshooting)
+  - [Common Issues](#common-issues)
+  - [Error Messages](#error-messages)
+- [Contributing](#contributing)
+- [License](#license)
+
+## ✨ Features
+
+- Natural language code modifications
+- Codebase analysis and question answering
+- Smart search and replace with indentation awareness
+- Git-aware operations
+- Interactive shell mode
+- Change preview and validation
+- Automatic backup and restore
+
+## 🚀 Installation
+
+### Prerequisites
+
+- Python 3.8 or higher
+- pip package manager
+- An Anthropic API key (default) or OpenAI API key
+
+### Steps
+
+1. Install using pip:
+```bash
+pip install janito
+```
+
+2. Configure your API key:
+
+For Anthropic Claude (default):
+```bash
+export ANTHROPIC_API_KEY=your_api_key_here
+```
+
+For OpenAI:
+```bash
+export OPENAI_API_KEY=your_api_key_here
+export AI_BACKEND=openai
+```
+
+## 💡 Usage
+
+### Basic Commands
+
+```bash
+# Modify code
+janito "add docstrings to this file"
+
+# Ask questions about the codebase
+janito --ask "explain the main function in this file"
+
+# Preview files that would be analyzed
+janito --scan
+
+# Start interactive shell
+janito
+```
+
+### Common Use Cases
+
+1. Code Documentation:
+```bash
+janito "add type hints to all functions"
+janito "improve docstrings with more details"
+```
+
+2. Code Analysis:
+```bash
+janito --ask "what are the main classes in this project?"
+janito --ask "explain the error handling flow"
+```
+
+3. Code Refactoring:
+```bash
+janito "convert this class to use dataclasses"
+janito "split this large function into smaller ones"
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+- `ANTHROPIC_API_KEY`: Anthropic API key
+- `OPENAI_API_KEY`: OpenAI API key (if using OpenAI backend)
+- `AI_BACKEND`: AI provider ('claudeai' or 'openai')
+- `JANITO_TEST_CMD`: Default test command to run after changes
+
+### Command Line Options
+
+- `-w, --workspace_dir`: Set working directory
+- `-i, --include`: Additional paths to include
+- `--debug`: Show debug information
+- `--verbose`: Show verbose output
+- `--auto-apply`: Apply changes without confirmation
+- `--history`: Display history of requests
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+1. API Key Issues:
+```bash
+# Verify API key is set
+echo $ANTHROPIC_API_KEY
+
+# Temporarily set API key for single command
+ANTHROPIC_API_KEY=your_key janito "your request"
+```
+
+2. Path Issues:
+```bash
+# Use absolute paths if having issues with relative paths
+janito -w /full/path/to/project "your request"
+
+# Specify additional paths explicitly
+janito -i ./src -i ./tests "your request"
+```
+
+3. Debug Mode:
+```bash
+# Enable debug output for troubleshooting
+janito --debug "your request"
+```
+
+### Error Messages
+
+- "No command given": Provide a change request or command
+- "No input provided": Check if using --input mode correctly
+- "Duplicate path provided": Remove duplicate paths from includes
+
+## 👥 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE)

janito-0.6.0/README.md

@@ -0,0 +1,160 @@
+# Janito
+
+[![PyPI version](https://badge.fury.io/py/janito.svg)](https://badge.fury.io/py/janito)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+AI-powered CLI tool for code modifications and analysis. Janito helps you modify, analyze, and understand your codebase using natural language commands.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+  - [Prerequisites](#prerequisites)
+  - [Steps](#steps)
+- [Usage](#usage)
+  - [Basic Commands](#basic-commands)
+  - [Common Use Cases](#common-use-cases)
+- [Configuration](#configuration)
+  - [Environment Variables](#environment-variables)
+  - [Command Line Options](#command-line-options)
+- [Troubleshooting](#troubleshooting)
+  - [Common Issues](#common-issues)
+  - [Error Messages](#error-messages)
+- [Contributing](#contributing)
+- [License](#license)
+
+## ✨ Features
+
+- Natural language code modifications
+- Codebase analysis and question answering
+- Smart search and replace with indentation awareness
+- Git-aware operations
+- Interactive shell mode
+- Change preview and validation
+- Automatic backup and restore
+
+## 🚀 Installation
+
+### Prerequisites
+
+- Python 3.8 or higher
+- pip package manager
+- An Anthropic API key (default) or OpenAI API key
+
+### Steps
+
+1. Install using pip:
+```bash
+pip install janito
+```
+
+2. Configure your API key:
+
+For Anthropic Claude (default):
+```bash
+export ANTHROPIC_API_KEY=your_api_key_here
+```
+
+For OpenAI:
+```bash
+export OPENAI_API_KEY=your_api_key_here
+export AI_BACKEND=openai
+```
+
+## 💡 Usage
+
+### Basic Commands
+
+```bash
+# Modify code
+janito "add docstrings to this file"
+
+# Ask questions about the codebase
+janito --ask "explain the main function in this file"
+
+# Preview files that would be analyzed
+janito --scan
+
+# Start interactive shell
+janito
+```
+
+### Common Use Cases
+
+1. Code Documentation:
+```bash
+janito "add type hints to all functions"
+janito "improve docstrings with more details"
+```
+
+2. Code Analysis:
+```bash
+janito --ask "what are the main classes in this project?"
+janito --ask "explain the error handling flow"
+```
+
+3. Code Refactoring:
+```bash
+janito "convert this class to use dataclasses"
+janito "split this large function into smaller ones"
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+- `ANTHROPIC_API_KEY`: Anthropic API key
+- `OPENAI_API_KEY`: OpenAI API key (if using OpenAI backend)
+- `AI_BACKEND`: AI provider ('claudeai' or 'openai')
+- `JANITO_TEST_CMD`: Default test command to run after changes
+
+### Command Line Options
+
+- `-w, --workspace_dir`: Set working directory
+- `-i, --include`: Additional paths to include
+- `--debug`: Show debug information
+- `--verbose`: Show verbose output
+- `--auto-apply`: Apply changes without confirmation
+- `--history`: Display history of requests
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+1. API Key Issues:
+```bash
+# Verify API key is set
+echo $ANTHROPIC_API_KEY
+
+# Temporarily set API key for single command
+ANTHROPIC_API_KEY=your_key janito "your request"
+```
+
+2. Path Issues:
+```bash
+# Use absolute paths if having issues with relative paths
+janito -w /full/path/to/project "your request"
+
+# Specify additional paths explicitly
+janito -i ./src -i ./tests "your request"
+```
+
+3. Debug Mode:
+```bash
+# Enable debug output for troubleshooting
+janito --debug "your request"
+```
+
+### Error Messages
+
+- "No command given": Provide a change request or command
+- "No input provided": Check if using --input mode correctly
+- "Duplicate path provided": Remove duplicate paths from includes
+
+## 👥 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE)

janito-0.6.0/janito/__init__.py

@@ -0,0 +1,2 @@
+"""Core package initialization for Janito."""
+

janito-0.6.0/janito/__main__.py

@@ -0,0 +1,135 @@
+import typer
+from typing import Optional, List, Set
+from pathlib import Path
+from rich.text import Text
+from rich import print as rich_print
+from rich.console import Console
+from rich.text import Text
+from .version import get_version
+
+from janito.agents import agent
+from janito.config import config
+
+from .cli.commands import handle_request, handle_ask, handle_play, handle_scan
+
+app = typer.Typer(add_completion=False)
+
+def validate_paths(paths: Optional[List[Path]]) -> Optional[List[Path]]:
+    """Validate include paths for duplicates.
+    
+    Args:
+        paths: List of paths to validate, or None if no paths provided
+        
+    Returns:
+        Validated list of paths or None if no paths provided
+    """
+    if not paths:  # This handles both None and empty list cases
+        return None
+
+    # Convert paths to absolute and resolve symlinks
+    resolved_paths: Set[Path] = set()
+    unique_paths: List[Path] = []
+
+    for path in paths:
+        resolved = path.absolute().resolve()
+        if resolved in resolved_paths:
+            error_text = Text(f"\nError: Duplicate path provided: {path} ", style="red")
+            rich_print(error_text)
+            raise typer.Exit(1)
+        resolved_paths.add(resolved)
+        unique_paths.append(path)
+
+    return unique_paths if unique_paths else None
+
+def typer_main(
+    change_request: str = typer.Argument(None, help="Change request or command"),
+    workspace_dir: Optional[Path] = typer.Option(None, "-w", "--workspace_dir", 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"),
+    scan: bool = typer.Option(False, "--scan", help="Preview files that would be analyzed"),
+    version: bool = typer.Option(False, "--version", help="Show version information"),
+    test_cmd: Optional[str] = typer.Option(None, "--test", help="Command to run tests after changes"),
+    auto_apply: bool = typer.Option(False, "--auto-apply", help="Apply changes without confirmation"),
+    tui: bool = typer.Option(False, "--tui", help="Use terminal user interface"),
+    history: bool = typer.Option(False, "--history", help="Display history of requests"),
+    recursive: Optional[List[Path]] = typer.Option(None, "-r", "--recursive", help="Paths to scan recursively (directories only)"),
+    demo: bool = typer.Option(False, "--demo", help="Run demo scenarios"),
+    skipwork: bool = typer.Option(False, "--skipwork", help="Skip scanning workspace_dir when using include paths"),
+):
+    """Janito - AI-powered code modification assistant"""
+    if version:
+        console = Console()
+        console.print(f"Janito version {get_version()}")
+        return
+
+    if demo:
+        from janito.cli.handlers.demo import DemoHandler
+        handler = DemoHandler()
+        handler.handle()
+        return
+
+    if history:
+        from janito.cli.history import display_history
+        display_history()
+        return
+
+    config.set_workspace_dir(workspace_dir)
+    config.set_debug(debug)
+    config.set_verbose(verbose)
+    config.set_auto_apply(auto_apply)
+    config.set_include(include)
+    config.set_tui(tui)
+    config.set_skipwork(skipwork)
+
+    # Validate skipwork usage
+    if skipwork and not include and not recursive:
+        error_text = Text("\nError: --skipwork requires at least one include path (-i or -r)", style="red")
+        rich_print(error_text)
+        raise typer.Exit(1)
+
+    if include:
+        resolved_paths = []
+        for path in include:
+            path = config.workspace_dir / path
+            resolved_paths.append(path.resolve())
+        config.set_include(resolved_paths)
+
+    # Validate recursive paths
+    if recursive:
+        resolved_paths = []
+        for path in recursive:
+            final_path = config.workspace_dir / path
+            if not path.is_dir():
+                error_text = Text(f"\nError: Recursive path must be a directory: {path} ", style="red")
+                rich_print(error_text)
+                raise typer.Exit(1)
+            resolved_paths.append(final_path.resolve())
+        config.set_recursive(resolved_paths)
+        include = include or []
+        include.extend(resolved_paths)
+        config.set_include(include)
+
+    if test_cmd:
+        config.set_test_cmd(test_cmd)
+
+    if ask:
+        handle_ask(ask)
+    elif play:
+        handle_play(play)
+    elif scan:
+        paths_to_scan = include or [config.workspace_dir]
+        handle_scan(paths_to_scan)
+    elif change_request:
+        handle_request(change_request)
+    else:
+        from janito.shell import start_shell
+        start_shell()
+
+def main():
+    typer.run(typer_main)
+
+if __name__ == "__main__":
+    main()

janito-0.6.0/janito/agents/__init__.py

@@ -0,0 +1,16 @@
+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}")
+
+# Create a singleton instance
+agent = AIAgent(SYSTEM_PROMPT)
+

janito-0.6.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.4.0/janito/claude.py → janito-0.6.0/janito/agents/claudeai.py

@@ -2,24 +2,27 @@ import anthropic
 import os
 from typing import Optional
 from threading import Event
+from .agent import Agent
 
-class ClaudeAPIAgent:
+class ClaudeAIAgent(Agent):
     """Handles interaction with Claude API, including message handling"""
-    def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
+    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")
-        self.api_key = api_key or os.getenv('ANTHROPIC_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 = "claude-3-5-sonnet-20241022"
+        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"""
@@ -35,23 +38,16 @@ class ClaudeAPIAgent:
             response = self.client.messages.create(
                 model=self.model,  # Use discovered model
                 system=self.system_message,
-                max_tokens=4000,
+                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
+            return response
             
         except KeyboardInterrupt:
             if stop_event:

janito-0.6.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.6.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?")