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

janito/__init__.py

@@ -1,2 +1,2 @@
+"""Core package initialization for Janito."""
 
-# Empty file to make the directory a Python package

janito/__main__.py

@@ -1,356 +1,132 @@
-import sys
 import typer
-from typing import Optional, Dict, Any, List
+from typing import Optional, List, Set
 from pathlib import Path
-from janito.claude import ClaudeAPIAgent
-import shutil
-from janito.prompts import (
-    build_selected_option_prompt,
-    SYSTEM_PROMPT,    
-)
+from rich.text import Text
+from rich import print as rich_print
 from rich.console import Console
-from rich.markdown import Markdown
-import re
-import tempfile
-import json
-from rich.syntax import Syntax
-from janito.contentchange import (
-    handle_changes_file, 
-    get_file_type,
-    parse_block_changes,
-    preview_and_apply_changes,
-    format_parsed_changes,
-)
-from rich.table import Table
-from rich.columns import Columns
-from rich.panel import Panel
 from rich.text import Text
-from rich.rule import Rule
-from rich import box
-from datetime import datetime, timezone
-from itertools import chain
-from janito.scan import collect_files_content, is_dir_empty, preview_scan
-from janito.qa import ask_question, display_answer
-from rich.prompt import Prompt, Confirm
-from janito.config import config
-from janito.version import get_version
-from janito.common import progress_send_message
-from janito.analysis import format_analysis, build_request_analysis_prompt, parse_analysis_options, get_history_file_type, AnalysisOption 
-
-
-def prompt_user(message: str, choices: List[str] = None) -> str:
-    """Display a prominent user prompt with optional choices using consistent colors"""
-    console = Console()
-    
-    # Define consistent colors
-    COLORS = {
-        'primary': '#729FCF',    # Soft blue for primary elements
-        'secondary': '#8AE234',  # Bright green for actions/success
-        'accent': '#AD7FA8',     # Purple for accents
-        'muted': '#7F9F7F',      # Muted green for less important text
-    }
-    
-    console.print()
-    console.print(Rule(" User Input Required ", style=f"bold {COLORS['primary']}"))
-    
-    if choices:
-        choice_text = f"[{COLORS['accent']}]Options: {', '.join(choices)}[/{COLORS['accent']}]"
-        console.print(Panel(choice_text, box=box.ROUNDED, border_style=COLORS['primary']))
-    
-    return Prompt.ask(f"[bold {COLORS['secondary']}]> {message}[/bold {COLORS['secondary']}]")
+from .version import get_version
 
-def validate_option_letter(letter: str, options: dict) -> bool:
-    """Validate if the given letter is a valid option or 'M' for modify"""
-    return letter.upper() in options or letter.upper() == 'M'
-
-def get_option_selection() -> str:
-    """Get user input for option selection with modify option"""
-    console = Console()
-    console.print("\n[cyan]Enter option letter or 'M' to modify request[/cyan]")
-    while True:
-        letter = prompt_user("Select option").strip().upper()
-        if letter == 'M' or (letter.isalpha() and len(letter) == 1):
-            return letter
-        console.print("[red]Please enter a valid letter or 'M'[/red]")
-
-def get_changes_history_path(workdir: Path) -> Path:
-    """Create and return the changes history directory path"""
-    changes_history_dir = workdir / '.janito' / 'changes_history'
-    changes_history_dir.mkdir(parents=True, exist_ok=True)
-    return changes_history_dir
-
-def get_timestamp() -> str:
-    """Get current UTC timestamp in YMD_HMS format with leading zeros"""
-    return datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
+from janito.agents import agent
+from janito.config import config
 
-def save_prompt_to_file(prompt: str) -> Path:
-    """Save prompt to a named temporary file that won't be deleted"""
-    temp_file = tempfile.NamedTemporaryFile(prefix='selected_', suffix='.txt', delete=False)
-    temp_path = Path(temp_file.name)
-    temp_path.write_text(prompt)
-    return temp_path
+from .cli.commands import handle_request, handle_ask, handle_play, handle_scan
 
-def save_to_file(content: str, prefix: str, workdir: Path) -> Path:
-    """Save content to a timestamped file in changes history directory"""
-    changes_history_dir = get_changes_history_path(workdir)
-    timestamp = get_timestamp()
-    filename = f"{timestamp}_{prefix}.txt"
-    file_path = changes_history_dir / filename
-    file_path.write_text(content)
-    return file_path
+app = typer.Typer(add_completion=False)
 
-def modify_request(request: str) -> str:
-    """Display current request and get modified version with improved formatting"""
-    console = Console()
+def validate_paths(paths: Optional[List[Path]]) -> Optional[List[Path]]:
+    """Validate include paths for duplicates.
     
-    # Display current request in a panel with clear formatting
-    console.print("\n[bold cyan]Current Request:[/bold cyan]")
-    console.print(Panel(
-        Text(request, style="white"),
-        border_style="blue",
-        title="Previous Request",
-        padding=(1, 2)
-    ))
-    
-    # Get modified request with clear prompt
-    console.print("\n[bold cyan]Enter modified request below:[/bold cyan]")
-    console.print("[dim](Press Enter to submit, Ctrl+C to cancel)[/dim]")
-    try:
-        new_request = prompt_user("Modified request")
-        if not new_request.strip():
-            console.print("[yellow]No changes made, keeping original request[/yellow]")
-            return request
-        return new_request
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Modification cancelled, keeping original request[/yellow]")
-        return request
-
-def format_option_text(option: AnalysisOption) -> str:
-    """Format an AnalysisOption into a string representation"""
-    option_text = f"Option {option.letter}:\n"
-    option_text += f"Summary: {option.summary}\n\n"
-    option_text += "Description:\n"
-    for item in option.description_items:
-        option_text += f"- {item}\n"
-    option_text += "\nAffected files:\n"
-    for file in option.affected_files:
-        option_text += f"- {file}\n"
-    return option_text
-
-def handle_option_selection(claude: ClaudeAPIAgent, initial_response: str, request: str, raw: bool = False, workdir: Optional[Path] = None, include: Optional[List[Path]] = None) -> None:
-    """Handle option selection and implementation details"""
-    options = parse_analysis_options(initial_response)
-    if not options:
-        console = Console()
-        console.print("[red]No valid options found in the response[/red]")
-        return
-
-    while True:
-        option = get_option_selection()
+    Args:
+        paths: List of paths to validate, or None if no paths provided
         
-        if option == 'M':
-            # Use the new modify_request function for better UX
-            new_request = modify_request(request)
-            if new_request == request:
-                continue
-                
-            # Rerun analysis with new request
-            paths_to_scan = [workdir] if workdir else []
-            if include:
-                paths_to_scan.extend(include)
-            files_content = collect_files_content(paths_to_scan, workdir) if paths_to_scan else ""
-            
-            initial_prompt = build_request_analysis_prompt(files_content, new_request)
-            initial_response = progress_send_message(claude, initial_prompt)
-            save_to_file(initial_response, 'analysis', workdir)
-            
-            format_analysis(initial_response, raw, claude)
-            options = parse_analysis_options(initial_response)
-            if not options:
-                console = Console()
-                console.print("[red]No valid options found in the response[/red]")
-                return
-            continue
-            
-        if not validate_option_letter(option, options):
-            console = Console()
-            console.print(f"[red]Invalid option '{option}'. Valid options are: {', '.join(options.keys())} or 'M' to modify[/red]")
-            continue
-            
-        break
-
-    paths_to_scan = [workdir] if workdir else []
-    if include:
-        paths_to_scan.extend(include)
-    files_content = collect_files_content(paths_to_scan, workdir) if paths_to_scan else ""
-    
-    # Format the selected option before building prompt
-    selected_option = options[option]
-    option_text = format_option_text(selected_option)
-    
-    # Remove initial_response from the arguments
-    selected_prompt = build_selected_option_prompt(option_text, request, files_content)
-    prompt_file = save_to_file(selected_prompt, 'selected', workdir)
-    if config.verbose:
-        print(f"\nSelected prompt saved to: {prompt_file}")
-    
-    selected_response = progress_send_message(claude, selected_prompt)
-    changes_file = save_to_file(selected_response, 'changes', workdir)
-
-    if config.verbose:
-        try:
-            rel_path = changes_file.relative_to(workdir)
-            print(f"\nChanges saved to: ./{rel_path}")
-        except ValueError:
-            print(f"\nChanges saved to: {changes_file}")
-    
-    changes = parse_block_changes(selected_response)
-    preview_and_apply_changes(changes, workdir, config.test_cmd)
-
-def replay_saved_file(filepath: Path, claude: ClaudeAPIAgent, workdir: Path, raw: bool = False) -> None:
-    """Process a saved prompt file and display the response"""
-    if not filepath.exists():
-        raise FileNotFoundError(f"File {filepath} not found")
-    
-    content = filepath.read_text()
-    
-    # Add debug output of file content
-    if config.debug:
-        console = Console()
-        console.print("\n[bold blue]Debug: File Content[/bold blue]")
-        console.print(Panel(
-            content,
-            title=f"Content of {filepath.name}",
-            border_style="blue",
-            padding=(1, 2)
-        ))
-        console.print()
-
-    file_type = get_history_file_type(filepath)
-    
-    if file_type == 'changes':
-        changes = parse_block_changes(content)
-        success = preview_and_apply_changes(changes, workdir, config.test_cmd)
-        if not success:
+    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)
-    elif file_type == 'analysis':
-        format_analysis(content, raw, claude)
-        handle_option_selection(claude, content, content, raw, workdir)
-    elif file_type == 'selected':
-        if raw:
-            console = Console()
-            console.print("\n=== Prompt Content ===")
-            console.print(content)
-            console.print("=== End Prompt Content ===\n")
-        
-        response = progress_send_message(claude, content)
-        changes_file = save_to_file(response, 'changes_', workdir)
-        print(f"\nChanges saved to: {changes_file}")
-        
-        changes = parse_block_changes(response)
-        preview_and_apply_changes(changes, workdir, config.test_cmd)
-    else:
-        response = progress_send_message(claude, content)
-        format_analysis(response, raw)
-
-def process_question(question: str, workdir: Path, include: List[Path], raw: bool, claude: ClaudeAPIAgent) -> None:
-    """Process a question about the codebase"""
-    paths_to_scan = [workdir] if workdir else []
-    if include:
-        paths_to_scan.extend(include)
-    files_content = collect_files_content(paths_to_scan, workdir)
-    answer = ask_question(question, files_content, claude)
-    display_answer(answer, raw)
+        resolved_paths.add(resolved)
+        unique_paths.append(path)
 
-def ensure_workdir(workdir: Path) -> Path:
-    """Ensure working directory exists, prompt for creation if it doesn't"""
-    if workdir.exists():
-        return workdir
-        
-    console = Console()
-    console.print(f"\n[yellow]Directory does not exist:[/yellow] {workdir}")
-    if Confirm.ask("Create directory?"):
-        workdir.mkdir(parents=True)
-        console.print(f"[green]Created directory:[/green] {workdir}")
-        return workdir
-    raise typer.Exit(1)
+    return unique_paths if unique_paths else None
 
 def typer_main(
-    request: Optional[str] = typer.Argument(None, help="The modification request"),
+    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"),
-    workdir: Optional[Path] = typer.Option(None, "-w", "--workdir", 
-                                         help="Working directory (defaults to current directory)", 
-                                         file_okay=False, dir_okay=True),
-    raw: bool = typer.Option(False, "--raw", help="Print raw response instead of markdown format"),
     play: Optional[Path] = typer.Option(None, "--play", help="Replay a saved prompt file"),
-    include: Optional[List[Path]] = typer.Option(None, "-i", "--include", help="Additional paths to include in analysis", exists=True),
-    debug: bool = typer.Option(False, "--debug", help="Show debug information"),
-    verbose: bool = typer.Option(False, "-v", "--verbose", help="Show verbose output"),
     scan: bool = typer.Option(False, "--scan", help="Preview files that would be analyzed"),
-    version: bool = typer.Option(False, "--version", help="Show version and exit"),
-    test: Optional[str] = typer.Option(None, "-t", "--test", help="Test command to run before applying changes"),
-) -> None:
-    """
-    Analyze files and provide modification instructions.
-    """
-
+    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 v{get_version()}")
-        raise typer.Exit()
-
-    config.set_debug(debug)
-    config.set_verbose(verbose)
-    config.set_test_cmd(test)
-
-    claude = ClaudeAPIAgent(system_prompt=SYSTEM_PROMPT)
-
-    if not any([request, ask, play, scan]):
-        workdir = workdir or Path.cwd()
-        workdir = ensure_workdir(workdir)
-        from janito.console import start_console_session
-        start_console_session(workdir, include)
+        console.print(f"Janito version {get_version()}")
         return
 
-    workdir = workdir or Path.cwd()
-    workdir = ensure_workdir(workdir)
-    
-    if include:
-        include = [
-            path if path.is_absolute() else (workdir / path).resolve()
-            for path in include
-        ]
-    
-    if ask:
-        process_question(ask, workdir, include, raw, claude)
+    if demo:
+        from janito.cli.handlers.demo import DemoHandler
+        handler = DemoHandler()
+        handler.handle()
         return
 
-    if scan:
-        paths_to_scan = include if include else [workdir]
-        preview_scan(paths_to_scan, workdir)
+    if history:
+        from janito.cli.history import display_history
+        display_history()
         return
 
-    if play:
-        replay_saved_file(play, claude, workdir, raw)
-        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)
 
-    paths_to_scan = include if include else [workdir]
-    
-    is_empty = is_dir_empty(workdir)
-    if is_empty and not include:
-        console = Console()
-        console.print("\n[bold blue]Empty directory - will create new files as needed[/bold blue]")
-        files_content = ""
+    # 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:
-        files_content = collect_files_content(paths_to_scan, workdir)
-    
-    initial_prompt = build_request_analysis_prompt(files_content, request)
-    initial_response = progress_send_message(claude, initial_prompt)
-    save_to_file(initial_response, 'analysis', workdir)
-    
-    format_analysis(initial_response, raw, claude)
-    
-    handle_option_selection(claude, initial_response, request, raw, workdir, include)
+        from janito.shell import start_shell
+        start_shell()
 
 def main():
     typer.run(typer_main)

janito/agents/__init__.py

@@ -0,0 +1,16 @@
+import os
+
+SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. I help you with coding tasks while being clear and concise in my responses."""
+
+ai_backend = os.getenv('AI_BACKEND', 'claudeai').lower()
+
+if ai_backend == 'openai':
+    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}")
+
+# Create a singleton instance
+agent = AIAgent(SYSTEM_PROMPT)
+

janito/agents/agent.py

@@ -0,0 +1,21 @@
+
+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, stop_event: Event = None) -> str:
+        """Send message to AI service and return response"""
+        pass

janito/{claude.py → agents/claudeai.py}

@@ -2,24 +2,27 @@ import anthropic
 import os
 from typing import Optional
 from threading import Event
+from .agent import Agent
 
-class ClaudeAPIAgent:
+class ClaudeAIAgent(Agent):
     """Handles interaction with Claude API, including message handling"""
-    def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
+    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")
-        self.api_key = api_key or os.getenv('ANTHROPIC_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 = "claude-3-5-sonnet-20241022"
+        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
-        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"""
@@ -35,23 +38,16 @@ class ClaudeAPIAgent:
             response = self.client.messages.create(
                 model=self.model,  # Use discovered model
                 system=self.system_message,
-                max_tokens=4000,
+                max_tokens=8192,
                 messages=[
                     {"role": "user", "content": message}
                 ],
                 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/agents/openai.py

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

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