chatty-agent 0.2.0__py3-none-any.whl

chatty/__init__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+__all__ = ["main"]

chatty/__main__.py

@@ -0,0 +1,4 @@
+from chatty.cli import main
+
+if __name__ == "__main__":
+    main()

chatty/backup.py

@@ -0,0 +1,141 @@
+import os
+import time
+import logging
+from typing import List, Tuple
+
+logger = logging.getLogger("chatty")
+
+
+def get_backups_dir(sandbox_dir: str) -> str:
+  return os.path.join(sandbox_dir, ".chatty", "backups")
+
+
+def ensure_gitignore_ignores_chatty(sandbox_dir: str) -> None:
+  """Ensures .chatty/ is present in .gitignore so backups are not committed to git."""
+  gitignore_path = os.path.join(sandbox_dir, ".gitignore")
+  try:
+    if os.path.exists(gitignore_path):
+      with open(gitignore_path, 'r', encoding='utf-8', errors='ignore') as f:
+        content = f.read()
+      if ".chatty/" in content or ".chatty" in content:
+        return
+      with open(gitignore_path, 'a', encoding='utf-8') as f:
+        if content and not content.endswith('\n'):
+          f.write('\n')
+        f.write('# Chatty backups\n.chatty/\n')
+    else:
+      with open(gitignore_path, 'w', encoding='utf-8') as f:
+        f.write('# Chatty backups\n.chatty/\n')
+  except Exception:
+    pass
+
+
+def backup_file(sandbox_dir: str, rel_path: str) -> None:
+  """Creates a timestamped backup of the file under .chatty/backups/path/to/file/timestamp.bak."""
+  from chatty.safety import get_safe_path, load_ignore_patterns, is_path_ignored
+  
+  try:
+    ignore_patterns = load_ignore_patterns(sandbox_dir)
+    if is_path_ignored(rel_path, ignore_patterns):
+      return
+      
+    abs_path = get_safe_path(sandbox_dir, rel_path)
+    if not os.path.exists(abs_path) or not os.path.isfile(abs_path):
+      return
+      
+    ensure_gitignore_ignores_chatty(sandbox_dir)
+    file_backups_dir = os.path.join(get_backups_dir(sandbox_dir), rel_path)
+    os.makedirs(file_backups_dir, exist_ok=True)
+    
+    timestamp = int(time.time() * 1000)
+    backup_path = os.path.join(file_backups_dir, f"{timestamp}.bak")
+    while os.path.exists(backup_path):
+      timestamp += 1
+      backup_path = os.path.join(file_backups_dir, f"{timestamp}.bak")
+    
+    import shutil
+    shutil.copy2(abs_path, backup_path)
+      
+    logger.info(f"Created backup of '{rel_path}' at '{os.path.relpath(backup_path, sandbox_dir)}'")
+    prune_backups(file_backups_dir, max_backups=10)
+  except Exception as e:
+    logger.warning(f"Failed to backup file '{rel_path}': {e}")
+
+
+def prune_backups(file_backups_dir: str, max_backups: int = 10) -> None:
+  """Keep only the latest max_backups in the directory."""
+  try:
+    if not os.path.isdir(file_backups_dir):
+      return
+    files = []
+    for f in os.listdir(file_backups_dir):
+      path = os.path.join(file_backups_dir, f)
+      if os.path.isfile(path) and f.endswith(".bak"):
+        files.append(path)
+        
+    def get_timestamp(filepath):
+      name = os.path.basename(filepath)
+      try:
+        return int(name.split(".")[0])
+      except ValueError:
+        return os.path.getmtime(filepath)
+        
+    files.sort(key=get_timestamp)
+    if len(files) > max_backups:
+      to_delete = files[:-max_backups]
+      for path in to_delete:
+        os.remove(path)
+  except Exception:
+    pass
+
+
+def list_backups(sandbox_dir: str, rel_path: str) -> List[Tuple[int, str]]:
+  """Returns a list of tuples (timestamp, format_time_str) of available backups for the given file."""
+  file_backups_dir = os.path.join(get_backups_dir(sandbox_dir), rel_path)
+  if not os.path.isdir(file_backups_dir):
+    return []
+    
+  backups = []
+  for f in os.listdir(file_backups_dir):
+    path = os.path.join(file_backups_dir, f)
+    if os.path.isfile(path) and f.endswith(".bak"):
+      name = f[:-4]
+      try:
+        ts = int(name)
+        time_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts / 1000.0))
+        backups.append((ts, time_str))
+      except ValueError:
+        pass
+        
+  backups.sort(key=lambda x: x[0], reverse=True)
+  return backups
+
+
+def restore_backup(sandbox_dir: str, rel_path: str, timestamp: int = None) -> str:
+  """Restores a backup for the given file. If timestamp is None, restores the latest backup."""
+  from chatty.safety import get_safe_path
+  
+  file_backups_dir = os.path.join(get_backups_dir(sandbox_dir), rel_path)
+  if not os.path.isdir(file_backups_dir):
+    return f"Error: No backups found for file '{rel_path}'."
+    
+  backups = list_backups(sandbox_dir, rel_path)
+  if not backups:
+    return f"Error: No backups found for file '{rel_path}'."
+    
+  target_ts = timestamp
+  if target_ts is None:
+    target_ts = backups[0][0]
+    
+  backup_file_path = os.path.join(file_backups_dir, f"{target_ts}.bak")
+  if not os.path.exists(backup_file_path):
+    return f"Error: Backup file with timestamp '{target_ts}' not found for '{rel_path}'."
+    
+  abs_path = get_safe_path(sandbox_dir, rel_path, write=True)
+  os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+  
+  import shutil
+  shutil.copy2(backup_file_path, abs_path)
+    
+  time_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(target_ts / 1000.0))
+  return f"Successfully restored '{rel_path}' to backup version from {time_str}."

chatty/cli.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+import argparse
+import logging
+import sys
+from rich.console import Console
+
+from chatty.logging_setup import setup_logging
+from chatty.utils import get_ollama_models, load_system_prompt_from_file
+from chatty.session import ChatbotSession
+from chatty.llm import get_default_openrouter_model
+
+logger = logging.getLogger("chatty")
+console = Console()
+
+
+def main():
+  parser = argparse.ArgumentParser(
+    description="AI Chatbot CLI with advanced sandboxed text and file system interaction."
+  )
+  parser.add_argument(
+    "--provider", "-p",
+    help="The LLM backend provider to use. Defaults to the domain of the --url if --url is provided, or 'ollama'."
+  )
+  parser.add_argument(
+    "--model", "-m",
+    action="append",
+    help="Model identifier(s) to use. Can be specified multiple times or as comma-separated values. The first model becomes the active model."
+  )
+  parser.add_argument(
+    "--oracle-model",
+    help="Model identifier to use as the oracle. Default determines based on provider."
+  )
+  parser.add_argument(
+    "--context-size", "-c",
+    type=int,
+    default=8192,
+    help="Target context window length constraint in tokens (default: 8192)."
+  )
+  parser.add_argument(
+    "--sandbox", "-s",
+    default="./sandbox",
+    help="Path to the sandboxed file system directory. Writes are strictly restricted here (default: ./sandbox)."
+  )
+  parser.add_argument(
+    "--skills-path", "-k",
+    action="append",
+    default=[],
+    help="Custom directories to search for skills. Can be specified multiple times."
+  )
+  parser.add_argument(
+    "--ondemand-skills-path", "-o",
+    action="append",
+    default=[],
+    help="Custom directories to search for on-demand skills. Can be specified multiple times."
+  )
+  parser.add_argument(
+    "--whitelist", "-w",
+    action="append",
+    default=[],
+    help="Add an out-of-sandbox path to the initial whitelist. Can end with :ro or :rw to set mode (defaults to ro). Can be specified multiple times."
+  )
+  parser.add_argument(
+    "--static-skills",
+    action="store_true",
+    default=None,
+    help="Load all available skills statically into the system prompt to maximize prompt caching (defaults to True for OpenRouter, False for Ollama)."
+  )
+  parser.add_argument(
+    "--prompt-caching",
+    action="store_true",
+    default=False,
+    help="Explicitly enable prompt caching for compatible models (adds cache_control tagging, default: False)."
+  )
+  parser.add_argument(
+    "--max-loops", "-l",
+    type=int,
+    default=20,
+    help="Maximum sequential tool execution loops allowed in a single turn (default: 20)."
+  )
+  parser.add_argument(
+    "--config-prompt", "-f",
+    help="Path to a YAML or text configuration file containing the custom system prompt."
+  )
+  parser.add_argument(
+    "--prompt-mode", "-d",
+    choices=["replace", "integrate"],
+    default="replace",
+    help="How to apply the custom system prompt file (replace default prompt, or integrate/append to it)."
+  )
+  parser.add_argument(
+    "--api-key", "-a",
+    help="OpenRouter API key. Overrides the OPENROUTER_API_KEY environment variable."
+  )
+  parser.add_argument(
+    "--url", "-u",
+    help="API Base URL override (defaults to Ollama local endpoint or OpenRouter base URL)."
+  )
+  parser.add_argument(
+    "--max-read-chars",
+    type=int,
+    default=40000,
+    help="Max characters to read from a file during full read tool execution (default: 40000)."
+  )
+  parser.add_argument(
+    "--max-grep-results",
+    type=int,
+    default=100,
+    help="Max results returned by regex search tool (default: 100)."
+  )
+  parser.add_argument(
+    "--max-command-chars",
+    type=int,
+    default=16000,
+    help="Max characters returned from standard output/error of a shell command (default: 16000)."
+  )
+  parser.add_argument(
+    "--max-history-tool-chars",
+    type=int,
+    default=1000,
+    help="Max characters to keep in historical tool outputs before compression (default: 1000)."
+  )
+  parser.add_argument(
+    "--history-keep-messages",
+    type=int,
+    default=4,
+    help="Number of recent messages to keep fully uncompressed (default: 4)."
+  )
+  parser.add_argument(
+    "--max-url-chars",
+    type=int,
+    default=24000,
+    help="Max characters returned from fetched URLs (default: 24000)."
+  )
+  parser.add_argument(
+    "--max-dir-items",
+    type=int,
+    default=200,
+    help="Max items listed by the directory list tool (default: 200)."
+  )
+  parser.add_argument(
+    "--log-file",
+    default="chatty.log",
+    help="Path to the file where operations will be logged (default: chatty.log). Set to empty string to disable logging."
+  )
+  parser.add_argument(
+    "--log-level",
+    default="info",
+    choices=["debug", "info", "warning", "error"],
+    help="Logging level (default: info)."
+  )
+  parser.add_argument(
+    "--headless",
+    action="store_true",
+    default=False,
+    help="Run the chatbot in headless mode (no console printing or terminal interactive loop)."
+  )
+  parser.add_argument(
+    "--max-thinking-chars",
+    type=int,
+    default=12000,
+    help="Maximum internal thinking characters before prompting the user (default: 12000)."
+  )
+  parser.add_argument(
+    "--max-thinking-leeway-chars",
+    type=int,
+    default=2000,
+    help="Leeway in characters beyond the maximum before hard-aborting or prompting (default: 2000)."
+  )
+  parser.add_argument(
+    "--api-delay",
+    type=float,
+    default=2.5,
+    help="Minimum delay in seconds between consecutive API requests (default: 2.5)."
+  )
+  parser.add_argument(
+    "--api-timeout",
+    type=float,
+    default=60.0,
+    help="Timeout in seconds for API requests and streams (default: 60.0)."
+  )
+  
+  args = parser.parse_args()
+  
+  # Initialize logging
+  if args.log_file:
+    setup_logging(args.log_file, args.log_level)
+    logger.info("==========================================")
+    logger.info(f"Logging initialized to '{args.log_file}' (level: {args.log_level}).")
+  
+  # Load system prompt from file if specified
+  custom_system_prompt = None
+  if args.config_prompt:
+    try:
+      custom_system_prompt = load_system_prompt_from_file(args.config_prompt)
+      if not args.headless:
+        console.print(f"[bold blue]Info:[/bold blue] Loaded custom system prompt from '{args.config_prompt}' (mode: {args.prompt_mode}).")
+    except Exception as e:
+      if not args.headless:
+        console.print(f"[bold red]Error loading prompt configuration:[/bold red] {e}")
+      sys.exit(1)
+          
+  from urllib.parse import urlparse
+
+  # Determine provider
+  provider = args.provider
+  if not provider:
+    if args.url:
+      parsed = urlparse(args.url)
+      domain = parsed.netloc or parsed.path
+      if ":" in domain:
+        domain = domain.split(":")[0]
+      if not domain:
+        parser.error("Could not parse domain name from --url.")
+      provider = domain
+    else:
+      provider = "ollama"
+
+  # Validate custom provider constraints
+  from chatty.providers import PROVIDER_KEYS, get_provider
+  is_standard_provider = provider in PROVIDER_KEYS
+  if not is_standard_provider:
+    if not args.url:
+      parser.error(f"Provider '{provider}' requires an API URL. Pass it via --url / -u.")
+    if not args.model:
+      parser.error(f"Provider '{provider}' requires a model. Pass it via --model / -m.")
+
+  # Resolve default models
+  models = []
+  if args.model:
+    for m in args.model:
+      for part in m.split(','):
+        part = part.strip()
+        if part:
+          models.append(part)
+
+  if not models:
+    prov_inst = get_provider(provider)
+    if provider == "ollama":
+      # Attempt to auto-detect model from local Ollama tags
+      ollama_url = args.url or prov_inst.get_default_url()
+      local_models = get_ollama_models(ollama_url)
+      if local_models:
+        models = [local_models[0]]
+        if not args.headless:
+          console.print(f"[bold blue]Info:[/bold blue] Auto-detected local Ollama model: [bold green]{models[0]}[/bold green]")
+      else:
+        models = [prov_inst.get_default_model()]
+        if not args.headless:
+          console.print(f"[bold blue]Info:[/bold blue] No local Ollama models detected. Fallback default: [bold green]{models[0]}[/bold green]")
+    else:
+      default_m = prov_inst.get_default_model(args.api_key)
+      if default_m:
+        models = [default_m]
+        if not args.headless:
+          console.print(f"[bold blue]Info:[/bold blue] {provider.capitalize()} provider selected. Default model: [bold green]{models[0]}[/bold green]")
+      else:
+        parser.error(f"Provider '{provider}' requires a model. Pass it via --model / -m.")
+          
+  model = models[0]
+  
+  # Initialize and execute chat session
+  with ChatbotSession(
+    provider=provider,
+    model=model,
+    models=models,
+    oracle_model=args.oracle_model,
+    context_size=args.context_size,
+    sandbox=args.sandbox,
+    api_key=args.api_key,
+    url=args.url,
+    max_loops=args.max_loops,
+    system_prompt_override=custom_system_prompt,
+    prompt_mode=args.prompt_mode,
+    skills_paths=args.skills_path,
+    ondemand_skills_paths=args.ondemand_skills_path,
+    max_read_chars=args.max_read_chars,
+    max_grep_results=args.max_grep_results,
+    max_command_chars=args.max_command_chars,
+    max_history_tool_chars=args.max_history_tool_chars,
+    history_keep_messages=args.history_keep_messages,
+    max_url_chars=args.max_url_chars,
+    max_dir_items=args.max_dir_items,
+    static_skills=args.static_skills,
+    prompt_caching=args.prompt_caching,
+    headless=args.headless,
+    whitelist=args.whitelist,
+    max_thinking_chars=args.max_thinking_chars,
+    max_thinking_leeway_chars=args.max_thinking_leeway_chars,
+    api_delay=args.api_delay,
+    api_timeout=args.api_timeout
+  ) as chat_session:
+    if not args.headless:
+      chat_session.start_loop()
+
+
+if __name__ == "__main__":
+  main()