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

janito/cli/commands.py

@@ -1,45 +1,68 @@
-from pathlib import Path
-from typing import Optional, List
-from rich.console import Console
-
-from janito.agents import AIAgent
-from janito.workspace.analysis import analyze_workspace_content
-from janito.config import config
-from janito.change.core import process_change_request
-from janito.change.play import play_saved_changes
-from janito.cli.history import save_to_history
-from janito.agents import agent
-
-
-from .handlers.ask import AskHandler
-from .handlers.request import RequestHandler
-from .handlers.scan import ScanHandler
-from janito.change.play import play_saved_changes
-
-def handle_ask(question: str):
-    """Ask a question about the codebase"""
-    handler = AskHandler()
-    handler.handle(question)
-
-def handle_scan(paths_to_scan: List[Path]):
-    """Preview files that would be analyzed"""
-    from janito.workspace import collect_files_content, preview_scan
-    from janito.workspace.analysis import analyze_workspace_content
-    preview_scan(paths_to_scan)
-    files_content = collect_files_content(paths_to_scan)
-    analyze_workspace_content(files_content)
-
-def handle_play(filepath: Path):
-    """Replay a saved changes or debug file"""
-    play_saved_changes(filepath)
-
-def handle_request(request: str, preview_only: bool = False):
-    """Process modification request"""
-
-
-    handler = RequestHandler()
-    handler.handle(request, preview_only)
-
-    # Save request and response to history
-    if agent.last_response:
-        save_to_history(request, agent.last_response)
+from pathlib import Path
+from rich.console import Console
+from janito.agents import agent
+
+from janito.workspace import workset
+from janito.config import config
+from janito.qa import ask_question, display_answer
+from janito.change.request import request_change, replay_saved_response
+
+
+console = Console()
+
+def handle_ask(question: str):
+    """Process a question about the codebase
+
+    Args:
+        question: The question to ask about the codebase
+        workset: Optional Workset instance for scoped operations
+    """
+    answer = ask_question(question)
+    display_answer(answer)
+
+def handle_scan():
+    """Preview files that would be analyzed"""
+    workset.show()
+
+
+
+def is_dir_empty(path: Path) -> bool:
+    """Check if directory is empty or only contains empty directories."""
+    if not path.is_dir():
+        return False
+
+    for item in path.iterdir():
+        if item.name.startswith(('.', '__pycache__')):
+            continue
+        if item.is_file():
+            return False
+        if item.is_dir() and not is_dir_empty(item):
+            return False
+    return True
+
+def handle_request(request: str = None, replay: bool = False):
+    """Process modification request
+    
+    Args:
+        request: The modification request to process
+        replay: If True, triggers the replay response flow
+    """
+    if not request and not replay:
+        return
+    
+    is_empty = is_dir_empty(config.workspace_dir)
+    if is_empty:
+        console.print("\n[bold blue]Empty directory - will create new files as needed[/bold blue]")
+
+    if replay:
+        replay_saved_response()
+    else:
+        request_change(request)
+
+
+# Command handler functions
+COMMANDS = {
+    'ask': handle_ask,
+    'scan': handle_scan,
+    'request': handle_request
+}

janito/cli/functions.py

@@ -1,111 +1,66 @@
-import sys
-import tempfile
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import List, Optional
-
-import typer
-from rich.console import Console
-from rich.markdown import Markdown
-from rich.panel import Panel
-from rich.prompt import Confirm, Prompt
-from rich.text import Text
-
-from janito.agents import AIAgent
-from janito.common import progress_send_message
-from janito.config import config
-from janito.qa import ask_question, display_answer
-from janito.workspace import collect_files_content
-
-
-def prompt_user(message: str, choices: List[str] = None) -> str:
-    """Display a simple user prompt with optional choices"""
-    console = Console()
-    
-    if choices:
-        console.print(f"\n[cyan]Options: {', '.join(choices)}[/cyan]")
-    
-    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
-
-def validate_option_letter(letter: str, options: dict) -> bool:
-    """Validate if the given letter is a valid option or 'M' for modify"""
-    return letter.upper() in options or letter.upper() == 'M'
-
-def get_option_selection() -> str:
-    """Get user input for option selection"""
-    console = Console()
-    console.print("\n[cyan]Enter option letter or 'M' to modify request[/cyan]")
-    
-    while True:
-        letter = Prompt.ask("[bold cyan]Select option[/bold cyan]").strip().upper()
-        if letter == 'M' or (letter.isalpha() and len(letter) == 1):
-            return letter
-        
-        console.print("[red]Please enter a valid letter or 'M'[/red]")
-
-def get_change_history_path() -> Path:
-    """Create and return the changes history directory path"""
-    changes_history_dir = config.workspace_dir / '.janito' / 'change_history'
-    changes_history_dir.mkdir(parents=True, exist_ok=True)
-    return changes_history_dir
-
-def get_timestamp() -> str:
-    """Get current UTC timestamp in YMD_HMS format with leading zeros"""
-    return datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
-
-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) -> Path:
-    """Save content to a timestamped file in changes history directory"""
-    changes_history_dir = get_change_history_path()
-    timestamp = get_timestamp()
-    filename = f"{timestamp}_{prefix}.txt"
-    file_path = changes_history_dir / filename
-    file_path.write_text(content)
-    return file_path
-
-def modify_request(request: str) -> str:
-    """Display current request and get modified version with improved formatting"""
-    console = Console()
-    
-    # Display current request in a panel with clear formatting
-    console.print("\n[bold cyan]Current Request:[/bold cyan]")
-    console.print(Panel(
-        Text(request, style="white"),
-        border_style="blue",
-        title="Previous Request",
-        padding=(1, 2)
-    ))
-    
-    # Get modified request with clear prompt
-    console.print("\n[bold cyan]Enter modified request below:[/bold cyan]")
-    console.print("[dim](Press Enter to submit, Ctrl+C to cancel)[/dim]")
-    try:
-        new_request = prompt_user("Modified request")
-        if not new_request.strip():
-            console.print("[yellow]No changes made, keeping original request[/yellow]")
-            return request
-        return new_request
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Modification cancelled, keeping original request[/yellow]")
-        return request
-
-
-def read_stdin() -> str:
-    """Read input from stdin until EOF"""
-    console = Console()
-    console.print("[dim]Enter your input (press Ctrl+D when finished):[/dim]")
-    return sys.stdin.read().strip()
-
-def process_question(question: str) -> None:
-    """Process a question about the codebase"""
-    paths_to_scan = [config.workspace_dir] if not config.include else config.include
-    files_content = collect_files_content(paths_to_scan)
-    answer = ask_question(question, files_content)
-    display_answer(answer)
-
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional
+from janito.shell.user_prompt import prompt_user
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+from janito.config import config
+
+
+def get_change_history_path() -> Path:
+    """Create and return the changes history directory path"""
+    changes_history_dir = config.workspace_dir / '.janito' / 'change_history'
+    changes_history_dir.mkdir(parents=True, exist_ok=True)
+    return changes_history_dir
+
+def get_timestamp() -> str:
+    """Get current UTC timestamp in YMD_HMS format with leading zeros"""
+    return datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
+
+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, encoding='utf-8')
+    return temp_path
+
+def save_to_file(content: str, prefix: str) -> Path:
+    """Save content to a timestamped file in changes history directory"""
+    changes_history_dir = get_change_history_path()
+    timestamp = get_timestamp()
+    filename = f"{timestamp}_{prefix}.txt"
+    file_path = changes_history_dir / filename
+    file_path.write_text(content)
+    return file_path
+
+def modify_request(request: str) -> str:
+    """Display current request and get modified version with improved formatting"""
+    console = Console()
+    
+    # Display current request in a panel with clear formatting
+    console.print("\n[bold cyan]Current Request:[/bold cyan]")
+    console.print(Panel(
+        Text(request, style="white"),
+        border_style="blue",
+        title="Previous Request",
+        padding=(1, 2)
+    ))
+    
+    # Get modified request with clear prompt
+    console.print("\n[bold cyan]Enter modified request below:[/bold cyan]")
+    console.print("[dim](Press Enter to submit, Ctrl+C to cancel)[/dim]")
+    try:
+        new_request = prompt_user("Modified request")
+        if not new_request.strip():
+            console.print("[yellow]No changes made, keeping original request[/yellow]")
+            return request
+        return new_request
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Modification cancelled, keeping original request[/yellow]")
+        return request

janito/common.py

@@ -1,54 +1,133 @@
-from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
-from rich.console import Console
-from rich.rule import Rule
-from janito.agents import agent
-from .config import config
-from rich import print
-
-console = Console()
-
-def progress_send_message(message: str) -> str:
-    """
-    Send a message to the AI agent with a progress indicator and elapsed time.
-    
-    Args:
-        message: The message to send
-        
-    Returns:
-        The response from the AI agent
-    """
-    if config.debug:
-        console.print("[yellow]======= Sending message[/yellow]")
-        print(message)
-        console.print("[yellow]======= End of message[/yellow]")
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}", justify="center"),
-        TimeElapsedColumn(),
-    ) as progress:
-        task = progress.add_task("Waiting for response from AI agent...", total=None)
-        response = agent.send_message(message)
-        progress.update(task, completed=True)
-
-    if config.debug:
-        console.print("[yellow]======= Received response[/yellow]")
-        print(response)
-        console.print("[yellow]======= End of response[/yellow]")
-    response_text = response.content[0].text
-    
-    # Add token usage summary with detailed cache info
-    usage = response.usage
-    
-    # Format cache info
-    cache_str = "(no cache used)"
-    if usage.cache_creation_input_tokens or usage.cache_read_input_tokens:
-        create_pct = (usage.cache_creation_input_tokens / usage.input_tokens) * 100
-        read_pct = (usage.cache_read_input_tokens / usage.input_tokens) * 100
-        cache_str = f"(cached in/out: {usage.cache_creation_input_tokens}[{create_pct:.1f}%]/{usage.cache_read_input_tokens}[{read_pct:.1f}%])"
-    
-    percentage = (usage.output_tokens / usage.input_tokens) * 100
-    usage_text = f"Tokens: {usage.input_tokens} sent {cache_str}, {usage.output_tokens} received ({percentage:.1f}% ratio)"
-    console.print(Rule(usage_text, style="blue", align="center"))
-    
+from datetime import datetime
+from rich.live import Live
+from rich.text import Text
+from rich.console import Console
+from rich.rule import Rule
+from threading import Thread
+from janito.agents import agent
+from .config import config
+from typing import Optional, List
+import importlib.resources
+from pathlib import Path
+
+
+console = Console()
+
+
+def _get_system_prompt() -> str:
+    """Get the system prompt from the package data or local file."""
+    try:
+        # First try to read from package data
+        with importlib.resources.files('janito.data').joinpath('system_prompt.txt').open('r') as f:
+            return f.read()
+    except Exception:
+        # Fallback to local file for development
+        local_path = Path(__file__).parent / 'data' / 'system_prompt.txt'
+        if local_path.exists():
+            return local_path.read_text()
+        raise FileNotFoundError("Could not find system_prompt.txt")
+
+
+def progress_send_message(message: str) -> Optional[str]:
+    """Send a message to the AI agent with progress indication.
+
+    Displays a progress spinner while waiting for the agent's response and shows
+    token usage statistics after receiving the response. Uses a background thread
+    to update the elapsed time display.
+
+    Args:
+        system_message: The system message to send to the AI agent
+        message: The message to send to the AI agent
+
+    Returns:
+        Optional[str]: The response text from the AI agent, or None if interrupted
+
+    Note:
+        - Returns None if the operation is cancelled via Ctrl+C
+        - If the request fails, raises the original exception
+    """
+    system_message = _get_system_prompt()
+
+    if config.debug:
+        console.print(f"[yellow]======= Sending message via {agent.__class__.__name__.replace('AIAgent', '')}[/yellow]")
+        print(system_message)
+        print(message)
+        console.print("[yellow]======= End of message[/yellow]")
+
+    start_time = datetime.now()
+
+
+    response = None
+    error = None
+
+    def agent_thread():
+        nonlocal response, error
+        try:
+            response = agent.send_message(system_message=system_message, message=message)
+        except Exception as e:
+            error = e
+
+    agent_thread = Thread(target=agent_thread, daemon=True)
+    agent_thread.start()
+
+    try:
+        with Live(Text("Waiting for response from AI agent...", justify="center"), refresh_per_second=4) as live:
+            while agent_thread.is_alive():
+                elapsed = datetime.now() - start_time
+                elapsed_seconds = elapsed.seconds
+                elapsed_minutes = elapsed_seconds // 60
+                remaining_seconds = elapsed_seconds % 60
+                time_str = f"{elapsed_minutes}m{remaining_seconds}s" if elapsed_minutes > 0 else f"{elapsed_seconds}s"
+                live.update(Text.assemble(
+                    f"Waiting for {agent.friendly_name} response... (",
+                    (time_str, "magenta"),
+                    ")",
+                    justify="center"
+                ))
+                agent_thread.join(timeout=0.25)
+
+            # Calculate final stats
+            elapsed = datetime.now() - start_time
+            elapsed_seconds = elapsed.seconds
+            elapsed_minutes = elapsed_seconds // 60
+            remaining_seconds = elapsed_seconds % 60
+            time_str = f"{elapsed_minutes}m{remaining_seconds}s" if elapsed_minutes > 0 else f"{elapsed_seconds}s"
+
+            if hasattr(response, 'usage'):
+                usage = response.usage
+                # Get total input tokens including cache if available
+                total_input = (
+                    getattr(usage, 'input_tokens', 0) +
+                    getattr(usage, 'cache_creation_input_tokens', 0) +
+                    getattr(usage, 'cache_read_input_tokens', 0)
+                )
+                output_tokens = getattr(usage, 'output_tokens', 0)
+
+                # Update final message with stats
+                stats_text = f"Got response from {agent.friendly_name} after {time_str} • [cyan]In:[/] [bold green]{total_input:,}[/] [cyan]Out:[/] [bold yellow]{output_tokens:,}[/]"
+                live.update(Rule(stats_text))
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Operation cancelled[/yellow]")
+        return None
+
+    if error:
+        if isinstance(error, KeyboardInterrupt):
+            console.print("\n[yellow]Operation cancelled[/yellow]")
+            return None
+        raise error
+
+    if config.debug:
+        console.print("[yellow]======= Received response[/yellow]")
+        print(response.content[0].text)
+        console.print("[yellow]======= End of response[/yellow]")
+    
+    # Extract response text based on response type
+    if hasattr(response, 'choices'):
+        response_text = response.choices[0].message.content
+    elif hasattr(response, 'content'):
+        response_text = response.content[0].text
+    else:
+        response_text = str(response)
+    
     return response_text