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

janito/cli/commands.py

@@ -3,51 +3,43 @@ from typing import Optional, List
 from rich.console import Console
 
 from janito.agents import AIAgent
-from janito.scan import preview_scan, is_dir_empty
+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 .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
-)
 
+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, workdir: Path, include: List[Path], raw: bool, agent: AIAgent):
+def handle_ask(question: str):
     """Ask a question about the codebase"""
-    workdir = ensure_workdir(workdir)
-    if question == ".":
-        question = read_stdin()
-    process_question(question, workdir, include, raw, agent)
+    handler = AskHandler()
+    handler.handle(question)
 
-def handle_scan(paths_to_scan: List[Path], workdir: Path):
+def handle_scan(paths_to_scan: List[Path]):
     """Preview files that would be analyzed"""
-    workdir = ensure_workdir(workdir)
-    preview_scan(paths_to_scan, workdir)
+    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, workdir: Path, raw: bool):
-    """Replay a saved prompt file"""
-    workdir = ensure_workdir(workdir)
-    replay_saved_file(filepath, workdir, raw)
+def handle_play(filepath: Path):
+    """Replay a saved changes or debug file"""
+    play_saved_changes(filepath)
 
-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()
-        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)
+
+
+    handler = RequestHandler()
+    handler.handle(request, preview_only)
+
+    # Save request and response to history
+    if agent.last_response:
+        save_to_history(request, agent.last_response)

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/handlers/ask.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from janito.config import config
+from janito.qa import ask_question, display_answer
+from janito.workspace.scan import collect_files_content
+from ..base import BaseCLIHandler
+
+class AskHandler(BaseCLIHandler):
+    def handle(self, question: str):
+        """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)
+
+        if config.tui:
+            answer = ask_question(question, files_content)
+            from janito.tui import TuiApp
+            app = TuiApp(content=answer)
+            app.run()
+        else:
+            answer = ask_question(question, files_content)
+            display_answer(answer)

janito/cli/handlers/demo.py

@@ -0,0 +1,22 @@
+from rich.console import Console
+from janito.demo import DemoRunner
+from janito.demo.data import get_demo_scenarios
+from ..base import BaseCLIHandler
+
+class DemoHandler(BaseCLIHandler):
+    def handle(self):
+        """Run demo scenarios"""
+        runner = DemoRunner()
+
+        # Add predefined scenarios
+        for scenario in get_demo_scenarios():
+            runner.add_scenario(scenario)
+
+        # Preview and run scenarios
+        self.console.print("\n[bold cyan]Demo Scenarios Preview:[/bold cyan]")
+        runner.preview_changes()
+
+        self.console.print("\n[bold cyan]Running Demo Scenarios:[/bold cyan]")
+        runner.run_all()
+
+        self.console.print("\n[green]Demo completed successfully![/green]")

janito/cli/handlers/request.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from rich.console import Console
+from janito.config import config
+from janito.workspace import is_dir_empty
+from janito.change.core import process_change_request
+from ..base import BaseCLIHandler
+
+class RequestHandler(BaseCLIHandler):
+    def handle(self, request: str, preview_only: bool = False):
+        """Process a modification request"""
+        is_empty = is_dir_empty(config.workspace_dir)
+        if is_empty and not config.include:
+            self.console.print("\n[bold blue]Empty directory - will create new files as needed[/bold blue]")
+
+        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)
+                self.console.print(f"\nChanges saved to: ./{rel_path}")
+            except ValueError:
+                self.console.print(f"\nChanges saved to: {history_file}")
+        elif not success:
+            self.console.print("[red]Failed to process change request[/red]")

janito/cli/handlers/scan.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+from typing import List
+from janito.workspace import preview_scan
+from ..base import BaseCLIHandler
+
+class ScanHandler(BaseCLIHandler):
+    def handle(self, paths_to_scan: List[Path]):
+        """Preview files that would be analyzed"""
+        preview_scan(paths_to_scan)

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,5 +1,11 @@
 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
+
+console = Console()
 
 def progress_send_message(message: str) -> str:
     """
@@ -11,7 +17,11 @@ def progress_send_message(message: str) -> str:
     Returns:
         The response from the AI agent
     """
-    agent = AgentSingleton.get_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"),
@@ -20,4 +30,25 @@ def progress_send_message(message: str) -> str:
         task = progress.add_task("Waiting for response from AI agent...", total=None)
         response = agent.send_message(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
+    
+    # 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"))
+    
+    return response_text

janito/config.py

@@ -1,30 +1,38 @@
-from typing import Optional
+from typing import Optional, List
 import os
+from pathlib import Path
 
 class ConfigManager:
     _instance = None
-    
+
     def __init__(self):
         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.include: List[Path] = []
+        self.recursive: List[Path] = []
+        self.auto_apply: bool = False
+        self.tui: bool = False
+        self.skipwork: bool = False
+
     @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:
         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 +41,62 @@ 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"""
+        self.raw = enabled
+
+    def set_include(self, paths: Optional[List[Path]]) -> None:
+        """
+        Set additional paths to include.
+
+        Args:
+            paths: List of paths to include
+
+        Raises:
+            ValueError: If duplicate paths are provided
+        """
+        if paths is None:
+            self.include = []
+            return
+
+        # Convert paths to absolute and resolve symlinks
+        resolved_paths = [p.absolute().resolve() for p in paths]
+
+        # Check for duplicates
+        seen_paths = set()
+        unique_paths = []
+
+        for path in resolved_paths:
+            if path in seen_paths:
+                raise ValueError(f"Duplicate path provided: {path}")
+            seen_paths.add(path)
+            unique_paths.append(path)
+
+        self.include = unique_paths
+
+    def set_auto_apply(self, enabled: bool) -> None:
+        """Set auto apply mode"""
+        self.auto_apply = enabled
+
+    def set_tui(self, enabled: bool) -> None:
+        """Set TUI mode"""
+        self.tui = enabled
+
+    def set_recursive(self, paths: Optional[List[Path]]) -> None:
+        """Set paths to scan recursively
+
+        Args:
+            paths: List of directory paths to scan recursively, or None to disable recursive scanning
+        """
+        self.recursive = paths
+
+    def set_skipwork(self, enabled: bool) -> None:
+        """Set skipwork flag to skip scanning workspace_dir"""
+        self.skipwork = 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()
+        )
+    ]