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

janito/cli/commands.py

@@ -1,88 +0,0 @@
-from pathlib import Path
-from typing import Optional, List
-from rich.console import Console
-from rich.text import Text
-
-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
-
-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_scan():
-    """Preview files that would be analyzed"""
-    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
-
-    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, preview_only: bool = False):
-    """Process modification request"""
-    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]")
-
-    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,111 +0,0 @@
-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/history.py

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

@@ -1,26 +0,0 @@
-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,80 +0,0 @@
-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
-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 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 to the AI agent
-        
-    Returns:
-        str: The response text from the AI agent
-        
-    Note:
-        If the request fails or is canceled, returns the error message as a string
-    """
-    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, system_message=system_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 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/demo/__init__.py

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

janito/demo/data.py

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

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

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

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

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

janito/prompt.py

@@ -1,36 +0,0 @@
-from .workspace import workset
-
-SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. 
-
-I help you with coding tasks while being clear and concise in my responses.
-
-I have received the following workset for analysis:
-
-{workset}
-
-"""
-
-def build_system_prompt() -> dict:
-
-    system_prompt = [
-        {
-            "type": "text",
-            "text": "You Janito, an AI assistant tasked with analyzing worksets of code. You have received the following workset for analysis:",
-        }
-    ]
-
-    blocks = workset.get_cache_blocks()
-    for block in blocks:
-        if not block:
-            continue
-        block_content = ""
-        for file in block:
-            block_content += f'<file name="{file.name}"\n"'
-            block_content += f'<content>\n"{file.content}"\n</content>\n</file>\n'
-        system_prompt.append( {
-            "type": "text",
-            "text": block_content,
-            "cache_control": {"type": "ephemeral"}
-            }
-        )
-    return system_prompt

janito/qa.py

@@ -1,57 +0,0 @@
-from rich.console import Console
-from rich.markdown import Markdown
-from rich.panel import Panel
-from rich.rule import Rule
-from janito.common import progress_send_message
-from janito.workspace import workset  # Updated import
-
-
-QA_PROMPT = """Please provide a clear and concise answer to the following question about the workset you received above.
-
-Question: {question}
-
-Focus on providing factual information and explanations. Do not suggest code changes.
-Format your response using markdown with appropriate headers and code blocks.
-"""
-
-def ask_question(question: str) -> str:
-    """Process a question about the codebase and return the answer"""
-    # Ensure content is refreshed and analyzed
-    workset.show()
-    
-    prompt = QA_PROMPT.format(
-        question=question,
-    )
-    return progress_send_message(prompt)
-
-
-def display_answer(answer: str, raw: bool = False) -> None:
-    """Display the answer as markdown with consistent colors"""
-    console = Console()
-    
-    # Define consistent colors
-    COLORS = {
-        'primary': '#729FCF',    # Soft blue for primary elements
-        'secondary': '#8AE234',  # Bright green for actions/success
-        'accent': '#AD7FA8',     # Purple for accents
-        'muted': '#7F9F7F',      # Muted green for less important text
-    }
-    
-    if raw:
-        console.print(answer)
-        return
-    
-    # Display markdown answer in a panel with consistent styling
-    answer_panel = Panel(
-        Markdown(answer),
-        title="[bold]Answer[/bold]",
-        title_align="center",
-        border_style=COLORS['primary'],
-        padding=(1, 2)
-    )
-    
-    console.print("\n")
-    console.print(Rule(style=COLORS['accent']))
-    console.print(answer_panel)
-    console.print(Rule(style=COLORS['accent']))
-    console.print("\n")

janito/review.py

@@ -1,13 +0,0 @@
-from rich.console import Console
-from rich.markdown import Markdown
-from janito.common import progress_send_message
-from janito.agents import AIAgent
-
-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))