compartment 3.3__tar.gz → 3.4__tar.gz

{compartment-3.3 → compartment-3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compartment
-Version: 3.3
+Version: 3.4
 Summary: Compartment - high-security, fully offline, encrypted vector memory for AI agents (MCP)
 Project-URL: Homepage, https://github.com/MaxFreedomPollard/Compartment
 Project-URL: Source, https://github.com/MaxFreedomPollard/Compartment
@@ -243,6 +243,11 @@ network at all.
 One command per platform. Each installs the package, creates your
 encrypted vault, and wires the agent.
 
+Every one of these is also a button in the app. Click the Compartment icon
+in your menu bar or notification area, and under **CONNECT AN AGENT** press
+Claude, Hermes or OpenClaw. The button runs the same `compartment integrate`
+command for you, so nobody has to open a terminal a second time.
+
 **Claude (Code + Desktop)** - macOS / Linux:
 ```bash
 pip install compartment && compartment init && compartment integrate claude

{compartment-3.3 → compartment-3.4}/README.md

@@ -197,6 +197,11 @@ network at all.
 One command per platform. Each installs the package, creates your
 encrypted vault, and wires the agent.
 
+Every one of these is also a button in the app. Click the Compartment icon
+in your menu bar or notification area, and under **CONNECT AN AGENT** press
+Claude, Hermes or OpenClaw. The button runs the same `compartment integrate`
+command for you, so nobody has to open a terminal a second time.
+
 **Claude (Code + Desktop)** - macOS / Linux:
 ```bash
 pip install compartment && compartment init && compartment integrate claude

{compartment-3.3 → compartment-3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "compartment"
-version = "3.3"
+version = "3.4"
 description = "Compartment - high-security, fully offline, encrypted vector memory for AI agents (MCP)"
 readme = "README.md"
 requires-python = ">=3.11"

{compartment-3.3 → compartment-3.4}/src/compartment/__init__.py

@@ -1,6 +1,6 @@
 """Compartment - high-security, fully offline, encrypted vector memory for AI agents."""
 
-__version__ = "3.3"
+__version__ = "3.4"
 
 from . import offline_guard as _og
 

{compartment-3.3 → compartment-3.4}/src/compartment/menubar.py

@@ -279,6 +279,40 @@ def change_passphrase(vault: str, new: str, repeat: str) -> tuple[bool, str]:
     return False, (out[:120] or "could not change the passphrase")
 
 
+#: The agents `compartment integrate` can wire, in the order they are offered.
+#: Kept here rather than in the UI so the menu bar and the tray cannot drift
+#: apart, and so adding a target is one edit.
+INTEGRATION_TARGETS = (("claude", "Claude"),
+                       ("hermes", "Hermes"),
+                       ("openclaw", "OpenClaw"))
+
+
+def integrate(vault: str, target: str) -> tuple[bool, str]:
+    """Connect an agent to this vault, from the panel. Returns (ok, message).
+
+    The same command the README gives, run for you. It is offered here
+    because the terminal step after installing is where people stop: the
+    vault exists, the icon is in the menu bar, and nothing is using it yet
+    because nobody knew there was a second command.
+
+    Wiring an agent edits that agent's own configuration, so this reports
+    what happened rather than assuming - a Claude Code CLI that is not
+    installed is a normal outcome, not an error to hide.
+    """
+    if target not in dict(INTEGRATION_TARGETS):
+        return False, f"unknown target {target!r}"
+    code, out = _run([*_cli_argv(), "--vault", vault, "integrate", target],
+                     timeout=300)
+    text = " ".join(out.split())
+    if code != 0:
+        return False, (text[:200] or f"could not connect {target}")
+    name = dict(INTEGRATION_TARGETS)[target]
+    if "not found" in text.lower():
+        return True, (f"{name} is not installed on this machine yet. "
+                      "Compartment is ready for it when it is.")
+    return True, f"{name} is connected. Restart it to pick up the change."
+
+
 def summarise(state: dict) -> str:
     """One line under the title. Also what --self-check prints."""
     if not state["exists"]:
@@ -592,6 +626,7 @@ def run(vault: str | None = None, show: bool = False,
             self.pw_new = None
             self.pw_repeat = None
             self.change_note = None
+            self.connect_note = None  # what the last Connect button reported
             return self
 
         # ---- building the popover contents -----------------------------
@@ -737,6 +772,27 @@ def run(vault: str | None = None, show: bool = False,
                                10, secondary=True))
             views.append(divider())
 
+            # Installing leaves you with a vault and an icon, and nothing
+            # using either until an agent is wired to it. That step is one
+            # terminal command, which is one command too many for most
+            # people, so it is a button.
+            views.append(label("CONNECT AN AGENT", 10, bold=True,
+                               secondary=True))
+            connect_buttons = []
+            for i, (_target, name) in enumerate(INTEGRATION_TARGETS):
+                b = NSButton.buttonWithTitle_target_action_(
+                    name, self, "connectAgent:")
+                b.setTag_(i)
+                connect_buttons.append(b)
+            views.append(row(*connect_buttons, _spacer()))
+            views.append(label(
+                self.connect_note or
+                "Registers memory with the agent, writes its instructions "
+                "and turns on capture. The same as running `compartment "
+                "integrate claude` in a terminal.", 10, secondary=True,
+                wrap=True))
+            views.append(divider())
+
             views.append(label(f"LAST {RECENT_COUNT} MEMORIES", 10, bold=True,
                                secondary=True))
             if st["locked"]:
@@ -871,6 +927,15 @@ def run(vault: str | None = None, show: bool = False,
             set_setting(vault_path, "auto_lock_minutes", AUTO_LOCK_CHOICES[idx])
             self.rebuild()
 
+        def connectAgent_(self, sender):
+            try:
+                target = INTEGRATION_TARGETS[int(sender.tag())][0]
+            except (IndexError, ValueError):
+                return
+            _ok, msg = integrate(vault_path, target)
+            self.connect_note = msg
+            self.rebuild()
+
         def refresh_(self, sender):
             self.rebuild()
 

{compartment-3.3 → compartment-3.4}/src/compartment/systray.py

@@ -29,10 +29,11 @@ from pathlib import Path
 
 from .home import env, home
 
-from .menubar import (AUTO_LOCK_CHOICES, RECENT_COUNT, auto_lock_label,
-                      change_passphrase, claim_first_run, default_vault,
-                      fetch_state, lock_vault, self_check, set_setting,
-                      starter_note, summarise, unlock_vault)
+from .menubar import (AUTO_LOCK_CHOICES, INTEGRATION_TARGETS, RECENT_COUNT,
+                      auto_lock_label, change_passphrase, claim_first_run,
+                      default_vault, fetch_state, integrate, lock_vault,
+                      self_check, set_setting, starter_note, summarise,
+                      unlock_vault)
 
 PANEL_WIDTH = 360
 PANEL_MAX_HEIGHT = 640
@@ -106,6 +107,16 @@ def panel_rows(state: dict) -> list[tuple[str, str]]:
                  f"{'on' if s['search_starter_facts'] else 'off'}"))
     rows.append(("choice:auto_lock_minutes",
                  f"Auto-lock: {auto_lock_label(s['auto_lock_minutes'])}"))
+    # Installing leaves you with a vault that nothing is using until an agent
+    # is wired to it. One button per agent, so that step is not a terminal
+    # command someone has to know about.
+    rows.append(("heading", "CONNECT AN AGENT"))
+    for target, name in INTEGRATION_TARGETS:
+        rows.append((f"connect:{target}", name))
+    rows.append(("note", state.get("connect_note") or
+                 "Registers memory with the agent, writes its instructions "
+                 "and turns on capture. The same as running "
+                 "`compartment integrate claude` in a terminal."))
     rows.append(("heading", f"LAST {RECENT_COUNT} MEMORIES"))
     recent = state.get("recent") or []
     if not recent:
@@ -335,13 +346,36 @@ def run(vault: str | None = None, show: bool = False,
                        *[auto_lock_label(m) for m in AUTO_LOCK_CHOICES],
                        command=set_lock).pack(side="right")
 
+        ttk.Separator(frame).pack(fill="x", pady=10)
+        ttk.Label(frame, text="CONNECT AN AGENT",
+                  font=("Segoe UI", 8, "bold")).pack(anchor="w")
+
+        def connect(target):
+            _ok, note = integrate(vault_path, target)
+            panel["connect_note"] = note
+            refresh()
+
+        connect_row = ttk.Frame(frame)
+        connect_row.pack(fill="x", pady=(6, 0))
+        for _target, _name in INTEGRATION_TARGETS:
+            ttk.Button(connect_row, text=_name,
+                       command=lambda t=_target: connect(t)
+                       ).pack(side="left", padx=(0, 6))
+        ttk.Label(frame, text=panel.get("connect_note") or
+                  "Registers memory with the agent, writes its instructions "
+                  "and turns on capture. The same as running "
+                  "`compartment integrate claude` in a terminal.",
+                  foreground="#666", wraplength=WRAP,
+                  justify="left").pack(anchor="w", pady=(4, 0))
+
         ttk.Separator(frame).pack(fill="x", pady=10)
         ttk.Label(frame, text=f"LAST {RECENT_COUNT} MEMORIES",
                   font=("Segoe UI", 8, "bold")).pack(anchor="w")
         recent = state.get("recent") or []
         if not recent:
-            ttk.Label(frame, text="Nothing yet.",
-                      foreground="#666").pack(anchor="w", pady=(4, 0))
+            ttk.Label(frame, text=starter_note(state), foreground="#666",
+                      wraplength=WRAP,
+                      justify="left").pack(anchor="w", pady=(4, 0))
         for r in recent:
             ttk.Label(frame, text=(r.get("text") or "").strip(),
                       wraplength=WRAP,

{compartment-3.3 → compartment-3.4}/src/compartment.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compartment
-Version: 3.3
+Version: 3.4
 Summary: Compartment - high-security, fully offline, encrypted vector memory for AI agents (MCP)
 Project-URL: Homepage, https://github.com/MaxFreedomPollard/Compartment
 Project-URL: Source, https://github.com/MaxFreedomPollard/Compartment
@@ -243,6 +243,11 @@ network at all.
 One command per platform. Each installs the package, creates your
 encrypted vault, and wires the agent.
 
+Every one of these is also a button in the app. Click the Compartment icon
+in your menu bar or notification area, and under **CONNECT AN AGENT** press
+Claude, Hermes or OpenClaw. The button runs the same `compartment integrate`
+command for you, so nobody has to open a terminal a second time.
+
 **Claude (Code + Desktop)** - macOS / Linux:
 ```bash
 pip install compartment && compartment init && compartment integrate claude

{compartment-3.3 → compartment-3.4}/src/compartment.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ tests/test_attempt_pacing.py
 tests/test_audit_chain.py
 tests/test_claude_hooks_and_integrate.py
 tests/test_claude_memory_and_recent.py
+tests/test_connect_buttons.py
 tests/test_crypto.py
 tests/test_dash.py
 tests/test_instructions.py

compartment-3.4/tests/test_connect_buttons.py

@@ -0,0 +1,165 @@
+"""Connecting an agent is a button, on both platforms.
+
+`compartment integrate <agent>` is the step people miss: the vault exists,
+the icon is in the menu bar, and nothing is using either because the second
+command was never run. The panel offers it directly, and these tests hold the
+two front ends to the same list of agents as the CLI.
+"""
+import re
+
+import pytest
+
+from compartment import cli, menubar, systray
+
+
+def _state(**over):
+    st = {"vault": "/v", "exists": True, "locked": False, "records": 6665,
+          "organic": 0, "recent": [], "error": None,
+          "settings": {"capture_hook": True, "search_starter_facts": True,
+                       "auto_lock_minutes": 30}}
+    st.update(over)
+    return st
+
+
+# ------------------------------------------------------------- the agent list
+
+@pytest.mark.parametrize("target,_name", menubar.INTEGRATION_TARGETS)
+def test_every_button_names_a_target_the_cli_accepts(monkeypatch, target,
+                                                     _name):
+    """A button for an agent the CLI rejects is a button that cannot work.
+    Goes through the real parser, which is the only thing that can say."""
+    seen = {}
+    monkeypatch.setattr(cli, "cmd_integrate",
+                        lambda args: seen.update(vars(args)))
+    cli.main(["integrate", target])
+    assert seen["target"] == target
+
+
+def test_no_agent_the_cli_accepts_is_missing_a_button(monkeypatch, capsys):
+    """The other direction: adding a target to the CLI and forgetting the
+    button leaves an agent nobody can reach from the app. argparse names
+    every choice it accepts when it rejects one, so ask it."""
+    monkeypatch.setattr(cli, "cmd_integrate", lambda args: None)
+    with pytest.raises(SystemExit):
+        cli.main(["integrate", "no-such-agent"])
+    err = capsys.readouterr().err
+    choices = set(re.findall(r"'([a-z]+)'", err.split("choose from")[-1]))
+    assert choices == {t for t, _ in menubar.INTEGRATION_TARGETS}
+
+
+def test_the_agents_are_offered_in_a_fixed_order():
+    assert [t for t, _ in menubar.INTEGRATION_TARGETS] == \
+        ["claude", "hermes", "openclaw"]
+
+
+def test_every_agent_has_a_display_name():
+    for target, name in menubar.INTEGRATION_TARGETS:
+        assert name and name.lower().replace(" ", "") == target
+
+
+# ---------------------------------------------------------------- the action
+
+def test_an_unknown_target_never_runs_anything(monkeypatch):
+    called = []
+    monkeypatch.setattr(menubar, "_run", lambda *a, **k: called.append(a))
+    ok, msg = menubar.integrate("/v", "notanagent")
+    assert ok is False and "notanagent" in msg
+    assert called == []
+
+
+def test_it_runs_the_documented_command(monkeypatch):
+    seen = {}
+
+    def fake_run(args, timeout=60):
+        seen["args"] = args
+        return 0, "registered."
+    monkeypatch.setattr(menubar, "_run", fake_run)
+    ok, _ = menubar.integrate("/path/to/v.vault", "claude")
+    assert ok is True
+    assert seen["args"][-3:] == ["v.vault", "integrate", "claude"] or \
+        seen["args"][-2:] == ["integrate", "claude"]
+    assert "--vault" in seen["args"]
+    assert "/path/to/v.vault" in seen["args"]
+
+
+def test_success_tells_the_user_to_restart_the_agent(monkeypatch):
+    monkeypatch.setattr(menubar, "_run", lambda *a, **k: (0, "registered."))
+    ok, msg = menubar.integrate("/v", "claude")
+    assert ok is True
+    assert "Claude" in msg and "estart" in msg
+
+
+def test_a_missing_agent_is_reported_as_normal_not_as_failure(monkeypatch):
+    """Not having Hermes installed is not an error, and must not read as
+    one: the wiring that can be done is still done."""
+    monkeypatch.setattr(menubar, "_run",
+                        lambda *a, **k: (0, "hermes not found; finish with…"))
+    ok, msg = menubar.integrate("/v", "hermes")
+    assert ok is True
+    assert "not installed" in msg
+
+
+def test_a_real_failure_surfaces_its_reason(monkeypatch):
+    monkeypatch.setattr(menubar, "_run",
+                        lambda *a, **k: (1, "permission denied writing config"))
+    ok, msg = menubar.integrate("/v", "claude")
+    assert ok is False
+    assert "permission denied" in msg
+
+
+def test_a_failure_with_no_output_still_says_something(monkeypatch):
+    monkeypatch.setattr(menubar, "_run", lambda *a, **k: (1, ""))
+    ok, msg = menubar.integrate("/v", "openclaw")
+    assert ok is False and msg
+
+
+def test_wiring_gets_a_longer_leash_than_a_status_call(monkeypatch):
+    """Installing into the Hermes venv can take a while; a 60 s default would
+    time out mid-pip and leave the agent half-wired."""
+    seen = {}
+
+    def fake_run(args, timeout=60):
+        seen["timeout"] = timeout
+        return 0, "ok"
+    monkeypatch.setattr(menubar, "_run", fake_run)
+    menubar.integrate("/v", "hermes")
+    assert seen["timeout"] >= 300
+
+
+# ----------------------------------------------------------------- the panel
+
+def test_the_tray_panel_has_a_button_per_agent():
+    rows = systray.panel_rows(_state())
+    connects = [text for kind, text in rows if kind.startswith("connect:")]
+    assert connects == ["Claude", "Hermes", "OpenClaw"]
+
+
+def test_the_tray_panel_heads_the_section():
+    rows = systray.panel_rows(_state())
+    assert ("heading", "CONNECT AN AGENT") in rows
+
+
+def test_the_tray_panel_explains_what_the_buttons_do():
+    rows = systray.panel_rows(_state())
+    note = [t for k, t in rows if k == "note"][0]
+    assert "integrate claude" in note
+
+
+def test_the_tray_panel_shows_the_last_result_once_there_is_one():
+    rows = systray.panel_rows(_state(connect_note="Claude is connected."))
+    note = [t for k, t in rows if k == "note"][0]
+    assert note == "Claude is connected."
+
+
+def test_the_buttons_are_offered_even_while_the_vault_is_locked():
+    """Wiring an agent edits the agent's config, not the vault, so a locked
+    vault is no reason to hide it."""
+    rows = systray.panel_rows(_state(locked=True))
+    assert [t for k, t in rows if k.startswith("connect:")] == \
+        ["Claude", "Hermes", "OpenClaw"]
+
+
+@pytest.mark.parametrize("target,name", menubar.INTEGRATION_TARGETS)
+def test_each_row_carries_the_target_the_action_needs(target, name):
+    rows = systray.panel_rows(_state())
+    assert (f"connect:{target}", name) in rows

{compartment-3.3 → compartment-3.4}/tests/test_systray.py

@@ -91,7 +91,8 @@ def test_missing_vault_and_errors_are_shown_not_raised():
 def test_settings_toggles_are_exactly_the_three_the_mac_panel_has():
     from compartment import menubar
     rows = systray.panel_rows(_state())
-    keys = {k.split(":", 1)[1] for k, _ in rows if ":" in k}
+    keys = {k.split(":", 1)[1] for k, _ in rows
+            if k.startswith(("toggle:", "choice:"))}
     assert keys == set(menubar.fetch_state("/does/not/exist")["settings"])