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

janito/cli/commands.py

@@ -1,53 +1,88 @@
 from pathlib import Path
 from typing import Optional, List
 from rich.console import Console
+from rich.text import Text
 
-from janito.agents import AIAgent
-from janito.scan import preview_scan, is_dir_empty
+from janito.agents import AIAgent, agent
+from janito.workspace import workset
 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.qa import ask_question, display_answer
+from janito.demo import DemoRunner
+from janito.demo.data import get_demo_scenarios
 
-from .functions import (
-    process_question, replay_saved_file, ensure_workdir,
-    review_text, save_to_file, collect_files_content,
-    build_request_analysis_prompt, progress_send_message,
-    format_analysis, handle_option_selection, read_stdin
-)
+console = Console()
 
+def handle_ask(question: str):
+    """Process a question about the codebase"""
+    
+    if config.tui:
+        answer = ask_question(question)
+        from janito.tui import TuiApp
+        app = TuiApp(content=answer)
+        app.run()
+    else:
+        answer = ask_question(question)
+        display_answer(answer)
 
-def handle_ask(question: str, workdir: Path, include: List[Path], raw: bool, agent: AIAgent):
-    """Ask a question about the codebase"""
-    workdir = ensure_workdir(workdir)
-    if question == ".":
-        question = read_stdin()
-    process_question(question, workdir, include, raw, agent)
-
-def handle_scan(paths_to_scan: List[Path], workdir: Path):
+def handle_scan():
     """Preview files that would be analyzed"""
-    workdir = ensure_workdir(workdir)
-    preview_scan(paths_to_scan, workdir)
+    workset.show()
+
+def handle_play(filepath: Path):
+    """Replay a saved changes or debug file"""
+    play_saved_changes(filepath)
+
+def is_dir_empty(path: Path) -> bool:
+    """Check if directory is empty or only contains empty directories."""
+    if not path.is_dir():
+        return False
 
-def handle_play(filepath: Path, workdir: Path, raw: bool):
-    """Replay a saved prompt file"""
-    workdir = ensure_workdir(workdir)
-    replay_saved_file(filepath, workdir, raw)
+    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, workdir: Path, include: List[Path], raw: bool, agent: AIAgent):
+def handle_request(request: str, preview_only: bool = False):
     """Process modification request"""
-    workdir = ensure_workdir(workdir)
-    paths_to_scan = include if include else [workdir]
-    
-    is_empty = is_dir_empty(workdir)
-    if is_empty and not include:
-        console = Console()
+    is_empty = is_dir_empty(config.workspace_dir)
+    if is_empty and not config.include:
         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_analysis_prompt(files_content, request)
-    initial_response = progress_send_message(initial_prompt)
-    save_to_file(initial_response, 'analysis', workdir)
-    
-    format_analysis(initial_response, raw, agent)
-    
-    handle_option_selection(initial_response, request, raw, workdir, include)
+
+    success, history_file = process_change_request(request, preview_only)
+
+    if success and history_file and config.verbose:
+        try:
+            rel_path = history_file.relative_to(config.workspace_dir)
+            console.print(f"\nChanges saved to: ./{rel_path}")
+        except ValueError:
+            console.print(f"\nChanges saved to: {history_file}")
+    elif not success:
+        console.print("[red]Failed to process change request[/red]")
+
+    # Save request and response to history
+    if agent.last_response:
+        save_to_history(request, agent.last_response)
+
+def handle_demo():
+    """Run demo scenarios"""
+    runner = DemoRunner()
+
+    # Add predefined scenarios
+    for scenario in get_demo_scenarios():
+        runner.add_scenario(scenario)
+
+    # Preview and run scenarios
+    console.print("\n[bold cyan]Demo Scenarios Preview:[/bold cyan]")
+    runner.preview_changes()
+
+    console.print("\n[bold cyan]Running Demo Scenarios:[/bold cyan]")
+    runner.run_all()
+
+    console.print("\n[green]Demo completed successfully![/green]")

janito/cli/functions.py

@@ -1,27 +1,22 @@
-from typing import Optional, List
+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.prompt import Prompt, Confirm
+from rich.markdown import Markdown
 from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
 from rich.text import Text
-from rich.markdown import Markdown
-from datetime import datetime, timezone
-import tempfile
-import typer
-import sys
 
 from janito.agents import AIAgent
+from janito.common import progress_send_message
 from janito.config import config
-from janito.scan import collect_files_content, show_content_stats
-from janito.analysis import (
-    format_analysis, build_request_analysis_prompt, 
-    parse_analysis_options, get_history_file_type, AnalysisOption
-)
 from janito.qa import ask_question, display_answer
-from janito.common import progress_send_message
-from janito.prompts import build_selected_option_prompt
-from janito.fileparser import parse_block_changes
-from janito.change.applier import preview_and_apply_changes
+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"""
@@ -48,9 +43,9 @@ def get_option_selection() -> str:
         
         console.print("[red]Please enter a valid letter or 'M'[/red]")
 
-def get_change_history_path(workdir: Path) -> Path:
+def get_change_history_path() -> Path:
     """Create and return the changes history directory path"""
-    changes_history_dir = workdir / '.janito' / 'change_history'
+    changes_history_dir = config.workspace_dir / '.janito' / 'change_history'
     changes_history_dir.mkdir(parents=True, exist_ok=True)
     return changes_history_dir
 
@@ -65,9 +60,9 @@ def save_prompt_to_file(prompt: str) -> Path:
     temp_path.write_text(prompt)
     return temp_path
 
-def save_to_file(content: str, prefix: str, workdir: Path) -> 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(workdir)
+    changes_history_dir = get_change_history_path()
     timestamp = get_timestamp()
     filename = f"{timestamp}_{prefix}.txt"
     file_path = changes_history_dir / filename
@@ -100,107 +95,6 @@ def modify_request(request: str) -> str:
         console.print("\n[yellow]Modification cancelled, keeping original request[/yellow]")
         return request
 
-def format_option_text(option: AnalysisOption) -> str:
-    """Format an AnalysisOption into a string representation"""
-    option_text = f"Option {option.letter}:\n"
-    option_text += f"Summary: {option.summary}\n\n"
-    option_text += "Description:\n"
-    for item in option.description_items:
-        option_text += f"- {item}\n"
-    option_text += "\nAffected files:\n"
-    for file in option.affected_files:
-        option_text += f"- {file}\n"
-    return option_text
-
-def handle_option_selection(initial_response: str, request: str, raw: bool = False, workdir: Optional[Path] = None, include: Optional[List[Path]] = None) -> None:
-    """Handle option selection and implementation details"""
-    options = parse_analysis_options(initial_response)
-    if not options:
-        console = Console()
-        console.print("[red]No valid options found in the response[/red]")
-        return
-
-    while True:
-        option = get_option_selection()
-        
-        if option == 'M':
-            # Use the new modify_request function for better UX
-            new_request = modify_request(request)
-            if new_request == request:
-                continue
-                
-            # Rerun analysis with new request
-            # Only scan files listed in the selected option's affected_files
-            selected_option = options[option]
-            files_to_scan = selected_option.affected_files
-    
-            # Convert relative paths to absolute paths
-            absolute_paths = []
-            for file_path in files_to_scan:
-                # Remove (new) suffix if present
-                clean_path = file_path.split(' (')[0].strip()
-                path = workdir / clean_path if workdir else Path(clean_path)
-                if path.exists():
-                    absolute_paths.append(path)
-    
-            files_content = collect_files_content(absolute_paths, workdir) if absolute_paths else ""   
-            show_content_stats(files_content)         
-            initial_prompt = build_request_analysis_prompt(files_content, new_request)
-            initial_response = progress_send_message(initial_prompt)
-            save_to_file(initial_response, 'analysis', workdir)
-            
-            format_analysis(initial_response, raw)
-            options = parse_analysis_options(initial_response)
-            if not options:
-                console = Console()
-                console.print("[red]No valid options found in the response[/red]")
-                return
-            continue
-            
-        if not validate_option_letter(option, options):
-            console = Console()
-            console.print(f"[red]Invalid option '{option}'. Valid options are: {', '.join(options.keys())} or 'M' to modify[/red]")
-            continue
-            
-        break
-
-    # Only scan files listed in the selected option's affected_files
-    selected_option = options[option]
-    files_to_scan = selected_option.affected_files
-    
-    # Convert relative paths to absolute paths
-    absolute_paths = []
-    for file_path in files_to_scan:
-        # Remove (new) suffix if present
-        clean_path = file_path.split(' (')[0].strip()
-        path = workdir / clean_path if workdir else Path(clean_path)
-        if path.exists():
-            absolute_paths.append(path)
-    
-    files_content = collect_files_content(absolute_paths, workdir) if absolute_paths else ""
-    show_content_stats(files_content)
-    
-    # Format the selected option before building prompt
-    selected_option = options[option]
-    option_text = format_option_text(selected_option)
-    
-    selected_prompt = build_selected_option_prompt(option_text, request, files_content)
-    prompt_file = save_to_file(selected_prompt, 'selected', workdir)
-    if config.verbose:
-        print(f"\nSelected prompt saved to: {prompt_file}")
-    
-    selected_response = progress_send_message(selected_prompt)
-    changes_file = save_to_file(selected_response, 'changes', workdir)
-
-    if config.verbose:
-        try:
-            rel_path = changes_file.relative_to(workdir)
-            print(f"\nChanges saved to: ./{rel_path}")
-        except ValueError:
-            print(f"\nChanges saved to: {changes_file}")
-    
-    changes = parse_block_changes(selected_response)
-    preview_and_apply_changes(changes, workdir, config.test_cmd)
 
 def read_stdin() -> str:
     """Read input from stdin until EOF"""
@@ -208,79 +102,10 @@ def read_stdin() -> str:
     console.print("[dim]Enter your input (press Ctrl+D when finished):[/dim]")
     return sys.stdin.read().strip()
 
-def replay_saved_file(filepath: Path, 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")
-    
-    content = filepath.read_text()
-    
-    # Add debug output of file content
-    if config.debug:
-        console = Console()
-        console.print("\n[bold blue]Debug: File Content[/bold blue]")
-        console.print(Panel(
-            content,
-            title=f"Content of {filepath.name}",
-            border_style="blue",
-            padding=(1, 2)
-        ))
-        console.print()
-
-    file_type = get_history_file_type(filepath)
-    
-    if file_type == 'changes':
-        changes = parse_block_changes(content)
-        success = preview_and_apply_changes(changes, workdir, config.test_cmd)
-        if not success:
-            raise typer.Exit(1)
-    elif file_type == 'analysis':
-        format_analysis(content, raw)
-        handle_option_selection(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 = progress_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(changes, workdir, config.test_cmd)
-    else:
-        response = progress_send_message(content)
-        format_analysis(response, raw)
-
-def process_question(question: str, workdir: Path, include: List[Path], raw: bool, agent: AIAgent) -> None:
+def process_question(question: str) -> 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)
+    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, raw)
+    display_answer(answer)
 
-def ensure_workdir(workdir: Path) -> Path:
-    """Ensure working directory exists, prompt for creation if it doesn't"""
-    if workdir.exists():
-        return workdir.absolute()
-        
-    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.absolute()
-    raise typer.Exit(1)
-
-def review_text(text: str, raw: bool = False) -> None:
-    """Review the provided text using Claude"""
-    console = Console()
-    response = progress_send_message(f"Please review this text and provide feedback:\n\n{text}")
-    if raw:
-        console.print(response)
-    else:
-        console.print(Markdown(response))

janito/cli/history.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from datetime import datetime, timezone
+from typing import List
+from rich.console import Console
+from rich.table import Table
+from janito.config import config
+
+def get_history_path() -> Path:
+    """Get the path to the history directory"""
+    history_dir = config.workspace_dir / '.janito' / 'history'
+    history_dir.mkdir(parents=True, exist_ok=True)
+    return history_dir
+
+def save_to_history(request: str, response: str) -> None:
+    """Save a request and its response to the history file"""
+    history_dir = get_history_path()
+    timestamp = datetime.now(timezone.utc).strftime('%Y-%m-%d_%H%M%S')
+    history_file = history_dir / f"{timestamp}_request.txt"
+
+    content = f"""Request: {request}
+Timestamp: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}
+
+Response:
+{response}
+"""
+    history_file.write_text(content)
+
+def display_history() -> None:
+    """Display the history of requests"""
+    console = Console()
+    history_dir = get_history_path()
+
+    if not history_dir.exists():
+        console.print("[yellow]No history found[/yellow]")
+        return
+
+    table = Table(title="Request History")
+    table.add_column("Timestamp", style="cyan")
+    table.add_column("Request", style="white")
+    table.add_column("File", style="dim")
+
+    history_files = sorted(history_dir.glob("*_request.txt"), reverse=True)
+
+    if not history_files:
+        console.print("[yellow]No history found[/yellow]")
+        return
+
+    for history_file in history_files:
+        try:
+            content = history_file.read_text()
+            request_line = next(line for line in content.splitlines() if line.startswith("Request:"))
+            timestamp_line = next(line for line in content.splitlines() if line.startswith("Timestamp:"))
+
+            request = request_line.replace("Request:", "").strip()
+            timestamp = timestamp_line.replace("Timestamp:", "").strip()
+
+            table.add_row(timestamp, request, history_file.name)
+        except Exception as e:
+            console.print(f"[red]Error reading {history_file}: {e}[/red]")
+
+    console.print(table)

janito/common.py

@@ -1,23 +1,80 @@
 from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
-from janito.agents import AgentSingleton
+from rich.console import Console
+from rich.rule import Rule
+from janito.agents import agent
+from .config import config
+from rich import print
+from threading import Event
+
+""" CACHE USAGE SUMMARY
+https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
+cache_creation_input_tokens: Number of tokens written to the cache when creating a new entry.
+cache_read_input_tokens: Number of tokens retrieved from the cache for this request.
+input_tokens: Number of input tokens which were not read from or used to create a cache.
+"""
+
+from janito.prompt import build_system_prompt
+
+console = Console()
 
 def progress_send_message(message: str) -> str:
-    """
-    Send a message to the AI agent with a progress indicator and elapsed time.
+    """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.
     
     Args:
-        message: The message to send
+        message: The message to send to the AI agent
         
     Returns:
-        The response from the AI agent
+        str: The response text from the AI agent
+        
+    Note:
+        If the request fails or is canceled, returns the error message as a string
     """
-    agent = AgentSingleton.get_agent()
+    system_message = build_system_prompt()
+    if config.debug:
+        console.print("[yellow]======= Sending message[/yellow]")
+        print(system_message)
+        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)
+        response = agent.send_message(message, system_message=system_message)
         progress.update(task, completed=True)
-    return response
+
+    if config.debug:
+        console.print("[yellow]======= Received response[/yellow]")
+        print(response)
+        console.print("[yellow]======= End of response[/yellow]")
+    
+    response_text = response.content[0].text if hasattr(response, 'content') else str(response)
+    
+    # Add token usage summary with detailed cache info
+    if hasattr(response, 'usage'):
+        usage = response.usage
+
+        direct_input = usage.input_tokens
+        cache_create = usage.cache_creation_input_tokens or 0
+        cache_read = usage.cache_read_input_tokens or 0
+        total_input = direct_input + cache_create + cache_read
+
+        # Calculate percentages relative to total input
+        create_pct = (cache_create / total_input * 100) if cache_create else 0
+        read_pct = (cache_read / total_input * 100) if cache_read else 0
+        direct_pct = (direct_input / total_input * 100) if direct_input else 0
+        output_ratio = (usage.output_tokens / total_input * 100)
+
+        # Compact single-line token usage summary
+        usage_text = f"[cyan]In: [/][bold green]{total_input:,} - direct: {direct_input} ({direct_pct:.1f}%))[/] [cyan]Out:[/] [bold yellow]{usage.output_tokens:,}[/][dim]({output_ratio:.1f}%)[/]"
+        if cache_create or cache_read:
+            cache_text = f" [magenta]Input Cache:[/] [blue]Write:{cache_create:,}[/][dim]({create_pct:.1f}%)[/] [green]Read:{cache_read:,}[/][dim]({read_pct:.1f}%)[/]"
+            usage_text += cache_text
+        console.print(Rule(usage_text, style="cyan"))
+    
+    return response_text

janito/config.py

@@ -1,30 +1,59 @@
 from typing import Optional
 import os
+from pathlib import Path
 
 class ConfigManager:
-    _instance = None
+    """Singleton configuration manager for the application."""
     
+    _instance = None
+
     def __init__(self):
+        """Initialize configuration with default values."""
         self.debug = False
         self.verbose = False
         self.debug_line = None
         self.test_cmd = os.getenv('JANITO_TEST_CMD')
-        
+        self.workspace_dir = Path.cwd()
+        self.raw = False
+        self.auto_apply: bool = False
+        self.tui: bool = False
+        self.skip_work: bool = False
+
     @classmethod
     def get_instance(cls) -> "ConfigManager":
+        """Return the singleton instance of ConfigManager.
+        
+        Returns:
+            ConfigManager: The singleton instance
+        """
         if cls._instance is None:
             cls._instance = cls()
         return cls._instance
-    
+
     def set_debug(self, enabled: bool) -> None:
+        """Set debug mode.
+        
+        Args:
+            enabled: True to enable debug mode, False to disable
+        """
         self.debug = enabled
 
     def set_verbose(self, enabled: bool) -> None:
-        self.verbose = enabled
+        """Set verbose output mode.
         
+        Args:
+            enabled: True to enable verbose output, False to disable
+        """
+        self.verbose = enabled
+
     def set_debug_line(self, line: Optional[int]) -> None:
-        self.debug_line = line
+        """Set specific line number for debug output.
         
+        Args:
+            line: Line number to debug, or None for all lines
+        """
+        self.debug_line = line
+
     def should_debug_line(self, line: int) -> bool:
         """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)
@@ -33,5 +62,41 @@ class ConfigManager:
         """Set the test command, overriding environment variable"""
         self.test_cmd = cmd if cmd is not None else os.getenv('JANITO_TEST_CMD')
 
+    def set_workspace_dir(self, path: Optional[Path]) -> None:
+        """Set the workspace directory"""
+        self.workspace_dir = path if path is not None else Path.cwd()
+
+    def set_raw(self, enabled: bool) -> None:
+        """Set raw output mode.
+        
+        Args:
+            enabled: True to enable raw output mode, False to disable
+        """
+        self.raw = enabled
+
+    def set_auto_apply(self, enabled: bool) -> None:
+        """Set auto apply mode for changes.
+        
+        Args:
+            enabled: True to enable auto apply mode, False to disable
+        """
+        self.auto_apply = enabled
+
+    def set_tui(self, enabled: bool) -> None:
+        """Set Text User Interface mode.
+        
+        Args:
+            enabled: True to enable TUI mode, False to disable
+        """
+        self.tui = enabled
+
+    def set_skip_work(self, enabled: bool) -> None:
+        """Set whether to skip scanning the workspace directory.
+        
+        Args:
+            enabled: True to skip workspace directory, False to include it
+        """
+        self.skip_work = enabled
+
 # Create a singleton instance
 config = ConfigManager.get_instance()

janito/demo/__init__.py

@@ -0,0 +1,4 @@
+from .runner import DemoRunner
+from .scenarios import DemoScenario
+
+__all__ = ['DemoRunner', 'DemoScenario']

janito/demo/data.py

@@ -0,0 +1,13 @@
+from typing import Dict, List
+from .scenarios import DemoScenario
+from .mock_data import get_mock_changes
+
+def get_demo_scenarios() -> List[DemoScenario]:
+    """Get list of predefined demo scenarios"""
+    return [
+        DemoScenario(
+            name="File Operations Demo",
+            description="Demonstrate various file operations with change viewer",
+            changes=get_mock_changes()
+        )
+    ]

janito/demo/mock_data.py

@@ -0,0 +1,20 @@
+from typing import List
+from .operations import CreateOperation, ModifyOperation, RemoveOperation, MockOperation
+
+def get_mock_changes() -> List[MockOperation]:
+    """Get predefined mock changes for demo"""
+    return [
+        CreateOperation(
+            name="example/hello.py",
+            content="def greet():\n    print('Hello, World!')\n"
+        ),
+        ModifyOperation(
+            name="example/utils.py",
+            content="def process():\n    return 'Processed'\n",
+            original_content="def old_process():\n    return 'Old'\n"
+        ),
+        RemoveOperation(
+            name="example/obsolete.py",
+            original_content="# Obsolete code\n"
+        )
+    ]