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

janito/__init__.py

@@ -1,2 +1,49 @@
+"""Core package initialization for Janito."""
 
-# Empty file to make the directory a Python package
+from .analysis import (
+    AnalysisOption,
+    parse_analysis_options,
+    format_analysis,
+    get_history_file_type,
+    get_history_path,
+    get_timestamp,
+    save_to_file,
+    build_request_analysis_prompt,
+    get_option_selection,
+    prompt_user,
+    validate_option_letter
+)
+
+from .change import (
+    apply_single_change,
+    parse_and_apply_changes_sequence,
+    get_file_type,
+    process_and_save_changes,
+    format_parsed_changes,
+    apply_content_changes,
+    handle_changes_file
+)
+
+__all__ = [
+    # Analysis exports
+    'AnalysisOption',
+    'parse_analysis_options',
+    'format_analysis',
+    'get_history_file_type',
+    'get_history_path',
+    'get_timestamp',
+    'save_to_file',
+    'build_request_analysis_prompt',
+    'get_option_selection',
+    'prompt_user',
+    'validate_option_letter',
+    
+    # Change exports
+    'apply_single_change',
+    'parse_and_apply_changes_sequence',
+    'get_file_type',
+    'process_and_save_changes',
+    'format_parsed_changes',
+    'apply_content_changes',
+    'handle_changes_file'
+]

janito/__main__.py

@@ -1,260 +1,54 @@
 import typer
-from typing import Optional, Dict, Any, List
+from typing import Optional, List
 from pathlib import Path
-from janito.claude import ClaudeAPIAgent
-import shutil
-from janito.prompts import (
-    build_request_analisys_prompt,
-    build_selected_option_prompt,
-    SYSTEM_PROMPT,
-    parse_options
-)
 from rich.console import Console
-from rich.markdown import Markdown
-import re
-import tempfile
-import json
-from rich.syntax import Syntax
-from janito.contentchange import (
-    handle_changes_file, 
-    get_file_type,
-    parse_block_changes,
-    preview_and_apply_changes,
-    format_parsed_changes,
-)
-from rich.table import Table
-from rich.columns import Columns
-from rich.panel import Panel
-from rich.text import Text
-from rich.rule import Rule
-from rich import box
-from datetime import datetime, timezone
-from itertools import chain
-from janito.scan import collect_files_content, is_dir_empty, preview_scan
-from janito.qa import ask_question, display_answer
-from rich.prompt import Prompt, Confirm
-from janito.config import config
-from importlib.metadata import version
-
-def get_version() -> str:
-    try:
-        return version("janito")
-    except:
-        return "dev"
-
-def format_analysis(analysis: str, raw: bool = False, claude: Optional[ClaudeAPIAgent] = None) -> None:
-    """Format and display the analysis output"""
-    console = Console()
-    if raw and claude:
-        console.print("\n=== Message History ===")
-        for role, content in claude.messages_history:
-            console.print(f"\n[bold cyan]{role.upper()}:[/bold cyan]")
-            console.print(content)
-        console.print("\n=== End Message History ===\n")
-    else:
-        md = Markdown(analysis)
-        console.print(md)
-
-def prompt_user(message: str, choices: List[str] = None) -> str:
-    """Display a prominent user prompt with optional choices"""
-    console = Console()
-    console.print()
-    console.print(Rule(" User Input Required ", style="bold cyan"))
-    
-    if choices:
-        choice_text = f"[cyan]Options: {', '.join(choices)}[/cyan]"
-        console.print(Panel(choice_text, box=box.ROUNDED))
-    
-    return Prompt.ask(f"[bold cyan]> {message}[/bold cyan]")
-
-def get_option_selection() -> int:
-    """Get user input for option selection"""
-    while True:
-        try:
-            option = int(prompt_user("Select option number"))
-            return option
-        except ValueError:
-            console = Console()
-            console.print("[red]Please enter a valid number[/red]")
-
-def get_history_path(workdir: Path) -> Path:
-    """Create and return the history directory path"""
-    history_dir = workdir / '.janito' / 'history'
-    history_dir.mkdir(parents=True, exist_ok=True)
-    return 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')
+from .version import get_version
 
-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, workdir: Path) -> Path:
-    """Save content to a timestamped file in history directory"""
-    history_dir = get_history_path(workdir)
-    timestamp = get_timestamp()
-    filename = f"{timestamp}_{prefix}.txt"
-    file_path = history_dir / filename
-    file_path.write_text(content)
-    return file_path
-
-def handle_option_selection(claude: ClaudeAPIAgent, initial_response: str, request: str, raw: bool = False, workdir: Optional[Path] = None, include: Optional[List[Path]] = None) -> None:
-    """Handle option selection and implementation details"""
-    option = get_option_selection()
-    paths_to_scan = [workdir] if workdir else []
-    if include:
-        paths_to_scan.extend(include)
-    files_content = collect_files_content(paths_to_scan, workdir) if paths_to_scan else ""
-    
-    selected_prompt = build_selected_option_prompt(option, request, initial_response, files_content)
-    prompt_file = save_to_file(selected_prompt, 'selected', workdir)
-    if config.verbose:
-        print(f"\nSelected prompt saved to: {prompt_file}")
-    
-    selected_response = claude.send_message(selected_prompt)
-    changes_file = save_to_file(selected_response, 'changes', workdir)
-    if config.verbose:
-        print(f"\nChanges saved to: {changes_file}")
-    
-    changes = parse_block_changes(selected_response)
-    preview_and_apply_changes(changes, workdir)
-
-def replay_saved_file(filepath: Path, claude: ClaudeAPIAgent, 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")
-    
-    file_type = get_file_type(filepath)
-    content = filepath.read_text()
-    
-    if file_type == 'changes':
-        changes = parse_block_changes(content)
-        preview_and_apply_changes(changes, workdir)
-    elif file_type == 'analysis':
-        format_analysis(content, raw, claude)
-        handle_option_selection(claude, 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 = claude.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(preview_changes, workdir)
-    else:
-        response = claude.send_message(content)
-        format_analysis(response, raw)
-
-def process_question(question: str, workdir: Path, include: List[Path], raw: bool, claude: ClaudeAPIAgent) -> 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)
+from janito.agents import AgentSingleton
+from janito.config import config
 
-    answer = ask_question(question, files_content, claude)
-    display_answer(answer, raw)
+from .cli.commands import handle_request, handle_ask, handle_play, handle_scan
 
-def ensure_workdir(workdir: Path) -> Path:
-    """Ensure working directory exists, prompt for creation if it doesn't"""
-    if workdir.exists():
-        return workdir
-        
-    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
-    raise typer.Exit(1)
+app = typer.Typer(add_completion=False)
 
 def typer_main(
-    request: Optional[str] = typer.Argument(None, help="The modification request"),
+    change_request: str = typer.Argument(None, help="Change request or command"),
+    workdir: Optional[Path] = typer.Option(None, "-w", "--workdir", help="Working directory", file_okay=False, dir_okay=True),
+    debug: bool = typer.Option(False, "--debug", help="Show debug information"),
+    verbose: bool = typer.Option(False, "--verbose", help="Show verbose output"),
+    include: Optional[List[Path]] = typer.Option(None, "-i", "--include", help="Additional paths to include"),
     ask: Optional[str] = typer.Option(None, "--ask", help="Ask a question about the codebase"),
-    workdir: Optional[Path] = typer.Option(None, "-w", "--workdir", 
-                                         help="Working directory (defaults to current directory)", 
-                                         file_okay=False, dir_okay=True),
-    raw: bool = typer.Option(False, "--raw", help="Print raw response instead of markdown format"),
     play: Optional[Path] = typer.Option(None, "--play", help="Replay a saved prompt file"),
-    include: Optional[List[Path]] = typer.Option(None, "-i", "--include", help="Additional paths to include in analysis", exists=True),
-    debug: bool = typer.Option(False, "--debug", help="Show debug information"),
-    debug_line: Optional[int] = typer.Option(None, "--debug-line", help="Show debug information only for specific line number"),
-    verbose: bool = typer.Option(False, "-v", "--verbose", help="Show verbose output"),
-    scan: bool = typer.Option(False, "--scan", help="Preview files that would be analyzed"),
-    version: bool = typer.Option(False, "--version", help="Show version and exit"),
-) -> None:
-    """
-    Analyze files and provide modification instructions.
-    """
+    version: bool = typer.Option(False, "--version", help="Show version information"),
+):
+    """Janito - AI-powered code modification assistant"""
     if version:
         console = Console()
-        console.print(f"Janito v{get_version()}")
-        raise typer.Exit()
+        console.print(f"Janito version {get_version()}")
+        return
 
+    workdir = workdir or Path.cwd()
     config.set_debug(debug)
     config.set_verbose(verbose)
-    config.set_debug_line(debug_line)
 
-    claude = ClaudeAPIAgent(system_prompt=SYSTEM_PROMPT)
+    agent = AgentSingleton.get_agent()
 
-    if not any([request, ask, play, scan]):
-        workdir = workdir or Path.cwd()
-        workdir = ensure_workdir(workdir)
-        from janito.console import start_console_session
-        start_console_session(workdir, include)
-        return
-
-    workdir = workdir or Path.cwd()
-    workdir = ensure_workdir(workdir)
-    
-    if include:
-        include = [
-            path if path.is_absolute() else (workdir / path).resolve()
-            for path in include
-        ]
-    
     if ask:
-        process_question(ask, workdir, include, raw, claude)
-        return
-
-    if scan:
+        handle_ask(ask, workdir, include, False, agent)
+    elif play:
+        handle_play(play, workdir, False)
+    elif change_request == "scan":
         paths_to_scan = include if include else [workdir]
-        preview_scan(paths_to_scan, workdir)
-        return
-
-    if play:
-        replay_saved_file(play, claude, workdir, raw)
-        return
-
-    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 = ""
+        handle_scan(paths_to_scan, workdir)
+    elif change_request:
+        handle_request(change_request, workdir, include, False, agent)
     else:
-        files_content = collect_files_content(paths_to_scan, workdir)
-    
-    initial_prompt = build_request_analisys_prompt(files_content, request)
-    initial_response = claude.send_message(initial_prompt)
-    analysis_file = save_to_file(initial_response, 'analysis', workdir)
-    
-    format_analysis(initial_response, raw, claude)
-    
-    handle_option_selection(claude, initial_response, request, raw, workdir, include)
+        console = Console()
+        console.print("Error: Please provide a change request or use --ask/--play options")
+        raise typer.Exit(1)
 
 def main():
     typer.run(typer_main)
 
 if __name__ == "__main__":
-    main()
+    main()

janito/_contextparser.py

@@ -0,0 +1,113 @@
+from typing import List, Tuple, Optional, NamedTuple
+from difflib import SequenceMatcher
+from janito.config import config
+from rich.console import Console
+
+class ContextError(NamedTuple):
+    """Contains error details for context matching failures"""
+    pre_context: List[str]
+    post_context: List[str]
+    content: str
+
+def parse_change_block(content: str) -> Tuple[List[str], List[str], List[str]]:
+    """Parse a change block into pre-context, post-context and change lines.
+    Returns (pre_context_lines, post_context_lines, change_lines)"""
+    pre_context_lines = []
+    post_context_lines = []
+    change_lines = []
+    in_pre_context = True
+    
+    for line in content.splitlines():
+        if line.startswith('='):
+            if in_pre_context:
+                pre_context_lines.append(line[1:])
+            else:
+                post_context_lines.append(line[1:])
+        elif line.startswith('>'):
+            in_pre_context = False
+            change_lines.append(line[1:])
+            
+    return pre_context_lines, post_context_lines, change_lines
+
+def find_context_match(file_content: str, pre_context: List[str], post_context: List[str], min_context: int = 2) -> Optional[Tuple[int, int]]:
+    """Find exact matching location using line-by-line matching.
+    Returns (start_index, end_index) or None if no match found."""
+    if not (pre_context or post_context) or (len(pre_context) + len(post_context)) < min_context:
+        return None
+
+    file_lines = file_content.splitlines()
+    
+    # Function to check if lines match at a given position
+    def lines_match_at(pos: int, target_lines: List[str]) -> bool:
+        if pos + len(target_lines) > len(file_lines):
+            return False
+        return all(a == b for a, b in zip(file_lines[pos:pos + len(target_lines)], target_lines))
+
+    # For debug output
+    debug_matches = []
+    
+    # Try to find pre_context match
+    pre_match_pos = None
+    if pre_context:
+        for i in range(len(file_lines) - len(pre_context) + 1):
+            if lines_match_at(i, pre_context):
+                pre_match_pos = i
+                break
+            if config.debug:
+                # Record first 20 non-matches for debug output
+                if len(debug_matches) < 20:
+                    debug_matches.append((i, file_lines[i:i + len(pre_context)]))
+
+    # Try to find post_context match after pre_context if found
+    if pre_match_pos is not None and post_context:
+        expected_post_pos = pre_match_pos + len(pre_context)
+        if not lines_match_at(expected_post_pos, post_context):
+            pre_match_pos = None
+
+    if pre_match_pos is None and config.debug:
+        console = Console()
+        console.print("\n[bold red]Context Match Debug:[/bold red]")
+        
+        if pre_context:
+            console.print("\n[yellow]Expected pre-context:[/yellow]")
+            for i, line in enumerate(pre_context):
+                console.print(f"  {i+1:2d} | '{line}'")
+
+        if post_context:
+            console.print("\n[yellow]Expected post-context:[/yellow]")
+            for i, line in enumerate(post_context):
+                console.print(f"  {i+1:2d} | '{line}'")
+
+        console.print("\n[yellow]First 20 attempted matches in file:[/yellow]")
+        for pos, lines in debug_matches:
+            console.print(f"\n[cyan]At line {pos+1}:[/cyan]")
+            for i, line in enumerate(lines):
+                match_status = "≠" if i < len(pre_context) and line != pre_context[i] else "="
+                console.print(f"  {i+1:2d} | '{line}' {match_status}")
+
+        return None
+
+    if pre_match_pos is None:
+        return None
+
+    end_pos = pre_match_pos + len(pre_context)
+    
+    return pre_match_pos, end_pos
+
+def apply_changes(content: str, 
+                 pre_context_lines: List[str], 
+                 post_context_lines: List[str], 
+                 change_lines: List[str]) -> Optional[Tuple[str, Optional[ContextError]]]:
+    """Apply changes with context matching, returns (new_content, error_details)"""
+    if not content.strip() and not pre_context_lines and not post_context_lines:
+        return '\n'.join(change_lines), None
+
+    pre_context = '\n'.join(pre_context_lines)
+    post_context = '\n'.join(post_context_lines)
+    
+    if pre_context and pre_context not in content:
+        return None, ContextError(pre_context_lines, post_context_lines, content)
+    
+    if post_context and post_context not in content:
+        return None, ContextError(pre_context_lines, post_context_lines, content)
+

janito/agents/__init__.py

@@ -0,0 +1,22 @@
+import os
+
+SYSTEM_PROMPT = """I am Janito, your friendly software development buddy. I help you with coding tasks while being clear and concise in my responses."""
+
+ai_backend = os.getenv('AI_BACKEND', 'claudeai').lower()
+
+if ai_backend == 'openai':
+    from .openai import OpenAIAgent as AIAgent
+elif ai_backend == 'claudeai':
+    from .claudeai import ClaudeAIAgent as AIAgent
+else:
+    raise ValueError(f"Unsupported AI_BACKEND: {ai_backend}")
+
+class AgentSingleton:
+    _instance = None
+
+    @classmethod
+    def get_agent(cls):
+        if cls._instance is None:
+            cls._instance = AIAgent(SYSTEM_PROMPT)
+        return cls._instance
+

janito/agents/agent.py

@@ -0,0 +1,21 @@
+
+from abc import ABC, abstractmethod
+from threading import Event
+from typing import Optional, List, Tuple
+
+class Agent(ABC):
+    """Abstract base class for AI agents"""
+    def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
+        self.api_key = api_key
+        self.system_message = system_prompt
+        self.last_prompt = None
+        self.last_full_message = None
+        self.last_response = None
+        self.messages_history: List[Tuple[str, str]] = []
+        if system_prompt:
+            self.messages_history.append(("system", system_prompt))
+
+    @abstractmethod
+    def send_message(self, message: str, stop_event: Event = None) -> str:
+        """Send message to AI service and return response"""
+        pass

janito/agents/claudeai.py

@@ -0,0 +1,64 @@
+import anthropic
+import os
+from typing import Optional
+from threading import Event
+from .agent import Agent
+
+class ClaudeAIAgent(Agent):
+    """Handles interaction with Claude API, including message handling"""
+    DEFAULT_MODEL = "claude-3-5-sonnet-20241022"
+    
+    def __init__(self, system_prompt: str = None):
+        self.api_key = os.getenv('ANTHROPIC_API_KEY')
+        super().__init__(self.api_key, system_prompt)
+        if not system_prompt:
+            raise ValueError("system_prompt is required")
+        
+        if not self.api_key:
+            raise ValueError("ANTHROPIC_API_KEY environment variable is required")
+        self.client = anthropic.Client(api_key=self.api_key)
+        self.model = os.getenv('CLAUDE_MODEL', self.DEFAULT_MODEL)
+        self.system_message = system_prompt
+        self.last_prompt = None
+        self.last_full_message = None
+        self.last_response = None
+        self.messages_history = []
+        if system_prompt:
+            self.messages_history.append(("system", system_prompt))
+
+    def send_message(self, message: str, stop_event: Event = None) -> str:
+        """Send message to Claude API and return response"""
+        self.messages_history.append(("user", message))
+        # Store the full message
+        self.last_full_message = message
+        
+        try:
+            # Check if already cancelled
+            if stop_event and stop_event.is_set():
+                return ""
+            
+            response = self.client.messages.create(
+                model=self.model,  # Use discovered model
+                system=self.system_message,
+                max_tokens=8192,
+                messages=[
+                    {"role": "user", "content": message}
+                ],
+                temperature=0,
+            )
+            
+            # Handle response
+            response_text = response.content[0].text
+            
+            # Only store and process response if not cancelled
+            if not (stop_event and stop_event.is_set()):
+                self.last_response = response_text
+                self.messages_history.append(("assistant", response_text))
+            
+            # Always return the response, let caller handle cancellation
+            return response_text
+            
+        except KeyboardInterrupt:
+            if stop_event:
+                stop_event.set()
+            return ""

janito/agents/openai.py

@@ -0,0 +1,53 @@
+import openai  # updated import
+import os
+from typing import Optional
+from threading import Event
+from .agent import Agent
+
+class OpenAIAgent(Agent):
+    """Handles interaction with OpenAI API, including message handling"""
+    DEFAULT_MODEL = "o1-mini-2024-09-12"
+    
+    def __init__(self, api_key: Optional[str] = None, system_prompt: str = None):
+        super().__init__(api_key, system_prompt)
+        if not system_prompt:
+            raise ValueError("system_prompt is required")
+        self.api_key = api_key or os.getenv('OPENAI_API_KEY')
+        if not self.api_key:
+            raise ValueError("OPENAI_API_KEY environment variable is required")
+        openai.api_key = self.api_key
+        openai.organization = os.getenv("OPENAI_ORG")
+        self.client = openai.Client()  # initialized client
+        self.model = os.getenv('OPENAI_MODEL', "o1-mini-2024-09-12")  # reverted to original default model
+
+    def send_message(self, message: str, stop_event: Event = None) -> str:
+        """Send message to OpenAI API and return response"""
+        self.messages_history.append(("user", message))
+        self.last_full_message = message
+        
+        try:
+            if stop_event and stop_event.is_set():
+                return ""
+            
+            #messages = [{"role": "system", "content": self.system_message}]
+            messages = [{"role": "user", "content": message}]
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                max_completion_tokens=4000,
+                temperature=1,
+            )
+            
+            response_text = response.choices[0].message.content
+            
+            if not (stop_event and stop_event.is_set()):
+                self.last_response = response_text
+                self.messages_history.append(("assistant", response_text))
+            
+            return response_text
+            
+        except KeyboardInterrupt:
+            if stop_event:
+                stop_event.set()
+            return ""

janito/agents/test.py

@@ -0,0 +1,34 @@
+import unittest
+import os
+from unittest.mock import patch, MagicMock
+from .openai import OpenAIAgent
+from .claudeai import AIAgent
+
+class TestAIAgents(unittest.TestCase):
+    def setUp(self):
+        self.system_prompt = "You are a helpful assistant."
+        self.test_message = "Hello, how are you?"
+        
+    def test_openai_agent_initialization(self):
+        with patch.dict(os.environ, {'OPENAI_API_KEY': 'test_key'}):
+            agent = OpenAIAgent(system_prompt=self.system_prompt)
+
+    def test_claudeai_agent_initialization(self):
+        with patch.dict(os.environ, {'ANTHROPIC_API_KEY': 'test_key'}):
+            agent = AIAgent(system_prompt=self.system_prompt)
+
+    def test_openai_agent_send_message(self):
+        with patch('openai.OpenAI.chat.completions.create') as mock_create:
+            mock_response = MagicMock()
+            mock_response.choices[0].message.content = "I'm good, thank you!"
+            mock_create.return_value = mock_response
+            response = self.openai_agent.send_message(self.test_message)
+            self.assertEqual(response, "I'm good, thank you!")
+
+    def test_claudeai_agent_send_message(self):
+        with patch('anthropic.Client.messages.create') as mock_create:
+            mock_response = MagicMock()
+            mock_response.content[0].text = "I'm Claude, how can I assist you?"
+            mock_create.return_value = mock_response
+            response = self.claudeai_agent.send_message(self.test_message)
+            self.assertEqual(response, "I'm Claude, how can I assist you?")