janito 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

janito/workspace/workspace.py

@@ -0,0 +1,335 @@
+from pathlib import Path
+from typing import List, Set, Dict, Optional, Tuple
+import time
+from rich.console import Console
+from janito.config import config
+from .models import WorksetContent, FileInfo, ScanPath  # Add ScanPath import
+import tempfile
+import shutil
+import pathspec
+
+class PathNotRelativeError(Exception):
+    """Raised when a path is not relative."""
+    pass
+
+class Workspace:
+    """Handles workspace scanning and content management."""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if not self._initialized:
+            self._content = WorksetContent()
+            self._root_dirs: Set[Path] = set()
+            self._initialized = True
+
+    def scan_files(self, paths: List[Path], recursive_paths: Set[Path]) -> None:
+        """Scan files from given paths and update content.
+        
+        Args:
+            paths: List of paths to scan
+            recursive_paths: Set of paths to scan recursively
+        """
+        for path in paths:
+            if path.is_absolute():
+                raise PathNotRelativeError(f"Path must be relative: {path}")
+        
+        scan_time = time.time()
+        
+        if config.debug:
+            console = Console(stderr=True)
+            console.print(f"\n[cyan]Debug: Starting scan of {len(paths)} paths[/cyan]")
+
+        # Find root directories if scanning workspace root
+        if not config.skip_work and Path(".") in paths:
+            self._root_dirs = {
+                path.relative_to(config.workspace_dir) 
+                for path in config.workspace_dir.iterdir() 
+                if path.is_dir() and not path.name.startswith('.')
+            }
+            if config.debug:
+                Console(stderr=True).print(f"[cyan]Debug: Found root directories: {self._root_dirs}[/cyan]")
+
+        processed_files: Set[Path] = set()
+        for path in paths:
+            abs_path = config.workspace_dir / path
+            # Skip workspace root if skip_work is enabled
+            if config.skip_work and path == Path("."):
+                if config.debug:
+                    Console(stderr=True).print("[cyan]Debug: Skipping workspace root due to skip_work[/cyan]")
+                continue
+            self._scan_path(abs_path, processed_files, scan_time, recursive_paths)
+
+        self._content.scan_completed = True
+        self._content.analyzed = False
+        self._content.scanned_paths = set(paths)
+
+    def _scan_path(self, path: Path, processed_files: Set[Path], scan_time: float, 
+                  recursive_paths: Set[Path]) -> None:
+        """Scan a single path and process its contents."""
+        if path in processed_files:
+            return
+
+        # Convert recursive_paths to absolute for comparison
+        abs_recursive_paths = {config.workspace_dir / p for p in recursive_paths}
+
+        path = path.resolve()
+        processed_files.add(path)
+
+        if path.is_dir():
+            try:
+                for item in path.iterdir():
+                    if item.name.startswith(('.', '__pycache__')):
+                        continue
+                    if path in abs_recursive_paths:
+                        self._scan_path(item, processed_files, scan_time, recursive_paths)
+                    elif item.is_file():
+                        self._scan_path(item, processed_files, scan_time, recursive_paths)
+            except PermissionError:
+                if config.debug:
+                    Console(stderr=True).print(f"[red]Debug: Permission denied: {path}[/red]")
+        elif path.is_file():
+            self._process_file(path, scan_time)
+
+    def _process_file(self, path: Path, scan_time: float, force_update: bool = False) -> None:
+        """Process a single file and add it to the content."""
+        try:
+            # Check if file has supported extension or no extension
+            supported_extensions = {
+                '.py', '.md', '.txt', '.json', '.yaml', '.yml', '.toml',
+                '.html', '.htm', '.css', '.js'
+            }
+            if path.suffix.lower() in supported_extensions or not path.suffix:
+                content = path.read_text(encoding='utf-8')
+                rel_path = path.relative_to(config.workspace_dir)
+                
+                # Check if file already exists in content
+                existing_files = [f for f in self._content.files if f.name == str(rel_path)]
+                if existing_files and not force_update:
+                    if config.debug:
+                        Console(stderr=True).print(f"[yellow]Debug: Skipping duplicate file: {rel_path}[/yellow]")
+                    return
+                elif existing_files:
+                    # Update existing file content
+                    existing_files[0].content = content
+                    existing_files[0].seconds_ago = int(scan_time - path.stat().st_mtime)
+                    if config.debug:
+                        Console(stderr=True).print(f"[cyan]Debug: Updated content: {rel_path}[/cyan]")
+                else:
+                    # Add new file
+                    seconds_ago = int(scan_time - path.stat().st_mtime)
+                    file_info = FileInfo(
+                        name=str(rel_path),
+                        content=content,
+                        seconds_ago=seconds_ago
+                    )
+                    self._content.add_file(file_info)
+                    if config.debug:
+                        Console(stderr=True).print(f"[cyan]Debug: Added file: {rel_path}[/cyan]")
+                    
+        except (UnicodeDecodeError, PermissionError) as e:
+            if config.debug:
+                Console(stderr=True).print(f"[red]Debug: Error reading file {path}: {str(e)}[/red]")
+
+    def create_file(self, path: Path, content: str) -> None:
+        """Create a new file in the workspace.
+        
+        Args:
+            path: Relative path to the file to create
+            content: Content to write to the file
+            
+        Raises:
+            PathNotRelativeError: If path is absolute
+            FileExistsError: If file already exists
+            OSError: If parent directory creation fails
+        """
+        if path.is_absolute():
+            raise PathNotRelativeError(f"Path must be relative: {path}")
+        
+        abs_path = config.workspace_dir / path
+        
+        if abs_path.exists():
+            raise FileExistsError(f"File already exists: {path}")
+        
+        # Create parent directories if they don't exist
+        abs_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write the file
+        abs_path.write_text(content, encoding='utf-8')
+        
+        if config.debug:
+            Console(stderr=True).print(f"[green]Debug: Created file: {path}[/green]")
+        
+        # Add to workspace content
+        scan_time = time.time()
+        self._process_file(abs_path, scan_time)
+
+    def clear(self) -> None:
+        """Clear all workspace content and settings."""
+        self._content = WorksetContent()
+
+    @property
+    def content(self) -> WorksetContent:
+        """Get the workspace content."""
+        return self._content
+
+    @property
+    def root_directories(self) -> Set[Path]:
+        """Get the directories found at the workspace root."""
+        return self._root_dirs
+
+    def modify_file(self, path: Path, content: str) -> None:
+        """Modify an existing file in the workspace.
+        
+        Args:
+            path: Relative path to the file to modify
+            content: New content for the file
+            
+        Raises:
+            PathNotRelativeError: If path is absolute
+            FileNotFoundError: If file doesn't exist
+            OSError: If write fails
+        """
+        if path.is_absolute():
+            raise PathNotRelativeError(f"Path must be relative: {path}")
+        
+        abs_path = config.workspace_dir / path
+        
+        if not abs_path.exists():
+            raise FileNotFoundError(f"File does not exist: {path}")
+        
+        # Write the file
+        abs_path.write_text(content, encoding='utf-8')
+        
+        if config.debug:
+            Console(stderr=True).print(f"[green]Debug: Modified file: {path}[/green]")
+        
+        # Update workspace content
+        scan_time = time.time()
+        self._process_file(abs_path, scan_time, force_update=True)
+
+    def setup_preview_directory(self) -> None:
+        """Setup the preview directory with workspace contents.
+        
+        Creates a copy of the current workspace contents in the preview directory.
+        Respects .gitignore patterns and excludes .git directory.
+        """
+        self._preview_dir = Path(tempfile.mkdtemp(prefix='janito_preview_'))
+
+        # Read .gitignore if it exists
+        gitignore_path = config.workspace_dir / '.gitignore'
+        if (gitignore_path.exists()):
+            gitignore = gitignore_path.read_text().splitlines()
+            # Always ignore .git directory
+            gitignore.append('.git')
+            spec = pathspec.PathSpec.from_lines('gitwildmatch', gitignore)
+        else:
+            # If no .gitignore exists, only ignore .git
+            spec = pathspec.PathSpec.from_lines('gitwildmatch', ['.git'])
+
+        # Copy workspace contents to preview directory
+        for item in config.workspace_dir.iterdir():
+            # Get relative path for gitignore matching
+            rel_path = item.relative_to(config.workspace_dir)
+            
+            # Skip if matches gitignore patterns
+            if spec.match_file(str(rel_path)):
+                continue
+            
+            # Skip hidden files/directories except .gitignore
+            if item.name.startswith('.') and item.name != '.gitignore':
+                continue
+                
+            if item.is_dir():
+                # For directories, we need to filter contents based on gitignore
+                def copy_filtered(src, dst):
+                    shutil.copytree(
+                        src, 
+                        dst,
+                        ignore=lambda d, files: [
+                            f for f in files 
+                            if spec.match_file(str(Path(d).relative_to(config.workspace_dir) / f))
+                        ]
+                    )
+                
+                copy_filtered(item, self._preview_dir / item.name)
+            else:
+                shutil.copy2(item, self._preview_dir / item.name)
+
+        return self._preview_dir
+
+
+    def preview_create_file(self, path: Path, content: str) -> None:
+        """Create a new file in the preview directory.
+        
+        Args:
+            path: Relative path to the file to create
+            content: Content to write to the file
+        """
+        preview_path = self.get_preview_path(path)
+        preview_path.parent.mkdir(parents=True, exist_ok=True)
+        preview_path.write_text(content, encoding='utf-8')
+
+    def preview_modify_file(self, path: Path, content: str) -> None:
+        """Modify a file in the preview directory.
+        
+        Args:
+            path: Relative path to the file to modify
+            content: New content for the file
+        """
+        preview_path = self.get_preview_path(path)
+        if not preview_path.exists():
+            raise FileNotFoundError(f"File does not exist in preview: {path}")
+        preview_path.write_text(content, encoding='utf-8')
+
+    def get_preview_path(self, path: Path) -> Path:
+        """Get the path to the preview directory."""
+        return self._preview_dir / path
+
+    def delete_file(self, path: Path) -> None:
+        """Delete a file from the workspace.
+        
+        Args:
+            path: Relative path to the file to delete
+            
+        Raises:
+            PathNotRelativeError: If path is absolute
+            FileNotFoundError: If file doesn't exist
+        """
+        if path.is_absolute():
+            raise PathNotRelativeError(f"Path must be relative: {path}")
+        
+        abs_path = config.workspace_dir / path
+        
+        if not abs_path.exists():
+            raise FileNotFoundError(f"File does not exist: {path}")
+        
+        # Delete the file
+        abs_path.unlink()
+        
+        if config.debug:
+            Console(stderr=True).print(f"[green]Debug: Deleted file: {path}[/green]")
+
+    def apply_changes(self, preview_dir: Path, created_files: List[Path], modified_files: Set[Path], deleted_files: Set[Path]):
+        """Apply changes from preview directory to workspace."""
+        for filename in created_files:
+            content = (preview_dir / filename).read_text(encoding='utf-8')
+            self.create_file(filename, content)
+            print("Created workspace file: ", filename)
+
+        for filename in modified_files:
+            content = (preview_dir / filename).read_text(encoding='utf-8')
+            self.modify_file(filename, content)
+            print("Modified workspace file: ", filename)  # This will now include cleaned files
+
+        for filename in deleted_files:
+            self.delete_file(filename)
+            print("Deleted workspace file: ", filename)
+
+

janito-0.8.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,40 @@
+janito/__main__.py,sha256=xYzdqkp-7L39F1aS7clcAFmdy_wwN-xFhrMSJJO3LZw,5640
+janito/common.py,sha256=OiOVIP34cna6i6Kc0kTGKM8jx9pudvOuapmkkDl8bpA,5114
+janito/config.py,sha256=3HNnlwLC6BxLHSMT-7PpG0rJekaJtZGLS8ZUmC-4hVg,3163
+janito/qa.py,sha256=iv53YOCtoT0-gUDDStL_WArxh0fqcbq3meZHFtUXOH4,1689
+janito/version.py,sha256=IEZ9-3cWXfCUmhFoP_LX02zvFfirWvYLDaRWJTHEh0s,761
+janito/agents/__init__.py,sha256=R4nHZ31OhqanLaHlFFtaz2FMTsFhhW74QvmvGfkdtpo,728
+janito/agents/agent.py,sha256=EZVtipg5WLbHR8JtwWMZaPWLtMvtlnEF8mY6kTvgg-Y,722
+janito/agents/claudeai.py,sha256=Cl-9eSDtVNMEW32Lp8XMUHyCKnBqtRYd4jn67drz8w8,1384
+janito/agents/deepseekai.py,sha256=viPI7xMdl_4tU9JbLtYpWUXZ-03M8rHQlqXN4aC0Xpo,1667
+janito/change/applied_blocks.py,sha256=IIYM_CBHyjBbG4YfU_g5CAjfSafCQh4J_EyljyByLjM,1040
+janito/change/applier.py,sha256=ByVfURYq6iFn5BQyPOfEbGvJfLzty6PgiuWZN9quE10,7266
+janito/change/edit_blocks.py,sha256=i3Ka_zHJRjaV-iInAH0uJV0QAtV0mvzRFDqDmaR7oRw,5483
+janito/change/finder.py,sha256=PhXA_3dNwDSgseEVdphIpo14n1zgbgqwGw4bD4EiRk4,2786
+janito/change/request.py,sha256=W1-yuzO385rNPuUozlSh_g8nDToKuwZaRkk7Mxo0TKQ,5904
+janito/change/validator.py,sha256=2E6kNKzWnu6QYuhYN9SAu4TNKuDJXf3KDQuG4AryTpg,3277
+janito/change/view/content.py,sha256=Yl_llNnxmnfgaaPGod1Q1sW85Rievhm9d1ZQFpMVSTo,1594
+janito/change/view/diff.py,sha256=32DPm4e-bt8qljvgV-5hGICrmxBiOCQLE0dhF63vJ9k,1859
+janito/change/view/panels.py,sha256=-MzpzElAtyObtioloAVGnhJMwEWAHwvh9kjnrR1VF9w,6643
+janito/change/view/sections.py,sha256=SrqWfmNHWbV4JvW_p7ynEoNvJUpiRg-IGVi4MLU1E-Q,2829
+janito/change/view/styling.py,sha256=Mze3WCn_6OPhKI6RFtjiqZJFNP3f-W_OPAI4Qwd_zGw,5483
+janito/change/view/summary.py,sha256=zCxyH_0TN4SPOikXYQEsKasBYX-8ELit62cupbTNCD4,1409
+janito/change/view/themes.py,sha256=g1VURi51siZrVnN8eE8Dh3lfh4lvoLCDpOHfXZ-4iss,1774
+janito/change/view/viewer.py,sha256=wAa_2mYS_ihZckpZ2VKFKf4TiXusnRAS6aNbEinqYWk,2165
+janito/cli/__init__.py,sha256=2tXs98pDDXyU-QTLJ-QpUKpjJJvxObRDGIgRtesVQP4,78
+janito/cli/commands.py,sha256=-PUmDBRdvOPgwmY9orbWAkUEyW5HgUyINotapG8I3L8,1826
+janito/cli/functions.py,sha256=c3-HtIKzKpSebewFCWBhaR0BFCttHyvA2xeACSPUgRw,2543
+janito/data/change_prompt.txt,sha256=iGPjxWvFBkxyCzny_9E6cSUg74c0gHenBNoga6YW7EM,3357
+janito/data/system_prompt.txt,sha256=ySqjFj9bbJJC6xNaX9gOAEbLp08Jc9ckUEtu7bSQGkA,161
+janito/workspace/__init__.py,sha256=KlU4uajYszb8qmvAhJDzOT4J9Uf04MoomrePP_wlBgI,188
+janito/workspace/analysis.py,sha256=pRzYzBm6OqaQ8MTlbZeeDXQkRjEKFLfN-fz3EUw1sQQ,4204
+janito/workspace/models.py,sha256=A4Hry2N1ZHMsZ60Vmi2ovR1oL7lEUGyiPWhcGxS5fSs,3283
+janito/workspace/show.py,sha256=ReJ97X6DBLiIcfHpTK6TZ6RLZ5g_U-2y8BIDHHBJGWk,3885
+janito/workspace/stats.py,sha256=0uOcyjoz_ZdtJK0thcZsvqULxYaZSVSsAtuK8k_57ps,1299
+janito/workspace/workset.py,sha256=qDtxUwjIbg87VfSmHMXfVfQ28uIeWrpvCC24XtvVNbw,4302
+janito/workspace/workspace.py,sha256=aXs37H-hfFQEGoAQJzQKB_wH0zCkxqVv2YiE8hPzjdQ,13565
+janito-0.8.0.dist-info/METADATA,sha256=s1PMT0iTn91rMzCa11ANf-UH2DNmhEoY97l6x6KUz2U,3156
+janito-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+janito-0.8.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-0.8.0.dist-info/licenses/LICENSE,sha256=agBzvmwXtxr2qfxpwmoi8VabRb2AXflZeTZA3AjZeJE,1082
+janito-0.8.0.dist-info/RECORD,,

{janito-0.6.0.dist-info → janito-0.8.0.dist-info}/licenses/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/__init__.py

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

janito/agents/openai.py

@@ -1,53 +0,0 @@
-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/agents/test.py

@@ -1,34 +0,0 @@
-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?")

janito/change/__init__.py

@@ -1,32 +0,0 @@
-"""
-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/change/analysis/__init__.py

@@ -1,23 +0,0 @@
-"""Analysis module for Janito.
-
-This module provides functionality for analyzing and displaying code changes.
-"""
-
-from .options import AnalysisOption, parse_analysis_options
-from .view import format_analysis, prompt_user, get_option_selection
-from .prompts import (
-    build_request_analysis_prompt,
-    validate_option_letter
-)
-from .analyze import analyze_request
-
-__all__ = [
-    'AnalysisOption',
-    'parse_analysis_options',
-    'format_analysis',
-    'build_request_analysis_prompt',
-    'get_option_selection',
-    'prompt_user',
-    'validate_option_letter',
-    'analyze_request'
-]