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

janito/__main__.py

@@ -1,135 +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.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__":
+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/agents/__init__.py

@@ -1,16 +1,22 @@
-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)
-
+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/agents/agent.py

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

janito/agents/claudeai.py

@@ -1,55 +1,41 @@
-import anthropic
-import os
-from typing import Optional
-from threading import Event
-from .agent import Agent
-
-class ClaudeAIAgent(Agent):
-    """Handles interaction with Claude API, including message handling"""
-    DEFAULT_MODEL = "claude-3-5-sonnet-20241022"
-    
-    def __init__(self, system_prompt: str = None):
-        self.api_key = os.getenv('ANTHROPIC_API_KEY')
-        super().__init__(self.api_key, system_prompt)
-        if not system_prompt:
-            raise ValueError("system_prompt is required")
-        
-        if not self.api_key:
-            raise ValueError("ANTHROPIC_API_KEY environment variable is required")
-        self.client = anthropic.Client(api_key=self.api_key)
-        self.model = os.getenv('CLAUDE_MODEL', self.DEFAULT_MODEL)
-        self.system_message = system_prompt
-        self.last_prompt = None
-        self.last_full_message = None
-        self.last_response = None
-
-
-    def send_message(self, message: str, stop_event: Event = None) -> str:
-        """Send message to Claude API and return response"""
-        self.messages_history.append(("user", message))
-        # Store the full message
-        self.last_full_message = message
-        
-        try:
-            # Check if already cancelled
-            if stop_event and stop_event.is_set():
-                return ""
-            
-            response = self.client.messages.create(
-                model=self.model,  # Use discovered model
-                system=self.system_message,
-                max_tokens=8192,
-                messages=[
-                    {"role": "user", "content": message}
-                ],
-                temperature=0,
-            )
-            
-
-            # Always return the response, let caller handle cancellation
-            return response
-            
-        except KeyboardInterrupt:
-            if stop_event:
-                stop_event.set()
-            return ""
+import anthropic
+import os
+
+from .agent import Agent
+
+class ClaudeAIAgent(Agent):
+    """Handles interaction with Claude API, including message handling"""
+    DEFAULT_MODEL = "claude-3-5-sonnet-20241022"
+    friendly_name = "Claude"
+    
+    def __init__(self):
+        self.api_key = os.getenv('ANTHROPIC_API_KEY')
+        super().__init__(self.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 = os.getenv('CLAUDE_MODEL', self.DEFAULT_MODEL)
+        self.last_prompt = None
+        self.last_full_message = None
+        self.last_response = None
+
+
+    def send_message(self, system_message: str, message: str) -> str:
+        """Send message to Claude API and return response"""
+        # Store the full message
+        self.last_full_message = message
+        
+        response = self.client.messages.create(
+            model=self.model,  # Use discovered model
+            system=system_message or self.system_message,
+            max_tokens=8192,
+            messages=[
+                {"role": "user", "content": message}
+            ],
+            temperature=0,
+        )
+        
+
+        # Always return the response, let caller handle cancellation
+        return response

janito/agents/deepseekai.py

@@ -0,0 +1,47 @@
+from openai import OpenAI
+import os
+from typing import Optional
+from threading import Event
+from .agent import Agent
+
+class DeepSeekAIAgent(Agent):
+    """ DeepSeek AI Agent """
+    DEFAULT_MODEL = "deepseek-chat"
+    friendly_name = "DeepSeek"
+    api_key = None
+    
+    def __init__(self, system_prompt: str = None):
+        self.api_key = os.getenv('DEEPSEEK_API_KEY')
+        super().__init__(self.api_key, system_prompt)
+        if not system_prompt:
+            raise ValueError("system_prompt is required")
+        if not self.api_key:
+            raise ValueError("DEEPSEEK_API_KEY environment variable is required")
+        self.client = OpenAI(api_key=self.api_key, base_url="https://api.deepseek.com")
+        self.model = self.DEFAULT_MODEL
+        self.system_message = system_prompt
+
+    def send_message(self, message: str, system_message: str = None) -> str:
+        """Send message to OpenAI API and return response"""
+        self.last_full_message = message
+        
+        try:
+            messages = [
+                { "role": "system", "content": system_message},
+                { "role": "user", "content": message}
+            ]
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                max_completion_tokens=4096,
+                temperature=0,
+            )
+            
+            response_text = response.choices[0].message.content
+            self.last_response = response_text
+            
+            return response
+            
+        except KeyboardInterrupt:
+            return ""

janito/change/applied_blocks.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+from .edit_blocks import EditType
+
+@dataclass
+class AppliedBlock:
+    filename: Path
+    edit_type: EditType
+    reason: str
+    original_content: List[str]
+    modified_content: List[str]
+    range_start: int
+    range_end: int
+    block_marker: Optional[str] = None
+    error_message: Optional[str] = None
+    has_error: bool = False
+
+@dataclass
+class AppliedBlocks:
+    blocks: List[AppliedBlock]
+    
+    def get_changes_summary(self):
+        """Get summary info for all applied blocks"""
+        return [{
+            'file': block.filename,
+            'type': block.edit_type.name,
+            'reason': block.reason,
+            'lines_original': len(block.original_content),
+            'lines_modified': len(block.modified_content),
+            'range_start': block.range_start,
+            'range_end': block.range_end,
+            'block_marker': block.block_marker
+        } for block in self.blocks]