ayechat-dev 0.36.9.20260204003405__tar.gz → 0.36.9.20260204171331__tar.gz

{ayechat_dev-0.36.9.20260204003405/src/ayechat_dev.egg-info → ayechat_dev-0.36.9.20260204171331}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ayechat-dev
-Version: 0.36.9.20260204003405
+Version: 0.36.9.20260204171331
 Summary: Aye Chat: Terminal-first AI Code Generator
 Author-email: "Acrotron, Inc." <info@acrotron.com>
 License: MIT

{ayechat_dev-0.36.9.20260204003405 → ayechat_dev-0.36.9.20260204171331}/pyproject.toml

@@ -8,7 +8,7 @@ description = "Aye Chat: Terminal-first AI Code Generator"
 readme = "README.md"
 requires-python = ">=3.10, <3.14"
 dependencies = [ "typer>=0.20.0", "httpx>=0.28.1", "keyring>=25.7.0", "prompt-toolkit>=3.0.52", "pathspec>=0.12.1", "chromadb>=1.3.5", "rapidfuzz",]
-version = "0.36.9.20260204003405"
+version = "0.36.9.20260204171331"
 [[project.authors]]
 name = "Acrotron, Inc."
 email = "info@acrotron.com"

{ayechat_dev-0.36.9.20260204003405 → ayechat_dev-0.36.9.20260204171331}/src/aye/controller/command_handlers.py

@@ -145,6 +145,25 @@ def handle_debug_command(tokens: list):
         rprint(f"[yellow]Debug mode is {current.title()}[/]")
 
 
+def handle_autodiff_command(tokens: list):
+    """Handle the 'autodiff' command for toggling automatic diff display.
+
+    When autodiff is enabled, diffs are automatically displayed for every
+    file modified by an LLM response.
+    """
+    if len(tokens) > 1:
+        val = tokens[1].lower()
+        if val in ("on", "off"):
+            set_user_config("autodiff", val)
+            rprint(f"[green]Autodiff set to {val.title()}[/]")
+        else:
+            rprint("[red]Usage: autodiff on|off[/]")
+    else:
+        current = get_user_config("autodiff", "off")
+        rprint(f"[yellow]Autodiff is {current.title()}[/]")
+        rprint("[dim]When on, diffs are shown automatically after each LLM file update.[/]")
+
+
 def handle_completion_command(tokens: list) -> Optional[str]:
     """Handle the 'completion' command for switching completion styles.
 
@@ -264,9 +283,9 @@ def handle_llm_command(session: Optional[PromptSession], tokens: list[str]) -> N
 
     # Show status message
     if final_url and final_key:
-        rprint("\n[green] OpenAI-compatible endpoint is configured and active.[/]")
+        rprint("\n[green] OpenAI-compatible endpoint is configured and active.[/]")
     else:
-        rprint("\n[yellow] Both URL and KEY are required for the local LLM endpoint to be active.[/]")
+        rprint("\n[yellow] Both URL and KEY are required for the local LLM endpoint to be active.[/]")
 
 
 def _expand_file_patterns(patterns: list[str], conf: Any) -> list[str]:

{ayechat_dev-0.36.9.20260204003405 → ayechat_dev-0.36.9.20260204171331}/src/aye/controller/llm_handler.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Optional, List
 
 from rich import print as rprint
 from rich.console import Console
@@ -11,10 +11,12 @@ from aye.presenter.repl_ui import (
     print_files_updated,
     print_error
 )
-from aye.model.snapshot import apply_updates
+from aye.presenter import diff_presenter
+from aye.model.snapshot import apply_updates, get_diff_base_for_file
 from aye.model.file_processor import filter_unchanged_files, make_paths_relative
 from aye.model.models import LLMResponse
 from aye.model.auth import get_user_config
+from aye.model.autodiff_config import is_autodiff_enabled
 from aye.model.write_validator import (
     check_files_against_ignore_patterns,
     is_strict_mode_enabled,
@@ -52,6 +54,51 @@ def _maybe_print_restore_tip(conf: Any, console: Console) -> None:
     console.print(Padding(msg, (0, 4, 0, 4)))
 
 
+def _run_autodiff(updated_files: List[dict], batch_id: str, conf: Any, console: Console) -> None:
+    """Display diffs for all updated files against their snapshot versions.
+
+    Args:
+        updated_files: List of file dicts with 'file_name' keys
+        batch_id: The batch identifier from apply_updates()
+        conf: Configuration object with root path
+        console: Rich console for output
+    """
+    verbose = getattr(conf, 'verbose', False)
+    debug = get_user_config("debug", "off").lower() == "on"
+
+    console.print(Padding("[dim]───── Auto-diff (autodiff=on) ─────[/]", (1, 0, 0, 0)))
+
+    for item in updated_files:
+        file_name = item.get("file_name")
+        if not file_name:
+            continue
+
+        file_path = Path(file_name)
+
+        # Get the snapshot reference for this file
+        diff_base = get_diff_base_for_file(batch_id, file_path)
+
+        if diff_base is None:
+            if verbose or debug:
+                rprint(f"[yellow]Warning: Could not find snapshot for {file_name}, skipping autodiff[/]")
+            continue
+
+        snapshot_ref, is_git_ref = diff_base
+
+        # Print file header
+        console.print(f"\n[bold cyan]{file_name}[/]")
+
+        try:
+            # show_diff expects: (current_file, snapshot_ref, is_stash_ref)
+            # For autodiff, we diff the current (new) file against the snapshot (old)
+            diff_presenter.show_diff(file_path, snapshot_ref, is_stash_ref=is_git_ref)
+        except Exception as e:
+            if verbose or debug:
+                rprint(f"[yellow]Warning: Could not show diff for {file_name}: {e}[/]")
+
+    console.print(Padding("[dim]───── End auto-diff ─────[/]", (1, 0, 0, 0)))
+
+
 def process_llm_response(
     response: LLMResponse,
     conf: Any,
@@ -118,12 +165,17 @@ def process_llm_response(
         else:
             # Apply updates to the model (Model update)
             try:
-                apply_updates(updated_files, prompt)
+                batch_id = apply_updates(updated_files, prompt)
                 file_names = [item.get("file_name") for item in updated_files if "file_name" in item]
                 if file_names:
                     # Update the view
                     print_files_updated(console, file_names)
                     _maybe_print_restore_tip(conf, console)
+
+                    # Run autodiff if enabled
+                    if is_autodiff_enabled():
+                        _run_autodiff(updated_files, batch_id, conf, console)
+
             except Exception as e:
                 rprint(f"[red]Error applying updates:[/] {e}")
 

{ayechat_dev-0.36.9.20260204003405 → ayechat_dev-0.36.9.20260204171331}/src/aye/controller/repl.py

@@ -42,6 +42,7 @@ from aye.controller.command_handlers import (
     handle_with_command,
     handle_blog_command,
     handle_llm_command,
+    handle_autodiff_command,
 )
 
 DEBUG = False
@@ -285,7 +286,7 @@ def _execute_forced_shell_command(command: str, args: List[str], conf: Any) -> N
 def chat_repl(conf: Any) -> None:
     is_first_run = run_first_time_tutorial_if_needed()
 
-    BUILTIN_COMMANDS = ["with", "blog", "new", "history", "diff", "restore", "undo", "keep", "model", "verbose", "debug", "completion", "exit", "quit", ":q", "help", "cd", "db", "llm"]
+    BUILTIN_COMMANDS = ["with", "blog", "new", "history", "diff", "restore", "undo", "keep", "model", "verbose", "debug", "autodiff", "completion", "exit", "quit", ":q", "help", "cd", "db", "llm"]
 
     # Get the completion style setting
     completion_style = get_user_config("completion_style", "readline").lower()
@@ -416,6 +417,9 @@ def chat_repl(conf: Any) -> None:
                 elif lowered_first == "debug":
                     telemetry.record_command("debug", has_args=len(tokens) > 1, prefix=_AYE_PREFIX)
                     handle_debug_command(tokens)
+                elif lowered_first == "autodiff":
+                    telemetry.record_command("autodiff", has_args=len(tokens) > 1, prefix=_AYE_PREFIX)
+                    handle_autodiff_command(tokens)
                 elif lowered_first == "completion":
                     telemetry.record_command("completion", has_args=len(tokens) > 1, prefix=_AYE_PREFIX)
                     new_style = handle_completion_command(tokens)

ayechat_dev-0.36.9.20260204171331/src/aye/model/autodiff_config.py

@@ -0,0 +1,32 @@
+"""Autodiff configuration for automatic diff display after LLM changes.
+
+This module provides functionality to check if autodiff mode is enabled.
+When enabled, diffs are automatically displayed for every file modified
+by an LLM response.
+
+See: autodiff.md for the full design plan.
+"""
+
+from aye.model.auth import get_user_config
+
+
+# Config key for autodiff mode
+AUTODIFF_KEY = "autodiff"
+
+
+def is_autodiff_enabled() -> bool:
+    """Check if autodiff mode is enabled.
+
+    When enabled, diffs are automatically displayed for every file
+    modified by an LLM response, immediately after the optimistic
+    write is applied.
+
+    Can be set via:
+    - Environment variable: AYE_AUTODIFF=on
+    - Config file (~/.ayecfg): autodiff=on
+
+    Returns:
+        True if autodiff mode is enabled, False otherwise (default)
+    """
+    value = get_user_config(AUTODIFF_KEY, "off")
+    return str(value).lower() in ("on", "true", "1", "yes")

{ayechat_dev-0.36.9.20260204003405 → ayechat_dev-0.36.9.20260204171331}/src/aye/model/snapshot/__init__.py

@@ -7,6 +7,7 @@ Note:
 - Git stash snapshots (GitStashBackend) are intentionally NOT used.
 """
 
+import json
 import subprocess
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
@@ -32,6 +33,7 @@ __all__ = [
     "delete_snapshot",
     "prune_snapshots",
     "cleanup_snapshots",
+    "get_diff_base_for_file",
     # Utilities
     "get_backend",
     "reset_backend",
@@ -145,6 +147,102 @@ def cleanup_snapshots(older_than_days: int = 30) -> int:
     return get_backend().cleanup_snapshots(older_than_days)
 
 
+def get_diff_base_for_file(batch_id: str, file_path: Path) -> Optional[Tuple[str, bool]]:
+    """Return the snapshot reference for a file in a given batch.
+
+    This provides a backend-agnostic way to get a reference suitable for
+    diff_presenter.show_diff().
+
+    Args:
+        batch_id: The batch identifier returned by apply_updates()
+        file_path: The file path to get the snapshot reference for
+
+    Returns:
+        Tuple of (snapshot_ref, is_git_ref) where:
+        - snapshot_ref: For FileBasedBackend, a filesystem path to the snapshot file.
+                        For GitRefBackend, a 'refname:repo_rel_path' string.
+        - is_git_ref: True if snapshot_ref is a git ref format, False for filesystem path.
+        Returns None if the file is not found in the snapshot.
+    """
+    backend = get_backend()
+
+    if isinstance(backend, FileBasedBackend):
+        return _get_diff_base_file_backend(backend, batch_id, file_path)
+    elif isinstance(backend, GitRefBackend):
+        return _get_diff_base_git_backend(backend, batch_id, file_path)
+
+    return None
+
+
+def _get_diff_base_file_backend(
+    backend: FileBasedBackend, batch_id: str, file_path: Path
+) -> Optional[Tuple[str, bool]]:
+    """Get diff base for FileBasedBackend.
+
+    Reads the metadata.json from the snapshot batch directory to find
+    the snapshot path for the given file.
+    """
+    # Find the batch directory matching the batch_id
+    # batch_id format is like "001_20231201T120000"
+    batch_dir = None
+    if backend.snap_root.is_dir():
+        for dir_path in backend.snap_root.iterdir():
+            if dir_path.is_dir() and dir_path.name == batch_id:
+                batch_dir = dir_path
+                break
+
+    if batch_dir is None:
+        return None
+
+    meta_file = batch_dir / "metadata.json"
+    if not meta_file.is_file():
+        return None
+
+    try:
+        meta = json.loads(meta_file.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+
+    # Resolve the target file path for comparison
+    file_resolved = file_path.resolve()
+
+    # Find the matching entry in metadata
+    for entry in meta.get("files", []):
+        original_path = entry.get("original")
+        snapshot_path = entry.get("snapshot")
+
+        if not original_path or not snapshot_path:
+            continue
+
+        if Path(original_path).resolve() == file_resolved:
+            # Return the snapshot path as a string, not a git ref
+            return (snapshot_path, False)
+
+    return None
+
+
+def _get_diff_base_git_backend(
+    backend: GitRefBackend, batch_id: str, file_path: Path
+) -> Optional[Tuple[str, bool]]:
+    """Get diff base for GitRefBackend.
+
+    Returns a ref:path format suitable for git show.
+    """
+    # Construct the refname from batch_id
+    refname = f"{backend.REF_NAMESPACE}/{batch_id}"
+
+    # Get repo-relative path
+    try:
+        file_resolved = file_path.resolve()
+        rel_path = file_resolved.relative_to(backend.git_root).as_posix()
+    except ValueError:
+        # File is outside git root
+        return None
+
+    # Return the git ref format
+    return (f"{refname}:{rel_path}", True)
+
+
 # ------------------------------------------------------------------
 # Legacy helper functions (for backward compatibility with tests)
 # ------------------------------------------------------------------

ayechat_dev-0.36.9.20260204171331/src/aye/plugins/databricks_model.py

@@ -0,0 +1,311 @@
+import os
+import json
+from typing import Dict, Any, Optional
+import httpx
+from pathlib import Path
+import traceback
+
+from rich import print as rprint
+
+from .plugin_base import Plugin
+from aye.model.config import SYSTEM_PROMPT, MODELS, DEFAULT_MAX_OUTPUT_TOKENS
+from aye.model.auth import get_user_config
+from aye.controller.util import is_truncated_json
+
+LLM_TIMEOUT = 600.0
+
+
+# Message shown when LLM response is truncated due to output token limits
+TRUNCATED_RESPONSE_MESSAGE = (
+    "It looks like my response was cut off because it exceeded the output limit. "
+    "This usually happens when you ask me to generate or modify many files at once.\n\n"
+    "**To fix this, please try:**\n"
+    "1. Break your request into smaller parts (e.g., one file at a time)\n"
+    "2. Use the `with` command to focus on specific files: `with file1.py, file2.py: your request`\n"
+    "3. Ask me to work on fewer files or smaller changes in each request\n\n"
+    "For example, instead of 'update all files to add logging', try:\n"
+    "  `with src/main.py: add logging to this file`"
+)
+
+
+def _get_model_config(model_id: str) -> Optional[Dict[str, Any]]:
+    """Get configuration for a specific model."""
+    for model in MODELS:
+        if model["id"] == model_id:
+            return model
+    return None
+
+
+def _extract_json_object(raw_response: str, prefer_last: bool = True, require_keys=None):
+    """
+    Best-effort extraction of a JSON object (dict) from a raw LLM response.
+
+    Handles common failure modes where the model returns:
+    - extra commentary before/after JSON
+    - multiple JSON objects (e.g., an invalid attempt + a corrected attempt)
+
+    Args:
+        raw_response: raw LLM response string
+        prefer_last: when multiple JSON objects exist, return the last parsed object
+        require_keys: optional iterable of keys; if provided, only consider objects
+                      that contain all of these keys
+
+    Returns:
+        dict or None
+    """
+    # 1) Direct JSON parse
+    try:
+        obj = json.loads(raw_response)
+        if isinstance(obj, dict):
+            if require_keys and not all(k in obj for k in require_keys):
+                return None
+            return obj
+    except Exception:
+        pass
+
+    text = str(raw_response)
+
+    # 2) Scan for balanced JSON object candidates (string/escape-aware)
+    candidates = []
+    depth = 0
+    start = None
+    in_str = False
+    escape = False
+
+    for i, ch in enumerate(text):
+        if in_str:
+            if escape:
+                escape = False
+            elif ch == '\\':
+                escape = True
+            elif ch == '"':
+                in_str = False
+            continue
+
+        # not in string
+        if ch == '"':
+            in_str = True
+            continue
+
+        if ch == '{':
+            if depth == 0:
+                start = i
+            depth += 1
+        elif ch == '}' and depth > 0:
+            depth -= 1
+            if depth == 0 and start is not None:
+                candidates.append(text[start : i + 1])
+                start = None
+
+    parsed = []
+    for cand in candidates:
+        try:
+            obj = json.loads(cand)
+            if not isinstance(obj, dict):
+                continue
+            if require_keys and not all(k in obj for k in require_keys):
+                continue
+            parsed.append(obj)
+        except Exception:
+            continue
+
+    if not parsed:
+        return None
+
+    return parsed[-1] if prefer_last else parsed[0]
+
+
+class DatabricksModelPlugin(Plugin):
+    name = "databricks_model"
+    version = "1.0.0"
+    premium = "free"
+
+    def __init__(self):
+        super().__init__()
+        self.chat_history: Dict[str, list] = {}
+        self.history_file: Optional[Path] = None
+
+    def init(self, cfg: Dict[str, Any]) -> None:
+        """Initialize the local model plugin."""
+        super().init(cfg)
+        if self.debug:
+            rprint(f"[bold yellow]Initializing {self.name} v{self.version}[/]")
+        
+    def _load_history(self) -> None:
+        """Load chat history from disk."""
+        if not self.history_file:
+            if self.verbose:
+                rprint("[yellow]History file path not set for local model. Skipping load.[/]")
+            self.chat_history = {}
+            return
+
+        if self.history_file.exists():
+            try:
+                data = json.loads(self.history_file.read_text(encoding="utf-8"))
+                self.chat_history = data.get("conversations", {})
+            except Exception as e:
+                if self.verbose:
+                    rprint(f"[yellow]Could not load chat history: {e}[/]")
+                self.chat_history = {}
+        else:
+            self.chat_history = {}
+
+    def _save_history(self) -> None:
+        """Save chat history to disk."""
+        if not self.history_file:
+            if self.verbose:
+                rprint("[yellow]History file path not set for local model. Skipping save.[/]")
+            return
+
+        try:
+            self.history_file.parent.mkdir(parents=True, exist_ok=True)
+            data = {"conversations": self.chat_history}
+            self.history_file.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except Exception as e:
+            if self.verbose:
+                rprint(f"[yellow]Could not save chat history: {e}[/]")
+
+    def _get_conversation_id(self, chat_id: Optional[int] = None) -> str:
+        """Get conversation ID for history tracking."""
+        return str(chat_id) if chat_id and chat_id > 0 else "default"
+
+    def _build_user_message(self, prompt: str, source_files: Dict[str, str]) -> str:
+        """Build the user message with optional source files appended."""
+        user_message = prompt
+        if source_files:
+            user_message += "\n\n--- Source files are below. ---\n"
+            for file_name, content in source_files.items():
+                user_message += f"\n** {file_name} **\n```\n{content}\n```\n"
+        return user_message
+
+    def _parse_llm_response(self, generated_text: str) -> Dict[str, Any]:
+        """Parse LLM response text and convert to expected format."""
+        try:
+            llm_response = json.loads(generated_text)
+        except json.JSONDecodeError:
+            # Check if this looks like a truncated response
+            #if is_truncated_json(generated_text):
+            #    return {
+            #        "summary": TRUNCATED_RESPONSE_MESSAGE,
+            #        "updated_files": []
+            #    }
+            
+            # Not truncated, just malformed - return as plain text
+            llm_response = {
+                "answer_summary": generated_text,
+                "source_files": []
+            }
+        
+        return {
+            "summary": llm_response.get("answer_summary", ""),
+            "updated_files": [
+                {
+                    "file_name": f.get("file_name"),
+                    "file_content": f.get("file_content")
+                }
+                for f in llm_response.get("source_files", [])
+            ]
+        }
+
+    def _create_error_response(self, error_msg: str) -> Dict[str, Any]:
+        """Create a standardized error response."""
+        if self.verbose:
+            rprint(f"[red]{error_msg}[/]")
+        return {
+            "summary": error_msg,
+            "updated_files": []
+        }
+
+    def _handle_databricks(self, prompt: str, source_files: Dict[str, str], chat_id: Optional[int] = None, system_prompt: Optional[str] = None, max_output_tokens: int = DEFAULT_MAX_OUTPUT_TOKENS) -> Optional[Dict[str, Any]]:
+        api_url = os.environ.get("AYE_DBX_API_URL")
+        api_key = os.environ.get("AYE_DBX_API_KEY")
+        model_name = os.environ.get("AYE_DBX_MODEL", "gpt-3.5-turbo")
+        
+        if not api_url or not api_key:
+            return None
+        
+        conv_id = self._get_conversation_id(chat_id)
+        if conv_id not in self.chat_history:
+            self.chat_history[conv_id] = []
+        
+        user_message = self._build_user_message(prompt, source_files)
+        effective_system_prompt = system_prompt if system_prompt else SYSTEM_PROMPT
+        
+        messages_json = [{"role": "system", "content": effective_system_prompt}] + self.chat_history[conv_id] + [{"role": "user", "content": user_message}]
+        messages = messages_json # json.dumps(messages_json)
+        if self.debug:
+            print(">>>>>>>>>>>>>>>>")
+            print(self.chat_history[conv_id])
+            print(">>>>>>>>>>>>>>>>")
+        
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"}
+        #payload = {"model": model_name, "messages": messages, "temperature": 0.7, "max_tokens": max_output_tokens, "response_format": {"type": "json_object"}}
+        payload = {"model": model_name, "messages": messages, "temperature": 0.7, "max_tokens": max_output_tokens}
+        
+        try:
+            with httpx.Client(timeout=LLM_TIMEOUT) as client:
+                response = client.post(api_url, json=payload, headers=headers)
+                if self.debug:
+                    print("-----------------")
+                    print(response.text)
+                    print("-----------------")
+                response.raise_for_status()
+                result = response.json()
+                if result.get("choices") and result["choices"][0].get("message"):
+                    raw_response = result["choices"][0]["message"]["content"]
+                    generated_json = _extract_json_object(raw_response)
+                    generated_text = json.dumps(generated_json)
+                    if self.debug:
+                        print("-----------------")
+                        print(response.text)
+                        print("-----------------")
+                        print(generated_text)
+                        print("-----------------")
+                    #generated_text = result["choices"][0]["message"]["content"][1]["text"]
+                    self.chat_history[conv_id].append({"role": "user", "content": user_message})
+                    self.chat_history[conv_id].append({"role": "assistant", "content": generated_text})
+                    self._save_history()
+                    #return json.dumps(generated_text)
+                    return self._parse_llm_response(generated_text)
+                return self._create_error_response("Failed to get a valid response from the Databricks API")
+        except httpx.HTTPStatusError as e:
+            traceback.print_exc()
+            error_msg = f"DBX API error: {e.response.status_code}"
+            try:
+                error_detail = e.response.json()
+                if "error" in error_detail:
+                    error_msg += f" - {error_detail['error'].get('message', str(error_detail['error']))}"
+            except: error_msg += f" - {e.response.text[:200]}"
+            return self._create_error_response(error_msg)
+        except Exception as e:
+            traceback.print_exc()
+            return self._create_error_response(f"Error calling Databricks API: {str(e)}")
+
+
+    def on_command(self, command_name: str, params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        if command_name == "new_chat":
+            root = params.get("root")
+            history_file = Path(root) / ".aye" / "chat_history.json" if root else Path.cwd() / ".aye" / "chat_history.json"
+            history_file.unlink(missing_ok=True)
+            self.chat_history = {}
+            if self.verbose: rprint("[yellow]Local model chat history cleared.[/]")
+            return {"status": "local_history_cleared"}
+
+        if command_name == "local_model_invoke":
+            prompt = params.get("prompt", "").strip()
+            model_id = params.get("model_id", "")
+            source_files = params.get("source_files", {})
+            chat_id = params.get("chat_id")
+            root = params.get("root")
+            system_prompt = params.get("system_prompt")
+            max_output_tokens = params.get("max_output_tokens", DEFAULT_MAX_OUTPUT_TOKENS)
+
+            self.history_file = Path(root) / ".aye" / "chat_history.json" if root else Path.cwd() / ".aye" / "chat_history.json"
+            self._load_history()
+
+            result = self._handle_databricks(prompt, source_files, chat_id, system_prompt, max_output_tokens)
+            if result is not None: return result
+
+            return None
+
+        return None

{ayechat_dev-0.36.9.20260204003405 → ayechat_dev-0.36.9.20260204171331}/src/aye/presenter/repl_ui.py

@@ -88,14 +88,15 @@ def print_help_message():
         # Some commands are intentionally undocumented: keep them as such.
         ("@filename", "Include a file in your prompt inline (e.g., \"explain @main.py\"). Supports wildcards (e.g., @*.py, @src/*.js)."),
         ("!command", "Force shell execution (e.g., \"!echo hello\")."),
+        ("new", "Start a new chat session (if you want to change the subject)"),
+        (r"restore, undo \[id] \[file]", "Revert changes to the last state, a specific snapshot `id`, or for a single `file`."),
+        ("history", "Show snapshot history"),
+        (r"diff <file> \[snapshot_id]", "Show diff of file with the latest snapshot, or a specified snapshot"),
         ("model", "Select a different model. Selection will persist between sessions."),
+        (r"autodiff \[on|off]", "Toggle automatic diff display after LLM file updates (off by default, persists between sessions)"),
         ("llm", "Configure OpenAI-compatible LLM endpoint (URL, key, model). Use 'llm clear' to reset."),
         (r"verbose \[on|off]", "Toggle verbose mode to increase or decrease chattiness (on/off, persists between sessions)"),
         (r"completion \[readline|multi]", "Switch auto-completion style (readline or multi, persists between sessions)"),
-        ("new", "Start a new chat session (if you want to change the subject)"),
-        ("history", "Show snapshot history"),
-        (r"diff <file> \[snapshot_id]", "Show diff of file with the latest snapshot, or a specified snapshot"),
-        (r"restore, undo \[id] \[file]", "Revert changes to the last state, a specific snapshot `id`, or for a single `file`."),
         ("keep [N]", "Keep only N most recent snapshots (10 by default)"),
         ("exit, quit, Ctrl+D", "Exit the chat session"),
         ("help", "Show this help message"),

{ayechat_dev-0.36.9.20260204003405 → ayechat_dev-0.36.9.20260204171331/src/ayechat_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ayechat-dev
-Version: 0.36.9.20260204003405
+Version: 0.36.9.20260204171331
 Summary: Aye Chat: Terminal-first AI Code Generator
 Author-email: "Acrotron, Inc." <info@acrotron.com>
 License: MIT