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

janito/cli/functions.py

@@ -0,0 +1,111 @@
+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)
+

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/cli/registry.py

@@ -0,0 +1,26 @@
+from typing import Callable, Dict
+from dataclasses import dataclass
+
+@dataclass
+class Command:
+    name: str
+    handler: Callable
+    help_text: str
+
+class CommandRegistry:
+    def __init__(self):
+        self._commands: Dict[str, Command] = {}
+        
+    def register(self, name: str, help_text: str):
+        def decorator(handler: Callable):
+            self._commands[name] = Command(name, handler, help_text)
+            return handler
+        return decorator
+        
+    def get_command(self, name: str) -> Command:
+        return self._commands.get(name)
+        
+    def get_all_commands(self) -> Dict[str, Command]:
+        return self._commands
+
+registry = CommandRegistry()

janito/common.py

@@ -1,23 +1,54 @@
-from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn
-from janito.claude import ClaudeAPIAgent
+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
 
-def progress_send_message(claude: ClaudeAPIAgent, message: str) -> str:
+console = Console()
+
+def progress_send_message(message: str) -> str:
     """
-    Send a message to Claude with a progress indicator and elapsed time.
+    Send a message to the AI agent with a progress indicator and elapsed time.
     
     Args:
-        claude: The Claude API agent instance
         message: The message to send
         
     Returns:
-        The response from Claude
+        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}"),
+        TextColumn("[progress.description]{task.description}", justify="center"),
         TimeElapsedColumn(),
     ) as progress:
-        task = progress.add_task("Waiting for response from Claude...", total=None)
-        response = claude.send_message(message)
+        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()
+        )
+    ]

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"
+        )
+    ]

janito/demo/operations.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from enum import Enum, auto
+from pathlib import Path
+
+class MockOperationType(Enum):
+    CREATE = auto()
+    MODIFY = auto()
+    REMOVE = auto()
+
+@dataclass
+class MockOperation:
+    """Base class for mock operations"""
+    operation_type: MockOperationType
+    name: str
+    reason: str
+
+@dataclass
+class CreateOperation(MockOperation):
+    """Operation for creating new files"""
+    content: str
+
+    def __init__(self, name: str, content: str, reason: str = "Create new file"):
+        super().__init__(MockOperationType.CREATE, name, reason)
+        self.content = content
+
+@dataclass
+class ModifyOperation(MockOperation):
+    """Operation for modifying existing files"""
+    content: str
+    original_content: str
+
+    def __init__(self, name: str, content: str, original_content: str, reason: str = "Modify existing file"):
+        super().__init__(MockOperationType.MODIFY, name, reason)
+        self.content = content
+        self.original_content = original_content
+
+@dataclass
+class RemoveOperation(MockOperation):
+    """Operation for removing files"""
+    original_content: Optional[str] = None
+
+    def __init__(self, name: str, original_content: Optional[str] = None, reason: str = "Remove file"):
+        super().__init__(MockOperationType.REMOVE, name, reason)
+        self.original_content = original_content

janito/demo/runner.py

@@ -0,0 +1,59 @@
+from typing import List, Optional
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from .scenarios import DemoScenario
+from .operations import MockOperationType
+from ..change.viewer import preview_all_changes
+from ..change.parser import FileChange, ChangeOperation
+
+class DemoRunner:
+    def __init__(self):
+        self.console = Console()
+        self.scenarios: List[DemoScenario] = []
+
+    def add_scenario(self, scenario: DemoScenario) -> None:
+        """Add a demo scenario to the runner"""
+        self.scenarios.append(scenario)
+
+    def run_all(self) -> None:
+        """Run all registered demo scenarios"""
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=self.console
+        ) as progress:
+            for scenario in self.scenarios:
+                task = progress.add_task(f"Running scenario: {scenario.name}")
+                self.preview_changes(scenario)
+                progress.update(task, completed=True)
+
+    def preview_changes(self, scenario: Optional[DemoScenario] = None) -> None:
+        """Preview changes for a scenario using change viewer"""
+        if scenario is None:
+            if not self.scenarios:
+                self.console.print("[yellow]No scenarios to preview[/yellow]")
+                return
+            scenario = self.scenarios[0]
+
+        # Convert mock changes to FileChange objects
+        changes = []
+        for mock in scenario.changes:
+            # Map mock operation type to ChangeOperation
+            operation_map = {
+                MockOperationType.CREATE: ChangeOperation.CREATE_FILE,
+                MockOperationType.MODIFY: ChangeOperation.MODIFY_FILE,
+                MockOperationType.REMOVE: ChangeOperation.REMOVE_FILE
+            }
+            operation = operation_map[mock.operation_type]
+            change = FileChange(
+                operation=operation,
+                name=Path(mock.name),
+                content=mock.content if hasattr(mock, 'content') else None,
+                original_content=mock.original_content if hasattr(mock, 'original_content') else None
+            )
+            changes.append(change)
+
+        # Show changes using change viewer
+        preview_all_changes(self.console, changes)

janito/demo/scenarios.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+from rich.text import Text
+from pathlib import Path
+from .operations import MockOperation
+from .mock_data import get_mock_changes
+
+@dataclass
+class DemoScenario:
+    name: str
+    description: str
+    changes: List[MockOperation]
+
+    def get_preview(self) -> Text:
+        """Get a preview of the changes"""
+        text = Text()
+        text.append(f"Description: {self.description}\n\n", style="cyan")
+
+        # Group changes by operation
+        by_operation = {}
+        for change in self.changes:
+            if change.operation not in by_operation:
+                by_operation[change.operation] = []
+            by_operation[change.operation].append(change)
+
+        # Show changes grouped by operation
+        for operation_type, changes in by_operation.items():
+            text.append(f"\n{operation_type.name.title()} Operations:\n", style="yellow")
+            for change in changes:
+                text.append(f"• {change.name}\n", style="white")
+
+        return text