janito 0.5.0__py3-none-any.whl → 0.6.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,63 @@
 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.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"),
-    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"),
+    skipwork: bool = typer.Option(False, "--skipwork", help="Skip scanning workspace_dir when using include paths"),
 ):
     """Janito - AI-powered code modification assistant"""
     if version:
@@ -27,28 +65,71 @@ def typer_main(
         console.print(f"Janito version {get_version()}")
         return
 
-    workdir = workdir or Path.cwd()
+    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)
 
-    agent = AgentSingleton.get_agent()
+    # 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, 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:
+        paths_to_scan = include or [config.workspace_dir]
+        handle_scan(paths_to_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

@@ -11,12 +11,6 @@ elif ai_backend == 'claudeai':
 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/claudeai.py

@@ -22,9 +22,7 @@ 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:
         """Send message to Claude API and return response"""
@@ -47,16 +45,9 @@ class ClaudeAIAgent(Agent):
                 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/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,61 @@
+"""Core analysis functionality."""
+
+from typing import Optional, Dict
+
+from janito.agents import agent
+from janito.common import progress_send_message
+from janito.config import config
+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,        
+    files_content_xml: str,
+    pre_select: str = ""
+) -> Optional[AnalysisOption]:
+    """
+    Analyze changes and get user selection.
+    
+    Args:
+        files_content: Content of files to analyze
+        request: User's change request
+        pre_select: Optional pre-selected option letter
+        
+    Returns:
+        Selected AnalysisOption or None if modified
+    """
+    # Build and send prompt
+    prompt = build_request_analysis_prompt(request, files_content_xml)
+    response = progress_send_message(prompt)
+    
+    # Parse 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

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

@@ -1,12 +1,15 @@
 """User prompts and input handling for analysis."""
 
-from typing import List
+from typing import List, Dict
 from rich.console import Console
 from rich.panel import Panel
 from rich.rule import Rule
 from rich.prompt import Prompt
 from rich import box
 
+
+from .options import AnalysisOption
+
 # Keep only prompt-related functionality
 CHANGE_ANALYSIS_PROMPT = """
 Current files:
@@ -16,8 +19,9 @@ Current files:
 
 Considering the above current files content, provide 3 sections, each identified by a keyword and representing an option.
 Each option should include a concise description and a list of affected files.
-1st option should be minimalistic style change, 2nd organized style, 3rd exntensible style.
-Do not use style as keyword, instead focus on the changes summaru
+1st option should be basic style change, 2nd organized style, 3rd exntensible style.
+Do not use style as keyword, instead focus on the changes summary.
+
 Use the following format:
 
 A. Keyword summary of the change
@@ -44,32 +48,51 @@ Request:
 def prompt_user(message: str, choices: List[str] = None) -> str:
     """Display a prominent user prompt with optional choices"""
     console = Console()
+    term_width = console.width or 80
     console.print()
-    console.print(Rule(" User Input Required ", style="bold cyan"))
+    console.print(Rule(" User Input Required ", style="bold cyan", align="center"))
     
     if choices:
         choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
-        console.print(Panel(choice_text, box=box.ROUNDED))
+        console.print(Panel(choice_text, box=box.ROUNDED, justify="center"))
     
-    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
+    # Center the prompt with padding
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+    return Prompt.ask(f"[bold cyan]{padded_message}[/bold cyan]")
 
-def validate_option_letter(letter: str, options: dict) -> bool:
+def validate_option_letter(letter: str, options: Dict[str, AnalysisOption]) -> bool:
     """Validate if the given letter is a valid option or 'M' for modify"""
-    return letter.upper() in options or letter.upper() == 'M'
+    if letter.upper() == 'M':
+        return True
+    return letter.upper() in options
 
 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]")
+    term_width = console.width or 80
+    message = "Enter option letter or 'M' to modify request"
+    padding = (term_width - len(message)) // 2
+    padded_message = " " * padding + message
+    
+    console.print(f"\n[cyan]{padded_message}[/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]")
+        
+        error_msg = "Please enter a valid letter or 'M'"
+        error_padding = (term_width - len(error_msg)) // 2
+        padded_error = " " * error_padding + error_msg
+        console.print(f"[red]{padded_error}[/red]")
 
-def build_request_analysis_prompt(files_content: str, request: str) -> str:
+def build_request_analysis_prompt(request: str, files_content_xml: str) -> str:
     """Build prompt for information requests"""
     return CHANGE_ANALYSIS_PROMPT.format(
-        files_content=files_content,
+        files_content=files_content_xml,
         request=request
     )
+
+    def build_request_analysis_prompt(request: str, files_content_xml: str) -> str:
+        """Build analysis prompt with minimal formatting."""
+        return f"Current files:\n{files_content_xml}\n\nRequest:\n{request}"

janito/change/analysis/view/__init__.py

@@ -0,0 +1,9 @@
+"""View package for analysis UI components."""
+
+from .terminal import format_analysis, prompt_user, get_option_selection
+
+__all__ = [
+    'format_analysis',
+    'prompt_user',
+    'get_option_selection'
+]