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

janito/change/indentation.py

@@ -0,0 +1,33 @@
+
+def adjust_indentation(original: str, replacement: str) -> str:
+    """Adjust replacement text indentation based on original text"""
+    if not original or not replacement:
+        return replacement
+        
+    # Get first non-empty lines to compare indentation
+    orig_lines = original.splitlines()
+    repl_lines = replacement.splitlines()
+    
+    orig_first = next((l for l in orig_lines if l.strip()), '')
+    repl_first = next((l for l in repl_lines if l.strip()), '')
+    
+    # Calculate indentation difference
+    orig_indent = len(orig_first) - len(orig_first.lstrip())
+    repl_indent = len(repl_first) - len(repl_first.lstrip())
+    indent_delta = orig_indent - repl_indent
+    
+    if indent_delta == 0:
+        return replacement
+        
+    # Adjust indentation for all lines
+    adjusted_lines = []
+    for line in repl_lines:
+        if not line.strip():  # Preserve empty lines
+            adjusted_lines.append(line)
+            continue
+        
+        current_indent = len(line) - len(line.lstrip())
+        new_indent = max(0, current_indent + indent_delta)
+        adjusted_lines.append(' ' * new_indent + line.lstrip())
+    
+    return '\n'.join(adjusted_lines)

janito/change/position.py

@@ -0,0 +1,169 @@
+
+from typing import List, Tuple
+from janito.config import config
+from rich.console import Console
+
+def get_line_boundaries(text: str) -> List[Tuple[int, int, int, int]]:
+    """Return list of (content_start, content_end, full_start, full_end) for each line.
+    content_start/end exclude leading/trailing whitespace
+    full_start/end include the whitespace and line endings"""
+    boundaries = []
+    start = 0
+    for line in text.splitlines(keepends=True):
+        content = line.strip()
+        if content:
+            content_start = start + len(line) - len(line.lstrip())
+            content_end = start + len(line.rstrip())
+            boundaries.append((content_start, content_end, start, start + len(line)))
+        else:
+            # Empty or whitespace-only lines
+            boundaries.append((start, start, start, start + len(line)))
+        start += len(line)
+    return boundaries
+
+def normalize_content(text: str) -> Tuple[str, List[Tuple[int, int, int, int]]]:
+    """Normalize text for searching while preserving position mapping.
+    Returns (normalized_text, line_boundaries)"""
+    # Replace Windows line endings
+    text = text.replace('\r\n', '\n')
+    text = text.replace('\r', '\n')
+    
+    # Get line boundaries before normalization
+    boundaries = get_line_boundaries(text)
+    
+    # Create normalized version with stripped lines
+    normalized = '\n'.join(line.strip() for line in text.splitlines())
+    
+    return normalized, boundaries
+
+def find_text_positions(text: str, search: str) -> List[Tuple[int, int]]:
+    """Find all non-overlapping positions of search text in content,
+    comparing without leading/trailing whitespace but returning original positions."""
+    normalized_text, text_boundaries = normalize_content(text)
+    normalized_search, search_boundaries = normalize_content(search)
+    
+    positions = []
+    start = 0
+    while True:
+        # Find next occurrence in normalized text
+        pos = normalized_text.find(normalized_search, start)
+        if pos == -1:
+            break
+            
+        # Find the corresponding original text boundaries
+        search_lines = normalized_search.count('\n') + 1
+        
+        # Get text line number at position
+        line_num = normalized_text.count('\n', 0, pos)
+        
+        if line_num + search_lines <= len(text_boundaries):
+            # Get original start position from first line
+            orig_start = text_boundaries[line_num][2]  # full_start
+            # Get original end position from last line
+            orig_end = text_boundaries[line_num + search_lines - 1][3]  # full_end
+            
+            positions.append((orig_start, orig_end))
+        
+        start = pos + len(normalized_search)
+    
+    return positions
+
+def format_whitespace_debug(text: str) -> str:
+    """Format text with visible whitespace markers"""
+    return text.replace(' ', '·').replace('\t', '→').replace('\n', '↵\n')
+
+def format_context_preview(lines: List[str], max_lines: int = 5) -> str:
+    """Format context lines for display, limiting the number of lines shown"""
+    if not lines:
+        return "No context lines"
+    preview = lines[:max_lines]
+    suffix = f"\n... and {len(lines) - max_lines} more lines" if len(lines) > max_lines else ""
+    return "\n".join(preview) + suffix
+
+def parse_and_apply_changes_sequence(input_text: str, changes_text: str) -> str:
+    """
+    Parse and apply changes to text:
+    = Find and keep line (preserving whitespace)
+    < Remove line at current position
+    > Add line at current position
+    """
+    def find_initial_start(text_lines, sequence):
+        for i in range(len(text_lines) - len(sequence) + 1):
+            matches = True
+            for j, seq_line in enumerate(sequence):
+                if text_lines[i + j] != seq_line:
+                    matches = False
+                    break
+            if matches:
+                return i
+                
+            if config.debug and i < 20:  # Show first 20 attempted matches
+                console = Console()
+                console.print(f"\n[cyan]Checking position {i}:[/cyan]")
+                for j, seq_line in enumerate(sequence):
+                    if i + j < len(text_lines):
+                        match_status = "=" if text_lines[i + j] == seq_line else "≠"
+                        console.print(f"  {match_status} Expected: '{seq_line}'")
+                        console.print(f"    Found:    '{text_lines[i + j]}'")
+        return -1
+
+    input_lines = input_text.splitlines()
+    changes = changes_text.splitlines()    
+    
+    sequence = []
+    # Find the context sequence in the input text
+    for line in changes:
+        if line[0] == '=':
+            sequence.append(line[1:])
+        else:
+            break
+    
+    start_pos = find_initial_start(input_lines, sequence)
+    
+    if start_pos == -1:
+        if config.debug:
+            console = Console()
+            console.print("\n[red]Failed to find context sequence match in file:[/red]")
+            console.print("[yellow]File content:[/yellow]")
+            for i, line in enumerate(input_lines):
+                console.print(f"  {i+1:2d} | '{line}'")
+        return input_text
+        
+    if config.debug:
+        console = Console()
+        console.print(f"\n[green]Found context match at line {start_pos + 1}[/green]")
+    
+    result_lines = input_lines[:start_pos]
+    i = start_pos
+    
+    for change in changes:
+        if not change:
+            if config.debug:
+                console.print(f"  Preserving empty line")
+            continue
+            
+        prefix = change[0]
+        content = change[1:]
+        
+        if prefix == '=':
+            if config.debug:
+                console.print(f"  Keep: '{content}'")
+            result_lines.append(content)
+            i += 1
+        elif prefix == '<':
+            if config.debug:
+                console.print(f"  Delete: '{content}'")
+            i += 1
+        elif prefix == '>':
+            if config.debug:
+                console.print(f"  Add: '{content}'")
+            result_lines.append(content)
+            
+    result_lines.extend(input_lines[i:])
+    
+    if config.debug:
+        console.print("\n[yellow]Final result:[/yellow]")
+        for i, line in enumerate(result_lines):
+            console.print(f"  {i+1:2d} | '{line}'")
+            
+    return '\n'.join(result_lines)

janito/changehistory.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+
+# Set fixed timestamp when module is loaded
+APP_TIMESTAMP = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+def get_history_path(workdir: Path) -> Path:
+    """Create and return the history directory path"""
+    history_dir = workdir / '.janito' / 'change_history'
+    history_dir.mkdir(parents=True, exist_ok=True)
+    return history_dir
+
+def determine_history_file_type(filepath: Path) -> str:
+    """Determine the type of saved file based on its name"""
+    name = filepath.name.lower()
+    if 'changes' in name:
+        return 'changes'
+    elif 'selected' in name:
+        return 'selected'
+    elif 'analysis' in name:
+        return 'analysis'
+    elif 'response' in name:
+        return 'response'
+    return 'unknown'
+
+def save_changes_to_history(content: str, request: str, workdir: Path) -> Path:
+    """Save change content to history folder with timestamp and request info"""
+    history_dir = get_history_path(workdir)
+    
+    # Create history entry with request and changes
+    history_file = history_dir / f"changes_{APP_TIMESTAMP}.txt"
+    
+    history_content = f"""Request: {request}
+Timestamp: {APP_TIMESTAMP}
+
+Changes:
+{content}
+"""
+    history_file.write_text(history_content)
+    return history_file
+
+def get_history_file_path(workdir: Path) -> Path:
+    """Get path for a history file with app timestamp"""
+    history_path = get_history_path(workdir)
+    return history_path / f"{APP_TIMESTAMP}_changes.txt"

janito/changeviewer/__init__.py

@@ -0,0 +1,12 @@
+from .panels import show_change_preview, preview_all_changes
+from .styling import set_theme
+from .themes import ColorTheme, ThemeType, get_theme_by_type
+
+__all__ = [
+    'show_change_preview',
+    'preview_all_changes',
+    'set_theme',
+    'ColorTheme',
+    'ThemeType',
+    'get_theme_by_type'
+]

janito/changeviewer/diff.py

@@ -0,0 +1,28 @@
+from typing import List, Tuple
+
+def find_common_sections(search_lines: List[str], replace_lines: List[str]) -> Tuple[List[str], List[str], List[str], List[str], List[str]]:
+    """Find common sections between search and replace content"""
+    # Find common lines from top
+    common_top = []
+    for s, r in zip(search_lines, replace_lines):
+        if s == r:
+            common_top.append(s)
+        else:
+            break
+            
+    # Find common lines from bottom
+    search_remaining = search_lines[len(common_top):]
+    replace_remaining = replace_lines[len(common_top):]
+    
+    common_bottom = []
+    for s, r in zip(reversed(search_remaining), reversed(replace_remaining)):
+        if s == r:
+            common_bottom.insert(0, s)
+        else:
+            break
+            
+    # Get the unique middle sections
+    search_middle = search_remaining[:-len(common_bottom)] if common_bottom else search_remaining
+    replace_middle = replace_remaining[:-len(common_bottom)] if common_bottom else replace_remaining
+    
+    return common_top, search_middle, replace_middle, common_bottom, search_lines

janito/changeviewer/panels.py

@@ -0,0 +1,268 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.columns import Columns
+from rich.text import Text
+from rich.syntax import Syntax
+from rich.table import Table
+from rich import box
+from pathlib import Path
+from typing import List
+from datetime import datetime
+from janito.fileparser import FileChange
+from janito.config import config
+from .styling import format_content, create_legend_items, current_theme
+from .themes import ColorTheme
+from .diff import find_common_sections
+
+
+def create_new_file_panel(filepath: Path, content: str) -> Panel:
+    """Create a panel for new file creation"""
+    size_bytes = len(content.encode('utf-8'))
+    size_str = f"{size_bytes} bytes" if size_bytes < 1024 else f"{size_bytes/1024:.1f} KB"
+
+    # Create metadata table
+    metadata = Table.grid(padding=(0, 1))
+    metadata.add_row("File Size:", size_str)
+    metadata.add_row("Created:", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+
+    # Create content preview with empty left panel
+    content_table = Table.grid(padding=(0, 2))
+    content_table.add_column("Before", justify="left")
+    content_table.add_column("After", justify="left")
+
+    empty_panel = Panel(
+        Text("(No previous content)", style="dim"),
+        title="Previous Content",
+        title_align="left",
+        border_style="#E06C75",
+        box=box.ROUNDED
+    )
+
+    content_display = content
+    if filepath.suffix in ['.py', '.js', '.ts', '.java', '.cpp', '.c']:
+        try:
+            content_display = Syntax(content, filepath.suffix.lstrip('.'), theme="monokai")
+        except:
+            pass
+
+    new_panel = Panel(
+        content_display,
+        title="New Content",
+        title_align="left",
+        border_style="#61AFEF",
+        box=box.ROUNDED
+    )
+
+    content_table.add_row(empty_panel, new_panel)
+    
+    content = Table.grid(padding=(1, 0))
+    content.add_row(Panel(metadata, title="File Metadata", border_style="white"))
+    content.add_row(Panel(content_table, title="Content Preview", border_style="white"))
+
+    return Panel(
+        content,
+        title=f"[bold]✨ Creating {filepath}[/bold]",
+        title_align="left",
+        border_style="#8AE234",
+        box=box.ROUNDED
+    )
+
+def create_change_panel(search: str, replace: str | None, description: str, index: int) -> Panel:
+    """Create a panel for file changes"""
+    operation = 'delete' if replace is None else 'modify'
+    
+    if replace is None:
+        return Panel(
+            Text(search, style="red"),
+            title=f"- Content to Delete{' - ' + description if description else ''}",
+            title_align="left",
+            border_style="#E06C75",
+            box=box.ROUNDED
+        )
+
+    search_lines = search.splitlines()
+    replace_lines = replace.splitlines()
+    common_top, search_middle, replace_middle, common_bottom, all_search_lines = find_common_sections(search_lines, replace_lines)
+
+    content_table = Table.grid(padding=(0, 2))
+    content_table.add_column("Current", justify="left", ratio=1)
+    content_table.add_column("New", justify="left", ratio=1)
+    
+    # Add column headers
+    content_table.add_row(
+        Text("Current Content", style="bold cyan"),
+        Text("New Content", style="bold cyan")
+    )
+    
+    # Add the actual content
+    content_table.add_row(
+        format_content(search_lines, search_lines, replace_lines, True, operation),
+        format_content(replace_lines, search_lines, replace_lines, False, operation)
+    )
+
+    header = f"Change {index}"
+    if description:
+        header += f": {description}"
+
+    return Panel(
+        content_table,
+        title=header,
+        title_align="left",
+        border_style="cyan",
+        box=box.ROUNDED
+    )
+
+def create_replace_panel(filepath: Path, change: FileChange) -> Panel:
+    """Create a panel for file replacement with metadata"""
+    old_size = len(change.original_content.encode('utf-8'))
+    new_size = len(change.content.encode('utf-8'))
+    
+    # Create metadata table
+    metadata = Table.grid(padding=(0, 1))
+    metadata.add_row("Original Size:", f"{old_size/1024:.1f} KB")
+    metadata.add_row("New Size:", f"{new_size/1024:.1f} KB")
+    metadata.add_row("Size Change:", f"{(new_size - old_size)/1024:+.1f} KB")
+    metadata.add_row("Modified:", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    
+    # Create unified diff preview
+    content_table = Table.grid(padding=(0, 2))
+    content_table.add_column("Current", justify="left")
+    content_table.add_column("New", justify="left")
+    
+    # Add column headers
+    content_table.add_row(
+        Text("Current Content", style="bold cyan"),
+        Text("New Content", style="bold cyan")
+    )
+    
+    # Add the actual content
+    content_table.add_row(
+        format_content(change.original_content.splitlines(),
+                      change.original_content.splitlines(),
+                      change.content.splitlines(), True),
+        format_content(change.content.splitlines(),
+                      change.original_content.splitlines(),
+                      change.content.splitlines(), False)
+    )
+    
+    content = Table.grid(padding=(1, 0))
+    content.add_row(Panel(metadata, title="File Metadata", border_style="white"))
+    content.add_row(Panel(content_table, title="Content Preview", border_style="white"))
+    
+    return Panel(
+        content,
+        title=f"[bold]🔄 Replacing {filepath}[/bold]",
+        title_align="left",
+        border_style="#FFB86C",
+        box=box.ROUNDED
+    )
+
+def create_remove_file_panel(filepath: Path) -> Panel:
+    """Create a panel for file removal"""
+    return Panel(
+        Text(f"This file will be deleted", style="red"),
+        title=f"[bold]- Removing {filepath}[/bold]",
+        title_align="left",
+        border_style="#F44336",
+        box=box.HEAVY,
+        padding=(1, 2)
+    )
+
+def show_change_preview(console: Console, filepath: Path, change: FileChange) -> None:
+    """Display a preview of changes for a single file"""
+    if change.remove_file:
+        panel = create_remove_file_panel(filepath)
+        console.print(panel)
+        console.print()
+        return
+        
+    if change.is_new_file:
+        panel = create_new_file_panel(filepath, change.content)
+        console.print(panel)
+        console.print()
+        return
+
+    if change.replace_file:
+        panel = create_replace_panel(filepath, change)
+        console.print(panel)
+        console.print()
+        return
+
+    main_content = []
+    for i, (search, replace, description) in enumerate(change.search_blocks, 1):
+        panel = create_change_panel(search, replace, description, i)
+        main_content.append(panel)
+
+    file_panel = Panel(
+        Columns(main_content, align="center"),
+        title=f"Modifying {filepath} - {change.description}",
+        title_align="left",
+        border_style="white",
+        box=box.ROUNDED
+    )
+    console.print(file_panel)
+    console.print()
+
+def preview_all_changes(console: Console, changes: List[FileChange]) -> None:
+    """Show preview for all file changes"""
+    if config.debug:
+        _print_debug_info(console, changes)
+
+    console.print("\n[bold blue]Change Preview[/bold blue]")
+    
+    has_modified_files = any(not change.is_new_file for change in changes)
+    if has_modified_files:
+        _show_legend(console)
+    
+    new_files = [change for change in changes if change.is_new_file]
+    modified_files = [change for change in changes if not change.is_new_file]
+    
+    for change in new_files:
+        show_change_preview(console, change.path, change)
+    for change in modified_files:
+        show_change_preview(console, change.path, change)
+
+def _print_debug_info(console: Console, changes: List[FileChange]) -> None:
+    """Print debug information about file changes"""
+    console.print("\n[blue]Debug: File Changes to Preview:[/blue]")
+    for change in changes:
+        console.print(f"\n[cyan]File:[/cyan] {change.path}")
+        console.print(f"  [yellow]Is New File:[/yellow] {change.is_new_file}")
+        console.print(f"  [yellow]Description:[/yellow] {change.description}")
+        if change.search_blocks:
+            console.print("  [yellow]Search Blocks:[/yellow]")
+            for i, (search, replace, desc) in enumerate(change.search_blocks, 1):
+                console.print(f"    Block {i}:")
+                console.print(f"      Description: {desc or 'No description'}")
+                console.print(f"      Operation: {'Replace' if replace else 'Delete'}")
+                console.print(f"      Search Length: {len(search)} chars")
+                if replace:
+                    console.print(f"      Replace Length: {len(replace)} chars")
+    console.print("\n[blue]End Debug File Changes[/blue]\n")
+
+def _show_legend(console: Console) -> None:
+    """Show the unified legend status bar"""
+    legend = create_legend_items()
+    
+    # Calculate panel width based on legend content
+    legend_width = len(str(legend)) + 10  # Add padding for borders
+    
+    legend_panel = Panel(
+        legend,
+        title="Changes Legend",
+        title_align="center",
+        border_style="white",
+        box=box.ROUNDED,
+        padding=(0, 2),
+        width=legend_width
+    )
+    
+    # Create a full-width container and center the legend panel
+    container = Columns(
+        [legend_panel],
+        align="center",
+        expand=True
+    )
+    
+    console.print(container)
+    console.print()

janito/changeviewer/styling.py

@@ -0,0 +1,59 @@
+from rich.text import Text
+from rich.console import Console
+from typing import List
+from .themes import DEFAULT_THEME, ColorTheme, ThemeType, get_theme_by_type
+
+current_theme = DEFAULT_THEME
+
+def set_theme(theme: ColorTheme) -> None:
+    """Set the current color theme"""
+    global current_theme
+    current_theme = theme
+
+def format_content(lines: List[str], search_lines: List[str], replace_lines: List[str], is_search: bool, operation: str = 'modify') -> Text:
+    """Format content with highlighting using consistent colors and line numbers"""
+    text = Text()
+    
+    # Create sets of lines for comparison
+    search_set = set(search_lines)
+    replace_set = set(replace_lines)
+    common_lines = search_set & replace_set
+    new_lines = replace_set - search_set
+
+    def add_line(line: str, prefix: str = " ", line_type: str = 'unchanged'):
+        # Ensure line_type is one of the valid types
+        valid_types = {'unchanged', 'deleted', 'modified', 'added'}
+        if line_type not in valid_types:
+            line_type = 'unchanged'
+            
+        bg_color = current_theme.line_backgrounds.get(line_type, current_theme.line_backgrounds['unchanged'])
+        style = f"{current_theme.text_color} on {bg_color}"
+        
+        # Add prefix with background
+        text.append(prefix, style=style)
+        # Add line content with background and pad with spaces
+        text.append(" " + line, style=style)
+        # Add newline with same background
+        text.append(" " * 1000 + "\n", style=style)
+
+    for line in lines:
+        if line in common_lines:
+            add_line(line, " ", 'unchanged')
+        elif not is_search and line in new_lines:
+            add_line(line, "✚", 'added')
+        else:
+            prefix = "✕" if is_search else "✚"
+            line_type = 'deleted' if is_search else 'modified'
+            add_line(line, prefix, line_type)
+    
+    return text
+
+def create_legend_items() -> Text:
+    """Create unified legend status bar"""
+    legend = Text()
+    legend.append(" Unchanged ", style=f"{current_theme.text_color} on {current_theme.line_backgrounds['unchanged']}")
+    legend.append(" │ ", style="dim")
+    legend.append(" ✕ Deleted ", style=f"{current_theme.text_color} on {current_theme.line_backgrounds['deleted']}")
+    legend.append(" │ ", style="dim")
+    legend.append(" ✚ Added ", style=f"{current_theme.text_color} on {current_theme.line_backgrounds['added']}")
+    return legend

janito/changeviewer/themes.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+from typing import Dict
+from enum import Enum
+
+class ThemeType(Enum):
+    DARK = "dark"
+    LIGHT = "light"
+
+# Dark theme colors
+DARK_LINE_BACKGROUNDS = {
+    'unchanged': '#1A1A1A',        
+    'added': '#003300',        
+    'deleted': '#660000',          
+    'modified': '#000030'          
+}
+
+# Light theme colors
+LIGHT_LINE_BACKGROUNDS = {
+    'unchanged': 'grey93',         # Light gray for unchanged
+    'added': 'light_green',       # Semantic light green for additions
+    'deleted': 'light_red',       # Semantic light red for deletions
+    'modified': 'light_blue'      # Semantic light blue for modifications
+}
+
+@dataclass
+class ColorTheme:
+    text_color: str
+    line_backgrounds: Dict[str, str]
+    theme_type: ThemeType
+
+# Predefined themes
+DARK_THEME = ColorTheme(
+    text_color="white",
+    line_backgrounds=DARK_LINE_BACKGROUNDS,
+    theme_type=ThemeType.DARK
+)
+
+LIGHT_THEME = ColorTheme(
+    text_color="black",
+    line_backgrounds=LIGHT_LINE_BACKGROUNDS,
+    theme_type=ThemeType.LIGHT
+)
+
+DEFAULT_THEME = DARK_THEME
+
+def validate_theme(theme: ColorTheme) -> bool:
+    """Validate that a theme contains all required colors"""
+    required_line_backgrounds = {'unchanged', 'added', 'deleted', 'modified'}
+    
+    if not isinstance(theme, ColorTheme):
+        return False
+        
+    return all(bg in theme.line_backgrounds for bg in required_line_backgrounds)
+
+def get_theme_by_type(theme_type: ThemeType) -> ColorTheme:
+    """Get a predefined theme by type"""
+    return LIGHT_THEME if theme_type == ThemeType.LIGHT else DARK_THEME

janito/cli/__init__.py

@@ -0,0 +1,2 @@
+
+# This file is intentionally left empty to make the cli directory a package.