aru-code 0.36.0__tar.gz → 0.37.0__tar.gz

{aru_code-0.36.0/aru_code.egg-info → aru_code-0.37.0}/PKG-INFO

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

aru_code-0.37.0/aru/__init__.py

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

{aru_code-0.36.0 → aru_code-0.37.0}/aru/config.py

@@ -227,7 +227,20 @@ class AgentConfig:
             try:
                 from aru.memory.loader import memory_section_for_prompt
                 import os
-                section = memory_section_for_prompt(os.getcwd())
+                # Prefer session.project_root (stable across subdir/worktree
+                # invocations) so memory is keyed to the project, not to
+                # whichever cwd `aru` happened to be launched from. Fall
+                # back to os.getcwd() during bootstrap or outside a ctx.
+                project_root = os.getcwd()
+                try:
+                    from aru.runtime import get_ctx
+                    _session = getattr(get_ctx(), "session", None)
+                    _pr = getattr(_session, "project_root", None) if _session else None
+                    if _pr:
+                        project_root = _pr
+                except LookupError:
+                    pass
+                section = memory_section_for_prompt(project_root)
                 if section:
                     parts.append(section.strip())
             except Exception:  # pragma: no cover — memory module failure mustn't break prompts

{aru_code-0.36.0 → aru_code-0.37.0}/aru/memory/__init__.py

@@ -10,11 +10,19 @@ Components:
 
 Storage layout:
 
-    ~/.aru/projects/<sha256(project_root)[:12]>/memory/
+    ~/.aru/projects/<path-encoded>/memory/
       ├── MEMORY.md              # one-line-per-memory index
       ├── feedback_*.md          # one file per memory, YAML frontmatter + body
       └── user_*.md
 
+``<path-encoded>`` mirrors Claude Code's scheme: every non-alphanumeric
+character in ``abspath(project_root)`` becomes a dash. Example::
+
+    D:\\OneDrive\\python_projects\\aru -> D--OneDrive-python-projects-aru
+
+The directory is created lazily on the first ``write_memory`` call, so a
+project that never writes a memory never leaves an empty folder behind.
+
 Config (aru.json):
 
     {

{aru_code-0.36.0 → aru_code-0.37.0}/aru/memory/store.py

@@ -11,7 +11,6 @@ etc. until free.
 
 from __future__ import annotations
 
-import hashlib
 import os
 import re
 from dataclasses import dataclass
@@ -44,18 +43,48 @@ class MemoryEntry:
 
 # ── Paths ────────────────────────────────────────────────────────────
 
-def _project_hash(project_root: str) -> str:
-    return hashlib.sha256(os.path.abspath(project_root).encode("utf-8")).hexdigest()[:12]
+_PATH_ENCODE_RE = re.compile(r"[^A-Za-z0-9]")
 
 
-def memory_dir_for_project(project_root: str, base: str | None = None) -> Path:
-    """Return (and create, if needed) the memory directory for *project_root*.
+def _encode_project_path(project_root: str) -> str:
+    """Encode an absolute project path as a human-readable folder name.
 
-    Defaults to ``~/.aru/projects/<hash>/memory``. Override ``base`` (test-only).
+    Matches Claude Code's scheme: every non-alphanumeric character (drive
+    colon, path separator, underscore, dot, dash, space, ...) becomes a
+    single dash, without collapsing runs. So ``D:\\`` → ``D--`` (colon
+    AND backslash each become a dash).
+
+    A quick ``ls ~/.aru/projects`` then shows which folder belongs to
+    which project without needing to decode a hash.
+
+    Examples::
+
+        D:\\OneDrive\\python_projects\\aru   -> D--OneDrive-python-projects-aru
+        /home/u/proj                        -> -home-u-proj
+    """
+    return _PATH_ENCODE_RE.sub("-", os.path.abspath(project_root))
+
+
+def memory_dir_for_project(
+    project_root: str,
+    base: str | None = None,
+    *,
+    create: bool = False,
+) -> Path:
+    """Return the memory directory path for *project_root*.
+
+    ``~/.aru/projects/<path-encoded>/memory`` by default. Override ``base``
+    for tests.
+
+    The directory is **not** created on disk unless ``create=True``. Read
+    paths (``load_memory_index``, ``list_memories``) pass the default so
+    a project that never writes a memory leaves no empty folder behind.
+    ``write_memory`` passes ``create=True``.
     """
     base_path = Path(base) if base else Path.home() / ".aru" / "projects"
-    d = base_path / _project_hash(project_root) / "memory"
-    d.mkdir(parents=True, exist_ok=True)
+    d = base_path / _encode_project_path(project_root) / "memory"
+    if create:
+        d.mkdir(parents=True, exist_ok=True)
     return d
 
 
@@ -153,7 +182,7 @@ def write_memory(project_root: str, entry: MemoryEntry,
             f"Invalid memory type {entry.type!r}; must be one of "
             f"{sorted(VALID_MEMORY_TYPES)}."
         )
-    mem_dir = memory_dir_for_project(project_root, base=base)
+    mem_dir = memory_dir_for_project(project_root, base=base, create=True)
     slug = _unique_slug(mem_dir, _slugify(entry.name, entry.type))
     entry.slug = slug
     (mem_dir / entry.filename).write_text(_render_memory_file(entry), encoding="utf-8")
@@ -239,6 +268,8 @@ def search_memories(
 def delete_memory(project_root: str, slug: str, base: str | None = None) -> bool:
     """Delete the memory file + remove its index line. True if something was removed."""
     mem_dir = memory_dir_for_project(project_root, base=base)
+    if not mem_dir.exists():
+        return False
     path = mem_dir / f"{slug}.md"
     removed = path.exists()
     if removed:

{aru_code-0.36.0 → aru_code-0.37.0}/aru/runner.py

@@ -670,6 +670,26 @@ async def run_agent_capture(agent, message: str, session=None, lightweight: bool
         except Exception:
             pass
         console.print("\n[yellow]Interrupted.[/yellow]")
+        # Python 3.11+: ``asyncio.run`` cancels the main task on SIGINT.
+        # Catching CancelledError here is not enough — the task stays in a
+        # "cancelling" state, so the caller's NEXT await (typically the
+        # REPL prompt in cli.py) re-raises CancelledError immediately,
+        # which looks to the user like "Ctrl+C exits aru". ``uncancel()``
+        # resets that counter so the turn ends cleanly and the REPL keeps
+        # running.
+        try:
+            current = asyncio.current_task()
+            if current is not None:
+                current.uncancel()
+        except Exception:
+            pass
+        # Mirror the TUI's reset at turn start — clear the shared abort
+        # flag so the next turn isn't short-circuited by leftover state.
+        try:
+            from aru.runtime import reset_abort
+            reset_abort()
+        except Exception:
+            pass
     except Exception as e:
         try:
             sink.exit()

{aru_code-0.36.0 → aru_code-0.37.0}/aru/tools/memory_tool.py

@@ -1,17 +1,20 @@
-"""Agent-facing memory query tool — Tier 3 #3.
+"""Agent-facing memory tools — Tier 3 #3.
 
-Exposes the per-project memory store (written by the Tier 2 auto-extractor)
-as a read-only tool. Two modes:
+Exposes the per-project memory store as a pair of tools:
 
 - ``memory_search(slug="...")``    → returns the full body of one memory
 - ``memory_search(query="...")``   → keyword substring search over
                                      name / description / body, returns a
                                      ranked list with 200-char previews
 - ``memory_search()``              → summary stats by type
+- ``memory_write(name, body, ...)`` → persist a new memory explicitly,
+                                      without waiting for the turn.end
+                                      extractor
 
 The system prompt already receives ``MEMORY.md`` as an index at startup
-(Tier 2 #4). This tool is the complement for *reading* a specific body
-or searching when the index alone isn't enough.
+(Tier 2 #4). ``memory_search`` is the read complement; ``memory_write``
+lets the agent honour direct user requests like "save X to memory" that
+would otherwise fall through the extractor's threshold.
 """
 
 from __future__ import annotations
@@ -20,10 +23,12 @@ import os
 from collections import Counter
 
 from aru.memory.store import (
+    MemoryEntry,
     VALID_MEMORY_TYPES,
     list_memories,
     read_memory,
     search_memories,
+    write_memory,
 )
 from aru.runtime import get_ctx
 
@@ -106,3 +111,56 @@ def memory_search(query: str = "", slug: str = "") -> str:
             f"\n  body: {preview}"
         )
     return "\n".join(lines)
+
+
+def memory_write(name: str, body: str, type: str = "user",
+                 description: str = "") -> str:
+    """Persist a durable memory for this project across future sessions.
+
+    Use when the user explicitly asks to save / remember / "lembra" / "salva"
+    something that should survive session boundaries. Pick the type carefully:
+
+    - ``user``      — user's persistent preferences or workflow rules
+                      ("prefer pytest", "always type hints")
+    - ``feedback``  — corrections the user gave ("don't mock the DB, got burned")
+    - ``project``   — project-level state / decisions / deadlines / incidents
+    - ``reference`` — pointers to external systems (dashboards, tickets, docs)
+
+    Do NOT save:
+    - Code patterns or anything derivable from reading the repo
+    - Ephemeral conversation state
+    - Duplicates of what is already in the memory index
+
+    Args:
+        name: Short title (under 60 chars). Used as the memory's display name
+            and as the base for its filename slug.
+        body: The fact to remember (under 400 chars). Prefer a single
+            declarative sentence; future sessions see this verbatim.
+        type: One of ``user`` / ``feedback`` / ``project`` / ``reference``.
+            Defaults to ``user``.
+        description: Optional one-line summary for the MEMORY.md index
+            (under 100 chars). If empty, defaults to ``name``.
+    """
+    mtype = (type or "user").strip().lower()
+    if mtype not in VALID_MEMORY_TYPES:
+        return (
+            f"Invalid memory type {mtype!r}. Must be one of "
+            f"{sorted(VALID_MEMORY_TYPES)}."
+        )
+    name_clean = (name or "").strip()[:60]
+    body_clean = (body or "").strip()[:400]
+    desc_clean = (description or "").strip()[:100] or name_clean
+    if not name_clean or not body_clean:
+        return "memory_write requires both `name` and `body`."
+
+    entry = MemoryEntry(
+        name=name_clean,
+        description=desc_clean,
+        type=mtype,
+        body=body_clean,
+    )
+    persisted = write_memory(_project_root(), entry)
+    return (
+        f"Saved memory '{persisted.slug}' ({persisted.type}): "
+        f"{persisted.name}"
+    )

{aru_code-0.36.0 → aru_code-0.37.0}/aru/tools/registry.py

@@ -35,7 +35,7 @@ from aru.tools.lsp import (
     lsp_references,
     lsp_rename,
 )
-from aru.tools.memory_tool import memory_search
+from aru.tools.memory_tool import memory_search, memory_write
 from aru.tools.web import web_fetch, web_search
 from aru.tools.worktree import worktree_info
 
@@ -82,7 +82,7 @@ _TASK_MGMT_TOOLS = [
 # clarity; excluded from subagent / planner / explorer sets.
 _SKILL_TOOLS = [invoke_skill]
 
-CORE_TOOLS = _READ_ONLY_TOOLS + _WRITE_TOOLS + [bash] + _NET_TOOLS + [delegate_task]
+CORE_TOOLS = _READ_ONLY_TOOLS + _WRITE_TOOLS + [bash] + _NET_TOOLS + [delegate_task, memory_write]
 
 ALL_TOOLS = _TASK_MGMT_TOOLS + _SKILL_TOOLS + CORE_TOOLS
 

{aru_code-0.36.0 → aru_code-0.37.0/aru_code.egg-info}/PKG-INFO

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

{aru_code-0.36.0 → aru_code-0.37.0}/aru_code.egg-info/SOURCES.txt

@@ -144,6 +144,7 @@ tests/test_plugins.py
 tests/test_providers.py
 tests/test_ranker.py
 tests/test_reasoning.py
+tests/test_runner_interrupt.py
 tests/test_runner_recovery.py
 tests/test_runtime.py
 tests/test_select.py

{aru_code-0.36.0 → aru_code-0.37.0}/pyproject.toml

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

{aru_code-0.36.0 → aru_code-0.37.0}/tests/test_memory.py

@@ -26,6 +26,7 @@ from aru.memory.loader import (
 from aru.memory.store import (
     MAX_MEMORIES_PER_PROJECT,
     MemoryEntry,
+    _encode_project_path,
     clear_memory,
     delete_memory,
     list_memories,
@@ -150,7 +151,7 @@ def test_memory_section_includes_body_when_index_exists(project_root, memory_bas
 
 
 def test_load_memory_index_truncates_above_cap(project_root, memory_base):
-    mem_dir = memory_dir_for_project(project_root, base=memory_base)
+    mem_dir = memory_dir_for_project(project_root, base=memory_base, create=True)
     # Seed a gigantic index file manually
     (mem_dir / "MEMORY.md").write_text(
         "# Memory Index\n\n" + "\n".join(f"- line {i}" for i in range(MAX_INDEX_LINES + 30)),
@@ -161,6 +162,42 @@ def test_load_memory_index_truncates_above_cap(project_root, memory_base):
     assert "truncated" in text
 
 
+def test_memory_dir_is_lazy_by_default(project_root, memory_base):
+    """Default call must NOT create the dir — avoids phantom empty folders."""
+    mem_dir = memory_dir_for_project(project_root, base=memory_base)
+    assert not mem_dir.exists()
+
+
+def test_memory_dir_creates_when_requested(project_root, memory_base):
+    mem_dir = memory_dir_for_project(project_root, base=memory_base, create=True)
+    assert mem_dir.exists()
+
+
+def test_load_memory_index_does_not_create_dir(project_root, memory_base):
+    """Calling the loader on a clean project must leave the FS untouched."""
+    assert load_memory_index(project_root, base=memory_base) == ""
+    mem_dir = memory_dir_for_project(project_root, base=memory_base)
+    assert not mem_dir.exists()
+
+
+def test_encode_project_path_matches_cc_scheme():
+    # Windows-style path: drive colon, backslashes, AND underscores all
+    # become dashes (matches Claude Code's scheme exactly).
+    assert _encode_project_path(
+        "D:\\OneDrive\\Documentos\\python_projects\\aru"
+    ).endswith("D--OneDrive-Documentos-python-projects-aru")
+    # Case is preserved; runs of separators are NOT collapsed.
+    encoded = _encode_project_path("D:\\Foo_Bar\\baz")
+    assert encoded.endswith("D--Foo-Bar-baz")
+
+
+def test_delete_memory_missing_dir_returns_false(project_root, memory_base):
+    """Deleting from a project that never wrote any memory is a no-op."""
+    assert delete_memory(project_root, "user_whatever", base=memory_base) is False
+    mem_dir = memory_dir_for_project(project_root, base=memory_base)
+    assert not mem_dir.exists()
+
+
 # ── Extractor ────────────────────────────────────────────────────────
 
 def test_should_trigger_respects_auto_extract_flag():
@@ -213,3 +250,47 @@ def test_candidate_to_entry_builds_valid_entry():
     assert entry is not None
     assert entry.type == "user"
     assert entry.name == "Prefer typing"
+
+
+# ── Agent-facing memory_write tool ────────────────────────────────────
+
+def test_memory_write_tool_persists_and_is_queryable(project_root, memory_base, monkeypatch):
+    """memory_write is the agent's direct way to save a fact; memory_search must find it."""
+    import aru.tools.memory_tool as mt
+    # Pin the tool's internal resolver to our tmp project_root + base so the
+    # write lands in the test-scoped directory rather than ~/.aru.
+    monkeypatch.setattr(mt, "_project_root", lambda: project_root)
+    from aru.memory import store as _store
+    original_dir = _store.memory_dir_for_project
+
+    def _scoped_dir(pr, base=None, *, create=False):
+        return original_dir(pr, base=memory_base, create=create)
+
+    monkeypatch.setattr(_store, "memory_dir_for_project", _scoped_dir)
+
+    result = mt.memory_write(
+        name="Prefer pytest",
+        body="The project uses pytest exclusively; pick pytest idioms.",
+        type="user",
+        description="pytest, never unittest",
+    )
+    assert "Saved memory" in result
+    assert "user_prefer_pytest" in result
+
+    hits = mt.memory_search(query="pytest")
+    assert "Prefer pytest" in hits
+    assert "pytest idioms" in hits
+
+
+def test_memory_write_tool_rejects_invalid_type(project_root, monkeypatch):
+    import aru.tools.memory_tool as mt
+    monkeypatch.setattr(mt, "_project_root", lambda: project_root)
+    out = mt.memory_write(name="X", body="b", type="bogus")
+    assert "Invalid memory type" in out
+
+
+def test_memory_write_tool_requires_name_and_body(project_root, monkeypatch):
+    import aru.tools.memory_tool as mt
+    monkeypatch.setattr(mt, "_project_root", lambda: project_root)
+    assert "requires both" in mt.memory_write(name="", body="b")
+    assert "requires both" in mt.memory_write(name="X", body="")

aru_code-0.37.0/tests/test_runner_interrupt.py

@@ -0,0 +1,70 @@
+"""Regression tests for Ctrl+C handling in ``run_agent_capture``.
+
+The bug: on Python 3.11+, ``asyncio.run`` cancels the main task when the
+user hits Ctrl+C. ``run_agent_capture`` catches the resulting
+``CancelledError`` — but Python leaves the task in a "cancelling" state
+until ``Task.uncancel()`` is called. As a result, the REPL's NEXT await
+(the prompt) would raise ``CancelledError`` immediately, making Ctrl+C
+during an agent turn look like it "exits aru" instead of just aborting
+the turn.
+
+These tests cover the narrow contract: after an interrupted turn, the
+task must not be in a cancelling state and the abort signal must be
+cleared.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+
+async def _catch_and_recover_like_runner() -> None:
+    """Mirror the runner.py:666 except block in isolation.
+
+    We don't import ``run_agent_capture`` here because a full mock would
+    drag in agno + RichLiveSink + ctx — overkill for testing an invariant
+    on three lines. Keeping it isolated is the point: if this pattern
+    stays valid, the real runner keeps working too.
+    """
+    from aru.runtime import reset_abort
+    try:
+        await asyncio.sleep(10)
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        current = asyncio.current_task()
+        if current is not None:
+            current.uncancel()
+        reset_abort()
+
+
+async def test_repl_task_survives_mid_turn_cancellation():
+    """After Ctrl+C during a turn, the next await must NOT re-raise."""
+    loop = asyncio.get_running_loop()
+    task = asyncio.current_task()
+    assert task is not None
+    loop.call_later(0.01, task.cancel)
+    await _catch_and_recover_like_runner()
+    # If the fix works, this await completes without re-raising. This is
+    # the moral equivalent of the REPL reaching its next prompt.
+    await asyncio.sleep(0.01)
+    assert task.cancelling() == 0
+
+
+async def test_abort_flag_is_cleared_after_interrupt():
+    """Leftover abort flag would silently short-circuit the next turn."""
+    from aru.runtime import abort_current, is_aborted, reset_abort
+
+    reset_abort()
+    assert is_aborted() is False
+
+    loop = asyncio.get_running_loop()
+    task = asyncio.current_task()
+    assert task is not None
+
+    # Set abort during the simulated turn, then cancel to trigger recovery.
+    def _trigger():
+        abort_current()
+        task.cancel()
+
+    loop.call_later(0.01, _trigger)
+    await _catch_and_recover_like_runner()
+    assert is_aborted() is False

aru_code-0.36.0/aru/__init__.py

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