janito 0.6.0__tar.gz → 0.8.0__tar.gz

janito-0.8.0/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.env
+.venv
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# Testing
+.coverage
+htmlcov/
+.tox/
+.pytest_cache/
+.janito_last_response.txt

{janito-0.6.0 → janito-0.8.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 João Pinto
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2024 João Pinto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

janito-0.8.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 0.8.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: 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)
+[![Python Versions](https://img.shields.io/pypi/pyversions/janito.svg)](https://pypi.org/project/janito/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Janito is an AI-powered CLI tool designed to help developers manage and modify their codebase with ease. It leverages advanced AI models to understand and transform your code intelligently.
+
+## ✨ Features
+
+### 🔄 Code Modifications
+- **Smart Code Changes**: Automated code modifications with AI understanding
+- **Context-Aware**: Considers your entire codebase for accurate changes
+- **Preview & Validate**: Review changes before applying them
+
+### 💡 Code Analysis
+- **Intelligent Queries**: Ask questions about your codebase
+- **Deep Understanding**: Get detailed explanations about code functionality
+- **Context-Rich Responses**: Answers based on your actual code
+
+### ⚙️ Easy Configuration
+- **Multiple AI Backends**: Support for Claude and DeepSeek AI
+- **Flexible Setup**: Simple environment variable configuration
+- **Workspace Control**: Fine-grained control over scanned files
+
+## 🚀 Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- pip package manager
+
+### Install from PyPI
+```bash
+pip install janito
+```
+
+## 🔧 Configuration
+
+Set up your preferred AI backend using environment variables:
+
+### For Claude AI
+```bash
+export ANTHROPIC_API_KEY=your_api_key
+export AI_BACKEND=claudeai  # Optional, detected from API key
+```
+
+### For DeepSeek AI
+```bash
+export DEEPSEEK_API_KEY=your_api_key
+export AI_BACKEND=deepseekai  # Optional, detected from API key
+```
+
+## 📖 Usage
+
+### Basic Commands
+
+1. **Ask Questions**
+```bash
+janito --ask "How does the error handling work in this codebase?"
+```
+
+2. **Request Changes**
+```bash
+janito "Add error handling to the process_data function"
+```
+
+3. **Preview Files**
+```bash
+janito --scan
+```
+
+### Advanced Options
+
+- **Workspace Directory**: `-w, --workspace_dir PATH`
+- **Include Paths**: `-i, --include PATH`
+- **Recursive Scan**: `-r, --recursive PATH`
+- **Debug Mode**: `--debug`
+- **Verbose Output**: `--verbose`
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

janito-0.8.0/README.md

@@ -0,0 +1,82 @@
+# 🤖 Janito
+
+[![PyPI version](https://badge.fury.io/py/janito.svg)](https://badge.fury.io/py/janito)
+[![Python Versions](https://img.shields.io/pypi/pyversions/janito.svg)](https://pypi.org/project/janito/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Janito is an AI-powered CLI tool designed to help developers manage and modify their codebase with ease. It leverages advanced AI models to understand and transform your code intelligently.
+
+## ✨ Features
+
+### 🔄 Code Modifications
+- **Smart Code Changes**: Automated code modifications with AI understanding
+- **Context-Aware**: Considers your entire codebase for accurate changes
+- **Preview & Validate**: Review changes before applying them
+
+### 💡 Code Analysis
+- **Intelligent Queries**: Ask questions about your codebase
+- **Deep Understanding**: Get detailed explanations about code functionality
+- **Context-Rich Responses**: Answers based on your actual code
+
+### ⚙️ Easy Configuration
+- **Multiple AI Backends**: Support for Claude and DeepSeek AI
+- **Flexible Setup**: Simple environment variable configuration
+- **Workspace Control**: Fine-grained control over scanned files
+
+## 🚀 Installation
+
+### Prerequisites
+- Python 3.8 or higher
+- pip package manager
+
+### Install from PyPI
+```bash
+pip install janito
+```
+
+## 🔧 Configuration
+
+Set up your preferred AI backend using environment variables:
+
+### For Claude AI
+```bash
+export ANTHROPIC_API_KEY=your_api_key
+export AI_BACKEND=claudeai  # Optional, detected from API key
+```
+
+### For DeepSeek AI
+```bash
+export DEEPSEEK_API_KEY=your_api_key
+export AI_BACKEND=deepseekai  # Optional, detected from API key
+```
+
+## 📖 Usage
+
+### Basic Commands
+
+1. **Ask Questions**
+```bash
+janito --ask "How does the error handling work in this codebase?"
+```
+
+2. **Request Changes**
+```bash
+janito "Add error handling to the process_data function"
+```
+
+3. **Preview Files**
+```bash
+janito --scan
+```
+
+### Advanced Options
+
+- **Workspace Directory**: `-w, --workspace_dir PATH`
+- **Include Paths**: `-i, --include PATH`
+- **Recursive Scan**: `-r, --recursive PATH`
+- **Debug Mode**: `--debug`
+- **Verbose Output**: `--verbose`
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

janito-0.8.0/janito/__main__.py

@@ -0,0 +1,128 @@
+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 .version import get_version
+
+from janito.config import config
+from janito.workspace import workset
+from janito.workspace.models import ScanType  # Add this import
+from .cli.commands import (
+    handle_request, handle_ask, 
+    handle_scan
+)
+
+
+app = typer.Typer(pretty_exceptions_enable=False)
+
+# Initialize console for CLI output
+console = Console()
+
+
+
+def typer_main(
+    user_request: Optional[str] = typer.Argument(None, help="User request"),
+    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: bool = typer.Option(False, "--ask", help="Treat the request as a question about the codebase"),
+    play: Optional[Path] = typer.Option(None, "--play", help="Replay a saved prompt file"),
+    replay: bool = typer.Option(False, "--replay", help="Trigger the replay response flow"),
+    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"),
+    recursive: Optional[List[Path]] = typer.Option(None, "-r", "--recursive", help="Paths to scan recursively (directories only)"),
+    skip_work: bool = typer.Option(False, "-s", "--skip-work", help="Skip scanning workspace_dir when using include paths"),
+):
+    """Janito - AI-powered code modification assistant"""
+    if version:
+        console.print(f"Janito version {get_version()}")
+        return
+
+    # Check if workspace directory exists and handle creation
+    if workspace_dir and not workspace_dir.exists():
+        create = typer.confirm(f"\nWorkspace directory '{workspace_dir}' does not exist. Create it?")
+        if create:
+            try:
+                workspace_dir.mkdir(parents=True)
+                console.print(f"[green]Created workspace directory: {workspace_dir}[/green]")
+            except Exception as e:
+                error_text = Text(f"\nError: Failed to create workspace directory: {e}", style="red")
+                rich_print(error_text)
+                raise typer.Exit(1)
+        else:
+            error_text = Text("\nError: Workspace directory does not exist and was not created", style="red")
+            rich_print(error_text)
+            raise typer.Exit(1)
+
+    # Configure workspace
+    config.set_workspace_dir(workspace_dir)
+    config.set_debug(debug)
+    config.set_verbose(verbose)
+    config.set_auto_apply(auto_apply)
+
+    # Configure workset with scan paths
+    if include:
+        if config.debug:
+            Console(stderr=True).print("[cyan]Debug: Processing include paths...[/cyan]")
+        for path in include:
+            full_path = config.workspace_dir / path
+            if not full_path.resolve().is_relative_to(config.workspace_dir):
+                error_text = Text(f"\nError: Path must be within workspace: {path}", style="red")
+                rich_print(error_text)
+                raise typer.Exit(1)
+            workset.add_scan_path(path, ScanType.PLAIN)
+
+    if recursive:
+        if config.debug:
+            Console(stderr=True).print("[cyan]Debug: Processing recursive paths...[/cyan]")
+        for path in recursive:
+            full_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)
+            if not full_path.resolve().is_relative_to(config.workspace_dir):
+                error_text = Text(f"\nError: Path must be within workspace: {path}", style="red")
+                rich_print(error_text)
+                raise typer.Exit(1)
+            workset.add_scan_path(path, ScanType.RECURSIVE)
+
+    # Validate skip_work usage
+    if skip_work:
+        # Check if any include or recursive paths are provided
+        if not include and not recursive:
+            error_text = Text("\nError: --skip-work requires at least one include path (-i or -r)", style="red")
+            rich_print(error_text)
+            raise typer.Exit(1)
+        # Remove root path from workset when skip_work is enabled
+        workset._scan_paths = [p for p in workset._scan_paths if p.path != Path(".")]
+
+    if test_cmd:
+        config.set_test_cmd(test_cmd)
+
+    # Refresh workset content before handling commands
+    workset.refresh()
+
+    if ask:
+        if not user_request:
+            error_text = Text("\nError: No question provided. Please provide a question as the main argument when using --ask", style="red")
+            rich_print(error_text)
+            raise typer.Exit(1)
+        handle_ask(user_request)
+    elif play:
+        handle_play(play)
+    elif scan:
+        handle_scan()
+    else:
+        handle_request(user_request, replay=replay)
+
+def main():
+    typer.run(typer_main)
+
+if __name__ == "__main__":
+    main()

janito-0.8.0/janito/agents/__init__.py

@@ -0,0 +1,22 @@
+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-0.8.0/janito/agents/agent.py

@@ -0,0 +1,25 @@
+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-0.8.0/janito/agents/claudeai.py

@@ -0,0 +1,41 @@
+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-0.8.0/janito/agents/deepseekai.py

@@ -0,0 +1,47 @@
+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-0.8.0/janito/change/applied_blocks.py

@@ -0,0 +1,34 @@
+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]