janito 0.7.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.7.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.7.0 → janito-0.8.0}/janito/__main__.py

@@ -1,142 +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 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__":
+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.7.0 → janito-0.8.0}/janito/agents/agent.py

@@ -1,28 +1,25 @@
-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, 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
-        """
+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