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

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

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

aru_code-0.22.1/aru/__init__.py

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

{aru_code-0.22.0 → aru_code-0.22.1}/aru/cache_patch.py

@@ -22,9 +22,9 @@ from __future__ import annotations
 # - Protect recent tool results within a token budget
 # - Only prune if there's enough to free (avoid churn)
 # - Walk backwards, protecting recent content first
-# OpenCode uses 40K protect / 20K minimum; we use chars (~4 chars/token)
-_PRUNE_PROTECT_CHARS = 160_000   # ~40K tokens — recent content always kept
-_PRUNE_MINIMUM_CHARS = 80_000    # ~20K tokens — only prune if this much is freeable
+# Aligned with context.py thresholds to keep context ~30K tokens.
+_PRUNE_PROTECT_CHARS = 55_000    # ~14K tokens — recent content always kept
+_PRUNE_MINIMUM_CHARS = 20_000    # ~5K tokens — only prune if this much is freeable
 _PRUNED_PLACEHOLDER = "[Old tool result cleared]"
 
 # Last API call metrics (updated on every internal API call)

{aru_code-0.22.0 → aru_code-0.22.1}/aru/checkpoints.py

@@ -1,189 +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
+"""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.22.0 → aru_code-0.22.1}/aru/context.py

@@ -24,8 +24,8 @@ from __future__ import annotations
 # ── Constants ──────────────────────────────────────────────────────
 
 # Pruning: minimum chars that must be freeable to justify a prune pass.
-# Matches opencode's PRUNE_MINIMUM = 20_000 tokens (~80K chars @ 4 chars/token).
-PRUNE_MINIMUM_CHARS = 80_000  # ~20K tokens
+# Lower than opencode's 20K tokens to fire early and keep context ~30K tokens.
+PRUNE_MINIMUM_CHARS = 20_000  # ~5K tokens
 # Placeholder that replaces cleared tool_result content. Matches
 # cache_patch.py's _PRUNED_PLACEHOLDER so both layers produce identical
 # text when a tool output is cleared.
@@ -177,24 +177,20 @@ def _tool_result_content_len(msg: dict) -> int:
 
 
 def _get_prune_protect_chars(model_id: str = "default") -> int:
-    """Chars of recent history that must NEVER be pruned.
+    """Chars of recent tool-result content that must NEVER be pruned.
 
-    Flat value across all models, mirroring opencode's fixed
-    `PRUNE_PROTECT = 40_000` tokens (compaction.ts:36). At ~4 chars/token
-    that's 160K chars of tool-result content kept intact in the recent
-    window. Older tool_result blocks beyond this budget are eligible for
-    the lossy clear pass in `prune_history`.
-
-    Why flat (not scaled by model): opencode validated this in production
-    on contexts from 128K to 1M — scaling by ratio adds complexity without
-    improving behavior, and protecting too much in 1M-context models can
-    actually hurt prompt caching by keeping rarely-touched tail content warm.
+    Targets a ~30K token total context window. With ~5K tokens of
+    system prompt + tool definitions and ~7K of user/assistant text,
+    the tool output budget is ~18K tokens ≈ 65K chars. We protect
+    55K chars (~14K tokens) of recent tool output so pruning fires
+    at protect + PRUNE_MINIMUM = 55K + 20K = 75K chars (~19K tokens
+    of tool output), keeping the steady-state around 30K total.
 
     The `model_id` parameter is retained for signature compatibility with
     older call sites; it has no effect on the returned value.
     """
     del model_id  # unused — kept for signature compatibility
-    return 160_000
+    return 55_000
 
 
 def prune_history(

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

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

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

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

{aru_code-0.22.0 → aru_code-0.22.1}/tests/test_checkpoints.py

@@ -1,190 +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
+"""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.22.0 → aru_code-0.22.1}/tests/test_context.py

@@ -37,16 +37,17 @@ class TestPruneHistory:
 
     def test_prunes_old_tool_results_when_over_threshold(self):
         """Should clear old tool_result content when total tool output
-        exceeds protect + minimum (opencode-aligned budget semantics).
+        exceeds protect + minimum (budget semantics).
 
         The budget walks backward over tool_result content chars only.
         Text and tool_use args don't count, so this test uses large
         tool_result payloads to actually trip the prune path.
         """
-        # Three rounds of read_file-sized outputs. Total ~300K chars
-        # of tool_result content — clears the 240K entry gate, and
-        # the 160K protect budget will cover only the most recent one.
-        big_output = "line of code\n" * 8_000  # ~100K chars
+        # Three rounds of tool outputs. Each ~30K chars, total ~90K chars.
+        # Entry gate: protect (55K) + minimum (20K) = 75K → 90K exceeds it.
+        # Protection budget (55K) covers the most recent block (30K) plus
+        # part of the middle, so at least tu_old gets cleared.
+        big_output = "line of code\n" * 2_300  # ~30K chars each
         messages = [
             {"role": "user", "content": "round 1"},
             {
@@ -97,7 +98,7 @@ class TestPruneHistory:
 
         # The older tool_result must have been cleared — at least one
         # of tu_old/tu_mid should now hold the placeholder, since only
-        # 160K chars worth fits inside the protect window.
+        # 55K chars worth fits inside the protect window.
         cleared_count = sum(
             1 for tu_id in ("tu_old", "tu_mid")
             if by_id[tu_id]["content"] == CLEARED_TOOL_RESULT

aru_code-0.22.0/aru/__init__.py

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