janito 0.5.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.5.0 → janito-0.6.0}/janito/agents/__init__.py

@@ -11,12 +11,6 @@ elif ai_backend == 'claudeai':
 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.6.0}/janito/agents/claudeai.py

@@ -22,9 +22,7 @@ class ClaudeAIAgent(Agent):
         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"""
@@ -47,16 +45,9 @@ class ClaudeAIAgent(Agent):
                 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/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.6.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.6.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
+

janito-0.6.0/janito/change/analysis/analyze.py

@@ -0,0 +1,61 @@
+"""Core analysis functionality."""
+
+from typing import Optional, Dict
+
+from janito.agents import agent
+from janito.common import progress_send_message
+from janito.config import config
+from .view import format_analysis
+from .options import AnalysisOption, parse_analysis_options
+from .prompts import (
+    build_request_analysis_prompt,
+    get_option_selection,
+    validate_option_letter
+)
+
+def analyze_request(
+    request: str,        
+    files_content_xml: str,
+    pre_select: str = ""
+) -> Optional[AnalysisOption]:
+    """
+    Analyze changes and get user selection.
+    
+    Args:
+        files_content: Content of files to analyze
+        request: User's change request
+        pre_select: Optional pre-selected option letter
+        
+    Returns:
+        Selected AnalysisOption or None if modified
+    """
+    # Build and send prompt
+    prompt = build_request_analysis_prompt(request, files_content_xml)
+    response = progress_send_message(prompt)
+    
+    # Parse options
+    options = parse_analysis_options(response)
+    if not options:
+        return None
+
+    if pre_select:
+        return options.get(pre_select.upper())
+
+    if config.tui:
+        from janito.tui import TuiApp
+        app = TuiApp(options=options)
+        app.run()
+        return app.selected_option
+        
+    # Display formatted analysis in terminal mode
+    format_analysis(response, config.raw)
+    
+    # Get user selection
+    while True:
+        selection = get_option_selection()
+        
+        if selection == 'M':
+            return None
+            
+        if validate_option_letter(selection, options):
+            return options[selection.upper()]