aru-code 0.20.1__tar.gz → 0.22.0__tar.gz

{aru_code-0.20.1/aru_code.egg-info → aru_code-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.20.1
+Version: 0.22.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

aru_code-0.22.0/aru/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.22.0"

aru_code-0.22.0/aru/checkpoints.py

@@ -0,0 +1,189 @@
+"""File checkpoint system for undo/rewind support.
+
+Tracks file state before tool mutations so changes can be reverted.
+Inspired by Claude Code's fileHistory system.
+
+Architecture:
+- Each user message creates a "snapshot" identified by a turn index.
+- Before any file mutation (write_file, edit_file, bash), the pre-edit
+  content is saved as a versioned backup in .aru/file-history/{session_id}/.
+- On /undo, the most recent snapshot is applied: files are restored to
+  their pre-turn state and the conversation is rewound.
+
+Backup naming: {sha256(path)[:16]}@v{version}
+Snapshot: {turn_index: {file_path: BackupEntry}}
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import threading
+from dataclasses import dataclass, field
+
+
+@dataclass
+class BackupEntry:
+    """A single file backup."""
+    backup_path: str | None  # None = file didn't exist before this turn
+    version: int
+    original_path: str
+
+
+@dataclass
+class Snapshot:
+    """Checkpoint at a specific conversation turn."""
+    turn_index: int
+    backups: dict[str, BackupEntry] = field(default_factory=dict)  # abs_path → BackupEntry
+
+
+MAX_SNAPSHOTS = 100
+
+
+class CheckpointManager:
+    """Manages file checkpoints for a session.
+
+    Thread-safe: multiple tools may run in parallel within a turn.
+    """
+
+    def __init__(self, session_id: str, base_dir: str | None = None):
+        self._session_id = session_id
+        self._base_dir = base_dir or os.path.join(os.getcwd(), ".aru", "file-history", session_id)
+        self._lock = threading.Lock()
+        self._snapshots: list[Snapshot] = []
+        self._current_turn: int = 0
+        self._tracked_files: set[str] = set()
+        # Per-file version counter (monotonic)
+        self._file_versions: dict[str, int] = {}
+        self._dir_created = False
+
+    def _ensure_dir(self):
+        if not self._dir_created:
+            os.makedirs(self._base_dir, exist_ok=True)
+            self._dir_created = True
+
+    def _backup_filename(self, file_path: str, version: int) -> str:
+        path_hash = hashlib.sha256(file_path.encode("utf-8")).hexdigest()[:16]
+        return f"{path_hash}@v{version}"
+
+    def begin_turn(self, turn_index: int):
+        """Start a new turn — creates a fresh snapshot for this turn."""
+        with self._lock:
+            self._current_turn = turn_index
+            # Create snapshot for this turn (backups added lazily as files are edited)
+            snapshot = Snapshot(turn_index=turn_index)
+            self._snapshots.append(snapshot)
+            # Enforce cap
+            if len(self._snapshots) > MAX_SNAPSHOTS:
+                evicted = self._snapshots.pop(0)
+                self._cleanup_snapshot_backups(evicted)
+
+    def track_edit(self, file_path: str):
+        """Capture pre-edit state of a file before mutation.
+
+        Call this BEFORE writing/editing a file. If the file was already
+        captured in the current turn's snapshot, this is a no-op.
+        """
+        abs_path = os.path.abspath(file_path)
+
+        with self._lock:
+            if not self._snapshots:
+                return
+
+            current_snapshot = self._snapshots[-1]
+
+            # Already tracked in this turn
+            if abs_path in current_snapshot.backups:
+                return
+
+            # Increment version
+            version = self._file_versions.get(abs_path, 0) + 1
+            self._file_versions[abs_path] = version
+            self._tracked_files.add(abs_path)
+
+        # Read file outside lock (IO)
+        backup_path = None
+        if os.path.isfile(abs_path):
+            self._ensure_dir()
+            backup_name = self._backup_filename(abs_path, version)
+            backup_path = os.path.join(self._base_dir, backup_name)
+            try:
+                shutil.copy2(abs_path, backup_path)
+            except OSError:
+                backup_path = None
+
+        # Commit to snapshot
+        with self._lock:
+            if not self._snapshots:
+                return
+            entry = BackupEntry(
+                backup_path=backup_path,
+                version=version,
+                original_path=abs_path,
+            )
+            self._snapshots[-1].backups[abs_path] = entry
+
+    def undo_last_turn(self) -> tuple[list[str], int]:
+        """Revert files changed in the most recent snapshot.
+
+        Returns:
+            (list of restored file paths, turn_index that was undone)
+        """
+        with self._lock:
+            if not self._snapshots:
+                return [], 0
+            snapshot = self._snapshots.pop()
+
+        restored = []
+        for abs_path, entry in snapshot.backups.items():
+            try:
+                if entry.backup_path is None:
+                    # File didn't exist before — delete it
+                    if os.path.isfile(abs_path):
+                        os.unlink(abs_path)
+                        restored.append(abs_path)
+                elif os.path.isfile(entry.backup_path):
+                    # Restore from backup
+                    shutil.copy2(entry.backup_path, abs_path)
+                    restored.append(abs_path)
+            except OSError:
+                pass  # best effort
+
+        return restored, snapshot.turn_index
+
+    def get_snapshot_count(self) -> int:
+        with self._lock:
+            return len(self._snapshots)
+
+    def get_last_snapshot_files(self) -> list[str]:
+        """Return files that would be affected by undo."""
+        with self._lock:
+            if not self._snapshots:
+                return []
+            return list(self._snapshots[-1].backups.keys())
+
+    def _cleanup_snapshot_backups(self, snapshot: Snapshot):
+        """Remove backup files for an evicted snapshot (if not referenced by others)."""
+        # Collect all backup paths still referenced
+        referenced = set()
+        for s in self._snapshots:
+            for entry in s.backups.values():
+                if entry.backup_path:
+                    referenced.add(entry.backup_path)
+
+        # Delete unreferenced backups
+        for entry in snapshot.backups.values():
+            if entry.backup_path and entry.backup_path not in referenced:
+                try:
+                    os.unlink(entry.backup_path)
+                except OSError:
+                    pass
+
+    def cleanup(self):
+        """Remove all backup files for this session."""
+        try:
+            if os.path.isdir(self._base_dir):
+                shutil.rmtree(self._base_dir, ignore_errors=True)
+        except OSError:
+            pass

{aru_code-0.20.1 → aru_code-0.22.0}/aru/cli.py

@@ -203,6 +203,11 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
     ctx.on_file_mutation = session.invalidate_context_cache
     atexit.register(lambda: cleanup_processes(ctx.tracked_processes))
 
+    # Initialize checkpoint manager for undo/rewind support
+    from aru.checkpoints import CheckpointManager
+    ctx.checkpoint_manager = CheckpointManager(session.session_id)
+    _turn_counter = 0
+
     planner = None
     executor = None
     paste_state = PasteState()
@@ -329,6 +334,64 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
         # Reset "allow all" approvals for each new user message
         perm_reset_session()
 
+        if user_input.lower() == "/undo":
+            affected_files = ctx.checkpoint_manager.get_last_snapshot_files()
+            if not affected_files and not session.history:
+                console.print("[dim]Nothing to undo.[/dim]")
+                continue
+
+            # Show what will be reverted
+            if affected_files:
+                cwd = os.getcwd()
+                console.print("[bold]Files that will be restored:[/bold]")
+                for f in affected_files:
+                    rel = os.path.relpath(f, cwd) if f.startswith(cwd) else f
+                    console.print(f"  [cyan]{rel}[/cyan]")
+
+            console.print()
+            console.print("[bold]Restore options:[/bold]")
+            console.print("  [cyan](b)[/cyan] Restore code and conversation (both)")
+            console.print("  [cyan](c)[/cyan] Restore only code (keep conversation)")
+            console.print("  [cyan](v)[/cyan] Restore only conversation (keep code)")
+            console.print("  [cyan](n)[/cyan] Cancel")
+            try:
+                choice = console.input("[bold yellow]Choice (b/c/v/n):[/bold yellow] ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                choice = "n"
+
+            if choice in ("n", ""):
+                console.print("[dim]Cancelled.[/dim]")
+                continue
+
+            restored_files = []
+            msgs_removed = 0
+
+            if choice in ("b", "c"):
+                # Restore files from checkpoint
+                restored_files, _ = ctx.checkpoint_manager.undo_last_turn()
+
+            if choice in ("b", "v"):
+                # Remove last turn from conversation
+                msgs_removed = session.undo_last_turn()
+
+            parts = []
+            if restored_files:
+                cwd = os.getcwd()
+                for f in restored_files:
+                    rel = os.path.relpath(f, cwd) if f.startswith(cwd) else f
+                    parts.append(f"  [cyan]{rel}[/cyan]")
+                console.print(f"[green]Restored {len(restored_files)} file(s):[/green]")
+                for p in parts:
+                    console.print(p)
+                session.invalidate_context_cache()
+            if msgs_removed:
+                console.print(f"[green]Removed {msgs_removed} message(s) from conversation.[/green]")
+            if not restored_files and not msgs_removed:
+                console.print("[dim]Nothing was changed.[/dim]")
+            else:
+                store.save(session)
+            continue
+
         if user_input.lower() in ("/quit", "/exit", "quit", "exit"):
             store.save(session)
             console.print(f"\n[dim]Session saved: {session.session_id}[/dim]")
@@ -455,6 +518,10 @@ async def run_cli(skip_permissions: bool = False, resume_id: str | None = None):
             ))
             continue
 
+        # Begin a new checkpoint turn for undo support
+        _turn_counter += 1
+        ctx.checkpoint_manager.begin_turn(_turn_counter)
+
         if user_input.startswith("! "):
             cmd = user_input[2:].strip()
             if not cmd:
@@ -609,6 +676,72 @@ def _list_sessions_and_exit():
     console.print(f"\n[dim]Resume with: aru --resume <id>[/dim]")
 
 
+async def run_oneshot(prompt: str, print_only: bool = False, skip_permissions: bool = False):
+    """Run a single prompt non-interactively and exit.
+
+    Args:
+        prompt: The user prompt to execute.
+        print_only: If True, run without tools (text-only response).
+        skip_permissions: If True, skip all permission checks.
+    """
+    from aru.runtime import init_ctx
+    from aru.config import load_config
+    from aru.cache_patch import apply_cache_patch
+
+    apply_cache_patch()
+    ctx = init_ctx(console=console, skip_permissions=skip_permissions)
+
+    config = load_config()
+    session = Session()
+    if config.default_model:
+        session.model_ref = config.default_model
+
+    ctx.model_id = session.model_id
+    small_ref = config.model_aliases.get("small") if config else None
+    if not small_ref:
+        from aru.providers import resolve_model_ref
+        provider_key, _ = resolve_model_ref(session.model_ref)
+        _small_defaults = {
+            "anthropic": "anthropic/claude-haiku-4-5",
+            "openai": "openai/gpt-4o-mini",
+            "groq": "groq/llama-3.1-8b-instant",
+            "deepseek": "deepseek/deepseek-chat",
+            "ollama": "ollama/llama3.1",
+        }
+        small_ref = _small_defaults.get(provider_key, session.model_ref)
+    ctx.small_model_ref = small_ref
+
+    extra_instructions = config.get_extra_instructions()
+
+    if print_only:
+        # Text-only mode: no tools, just a direct LLM call
+        from agno.agent import Agent
+        from aru.providers import create_model
+        from aru.agents.base import build_instructions
+
+        agent = Agent(
+            name="Aru",
+            model=create_model(session.model_ref, max_tokens=8192),
+            tools=[],
+            instructions=build_instructions("general", extra_instructions),
+            markdown=True,
+        )
+        response = await agent.arun(prompt)
+        if response and response.content:
+            # Print raw text to stdout for piping
+            print(response.content)
+    else:
+        # Full mode with tools
+        from aru.runner import build_env_context
+        env_ctx = build_env_context(session)
+        agent = create_general_agent(session, config, env_context=env_ctx)
+        session.add_message("user", prompt)
+        await run_agent_capture(agent, prompt, session)
+
+        if session.token_summary:
+            console.print(f"[dim]{session.token_summary}[/dim]")
+
+
 def main():
     """Entry point for the aru CLI."""
     from dotenv import load_dotenv
@@ -616,6 +749,7 @@ def main():
     load_dotenv()
     args = sys.argv[1:]
     skip_permissions = "--dangerously-skip-permissions" in args
+    print_only = "--print" in args or "-p" in args
 
     if "--list" in args:
         _list_sessions_and_exit()
@@ -629,6 +763,39 @@ def main():
         else:
             resume_id = "last"
 
+    # Collect positional arguments (non-flag, non-flag-value)
+    flags_with_value = {"--resume"}
+    positional = []
+    skip_next = False
+    for i, arg in enumerate(args):
+        if skip_next:
+            skip_next = False
+            continue
+        if arg.startswith("--") or arg.startswith("-"):
+            if arg in flags_with_value:
+                skip_next = True
+            continue
+        positional.append(arg)
+
+    # Piped stdin: echo "fix bug" | aru
+    if not sys.stdin.isatty() and not positional:
+        piped_input = sys.stdin.read().strip()
+        if piped_input:
+            positional = [piped_input]
+
+    # One-shot mode: aru "fix the bug" or aru --print "explain this"
+    if positional:
+        prompt = " ".join(positional)
+        try:
+            asyncio.run(run_oneshot(prompt, print_only=print_only, skip_permissions=skip_permissions))
+        except (KeyboardInterrupt, asyncio.CancelledError, SystemExit):
+            pass
+        except Exception as e:
+            from rich.markup import escape
+            console.print(f"\n[bold red]Fatal error: {escape(str(e))}[/bold red]")
+        return
+
+    # Interactive REPL mode
     try:
         asyncio.run(run_cli(skip_permissions=skip_permissions, resume_id=resume_id))
     except (KeyboardInterrupt, asyncio.CancelledError, SystemExit):

{aru_code-0.20.1 → aru_code-0.22.0}/aru/commands.py

@@ -21,6 +21,7 @@ SLASH_COMMANDS = [
     ("/skills", "List available skills", "/skills"),
     ("/agents", "List custom agents", "/agents"),
     ("/mcp", "List loaded MCP tools", "/mcp"),
+    ("/undo", "Undo last turn — restore files and/or conversation", "/undo"),
     ("/cost", "Show detailed token usage and cost", "/cost"),
     ("/quit", "Exit aru", "/quit"),
 ]
@@ -83,6 +84,7 @@ def _show_help(config) -> None:
     table.add_row("/skills", "List available skills")
     table.add_row("/agents", "List custom agents")
     table.add_row("/mcp", "List loaded MCP tools")
+    table.add_row("/undo", "Undo last turn (restore files and/or conversation)")
     table.add_row("/help", "Show this help")
     table.add_row("/quit", "Exit aru")
     table.add_row("! <cmd>", "Run shell command")

{aru_code-0.20.1 → aru_code-0.22.0}/aru/runtime.py

@@ -122,6 +122,9 @@ class RuntimeContext:
     # -- Plugins --
     plugin_manager: Any = None  # aru.plugins.manager.PluginManager (lazy to avoid circular)
 
+    # -- Checkpoints --
+    checkpoint_manager: Any = None  # aru.checkpoints.CheckpointManager (lazy)
+
 
 # ── ContextVar plumbing ──────────────────────────────────────────────
 

{aru_code-0.20.1 → aru_code-0.22.0}/aru/session.py

@@ -386,6 +386,24 @@ class Session:
             return f"[yellow]Token budget at {pct:.0f}%[/yellow]"
         return None
 
+    def undo_last_turn(self) -> int:
+        """Remove the last complete turn (user message + assistant/tool responses).
+
+        Pops backward from the end of history until the last user message
+        (inclusive) is removed. Returns the number of messages removed.
+        """
+        if not self.history:
+            return 0
+        removed = 0
+        # Pop from the end until we've removed one user message
+        while self.history:
+            msg = self.history.pop()
+            removed += 1
+            if msg["role"] == "user":
+                break
+        self.updated_at = datetime.now().isoformat(timespec="milliseconds")
+        return removed
+
     def add_message(self, role: str, content):
         """Append a message to history.
 

{aru_code-0.20.1 → aru_code-0.22.0}/aru/tools/codebase.py

@@ -31,6 +31,16 @@ def _notify_file_mutation():
         ctx.on_file_mutation()
 
 
+def _checkpoint_file(file_path: str):
+    """Capture pre-edit state of a file for undo support.
+
+    Must be called BEFORE writing/editing the file.
+    """
+    ctx = get_ctx()
+    if ctx.checkpoint_manager:
+        ctx.checkpoint_manager.track_edit(file_path)
+
+
 def _get_small_model_ref() -> str:
     """Get the small model reference for sub-agents."""
     return get_ctx().small_model_ref
@@ -266,6 +276,7 @@ def write_file(file_path: str, content: str) -> str:
     if not check_permission("write", file_path, Group(header, Text(), diff)):
         return f"PERMISSION DENIED by user: write to {file_path}. Do NOT retry this operation. Stop and ask the user for new instructions."
     try:
+        _checkpoint_file(file_path)
         os.makedirs(os.path.dirname(file_path) or ".", exist_ok=True)
         with open(file_path, "w", encoding="utf-8") as f:
             f.write(content)
@@ -305,6 +316,7 @@ def write_files(file_list: list[dict]) -> str:
             errors.append("Error: missing 'path' in entry")
             continue
         try:
+            _checkpoint_file(path)
             os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
             with open(path, "w", encoding="utf-8") as f:
                 f.write(content)
@@ -363,6 +375,7 @@ def edit_file(file_path: str, old_string: str, new_string: str) -> str:
     if not check_permission("edit", file_path, Group(header, Text(), diff)):
         return f"PERMISSION DENIED by user: edit {file_path}. Do NOT retry this operation. Stop and ask the user for new instructions."
     try:
+        _checkpoint_file(file_path)
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
 
@@ -424,6 +437,7 @@ def edit_files(edits: list[dict]) -> str:
             continue
         try:
             if path not in cache:
+                _checkpoint_file(path)
                 with open(path, "r", encoding="utf-8") as f:
                     cache[path] = f.read()
 
@@ -915,37 +929,80 @@ async def bash(command: str, timeout: int = 60, working_directory: str = "") ->
 
 
 class _HTMLToText(html.parser.HTMLParser):
-    """Minimal HTML-to-text converter — no external dependencies."""
+    """HTML-to-text converter with improved content extraction."""
 
-    SKIP_TAGS = {"script", "style", "svg", "noscript", "head"}
+    SKIP_TAGS = {"script", "style", "svg", "noscript", "head", "nav", "footer",
+                 "iframe", "form", "button", "input", "select", "textarea"}
     BLOCK_TAGS = {"p", "div", "br", "h1", "h2", "h3", "h4", "h5", "h6",
-                  "li", "tr", "blockquote", "pre", "section", "article", "header", "footer"}
+                  "li", "tr", "blockquote", "pre", "section", "article",
+                  "header", "main", "figcaption", "details", "summary", "dt", "dd"}
+    HEADING_TAGS = {"h1", "h2", "h3", "h4", "h5", "h6"}
+    LIST_TAGS = {"li"}
 
     def __init__(self):
         super().__init__()
         self._pieces: list[str] = []
         self._skip_depth = 0
+        self._in_pre = False
+        self._in_anchor = False
+        self._anchor_href = ""
 
     def handle_starttag(self, tag, attrs):
         if tag in self.SKIP_TAGS:
             self._skip_depth += 1
-        elif tag in self.BLOCK_TAGS and not self._skip_depth:
+        elif self._skip_depth:
+            return
+        elif tag == "pre":
+            self._in_pre = True
+            self._pieces.append("\n```\n")
+        elif tag == "code" and not self._in_pre:
+            self._pieces.append("`")
+        elif tag == "a":
+            self._in_anchor = True
+            attrs_dict = dict(attrs)
+            self._anchor_href = attrs_dict.get("href", "")
+        elif tag in self.HEADING_TAGS:
+            level = int(tag[1])
+            self._pieces.append(f"\n{'#' * level} ")
+        elif tag in self.LIST_TAGS:
+            self._pieces.append("\n- ")
+        elif tag in self.BLOCK_TAGS:
+            self._pieces.append("\n")
+        elif tag == "br":
             self._pieces.append("\n")
 
     def handle_endtag(self, tag):
         if tag in self.SKIP_TAGS:
             self._skip_depth = max(0, self._skip_depth - 1)
-        elif tag in self.BLOCK_TAGS and not self._skip_depth:
+        elif self._skip_depth:
+            return
+        elif tag == "pre":
+            self._in_pre = False
+            self._pieces.append("\n```\n")
+        elif tag == "code" and not self._in_pre:
+            self._pieces.append("`")
+        elif tag == "a":
+            if self._anchor_href and not self._anchor_href.startswith(("#", "javascript:")):
+                self._pieces.append(f" ({self._anchor_href})")
+            self._in_anchor = False
+            self._anchor_href = ""
+        elif tag in self.HEADING_TAGS:
+            self._pieces.append("\n")
+        elif tag in self.BLOCK_TAGS:
             self._pieces.append("\n")
 
     def handle_data(self, data):
         if not self._skip_depth:
-            self._pieces.append(data)
+            if self._in_pre:
+                self._pieces.append(data)
+            else:
+                self._pieces.append(data)
 
     def get_text(self) -> str:
         raw = "".join(self._pieces)
         # Collapse whitespace within lines, preserve line breaks
-        lines = [" ".join(line.split()) for line in raw.splitlines()]
+        lines = [" ".join(line.split()) if not line.startswith("```") else line
+                 for line in raw.splitlines()]
         # Collapse multiple blank lines
         text = re.sub(r"\n{3,}", "\n\n", "\n".join(lines))
         return text.strip()
@@ -967,6 +1024,67 @@ def web_search(query: str, max_results: int = 5) -> str:
     import re as _re
     import urllib.parse
 
+    # Try DuckDuckGo Lite (simpler, more stable HTML than full version)
+    results = _ddg_lite_search(query, max_results)
+    if not results:
+        # Fallback to DuckDuckGo HTML (classic scraping)
+        results = _ddg_html_search(query, max_results)
+    if not results:
+        return f"No results found for: {query}"
+    return "\n\n".join(results)
+
+
+def _ddg_lite_search(query: str, max_results: int) -> list[str]:
+    """Search via DuckDuckGo Lite — minimal HTML, more stable parsing."""
+    import re as _re
+    import urllib.parse
+
+    try:
+        with httpx.Client(follow_redirects=True, timeout=15) as client:
+            resp = client.post(
+                "https://lite.duckduckgo.com/lite/",
+                data={"q": query},
+                headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"},
+            )
+            resp.raise_for_status()
+    except httpx.RequestError:
+        return []
+
+    html_text = resp.text
+    results = []
+
+    # DuckDuckGo Lite uses table rows with class "result-link" for titles
+    # and "result-snippet" for snippets
+    link_pattern = _re.compile(
+        r'<a[^>]+class="result-link"[^>]*href="([^"]*)"[^>]*>(.*?)</a>',
+        _re.DOTALL,
+    )
+    snippet_pattern = _re.compile(
+        r'<td[^>]+class="result-snippet"[^>]*>(.*?)</td>',
+        _re.DOTALL,
+    )
+
+    links = link_pattern.findall(html_text)
+    snippets = snippet_pattern.findall(html_text)
+
+    for i, (url, title) in enumerate(links[:max_results]):
+        title_clean = _re.sub(r"<[^>]+>", "", title).strip()
+        snippet_clean = _re.sub(r"<[^>]+>", "", snippets[i]).strip() if i < len(snippets) else ""
+        # Decode DuckDuckGo redirect URLs
+        actual_url = url
+        ud_match = _re.search(r"uddg=([^&]+)", url)
+        if ud_match:
+            actual_url = urllib.parse.unquote(ud_match.group(1))
+        results.append(f"{i + 1}. {title_clean}\n   {actual_url}\n   {snippet_clean}")
+
+    return results
+
+
+def _ddg_html_search(query: str, max_results: int) -> list[str]:
+    """Fallback: search via DuckDuckGo HTML version."""
+    import re as _re
+    import urllib.parse
+
     encoded = urllib.parse.quote_plus(query)
     url = f"https://html.duckduckgo.com/html/?q={encoded}"
 
@@ -976,42 +1094,74 @@ def web_search(query: str, max_results: int = 5) -> str:
                 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
             })
             resp.raise_for_status()
-    except httpx.RequestError as e:
-        return f"Search error: {e}"
+    except httpx.RequestError:
+        return []
 
-    html = resp.text
+    html_text = resp.text
     results = []
 
-    # Parse DuckDuckGo HTML results
     blocks = _re.findall(
         r'<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)</a>.*?'
         r'<a[^>]+class="result__snippet"[^>]*>(.*?)</a>',
-        html, _re.DOTALL,
+        html_text, _re.DOTALL,
     )
 
     for i, (link, title, snippet) in enumerate(blocks[:max_results], 1):
-        # Clean HTML tags
         title_clean = _re.sub(r"<[^>]+>", "", title).strip()
         snippet_clean = _re.sub(r"<[^>]+>", "", snippet).strip()
-        # DuckDuckGo wraps URLs in a redirect — extract the actual URL
         actual_url = link
         ud_match = _re.search(r"uddg=([^&]+)", link)
         if ud_match:
             actual_url = urllib.parse.unquote(ud_match.group(1))
         results.append(f"{i}. {title_clean}\n   {actual_url}\n   {snippet_clean}")
 
-    if not results:
-        return f"No results found for: {query}"
-    return "\n\n".join(results)
+    return results
 
 
 def web_fetch(url: str, max_chars: int = 8000) -> str:
     """Fetch a URL and return content as text.
 
+    Uses Jina Reader (r.jina.ai) for clean content extraction from HTML pages.
+    Falls back to direct fetch with local HTML-to-text conversion if Jina is
+    unavailable.
+
     Args:
         url: The URL to fetch.
         max_chars: Max characters to return (default 8000).
     """
+    # Try Jina Reader first for HTML URLs — produces clean markdown
+    if not url.endswith((".json", ".txt", ".xml", ".csv", ".pdf")):
+        jina_text = _fetch_via_jina(url, max_chars)
+        if jina_text:
+            return _truncate_output(jina_text, source_tool="web_fetch")
+
+    # Direct fetch fallback
+    return _fetch_direct(url, max_chars)
+
+
+def _fetch_via_jina(url: str, max_chars: int) -> str | None:
+    """Fetch URL content via Jina Reader for clean markdown output."""
+    jina_url = f"https://r.jina.ai/{url}"
+    try:
+        with httpx.Client(follow_redirects=True, timeout=30) as client:
+            resp = client.get(jina_url, headers={
+                "Accept": "text/plain",
+                "User-Agent": "Mozilla/5.0 (compatible; aru-agent/0.1)",
+            })
+            if resp.status_code != 200:
+                return None
+            text = resp.text.strip()
+            if not text or len(text) < 50:
+                return None
+            if len(text) > max_chars:
+                text = text[:max_chars] + f"\n\n... [truncated at {max_chars} chars]"
+            return text
+    except (httpx.RequestError, httpx.HTTPStatusError):
+        return None
+
+
+def _fetch_direct(url: str, max_chars: int) -> str:
+    """Direct URL fetch with local HTML-to-text conversion."""
     try:
         with httpx.Client(follow_redirects=True, timeout=30) as client:
             resp = client.get(url, headers={
@@ -1028,12 +1178,10 @@ def web_fetch(url: str, max_chars: int = 8000) -> str:
     body = resp.text
 
     if "json" in content_type:
-        # JSON — return as-is (already readable)
         text = body
     elif "html" in content_type:
         text = _html_to_text(body)
     else:
-        # Plain text or other
         text = body
 
     if len(text) > max_chars:

{aru_code-0.20.1 → aru_code-0.22.0/aru_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aru-code
-Version: 0.20.1
+Version: 0.22.0
 Summary: A Claude Code clone built with Agno agents
 Author-email: Estevao <estevaofon@gmail.com>
 License-Expression: MIT

{aru_code-0.20.1 → aru_code-0.22.0}/aru_code.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 aru/__init__.py
 aru/agent_factory.py
 aru/cache_patch.py
+aru/checkpoints.py
 aru/cli.py
 aru/commands.py
 aru/completers.py
@@ -39,6 +40,7 @@ aru_code.egg-info/entry_points.txt
 aru_code.egg-info/requires.txt
 aru_code.egg-info/top_level.txt
 tests/test_agents_base.py
+tests/test_checkpoints.py
 tests/test_cli.py
 tests/test_cli_advanced.py
 tests/test_cli_base.py

{aru_code-0.20.1 → aru_code-0.22.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aru-code"
-version = "0.20.1"
+version = "0.22.0"
 description = "A Claude Code clone built with Agno agents"
 readme = "README.md"
 license = "MIT"

aru_code-0.22.0/tests/test_checkpoints.py

@@ -0,0 +1,190 @@
+"""Tests for the checkpoint/undo system."""
+
+import os
+import tempfile
+
+import pytest
+
+from aru.checkpoints import CheckpointManager
+
+
+@pytest.fixture
+def tmp_workspace(tmp_path):
+    """Create a temporary workspace with some files."""
+    (tmp_path / "hello.py").write_text("print('hello')\n")
+    (tmp_path / "config.json").write_text('{"key": "value"}\n')
+    return tmp_path
+
+
+@pytest.fixture
+def manager(tmp_path):
+    """Create a CheckpointManager with temp backup dir."""
+    backup_dir = str(tmp_path / "backups")
+    return CheckpointManager("test-session", base_dir=backup_dir)
+
+
+class TestCheckpointManager:
+    def test_begin_turn_creates_snapshot(self, manager):
+        manager.begin_turn(1)
+        assert manager.get_snapshot_count() == 1
+
+    def test_track_edit_captures_file_state(self, manager, tmp_workspace):
+        manager.begin_turn(1)
+        file_path = str(tmp_workspace / "hello.py")
+        manager.track_edit(file_path)
+
+        affected = manager.get_last_snapshot_files()
+        assert os.path.abspath(file_path) in affected
+
+    def test_track_edit_idempotent_within_turn(self, manager, tmp_workspace):
+        manager.begin_turn(1)
+        file_path = str(tmp_workspace / "hello.py")
+        manager.track_edit(file_path)
+        manager.track_edit(file_path)  # should be no-op
+
+        affected = manager.get_last_snapshot_files()
+        assert len(affected) == 1
+
+    def test_undo_restores_edited_file(self, manager, tmp_workspace):
+        file_path = str(tmp_workspace / "hello.py")
+        original_content = "print('hello')\n"
+
+        manager.begin_turn(1)
+        manager.track_edit(file_path)
+
+        # Simulate edit
+        with open(file_path, "w") as f:
+            f.write("print('CHANGED')\n")
+        assert open(file_path).read() == "print('CHANGED')\n"
+
+        # Undo
+        restored, turn = manager.undo_last_turn()
+        assert turn == 1
+        assert os.path.abspath(file_path) in restored
+        assert open(file_path).read() == original_content
+
+    def test_undo_deletes_newly_created_file(self, manager, tmp_workspace):
+        new_file = str(tmp_workspace / "new_file.py")
+
+        manager.begin_turn(1)
+        manager.track_edit(new_file)  # file doesn't exist yet
+
+        # Simulate creation
+        with open(new_file, "w") as f:
+            f.write("new content\n")
+        assert os.path.isfile(new_file)
+
+        # Undo should delete the file
+        restored, turn = manager.undo_last_turn()
+        assert os.path.abspath(new_file) in restored
+        assert not os.path.isfile(new_file)
+
+    def test_undo_multiple_files(self, manager, tmp_workspace):
+        file1 = str(tmp_workspace / "hello.py")
+        file2 = str(tmp_workspace / "config.json")
+
+        manager.begin_turn(1)
+        manager.track_edit(file1)
+        manager.track_edit(file2)
+
+        # Edit both
+        with open(file1, "w") as f:
+            f.write("changed1\n")
+        with open(file2, "w") as f:
+            f.write("changed2\n")
+
+        # Undo
+        restored, _ = manager.undo_last_turn()
+        assert len(restored) == 2
+        assert open(file1).read() == "print('hello')\n"
+        assert open(file2).read() == '{"key": "value"}\n'
+
+    def test_undo_only_affects_last_turn(self, manager, tmp_workspace):
+        file_path = str(tmp_workspace / "hello.py")
+
+        # Turn 1: edit file
+        manager.begin_turn(1)
+        manager.track_edit(file_path)
+        with open(file_path, "w") as f:
+            f.write("turn1\n")
+
+        # Turn 2: edit file again
+        manager.begin_turn(2)
+        manager.track_edit(file_path)
+        with open(file_path, "w") as f:
+            f.write("turn2\n")
+
+        # Undo turn 2 → should restore to turn1 state
+        restored, turn = manager.undo_last_turn()
+        assert turn == 2
+        assert open(file_path).read() == "turn1\n"
+
+        # Undo turn 1 → should restore to original
+        restored, turn = manager.undo_last_turn()
+        assert turn == 1
+        assert open(file_path).read() == "print('hello')\n"
+
+    def test_undo_empty_returns_empty(self, manager):
+        restored, turn = manager.undo_last_turn()
+        assert restored == []
+        assert turn == 0
+
+    def test_get_last_snapshot_files_empty(self, manager):
+        assert manager.get_last_snapshot_files() == []
+
+    def test_max_snapshots_enforced(self, manager, tmp_workspace):
+        file_path = str(tmp_workspace / "hello.py")
+        for i in range(105):
+            manager.begin_turn(i)
+            manager.track_edit(file_path)
+            with open(file_path, "w") as f:
+                f.write(f"v{i}\n")
+
+        assert manager.get_snapshot_count() == 100
+
+    def test_cleanup_removes_backup_dir(self, manager, tmp_workspace):
+        file_path = str(tmp_workspace / "hello.py")
+        manager.begin_turn(1)
+        manager.track_edit(file_path)
+
+        assert os.path.isdir(manager._base_dir)
+        manager.cleanup()
+        assert not os.path.isdir(manager._base_dir)
+
+
+class TestSessionUndoLastTurn:
+    """Tests for Session.undo_last_turn (conversation history only)."""
+
+    def test_undo_removes_last_turn(self):
+        from aru.session import Session
+        session = Session()
+        session.add_message("user", "hello")
+        session.add_message("assistant", "hi there")
+        session.add_message("user", "how are you")
+        session.add_message("assistant", "good")
+
+        removed = session.undo_last_turn()
+        assert removed == 2  # user + assistant
+        assert len(session.history) == 2
+        assert session.history[-1]["role"] == "assistant"
+
+    def test_undo_removes_tool_messages(self):
+        from aru.session import Session
+        session = Session()
+        session.add_message("user", "fix the bug")
+        session.add_message("assistant", "reading file")
+        session.add_message("tool", "file contents here")
+        session.add_message("assistant", "done")
+
+        removed = session.undo_last_turn()
+        # Should remove: user + assistant + tool + assistant = 4 if they go back to last user
+        # Actually: pops from end until user is found
+        # done (assistant) → tool → reading file (assistant) → fix the bug (user) = 4
+        assert removed == 4
+        assert len(session.history) == 0
+
+    def test_undo_empty_history(self):
+        from aru.session import Session
+        session = Session()
+        removed = session.undo_last_turn()
+        assert removed == 0

aru_code-0.20.1/aru/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.20.1"