janito 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

janito/__init__.py

@@ -1,49 +1,2 @@
 """Core package initialization for Janito."""
 
-from .analysis import (
-    AnalysisOption,
-    parse_analysis_options,
-    format_analysis,
-    get_history_file_type,
-    get_history_path,
-    get_timestamp,
-    save_to_file,
-    build_request_analysis_prompt,
-    get_option_selection,
-    prompt_user,
-    validate_option_letter
-)
-
-from .change import (
-    apply_single_change,
-    parse_and_apply_changes_sequence,
-    get_file_type,
-    process_and_save_changes,
-    format_parsed_changes,
-    apply_content_changes,
-    handle_changes_file
-)
-
-__all__ = [
-    # Analysis exports
-    'AnalysisOption',
-    'parse_analysis_options',
-    'format_analysis',
-    'get_history_file_type',
-    'get_history_path',
-    'get_timestamp',
-    'save_to_file',
-    'build_request_analysis_prompt',
-    'get_option_selection',
-    'prompt_user',
-    'validate_option_letter',
-    
-    # Change exports
-    'apply_single_change',
-    'parse_and_apply_changes_sequence',
-    'get_file_type',
-    'process_and_save_changes',
-    'format_parsed_changes',
-    'apply_content_changes',
-    'handle_changes_file'
-]

janito/__main__.py

@@ -1,25 +1,66 @@
 import typer
-from typing import Optional, List
+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 AgentSingleton
 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
+)
 
-from .cli.commands import handle_request, handle_ask, handle_play, handle_scan
+app = typer.Typer(pretty_exceptions_enable=False)
 
-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"),
-    workdir: Optional[Path] = typer.Option(None, "-w", "--workdir", help="Working directory", file_okay=False, dir_okay=True),
+    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:
@@ -27,28 +68,75 @@ def typer_main(
         console.print(f"Janito version {get_version()}")
         return
 
-    workdir = workdir or Path.cwd()
+    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)
 
-    agent = AgentSingleton.get_agent()
+    # 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, workdir, include, False, agent)
+        handle_ask(ask)
     elif play:
-        handle_play(play, workdir, False)
-    elif change_request == "scan":
-        paths_to_scan = include if include else [workdir]
-        handle_scan(paths_to_scan, workdir)
+        handle_play(play)
+    elif scan:
+        handle_scan()
     elif change_request:
-        handle_request(change_request, workdir, include, False, agent)
+        handle_request(change_request)
     else:
-        console = Console()
-        console.print("Error: Please provide a change request or use --ask/--play options")
-        raise typer.Exit(1)
+        from janito.shell import start_shell
+        start_shell()
 
 def main():
     typer.run(typer_main)
 
 if __name__ == "__main__":
-    main()
+    main()

janito/agents/__init__.py

@@ -5,18 +5,18 @@ SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. I help
 ai_backend = os.getenv('AI_BACKEND', 'claudeai').lower()
 
 if ai_backend == 'openai':
+    import warnings
+    warnings.warn(
+        "Using deprecated OpenAI backend. Please switch to Claude AI backend by removing AI_BACKEND=openai "
+        "from your environment variables.",
+        DeprecationWarning,
+        stacklevel=2
+    )
     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}")
 
-class AgentSingleton:
-    _instance = None
-
-    @classmethod
-    def get_agent(cls):
-        if cls._instance is None:
-            cls._instance = AIAgent(SYSTEM_PROMPT)
-        return cls._instance
-
+# Create a singleton instance
+agent = AIAgent(SYSTEM_PROMPT)

janito/agents/agent.py

@@ -1,4 +1,3 @@
-
 from abc import ABC, abstractmethod
 from threading import Event
 from typing import Optional, List, Tuple
@@ -16,6 +15,14 @@ class Agent(ABC):
             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"""
+    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

@@ -22,43 +22,24 @@ class ClaudeAIAgent(Agent):
         self.last_prompt = None
         self.last_full_message = None
         self.last_response = None
-        self.messages_history = []
-        if system_prompt:
-            self.messages_history.append(("system", system_prompt))
 
-    def send_message(self, message: str, stop_event: Event = None) -> str:
+
+    def send_message(self, message: str, system_message: str = 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,
-            )
-            
-            # 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
-            
-        except KeyboardInterrupt:
-            if stop_event:
-                stop_event.set()
-            return ""
+        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/openai.py

@@ -5,7 +5,11 @@ from threading import Event
 from .agent import Agent
 
 class OpenAIAgent(Agent):
-    """Handles interaction with OpenAI API, including message handling"""
+    """[DEPRECATED] Handles interaction with OpenAI API, including message handling.
+
+    This backend is no longer actively maintained. Please use the Claude AI backend instead.
+    The code is kept for backward compatibility but may be removed in future versions.
+    """
     DEFAULT_MODEL = "o1-mini-2024-09-12"
     
     def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):

janito/change/__init__.py

@@ -1,19 +1,32 @@
-from .applier import apply_single_change
-from .position import parse_and_apply_changes_sequence
-from .content import (
-    get_file_type,
-    process_and_save_changes,
-    format_parsed_changes,
-    apply_content_changes,
-    handle_changes_file
-)
+"""
+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__ = [
-    'apply_single_change',
-    'parse_and_apply_changes_sequence',
-    'get_file_type',
-    'process_and_save_changes',
-    'format_parsed_changes',
-    'apply_content_changes',
-    'handle_changes_file'
+    'build_change_request_prompt',
+    'get_change_response',
+    'parse_response',
+    'setup_workspace_dir_preview',
+    'parse_change_response',
+    'save_change_response',
+    'ChangeApplier'
 ]

janito/{analysis → change/analysis}/__init__.py

@@ -4,30 +4,20 @@ This module provides functionality for analyzing and displaying code changes.
 """
 
 from .options import AnalysisOption, parse_analysis_options
-from .display import (
-    format_analysis,
-    get_history_file_type,
-    get_history_path,
-    get_timestamp,
-    save_to_file
-)
+from .view import format_analysis, prompt_user, get_option_selection
 from .prompts import (
     build_request_analysis_prompt,
-    get_option_selection,
-    prompt_user,
     validate_option_letter
 )
+from .analyze import analyze_request
 
 __all__ = [
     'AnalysisOption',
     'parse_analysis_options',
     'format_analysis',
-    'get_history_file_type',
-    'get_history_path', 
-    'get_timestamp',
-    'save_to_file',
     'build_request_analysis_prompt',
     'get_option_selection',
     'prompt_user',
-    'validate_option_letter'
-]
+    'validate_option_letter',
+    'analyze_request'
+]

janito/change/analysis/__main__.py

@@ -0,0 +1,7 @@
+"""Main entry point for the analysis module."""
+
+from .analyze import analyze_request
+from janito.config import config
+from janito.workspace import collect_files_content
+from pathlib import Path
+

janito/change/analysis/analyze.py

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

janito/change/analysis/formatting.py

@@ -0,0 +1,78 @@
+"""Centralized formatting utilities for analysis display."""
+
+from typing import Dict, List, Text
+from rich.text import Text
+from rich.columns import Columns
+from rich.padding import Padding
+from pathlib import Path
+
+# Layout constants
+COLUMN_SPACING = 6  # Increased spacing between columns
+MIN_PANEL_WIDTH = 45  # Wider minimum width for better readability
+SECTION_PADDING = (2, 0)  # More vertical padding
+
+# Color scheme constants
+STATUS_COLORS = {
+    'new': 'bright_green',
+    'modified': 'yellow',
+    'removed': 'red',
+    'default': 'white'
+}
+
+STRUCTURAL_COLORS = {
+    'directory': 'dim',
+    'separator': 'blue dim',
+    'repeat': 'bright_magenta bold'
+}
+
+def create_header(text: str, style: str = "bold cyan") -> Text:
+    """Create formatted header with separator."""
+    content = Text()
+    content.append(text, style=style)
+    content.append("\n")
+    content.append("═" * len(text), style="cyan")
+    return content
+
+def create_section_header(text: str, width: int = 20) -> Text:
+    """Create centered section header with separator."""
+    content = Text()
+    padding = (width - len(text)) // 2
+    content.append(" " * padding + text, style="bold cyan")
+    content.append("\n")
+    content.append("─" * width, style="cyan")
+    return content
+
+def format_file_path(path: str, status: str, max_dir_length: int = 0, is_repeated: bool = False) -> Text:
+    """Format file path with status indicators and consistent alignment.
+
+    Args:
+        path: File path to format
+        status: File status (Modified, New, Removed)
+        max_dir_length: Maximum directory name length for padding
+        is_repeated: Whether this directory was seen before
+    """
+    content = Text()
+    style = STATUS_COLORS.get(status.lower(), STATUS_COLORS['default'])
+
+    parts = Path(path).parts
+    parent_dir = str(Path(path).parent)
+
+    if parent_dir != '.':
+        # Add 4 spaces for consistent base padding
+        base_padding = 4
+        dir_padding = max_dir_length + base_padding
+
+        if is_repeated:
+            # Add arrow with consistent spacing
+            content.append(" " * base_padding)
+            content.append("↑ ", style="magenta")
+            content.append(" " * (dir_padding - base_padding - 2))
+        else:
+            # Left-align directory name with consistent padding
+            content.append(" " * base_padding)
+            content.append(parent_dir, style="dim")
+            content.append(" " * (dir_padding - len(parent_dir) - base_padding))
+
+    # Add filename with consistent spacing
+    content.append(parts[-1], style=style)
+    return content

janito/change/analysis/options.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass, field
+from typing import Dict, List
+from pathlib import Path
+
+@dataclass
+class AnalysisOption:
+    """Represents an analysis option with letter identifier and details"""
+    letter: str
+    summary: str
+    description_items: List[str] = field(default_factory=list)
+    affected_files: List[str] = field(default_factory=list)
+
+    def format_option_text(self) -> str:
+        """Format option details as text for change core"""
+        text = f"Option {self.letter} - {self.summary}\n"
+        text += "=" * len(f"Option {self.letter} - {self.summary}") + "\n\n"
+        
+        if self.description_items:
+            text += "Description:\n"
+            for item in self.description_items:
+                text += f"- {item}\n"
+            text += "\n"
+            
+        if self.affected_files:
+            text += "Affected files:\n"
+            for file in self.affected_files:
+                text += f"- {file}\n"
+                
+        return text
+
+    def is_new_directory(self, file_path: str) -> bool:
+        """Check if file path represents the first occurrence of a directory"""
+        parent = str(Path(file_path).parent)
+        return parent != '.' and not any(
+            parent in self.get_clean_path(file)
+            for file in self.affected_files
+            if self.get_clean_path(file) != file_path
+        )
+
+    def get_clean_path(self, file_path: str) -> str:
+        """Remove status markers from file path"""
+        return file_path.split(' (')[0].strip()
+
+def parse_analysis_options(content: str) -> Dict[str, AnalysisOption]:
+    """Parse analysis options from formatted text file"""
+    options = {}
+    current_option = None
+    current_section = None
+    
+    for line in content.splitlines():
+        line = line.strip()
+        
+        # Skip empty lines and section separators
+        if not line or line.startswith('---') or line == 'END_OF_OPTIONS':
+            continue
+            
+        # New option starts with a letter and period
+        if line[0].isalpha() and line[1:3] == '. ':
+            letter, summary = line.split('. ', 1)
+            current_option = AnalysisOption(letter=letter.upper(), summary=summary)
+            options[letter.upper()] = current_option
+            current_section = None
+            continue
+            
+        # Section headers
+        if line.lower() == 'description:':
+            current_section = 'description'
+            continue
+        elif line.lower() == 'affected files:':
+            current_section = 'files'
+            continue
+            
+        # Add items to current section
+        if current_option and line.startswith('- '):
+            content = line[2:].strip()
+            if current_section == 'description':
+                current_option.description_items.append(content)
+            elif current_section == 'files':
+                current_option.affected_files.append(content)
+    
+    return options