janito 0.5.0__tar.gz → 0.7.0__tar.gz

janito-0.7.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 0.7.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)
+- [Usage](#usage)
+  - [Basic Commands](#basic-commands)
+  - [Examples](#examples)
+- [Configuration](#configuration)
+- [Development](#development)
+- [License](#license)
+
+## Features
+
+- 🤖 AI-powered code analysis and modifications
+- 🔄 Incremental code changes with search/replace operations
+- 🎯 Precise text modifications with context matching
+- 💬 Natural language interface for code operations
+- 🔍 Interactive code exploration
+- 📝 Automatic documentation generation
+- ⚡ Fast and efficient codebase navigation
+- 💾 Smart Claude AI prompt caching for faster responses
+
+## Installation
+
+### Prerequisites
+
+- Python 3.8 or higher
+- Anthropic API key (with smart caching to reduce API costs)
+
+### Install via pip
+
+```bash
+pip install janito
+```
+
+### Set up API key
+
+```bash
+export ANTHROPIC_API_KEY=your_api_key_here
+```
+
+## Usage
+
+### Basic Commands
+
+Janito supports incremental code changes through precise text operations:
+- Search and replace with context matching
+- Delete specific code blocks
+- File operations (create, replace, rename, move, remove)
+
+```bash
+# Start interactive shell
+janito
+
+# Modify code with natural language
+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
+```
+
+### Examples
+
+1. Add documentation to a file:
+```bash
+janito "add docstrings to all functions in src/main.py"
+```
+
+2. Analyze code structure:
+```bash
+janito --ask "what are the main classes in this project?"
+```
+
+3. Refactor code:
+```bash
+janito "convert this function to use async/await"
+```
+
+4. Generate tests:
+```bash
+janito "create unit tests for the User class"
+```
+
+## Configuration
+
+### Environment Variables
+
+- `ANTHROPIC_API_KEY`: Anthropic API key for Claude AI
+- `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
+
+## Development
+
+### Setting up Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/joaompinto/janito.git
+cd janito
+
+# Create and activate virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install development dependencies
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+MIT License - see [LICENSE](LICENSE)

janito-0.7.0/README.md

@@ -0,0 +1,142 @@
+# 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)
+- [Usage](#usage)
+  - [Basic Commands](#basic-commands)
+  - [Examples](#examples)
+- [Configuration](#configuration)
+- [Development](#development)
+- [License](#license)
+
+## Features
+
+- 🤖 AI-powered code analysis and modifications
+- 🔄 Incremental code changes with search/replace operations
+- 🎯 Precise text modifications with context matching
+- 💬 Natural language interface for code operations
+- 🔍 Interactive code exploration
+- 📝 Automatic documentation generation
+- ⚡ Fast and efficient codebase navigation
+- 💾 Smart Claude AI prompt caching for faster responses
+
+## Installation
+
+### Prerequisites
+
+- Python 3.8 or higher
+- Anthropic API key (with smart caching to reduce API costs)
+
+### Install via pip
+
+```bash
+pip install janito
+```
+
+### Set up API key
+
+```bash
+export ANTHROPIC_API_KEY=your_api_key_here
+```
+
+## Usage
+
+### Basic Commands
+
+Janito supports incremental code changes through precise text operations:
+- Search and replace with context matching
+- Delete specific code blocks
+- File operations (create, replace, rename, move, remove)
+
+```bash
+# Start interactive shell
+janito
+
+# Modify code with natural language
+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
+```
+
+### Examples
+
+1. Add documentation to a file:
+```bash
+janito "add docstrings to all functions in src/main.py"
+```
+
+2. Analyze code structure:
+```bash
+janito --ask "what are the main classes in this project?"
+```
+
+3. Refactor code:
+```bash
+janito "convert this function to use async/await"
+```
+
+4. Generate tests:
+```bash
+janito "create unit tests for the User class"
+```
+
+## Configuration
+
+### Environment Variables
+
+- `ANTHROPIC_API_KEY`: Anthropic API key for Claude AI
+- `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
+
+## Development
+
+### Setting up Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/joaompinto/janito.git
+cd janito
+
+# Create and activate virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install development dependencies
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+MIT License - see [LICENSE](LICENSE)

janito-0.7.0/janito/__init__.py

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

janito-0.7.0/janito/__main__.py

@@ -0,0 +1,142 @@
+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.config import config
+from janito.workspace import workset
+from janito.workspace.types import ScanType  # Add this import
+from .cli.commands import (
+    handle_request, handle_ask, handle_play, 
+    handle_scan, handle_demo
+)
+
+app = typer.Typer(pretty_exceptions_enable=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"),
+    skip_work: bool = typer.Option(False, "--skip-work", 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:
+        handle_demo()
+        return
+
+    if history:
+        from janito.cli.history import display_history
+        display_history()
+        return
+
+    # Configure workspace
+    config.set_workspace_dir(workspace_dir)
+    config.set_debug(debug)
+    config.set_verbose(verbose)
+    config.set_auto_apply(auto_apply)
+    config.set_tui(tui)
+
+    # 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 and not workset.paths:
+        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)
+
+    if test_cmd:
+        config.set_test_cmd(test_cmd)
+
+    # Refresh workset content before handling commands
+    workset.refresh()
+
+    if ask:
+        handle_ask(ask)
+    elif play:
+        handle_play(play)
+    elif scan:
+        handle_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.5.0 → janito-0.7.0}/janito/agents/__init__.py

@@ -5,18 +5,18 @@ SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. I help
 ai_backend = os.getenv('AI_BACKEND', 'claudeai').lower()
 
 if ai_backend == 'openai':
+    import warnings
+    warnings.warn(
+        "Using deprecated OpenAI backend. Please switch to Claude AI backend by removing AI_BACKEND=openai "
+        "from your environment variables.",
+        DeprecationWarning,
+        stacklevel=2
+    )
     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
-
+# Create a singleton instance
+agent = AIAgent(SYSTEM_PROMPT)

{janito-0.5.0 → janito-0.7.0}/janito/agents/agent.py

@@ -1,4 +1,3 @@
-
 from abc import ABC, abstractmethod
 from threading import Event
 from typing import Optional, List, Tuple
@@ -16,6 +15,14 @@ class Agent(ABC):
             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"""
+    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.7.0/janito/agents/claudeai.py

@@ -0,0 +1,45 @@
+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
+
+
+    def send_message(self, message: str, system_message: str = 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
+        
+        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.5.0 → janito-0.7.0}/janito/agents/openai.py

@@ -5,7 +5,11 @@ from threading import Event
 from .agent import Agent
 
 class OpenAIAgent(Agent):
-    """Handles interaction with OpenAI API, including message handling"""
+    """[DEPRECATED] Handles interaction with OpenAI API, including message handling.
+
+    This backend is no longer actively maintained. Please use the Claude AI backend instead.
+    The code is kept for backward compatibility but may be removed in future versions.
+    """
     DEFAULT_MODEL = "o1-mini-2024-09-12"
     
     def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):

janito-0.7.0/janito/change/__init__.py

@@ -0,0 +1,32 @@
+"""
+This package provides the following change flow steps:
+
+- Create a preview directory
+- Build change request prompt
+- Send change request to AI agent
+- Parse the response into changes
+- Save response to history file
+- Preview the changes (applying them to the preview directory)
+- Validate the changes
+- Run tests if specified
+- Show the change view (using janito.changeviewer)
+- Prompt the user to apply the changes to the working directory
+- Apply the changes
+"""
+
+from typing import Tuple
+from pathlib import Path
+from ..agents import agent  # Updated import to use singleton directly
+from .parser import build_change_request_prompt, parse_response
+from .preview import setup_workspace_dir_preview
+from .applier.main import ChangeApplier
+
+__all__ = [
+    'build_change_request_prompt',
+    'get_change_response',
+    'parse_response',
+    'setup_workspace_dir_preview',
+    'parse_change_response',
+    'save_change_response',
+    'ChangeApplier'
+]

{janito-0.5.0/janito → janito-0.7.0/janito/change}/analysis/__init__.py

@@ -4,30 +4,20 @@ This module provides functionality for analyzing and displaying code changes.
 """
 
 from .options import AnalysisOption, parse_analysis_options
-from .display import (
-    format_analysis,
-    get_history_file_type,
-    get_history_path,
-    get_timestamp,
-    save_to_file
-)
+from .view import format_analysis, prompt_user, get_option_selection
 from .prompts import (
     build_request_analysis_prompt,
-    get_option_selection,
-    prompt_user,
     validate_option_letter
 )
+from .analyze import analyze_request
 
 __all__ = [
     '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'
-]
+    'validate_option_letter',
+    'analyze_request'
+]

janito-0.7.0/janito/change/analysis/__main__.py

@@ -0,0 +1,7 @@
+"""Main entry point for the analysis module."""
+
+from .analyze import analyze_request
+from janito.config import config
+from janito.workspace import collect_files_content
+from pathlib import Path
+