janito 0.3.0__py3-none-any.whl

janito/__init__.py

@@ -0,0 +1,2 @@
+
+# Empty file to make the directory a Python package

janito/__main__.py

@@ -0,0 +1,260 @@
+import typer
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+from janito.claude import ClaudeAPIAgent
+import shutil
+from janito.prompts import (
+    build_request_analisys_prompt,
+    build_selected_option_prompt,
+    SYSTEM_PROMPT,
+    parse_options
+)
+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 importlib.metadata import version
+
+def get_version() -> str:
+    try:
+        return version("janito")
+    except:
+        return "dev"
+
+def format_analysis(analysis: str, raw: bool = False, claude: Optional[ClaudeAPIAgent] = None) -> None:
+    """Format and display the analysis output"""
+    console = Console()
+    if raw and claude:
+        console.print("\n=== Message History ===")
+        for role, content in claude.messages_history:
+            console.print(f"\n[bold cyan]{role.upper()}:[/bold cyan]")
+            console.print(content)
+        console.print("\n=== End Message History ===\n")
+    else:
+        md = Markdown(analysis)
+        console.print(md)
+
+def prompt_user(message: str, choices: List[str] = None) -> str:
+    """Display a prominent user prompt with optional choices"""
+    console = Console()
+    console.print()
+    console.print(Rule(" User Input Required ", style="bold cyan"))
+    
+    if choices:
+        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
+        console.print(Panel(choice_text, box=box.ROUNDED))
+    
+    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
+
+def get_option_selection() -> int:
+    """Get user input for option selection"""
+    while True:
+        try:
+            option = int(prompt_user("Select option number"))
+            return option
+        except ValueError:
+            console = Console()
+            console.print("[red]Please enter a valid number[/red]")
+
+def get_history_path(workdir: Path) -> Path:
+    """Create and return the history directory path"""
+    history_dir = workdir / '.janito' / 'history'
+    history_dir.mkdir(parents=True, exist_ok=True)
+    return 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')
+
+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
+
+def save_to_file(content: str, prefix: str, workdir: Path) -> Path:
+    """Save content to a timestamped file in history directory"""
+    history_dir = get_history_path(workdir)
+    timestamp = get_timestamp()
+    filename = f"{timestamp}_{prefix}.txt"
+    file_path = history_dir / filename
+    file_path.write_text(content)
+    return file_path
+
+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"""
+    option = get_option_selection()
+    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 ""
+    
+    selected_prompt = build_selected_option_prompt(option, request, initial_response, files_content)
+    prompt_file = save_to_file(selected_prompt, 'selected', workdir)
+    if config.verbose:
+        print(f"\nSelected prompt saved to: {prompt_file}")
+    
+    selected_response = claude.send_message(selected_prompt)
+    changes_file = save_to_file(selected_response, 'changes', workdir)
+    if config.verbose:
+        print(f"\nChanges saved to: {changes_file}")
+    
+    changes = parse_block_changes(selected_response)
+    preview_and_apply_changes(changes, workdir)
+
+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")
+    
+    file_type = get_file_type(filepath)
+    content = filepath.read_text()
+    
+    if file_type == 'changes':
+        changes = parse_block_changes(content)
+        preview_and_apply_changes(changes, workdir)
+    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 = claude.send_message(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(preview_changes, workdir)
+    else:
+        response = claude.send_message(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)
+
+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)
+
+def typer_main(
+    request: Optional[str] = typer.Argument(None, help="The modification request"),
+    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"),
+    debug_line: Optional[int] = typer.Option(None, "--debug-line", help="Show debug information only for specific line number"),
+    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"),
+) -> None:
+    """
+    Analyze files and provide modification instructions.
+    """
+    if version:
+        console = Console()
+        console.print(f"Janito v{get_version()}")
+        raise typer.Exit()
+
+    config.set_debug(debug)
+    config.set_verbose(verbose)
+    config.set_debug_line(debug_line)
+
+    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)
+        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)
+        return
+
+    if scan:
+        paths_to_scan = include if include else [workdir]
+        preview_scan(paths_to_scan, workdir)
+        return
+
+    if play:
+        replay_saved_file(play, claude, workdir, raw)
+        return
+
+    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 = ""
+    else:
+        files_content = collect_files_content(paths_to_scan, workdir)
+    
+    initial_prompt = build_request_analisys_prompt(files_content, request)
+    initial_response = claude.send_message(initial_prompt)
+    analysis_file = save_to_file(initial_response, 'analysis', workdir)
+    
+    format_analysis(initial_response, raw, claude)
+    
+    handle_option_selection(claude, initial_response, request, raw, workdir, include)
+
+def main():
+    typer.run(typer_main)
+
+if __name__ == "__main__":
+    main()

janito/changeviewer.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+from rich.console import Console
+from rich.text import Text
+from typing import TypedDict
+import difflib
+
+class FileChange(TypedDict):
+    """Type definition for a file change"""
+    description: str
+    new_content: str
+
+def show_file_changes(console: Console, filepath: Path, original: str, new_content: str, description: str) -> None:
+    """Display side by side comparison of file changes"""
+    half_width = (console.width - 3) // 2
+    
+    # Show header
+    console.print(f"\n[bold blue]Changes for {filepath}[/bold blue]")
+    console.print(f"[dim]{description}[/dim]\n")
+    
+    # Show side by side content
+    console.print(Text("OLD".center(half_width) + "│" + "NEW".center(half_width), style="blue bold"))
+    console.print(Text("─" * half_width + "┼" + "─" * half_width, style="blue"))
+    
+    old_lines = original.splitlines()
+    new_lines = new_content.splitlines()
+    
+    for i in range(max(len(old_lines), len(new_lines))):
+        old = old_lines[i] if i < len(old_lines) else ""
+        new = new_lines[i] if i < len(new_lines) else ""
+        
+        old_text = Text(f"{old:<{half_width}}", style="red" if old != new else None)
+        new_text = Text(f"{new:<{half_width}}", style="green" if old != new else None)
+        console.print(old_text + Text("│", style="blue") + new_text)
+
+def show_diff_changes(console: Console, filepath: Path, original: str, new_content: str, description: str) -> None:
+    """Display file changes using unified diff format"""
+    # Show header
+    console.print(f"\n[bold blue]Changes for {filepath}[/bold blue]")
+    console.print(f"[dim]{description}[/dim]\n")
+    
+    # Generate diff
+    diff = difflib.unified_diff(
+        original.splitlines(keepends=True),
+        new_content.splitlines(keepends=True),
+        fromfile='old',
+        tofile='new',
+        lineterm=''
+    )
+    
+    # Print diff with colors
+    for line in diff:
+        if line.startswith('+++'):
+            console.print(Text(line.rstrip(), style="bold green"))
+        elif line.startswith('---'):
+            console.print(Text(line.rstrip(), style="bold red"))
+        elif line.startswith('+'):
+            console.print(Text(line.rstrip(), style="green"))
+        elif line.startswith('-'):
+            console.print(Text(line.rstrip(), style="red"))
+        elif line.startswith('@@'):
+            console.print(Text(line.rstrip(), style="cyan"))
+        else:
+            console.print(Text(line.rstrip()))
+

janito/claude.py

@@ -0,0 +1,74 @@
+from rich.traceback import install
+import anthropic
+import os
+from typing import Optional
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from threading import Event
+
+# Install rich traceback handler
+install(show_locals=True)
+
+class ClaudeAPIAgent:
+    """Handles interaction with Claude API, including message handling"""
+    def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
+        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.stop_progress = Event()
+        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"""
+        try:
+            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 ""
+                
+                # Start API request
+                response = self.client.messages.create(
+                    model=self.model,  # Use discovered model
+                    system=self.system_message,
+                    max_tokens=4000,
+                    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 ""
+                
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            self.messages_history.append(("error", error_msg))
+            if stop_event and stop_event.is_set():
+                return ""
+            return error_msg

janito/config.py

@@ -0,0 +1,32 @@
+from typing import Optional
+import os
+
+class ConfigManager:
+    _instance = None
+    
+    def __init__(self):
+        self.debug = False
+        self.verbose = False
+        self.debug_line = None  # Add this line
+        
+    @classmethod
+    def get_instance(cls) -> "ConfigManager":
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+    
+    def set_debug(self, enabled: bool) -> None:
+        self.debug = enabled
+
+    def set_verbose(self, enabled: bool) -> None:
+        self.verbose = enabled
+        
+    def set_debug_line(self, line: Optional[int]) -> None:  # Add this method
+        self.debug_line = line
+        
+    def should_debug_line(self, line: int) -> bool:  # Add this method
+        """Return True if we should show debug for this line number"""
+        return self.debug and (self.debug_line is None or self.debug_line == line)
+
+# Create a singleton instance
+config = ConfigManager.get_instance()

janito/console.py

@@ -0,0 +1,60 @@
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from pathlib import Path
+from rich.console import Console
+from janito.claude import ClaudeAPIAgent
+from janito.prompts import build_request_analisys_prompt, SYSTEM_PROMPT
+from janito.scan import collect_files_content
+from janito.__main__ import handle_option_selection
+
+def start_console_session(workdir: Path, include: list[Path] = None) -> None:
+    """Start an interactive console session using prompt_toolkit"""
+    console = Console()
+    claude = ClaudeAPIAgent(system_prompt=SYSTEM_PROMPT)
+
+    # Setup prompt session with history
+    history_file = workdir / '.janito' / 'console_history'
+    history_file.parent.mkdir(parents=True, exist_ok=True)
+    session = PromptSession(history=FileHistory(str(history_file)))
+
+    from importlib.metadata import version
+    try:
+        ver = version("janito")
+    except:
+        ver = "dev"
+
+    console.print("\n[bold blue]╔═══════════════════════════════════════════╗[/bold blue]")
+    console.print("[bold blue]║           Janito AI Assistant             ║[/bold blue]")
+    console.print("[bold blue]║                v" + ver.ljust(8) + "                  ║[/bold blue]")
+    console.print("[bold blue]╠═══════════════════════════════════════════╣[/bold blue]")
+    console.print("[bold blue]║  Your AI-powered development companion    ║[/bold blue]")
+    console.print("[bold blue]╚═══════════════════════════════════════════╝[/bold blue]")
+    console.print("\n[cyan]Type your requests or 'exit' to quit[/cyan]\n")
+
+    while True:
+        try:
+            request = session.prompt("janito> ")
+            if request.lower() in ('exit', 'quit'):
+                break
+
+            if not request.strip():
+                continue
+
+            # Get current files content
+            paths_to_scan = [workdir] if workdir else []
+            if include:
+                paths_to_scan.extend(include)
+            files_content = collect_files_content(paths_to_scan, workdir)
+
+            # Get initial analysis
+            initial_prompt = build_request_analisys_prompt(files_content, request)
+            initial_response = claude.send_message(initial_prompt)
+
+            # Show response and handle options
+            console.print(initial_response)
+            handle_option_selection(claude, initial_response, request, False, workdir, include)
+
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            break

janito/contentchange.py

@@ -0,0 +1,165 @@
+import re
+from pathlib import Path
+from typing import Dict, Tuple, TypedDict, List
+from rich.console import Console
+from rich.prompt import Confirm
+import tempfile
+from janito.changeviewer import show_file_changes, FileChange, show_diff_changes
+import ast
+from datetime import datetime
+import shutil
+
+def get_file_type(filepath: Path) -> str:
+    """Determine the type of saved file based on its name"""
+    name = filepath.name.lower()
+    if 'changes' in name:
+        return 'changes'
+    elif 'selected' in name:
+        return 'selected'
+    elif 'analysis' in name:
+        return 'analysis'
+    elif 'response' in name:
+        return 'response'
+    return 'unknown'
+
+def parse_block_changes(content: str) -> Dict[Path, FileChange]:
+    """Parse file changes from code blocks in the content.
+    Returns dict mapping filepath -> FileChange"""
+    changes = {}
+    pattern = r'##\s*([\da-f-]+)\s+([^\n]+)\s+begin\s*"([^"]*)"[^\n]*##\n(.*?)##\s*\1\s+\2\s+end\s*##'
+    matches = re.finditer(pattern, content, re.DOTALL)
+    
+    for match in matches:
+        filepath = Path(match.group(2))
+        description = match.group(3)
+        file_content = match.group(4).strip()
+        changes[filepath] = FileChange(
+            description=description,
+            new_content=file_content
+        )
+        
+    return changes
+
+def save_changes_to_history(content: str, request: str, workdir: Path) -> Path:
+    """Save change content to history folder with timestamp and request info"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")  # Already in the correct format
+    history_dir = workdir / '.janito' / 'history'
+    history_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Create history entry with request and changes
+    history_file = history_dir / f"changes_{timestamp}.txt"
+    
+    history_content = f"""Request: {request}
+Timestamp: {timestamp}
+
+Changes:
+{content}
+"""
+    history_file.write_text(history_content)
+    return history_file
+
+def process_and_save_changes(content: str, request: str, workdir: Path) -> Tuple[Dict[Path, Tuple[str, str]], Path]:
+    """Parse changes and save to history, returns (changes_dict, history_file)"""
+    changes = parse_block_changes(content)
+    history_file = save_changes_to_history(content, request, workdir)
+    return changes, history_file
+
+def validate_python_syntax(content: str, filepath: Path) -> Tuple[bool, str]:
+    """Validate Python syntax and return (is_valid, error_message)"""
+    try:
+        ast.parse(content)
+        return True, ""
+    except SyntaxError as e:
+        return False, f"Line {e.lineno}: {e.msg}"
+    except Exception as e:
+        return False, str(e)
+
+def format_parsed_changes(changes: Dict[Path, Tuple[str, str]]) -> str:
+    """Format parsed changes to show only file change descriptions"""
+    result = []
+    for filepath, (_, description) in changes.items():  # Updated tuple unpacking
+        result.append(f"=== {filepath} ===\n{description}\n")
+    return "\n".join(result)
+
+def validate_changes(changes: Dict[Path, FileChange]) -> Tuple[bool, List[Tuple[Path, str]]]:
+    """Validate all changes, returns (is_valid, list of errors)"""
+    errors = []
+    for filepath, change in changes.items():
+        if filepath.suffix == '.py':
+            is_valid, error = validate_python_syntax(change['new_content'], filepath)
+            if not is_valid:
+                errors.append((filepath, error))
+    return len(errors) == 0, errors
+
+def preview_and_apply_changes(changes: Dict[Path, FileChange], workdir: Path) -> bool:
+    """Preview changes in temporary directory and apply if confirmed."""
+    console = Console()
+
+    if not changes:
+        console.print("\n[yellow]No changes were found to apply[/yellow]")
+        return False
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        preview_dir = Path(temp_dir)
+        if workdir.exists():
+            shutil.copytree(workdir, preview_dir, dirs_exist_ok=True)
+        
+        for filepath, change in changes.items():
+            # Get original content
+            orig_path = workdir / filepath
+            original = orig_path.read_text() if orig_path.exists() else ""
+            
+            # Prepare preview
+            preview_path = preview_dir / filepath
+            preview_path.parent.mkdir(parents=True, exist_ok=True)
+            preview_path.write_text(change['new_content'])
+            
+            # Show changes
+            show_diff_changes(console, filepath, original, change['new_content'], change['description'])
+
+        # Apply changes if confirmed
+        if Confirm.ask("\nApply these changes?"):
+            for filepath, _ in changes.items():
+                preview_path = preview_dir / filepath
+                target_path = workdir / filepath
+                target_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(preview_path, target_path)
+                console.print(f"[green]✓[/green] Applied changes to {filepath}")
+            return True
+            
+    return False
+
+def apply_content_changes(content: str, request: str, workdir: Path) -> Tuple[bool, Path]:
+    """Regular flow: Parse content, save to history, and apply changes."""
+    console = Console()
+    changes = parse_block_changes(content)
+    
+    if not changes:
+        console.print("\n[yellow]No file changes were found in the response[/yellow]")
+        return False, None
+
+    # Validate changes before proceeding
+    is_valid, errors = validate_changes(changes)
+    if not is_valid:
+        console = Console()
+        console.print("\n[red bold]⚠️ Cannot apply changes: Python syntax errors detected![/red bold]")
+        for filepath, error in errors:
+            console.print(f"\n[red]⚠️ {filepath}: {error}[/red]")
+        return False, None
+
+    history_file = save_changes_to_history(content, request, workdir)
+    success = preview_and_apply_changes(changes, workdir)
+    return success, history_file
+
+def handle_changes_file(filepath: Path, workdir: Path) -> Tuple[bool, Path]:
+    """Replay flow: Load changes from file and apply them."""
+    content = filepath.read_text()
+    changes = parse_block_changes(content)
+    
+    if not changes:
+        console = Console()
+        console.print("\n[yellow]No file changes were found in the file[/yellow]")
+        return False, None
+
+    success = preview_and_apply_changes(changes, workdir)
+    return success, filepath

janito/prompts.py

@@ -0,0 +1,97 @@
+import re
+
+# Core system prompt focused on role and purpose
+SYSTEM_PROMPT = """You are Janito, an AI assistant for software development tasks. Be concise.
+"""
+
+
+CHANGE_ANALISYS_PROMPT = """
+Current files:
+<files>
+{files_content}
+</files>
+
+Considering the current files content, provide a table of options for the requested change.
+Always provide options using a header label "=== **Option 1** : ...", "=== **Option 2**: ...", etc.
+Provide the header with a short description followed by the file changes on the next line
+What files should be modified and what should they contain? (one line description)
+Do not provide the content of any of the file suggested to be created or modified.
+
+Request:
+{request}
+"""
+
+SELECTED_OPTION_PROMPT = """
+Original request: {request}
+
+Please provide detailed implementation using the following guide:
+{option_text}
+
+Current files:
+<files>
+{files_content}
+</files>
+
+After checking the above files and the provided implementation, please provide the following:
+
+## <uuid4> filename begin "short description of the change" ##
+<entire file content>
+## <uuid4> filename end ##
+
+ALWAYS provide the entire file content, not just the changes.
+If no changes are needed answer to any worksppace just reply <
+"""
+
+def build_selected_option_prompt(option_number: int, request: str, initial_response: str, files_content: str = "") -> str:
+    """Build prompt for selected option details"""
+    options = parse_options(initial_response)
+    if option_number not in options:
+        raise ValueError(f"Option {option_number} not found in response")
+    
+    return SELECTED_OPTION_PROMPT.format(
+        option_text=options[option_number],
+        request=request,
+        files_content=files_content
+    )
+
+def parse_options(response: str) -> dict[int, str]:
+    """Parse options from the response text, including any list items after the option label"""
+    options = {}
+    pattern = r"===\s*\*\*Option (\d+)\*\*\s*:\s*(.+?)(?====\s*\*\*Option|\Z)"
+    matches = re.finditer(pattern, response, re.DOTALL)
+    
+    for match in matches:
+        option_num = int(match.group(1))
+        option_text = match.group(2).strip()
+        
+        # Split into description and list items
+        lines = option_text.splitlines()
+        description = lines[0]
+        list_items = []
+        
+        # Collect list items that follow
+        for line in lines[1:]:
+            line = line.strip()
+            if line.startswith(('- ', '* ', '• ')):
+                list_items.append(line)
+            elif not line:
+                continue
+            else:
+                break
+                
+        # Combine description with list items if any exist
+        if list_items:
+            option_text = description + '\n' + '\n'.join(list_items)
+        
+        options[option_num] = option_text
+        
+    return options
+
+
+def build_request_analisys_prompt(files_content: str, request: str) -> str:
+    """Build prompt for information requests"""
+
+    return CHANGE_ANALISYS_PROMPT.format(
+        files_content=files_content,
+        request=request
+    )

janito/qa.py

@@ -0,0 +1,32 @@
+from rich.console import Console
+from rich.markdown import Markdown
+from janito.claude import ClaudeAPIAgent
+
+QA_PROMPT = """Please provide a clear and concise answer to the following question about the codebase:
+
+Question: {question}
+
+Current files:
+<files>
+{files_content}
+</files>
+
+Focus on providing factual information and explanations. Do not suggest code changes.
+"""
+
+def ask_question(question: str, files_content: str, claude: ClaudeAPIAgent) -> str:
+    """Process a question about the codebase and return the answer"""
+    prompt = QA_PROMPT.format(
+        question=question,
+        files_content=files_content
+    )
+    return claude.send_message(prompt)
+
+def display_answer(answer: str, raw: bool = False) -> None:
+    """Display the answer in markdown or raw format"""
+    console = Console()
+    if raw:
+        console.print(answer)
+    else:
+        md = Markdown(answer)
+        console.print(md)

janito/scan.py

@@ -0,0 +1,122 @@
+from pathlib import Path
+from typing import List, Tuple
+from rich.console import Console
+from rich.columns import Columns
+from janito.config import config
+from pathspec import PathSpec
+from pathspec.patterns import GitWildMatchPattern
+
+
+SPECIAL_FILES = ["README.md", "__init__.py", "__main__.py"]
+
+def _scan_paths(paths: List[Path], workdir: Path = None) -> Tuple[List[str], List[str]]:
+    """Common scanning logic used by both preview and content collection"""
+    content_parts = []
+    file_items = []
+    skipped_files = []
+    console = Console()
+    
+    # Load gitignore if it exists
+    gitignore_path = workdir / '.gitignore' if workdir else None
+    gitignore_spec = None
+    if gitignore_path and gitignore_path.exists():
+        with open(gitignore_path) as f:
+            gitignore = f.read()
+        gitignore_spec = PathSpec.from_lines(GitWildMatchPattern, gitignore.splitlines())
+    
+
+    def scan_path(path: Path, level: int) -> None:
+        """
+        Scan a path and add it to the content_parts list
+        level 0 means we are scanning the root directory
+        level 1 we provide both directory directory name and file content
+        level > 1 we just return
+        """
+        if level > 1:
+            return
+
+        relative_base = workdir
+        if path.is_dir():
+            relative_path = path.relative_to(relative_base)
+            content_parts.append(f'<directory><path>{relative_path}</path>not sent</directory>')
+            file_items.append(f"[blue]•[/blue] {relative_path}/")
+            # Check for special files
+            special_found = []
+            for special_file in SPECIAL_FILES:
+                if (path / special_file).exists():
+                    special_found.append(special_file)
+            if special_found:
+                file_items[-1] = f"[blue]•[/blue] {relative_path}/ [cyan]({', '.join(special_found)})[/cyan]"
+                for special_file in special_found:
+                    special_path = path / special_file
+                    try:
+                        relative_path = special_path.relative_to(relative_base)
+                        file_content = special_path.read_text(encoding='utf-8')
+                        content_parts.append(f"<file>\n<path>{relative_path}</path>\n<content>\n{file_content}\n</content>\n</file>")
+                    except UnicodeDecodeError:
+                        skipped_files.append(str(relative_path))
+                        console.print(f"[yellow]Warning: Skipping file due to encoding issues: {relative_path}[/yellow]")
+
+            for item in path.iterdir():
+                # Skip if matches gitignore patterns
+                if gitignore_spec:
+                    rel_path = str(item.relative_to(workdir))
+                    if gitignore_spec.match_file(rel_path):
+                        continue
+                scan_path(item, level+1)
+
+        else:
+            relative_path = path.relative_to(relative_base)
+            # check if file is binary
+            try:
+                if path.is_file() and path.read_bytes().find(b'\x00') != -1:
+                    console.print(f"[red]Skipped binary file found: {relative_path}[/red]")
+                    return
+                file_content = path.read_text(encoding='utf-8')
+                content_parts.append(f"<file>\n<path>{relative_path}</path>\n<content>\n{file_content}\n</content>\n</file>")
+                file_items.append(f"[cyan]•[/cyan] {relative_path}")
+            except UnicodeDecodeError:
+                skipped_files.append(str(relative_path))
+                console.print(f"[yellow]Warning: Skipping file due to encoding issues: {relative_path}[/yellow]")
+
+    for path in paths:
+        scan_path(path, 0)
+        
+    if skipped_files and config.verbose:
+        console.print("\n[yellow]Files skipped due to encoding issues:[/yellow]")
+        for file in skipped_files:
+            console.print(f"  • {file}")
+        
+    return content_parts, file_items
+
+def collect_files_content(paths: List[Path], workdir: Path = None) -> str:
+    """Collect content from all files in XML format"""
+    console = Console()
+    content_parts, file_items = _scan_paths(paths, workdir)
+
+    if file_items and config.verbose:
+        console.print("\n[bold blue]Contents being analyzed:[/bold blue]")
+        console.print(Columns(file_items, padding=(0, 4), expand=True))
+    
+    return "\n".join(content_parts)
+
+def preview_scan(paths: List[Path], workdir: Path = None) -> None:
+    """Preview what files and directories would be scanned"""
+    console = Console()
+    _, file_items = _scan_paths(paths, workdir)
+    
+    # Change message based on whether we're scanning included paths or workdir
+    if len(paths) == 1 and paths[0] == workdir:
+        console.print(f"\n[bold blue]Scanning working directory:[/bold blue] {workdir.absolute()}")
+    else:
+        console.print(f"\n[bold blue]Working directory:[/bold blue] {workdir.absolute()}")
+        console.print("\n[bold blue]Scanning included paths:[/bold blue]")
+        for path in paths:
+            console.print(f"  • {path.absolute()}")
+            
+    console.print("\n[bold blue]Files that would be analyzed:[/bold blue]")
+    console.print(Columns(file_items, padding=(0, 4), expand=True))
+
+def is_dir_empty(path: Path) -> bool:
+    """Check if directory is empty, ignoring hidden files"""
+    return not any(item for item in path.iterdir() if not item.name.startswith('.'))

janito-0.3.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.3
+Name: janito
+Version: 0.3.0
+Summary: A CLI tool for software development tasks powered by AI
+Project-URL: Homepage, https://github.com/joaompinto/janito
+Project-URL: Repository, https://github.com/joaompinto/janito.git
+Author-email: João Pinto <lamego.pinto@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Requires-Dist: anthropic
+Requires-Dist: pathspec
+Requires-Dist: rich
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# 🤖 Janito CLI
+
+A CLI tool for software development tasks powered by AI.
+
+Janito is an AI-powered assistant that helps automate common software development tasks like refactoring, documentation updates, and code optimization.
+
+## 📥 Installation
+
+```bash
+# Install from PyPI
+pip install janito
+
+# Install from source
+git clone https://github.com/joaompinto/janito.git
+cd janito
+pip install -e .
+```
+
+## ⚡ Requirements
+
+- Python 3.8+
+- Anthropic API key
+- Required packages (automatically installed):
+  - typer
+  - pathspec
+  - rich
+
+## ⚙️ Configuration
+
+### 🔑 API Key Setup
+Janito requires an Anthropic API key to function. Set it as an environment variable:
+
+```bash
+export ANTHROPIC_API_KEY='your-api-key-here'
+```
+
+You can also add this to your shell profile (~/.bashrc, ~/.zshrc, etc.) for persistence.
+
+## 📖 Usage
+
+Janito can be used in two modes: Command Line or Interactive Console.
+
+### 💻 Command Line Mode
+
+```bash
+janito REQUEST [OPTIONS]
+```
+
+#### Arguments
+- `REQUEST`: The modification request
+
+#### Options
+- `-w, --workdir PATH`: Working directory (defaults to current directory)
+- `--raw`: Print raw response instead of markdown format
+- `--play PATH`: Replay a saved prompt file
+- `-i, --include PATH`: Additional paths to include in analysis
+- `--debug`: Show debug information
+- `-v, --verbose`: Show verbose output
+- `--ask`: Ask a question about the codebase
+- `--scan`: Preview files that would be analyzed
+
+### 🖥️ Interactive Console Mode
+
+Start the interactive console by running `janito` without arguments:
+
+```bash
+janito
+```
+
+In console mode, you can:
+- Enter requests directly
+- Navigate history with up/down arrows
+- Use special commands starting with /
+
+### 📝 Examples
+
+```bash
+# Command Line Mode Examples
+janito "create docstrings for all functions"
+janito "add error handling" -w ./myproject
+janito "update tests" -i ./tests -i ./lib
+janito --ask "explain the authentication flow"
+janito --scan  # Preview files to be analyzed
+
+# Console Mode
+janito  # Starts interactive session
+```
+
+## ✨ Features
+
+- 🤖 AI-powered code analysis and modifications
+- 💻 Interactive console mode for continuous interaction
+- 📁 Support for multiple file types
+- ✅ Syntax validation for Python files
+- 👀 Interactive change preview and confirmation
+- 📜 History tracking of all changes
+- 🐛 Debug and verbose output modes
+- ❓ Question-answering about codebase
+- 🔍 File scanning preview
+
+## 📚 History and Debugging
+
+Changes are automatically saved in `.janito/history/` with timestamps:
+- `*_analysis.txt`: Initial analysis
+- `*_selected.txt`: Selected implementation
+- `*_changes.txt`: Actual changes
+
+Enable debug mode for detailed logging:
+```bash
+janito "request" --debug
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

janito-0.3.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+janito/__init__.py,sha256=CLeVFqpY9Ki3R3MgLAiTjNsJjsj1BD3_9CzP2kgCj-k,52
+janito/__main__.py,sha256=bGp3nWUZC5omneyE3hn78D_J5PkBfk19qKfMV1kIThI,9892
+janito/changeviewer.py,sha256=C_CRdeD6dE4AIpOM_kryTn_HyD5XC-glaZO8n8zrQPE,2487
+janito/claude.py,sha256=tj0lNNVE0CW0bBkbhVDFgBl0AFoMHicWaHnYuYOk3_E,2911
+janito/config.py,sha256=YsS0bNVkjl7cIboP9nSDy0NXsJaVHYAIpPkc6bbErpo,967
+janito/console.py,sha256=ieKZ7IRbvJO_KW8A3CU4FCoO4YFEjJQT8BN98YotAnM,2770
+janito/contentchange.py,sha256=BxFmW8JtRjzX5lnfGfzo0JPRnGRw1RQEtqZCK1wVArw,6404
+janito/prompts.py,sha256=XonVVbfIg3YY1Dpbkx9m0ZSRE4bgDP3MYHO3D-5FcIE,3080
+janito/qa.py,sha256=F9bd18CBaZDpbJwwvwFL18gXPBA0cq8kRY0nA3_AKPY,916
+janito/scan.py,sha256=5JV0crOepVUqCZ3LAUqCJL2yerLFvjZ6RYdOwIGHvX0,5450
+janito-0.3.0.dist-info/METADATA,sha256=fq7zvCHx_PV8RND5SVfOMnM082BEptZQ2G2qWPOVisQ,3681
+janito-0.3.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+janito-0.3.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-0.3.0.dist-info/licenses/LICENSE,sha256=xLIUXRPjtsgQml2zD1Pn4LpgiyZ49raw6jZDlO_gZdo,1062
+janito-0.3.0.dist-info/RECORD,,

janito-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py3-none-any

janito-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+janito = janito.__main__:main

janito-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 João Pinto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.