openreflex 0.9.2__tar.gz → 0.9.3__tar.gz

{openreflex-0.9.2/src/openreflex.egg-info → openreflex-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreflex
-Version: 0.9.2
+Version: 0.9.3
 Summary: Ambient project muscle memory for AI coding agents: learns and reuses project Reflexes automatically
 Author: vishnu-77
 License-Expression: MIT

{openreflex-0.9.2 → openreflex-0.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openreflex"
-version = "0.9.2"
+version = "0.9.3"
 description = "Ambient project muscle memory for AI coding agents: learns and reuses project Reflexes automatically"
 readme = "README.md"
 license = "MIT"

{openreflex-0.9.2 → openreflex-0.9.3}/src/openreflex/__init__.py

@@ -1,3 +1,3 @@
 """Ambient, local execution intelligence."""
 
-__version__ = "0.9.2"
+__version__ = "0.9.3"

openreflex-0.9.3/src/openreflex/claude_ui.py

@@ -0,0 +1,186 @@
+"""Claude Code presentation integration.
+
+OpenReflex owns a user-level status line, never a project-level statusLine entry.
+Legacy OpenReflex project entries are migrated away without touching user-owned settings.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+LEGACY_STATUSLINE_COMMAND = "openreflex statusline"
+
+
+def statusline_command() -> str:
+    """Return the runtime-owned statusline command.
+
+    Plugin-managed runtimes pass OPENREFLEX_RUNTIME_COMMAND so the status line cannot
+    resolve an unrelated or stale global `openreflex` executable from PATH.
+    """
+    runtime = os.environ.get("OPENREFLEX_RUNTIME_COMMAND", "").strip()
+    return f"{runtime} statusline" if runtime else LEGACY_STATUSLINE_COMMAND
+
+
+def claude_settings_path() -> Path:
+    """Return Claude Code's user-level settings path.
+
+    CLAUDE_CONFIG_DIR is respected so alternate Claude profiles and isolated tests do
+    not fall back to the real user home directory.
+    """
+    configured = os.environ.get("CLAUDE_CONFIG_DIR", "").strip()
+    root = Path(configured).expanduser() if configured else Path.home() / ".claude"
+    return root / "settings.json"
+
+
+def _ours(command: object) -> bool:
+    if not isinstance(command, str):
+        return False
+    value = command.replace("\\", "/").lower()
+    return command == LEGACY_STATUSLINE_COMMAND or (
+        ".openreflex/runtime/" in value and value.rstrip().endswith(" statusline")
+    )
+
+
+def _owned_project_hook(entry: object) -> bool:
+    """True only for hook entries installed by OpenReflex into project settings."""
+    value = json.dumps(entry, default=str).replace("\\\\", "/").lower()
+    return (
+        "openreflex hook claude-code" in value
+        or ("runtime/launcher.cjs" in value and " hook claude-code " in value)
+    )
+
+
+def _load(path: Path) -> dict | None:
+    if not path.exists():
+        return {}
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def _write(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_suffix(path.suffix + ".tmp")
+    temp.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    os.replace(temp, path)
+
+
+def _remove_owned_statusline(path: Path, *, delete_empty: bool = False) -> bool:
+    data = _load(path)
+    if data is None:
+        return False
+    current = data.get("statusLine")
+    if not isinstance(current, dict) or not _ours(current.get("command")):
+        return False
+
+    data.pop("statusLine", None)
+    if delete_empty and not data:
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            pass
+        try:
+            path.parent.rmdir()
+        except OSError:
+            pass
+    else:
+        _write(path, data)
+    return True
+
+
+def remove_project_integration(project: Path) -> bool:
+    """Remove legacy OpenReflex-owned Claude project config, preserving user config.
+
+    The Claude plugin is user-scoped and must not require repository-local Claude
+    settings. Older OpenReflex releases could leave a project statusLine or hook entries
+    behind; remove only those entries and delete the file/directory when it becomes empty.
+    """
+    path = project / ".claude" / "settings.json"
+    data = _load(path)
+    if data is None or not path.exists():
+        return False
+
+    changed = False
+    current = data.get("statusLine")
+    if isinstance(current, dict) and _ours(current.get("command")):
+        data.pop("statusLine", None)
+        changed = True
+
+    hooks = data.get("hooks")
+    if isinstance(hooks, dict):
+        cleaned = {}
+        for event, entries in hooks.items():
+            if not isinstance(entries, list):
+                cleaned[event] = entries
+                continue
+            kept = [entry for entry in entries if not _owned_project_hook(entry)]
+            if kept:
+                cleaned[event] = kept
+            if len(kept) != len(entries):
+                changed = True
+        if cleaned:
+            data["hooks"] = cleaned
+        elif "hooks" in data:
+            data.pop("hooks", None)
+
+    if not changed:
+        return False
+
+    if not data:
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            pass
+        try:
+            path.parent.rmdir()
+        except OSError:
+            pass
+    else:
+        _write(path, data)
+    return True
+
+
+def remove_project_statusline(project: Path) -> bool:
+    """Backward-compatible cleanup entry point for legacy callers."""
+    return remove_project_integration(project)
+
+
+def configure_statusline(project: Path | None = None) -> str:
+    """Configure the OpenReflex status line in Claude's user settings.
+
+    A project argument is accepted because session hooks know the active project. It is
+    used only to migrate a legacy OpenReflex-owned project statusLine entry; the desired
+    status line is always written to the user scope.
+    """
+    if project is not None:
+        remove_project_integration(project)
+
+    path = claude_settings_path()
+    data = _load(path)
+    if data is None:
+        return "preserved-invalid"
+
+    existing = data.get("statusLine")
+    desired = statusline_command()
+    if isinstance(existing, dict):
+        current = existing.get("command")
+        if current == desired:
+            return "already-configured"
+        if not _ours(current):
+            return "preserved-existing"
+        data["statusLine"] = {**existing, "command": desired, "padding": 0, "refreshInterval": 2}
+        _write(path, data)
+        return "updated-runtime"
+
+    data["statusLine"] = {"type": "command", "command": desired, "padding": 0, "refreshInterval": 2}
+    _write(path, data)
+    return "configured"
+
+
+def remove_statusline() -> bool:
+    """Remove only the OpenReflex-owned user-level status line."""
+    return _remove_owned_statusline(claude_settings_path())

{openreflex-0.9.2 → openreflex-0.9.3}/src/openreflex/entrypoint.py

@@ -18,7 +18,7 @@ from pathlib import Path
 from typing import Callable, TypeVar
 
 from . import __version__, cli
-from .claude_ui import configure_statusline, remove_statusline
+from .claude_ui import configure_statusline, remove_project_integration
 from .project import approval, approve, log_error, project_root
 from .project_map import enrich_snapshot
 from .project_memory import ensure_background_refresh, load_snapshot, read_state, run_worker, update_state
@@ -564,8 +564,10 @@ def _onboard(argv: list[str]) -> int:
     print("  memory      enabled · local")
     if status == "preserved-existing":
         print("  statusline  existing user status line preserved")
+    elif status == "preserved-invalid":
+        print("  statusline  user settings unreadable; preserved unchanged")
     else:
-        print("  statusline  managed OpenReflex runtime")
+        print("  statusline  managed OpenReflex runtime · user scope")
     print("")
     print(dashboard(project))
     return 0
@@ -694,14 +696,16 @@ def _augment_install(argv: list[str], result: int) -> None:
         print(f"  statusline  OpenReflex v{__version__} enabled")
     elif status == "preserved-existing":
         print("  statusline  existing user status line preserved")
+    elif status == "preserved-invalid":
+        print("  statusline  user settings unreadable; preserved unchanged")
 
 
 def _augment_uninstall(argv: list[str], result: int) -> None:
     if result != 0 or len(argv) < 2 or argv[1] != "claude-code" or "--dry-run" in argv:
         return
     project = project_root(_project_arg(argv))
-    if remove_statusline(project):
-        print("  statusline  OpenReflex status line removed")
+    if remove_project_integration(project):
+        print("  project     legacy OpenReflex Claude config removed")
 
 
 def main(argv: list[str] | None = None) -> int:

{openreflex-0.9.2 → openreflex-0.9.3/src/openreflex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreflex
-Version: 0.9.2
+Version: 0.9.3
 Summary: Ambient project muscle memory for AI coding agents: learns and reuses project Reflexes automatically
 Author: vishnu-77
 License-Expression: MIT

{openreflex-0.9.2 → openreflex-0.9.3}/src/openreflex.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ src/openreflex.egg-info/requires.txt
 src/openreflex.egg-info/top_level.txt
 src/openreflex/integrations/opencode.ts
 src/openreflex/policies/default.toml
+tests/test_claude_ui.py
 tests/test_completion_recap_semantics.py
 tests/test_engine.py
 tests/test_execution_state.py

openreflex-0.9.3/tests/test_claude_ui.py

@@ -0,0 +1,152 @@
+import json
+
+from openreflex import __version__
+from openreflex.claude_ui import (
+    configure_statusline,
+    remove_project_integration,
+    remove_project_statusline,
+    remove_statusline,
+)
+
+
+def _user_settings(tmp_path, monkeypatch):
+    config = tmp_path / "claude-user"
+    monkeypatch.setenv("CLAUDE_CONFIG_DIR", str(config))
+    return config / "settings.json"
+
+
+def test_statusline_is_user_scoped_and_does_not_create_project_settings(tmp_path, monkeypatch):
+    settings = _user_settings(tmp_path, monkeypatch)
+    project = tmp_path / "repo"
+    project.mkdir()
+    runtime = tmp_path / ".openreflex" / "runtime" / f"v{__version__}" / "bin" / "openreflex"
+    monkeypatch.setenv("OPENREFLEX_RUNTIME_COMMAND", f'"{runtime}"')
+
+    assert configure_statusline(project) == "configured"
+
+    data = json.loads(settings.read_text(encoding="utf-8"))
+    assert data["statusLine"]["command"].endswith(" statusline")
+    assert f"/runtime/v{__version__}/" in data["statusLine"]["command"].replace("\\", "/")
+    assert not (project / ".claude" / "settings.json").exists()
+
+
+def test_configure_migrates_legacy_project_statusline_without_touching_other_settings(tmp_path, monkeypatch):
+    user_settings = _user_settings(tmp_path, monkeypatch)
+    project = tmp_path / "repo"
+    project_settings = project / ".claude" / "settings.json"
+    project_settings.parent.mkdir(parents=True)
+    project_settings.write_text(json.dumps({
+        "permissions": {"allow": ["Bash(git status)"]},
+        "statusLine": {"type": "command", "command": "openreflex statusline"},
+    }), encoding="utf-8")
+
+    assert configure_statusline(project) == "configured"
+
+    migrated = json.loads(project_settings.read_text(encoding="utf-8"))
+    assert migrated == {"permissions": {"allow": ["Bash(git status)"]}}
+    assert "statusLine" in json.loads(user_settings.read_text(encoding="utf-8"))
+
+
+def test_configure_removes_statusline_only_project_file_entirely(tmp_path, monkeypatch):
+    _user_settings(tmp_path, monkeypatch)
+    project = tmp_path / "repo"
+    project_settings = project / ".claude" / "settings.json"
+    project_settings.parent.mkdir(parents=True)
+    project_settings.write_text(json.dumps({
+        "statusLine": {"type": "command", "command": "openreflex statusline"},
+    }), encoding="utf-8")
+
+    configure_statusline(project)
+
+    assert not project_settings.exists()
+    assert not project_settings.parent.exists()
+
+
+def test_existing_user_statusline_is_preserved(tmp_path, monkeypatch):
+    settings = _user_settings(tmp_path, monkeypatch)
+    settings.parent.mkdir(parents=True)
+    original = {
+        "theme": "dark",
+        "statusLine": {"type": "command", "command": "~/.claude/my-statusline.sh", "padding": 1},
+    }
+    settings.write_text(json.dumps(original), encoding="utf-8")
+
+    assert configure_statusline(tmp_path / "repo") == "preserved-existing"
+    assert json.loads(settings.read_text(encoding="utf-8")) == original
+
+
+def test_invalid_user_settings_are_never_overwritten(tmp_path, monkeypatch):
+    settings = _user_settings(tmp_path, monkeypatch)
+    settings.parent.mkdir(parents=True)
+    settings.write_text("{broken", encoding="utf-8")
+
+    assert configure_statusline(tmp_path / "repo") == "preserved-invalid"
+    assert settings.read_text(encoding="utf-8") == "{broken"
+
+
+def test_project_cleanup_never_removes_user_statusline(tmp_path, monkeypatch):
+    settings = _user_settings(tmp_path, monkeypatch)
+    settings.parent.mkdir(parents=True)
+    settings.write_text(json.dumps({
+        "statusLine": {"type": "command", "command": "openreflex statusline"},
+    }), encoding="utf-8")
+
+    project = tmp_path / "repo"
+    project_settings = project / ".claude" / "settings.json"
+    project_settings.parent.mkdir(parents=True)
+    project_settings.write_text(json.dumps({
+        "statusLine": {"type": "command", "command": "openreflex statusline"},
+    }), encoding="utf-8")
+
+    assert remove_project_statusline(project) is True
+    assert not project_settings.exists()
+    assert settings.exists()
+    assert remove_statusline() is True
+    assert json.loads(settings.read_text(encoding="utf-8")) == {}
+
+
+def test_project_cleanup_removes_legacy_openreflex_hooks_and_preserves_user_hooks(tmp_path, monkeypatch):
+    _user_settings(tmp_path, monkeypatch)
+    project = tmp_path / "repo"
+    project_settings = project / ".claude" / "settings.json"
+    project_settings.parent.mkdir(parents=True)
+    user_hook = {"hooks": [{"type": "command", "command": "echo user-owned"}]}
+    openreflex_hook = {
+        "hooks": [{
+            "type": "command",
+            "command": 'openreflex hook claude-code Stop --plugin-root "${CLAUDE_PLUGIN_ROOT}"',
+            "timeout": 15,
+        }]
+    }
+    project_settings.write_text(json.dumps({
+        "permissions": {"allow": ["Bash(git status)"]},
+        "hooks": {"Stop": [user_hook, openreflex_hook]},
+    }), encoding="utf-8")
+
+    assert remove_project_integration(project) is True
+
+    data = json.loads(project_settings.read_text(encoding="utf-8"))
+    assert data["permissions"] == {"allow": ["Bash(git status)"]}
+    assert data["hooks"]["Stop"] == [user_hook]
+
+
+def test_project_cleanup_deletes_openreflex_only_hook_file(tmp_path, monkeypatch):
+    _user_settings(tmp_path, monkeypatch)
+    project = tmp_path / "repo"
+    project_settings = project / ".claude" / "settings.json"
+    project_settings.parent.mkdir(parents=True)
+    project_settings.write_text(json.dumps({
+        "hooks": {
+            "SessionStart": [{
+                "hooks": [{
+                    "type": "command",
+                    "command": 'openreflex hook claude-code SessionStart --plugin-root "${CLAUDE_PLUGIN_ROOT}"',
+                    "timeout": 10,
+                }]
+            }]
+        }
+    }), encoding="utf-8")
+
+    assert remove_project_integration(project) is True
+    assert not project_settings.exists()
+    assert not project_settings.parent.exists()

{openreflex-0.9.2 → openreflex-0.9.3}/tests/test_tui_memory.py

@@ -2,7 +2,7 @@ import io
 import json
 
 from openreflex import __version__, entrypoint
-from openreflex.claude_ui import configure_statusline, remove_statusline
+from openreflex.claude_ui import claude_settings_path, configure_statusline, remove_statusline
 from openreflex.entrypoint import (
     _prompt_state,
     _record_hook_runtime,
@@ -202,20 +202,19 @@ def test_dashboard_is_readable_without_colour(project):
 
 
 def test_claude_statusline_is_added_only_when_user_has_none(project):
-    settings = project / ".claude" / "settings.json"
-    settings.parent.mkdir(parents=True)
-    settings.write_text('{"hooks": {}}\n', encoding="utf-8")
+    settings = claude_settings_path()
 
     assert configure_statusline(project) == "configured"
     data = json.loads(settings.read_text(encoding="utf-8"))
     assert data["statusLine"]["command"] == "openreflex statusline"
     assert data["statusLine"]["refreshInterval"] == 2
-    assert remove_statusline(project) is True
+    assert not (project / ".claude" / "settings.json").exists()
+    assert remove_statusline() is True
     assert "statusLine" not in json.loads(settings.read_text(encoding="utf-8"))
 
 
 def test_managed_statusline_replaces_only_openreflex_owned_runtime(monkeypatch, project):
-    settings = project / ".claude" / "settings.json"
+    settings = claude_settings_path()
     settings.parent.mkdir(parents=True)
     settings.write_text(json.dumps({
         "statusLine": {"type": "command", "command": "openreflex statusline", "refreshInterval": 2}
@@ -227,7 +226,8 @@ def test_managed_statusline_replaces_only_openreflex_owned_runtime(monkeypatch,
     assert configure_statusline(project) == "updated-runtime"
     current = json.loads(settings.read_text(encoding="utf-8"))["statusLine"]["command"]
     assert current == managed + " statusline"
-    assert remove_statusline(project) is True
+    assert not (project / ".claude" / "settings.json").exists()
+    assert remove_statusline() is True
 
 
 def test_onboard_enables_project_and_uses_plugin_managed_runtime(monkeypatch, project, tmp_path, capsys):
@@ -246,8 +246,9 @@ def test_onboard_enables_project_and_uses_plugin_managed_runtime(monkeypatch, pr
     assert state["runtime_source"] == "plugin-managed"
     assert state["hook_runtime_version"] == __version__
     assert state["plugin_version"] == __version__
-    settings = json.loads((project / ".claude" / "settings.json").read_text(encoding="utf-8"))
+    settings = json.loads(claude_settings_path().read_text(encoding="utf-8"))
     assert settings["statusLine"]["command"] == managed + " statusline"
+    assert not (project / ".claude" / "settings.json").exists()
     output = capsys.readouterr().out
     assert "OPENREFLEX / READY" in output
     assert "project memory   enabled" in output
@@ -255,15 +256,14 @@ def test_onboard_enables_project_and_uses_plugin_managed_runtime(monkeypatch, pr
 
 
 def test_existing_user_statusline_is_never_replaced_or_removed(project):
-    settings = project / ".claude" / "settings.json"
+    settings = claude_settings_path()
     settings.parent.mkdir(parents=True)
     original = {"statusLine": {"type": "command", "command": "~/my-status.sh"}, "hooks": {}}
     settings.write_text(json.dumps(original), encoding="utf-8")
 
     assert configure_statusline(project) == "preserved-existing"
     assert json.loads(settings.read_text(encoding="utf-8"))["statusLine"] == original["statusLine"]
-    assert remove_statusline(project) is False
-
+    assert remove_statusline() is False
 
 def test_tui_survives_a_non_utf8_console(monkeypatch, project):
     """The dashboard's OpenReflex glyph (U+21BA) must not crash on a legacy Windows console codepage."""

openreflex-0.9.2/src/openreflex/claude_ui.py

@@ -1,77 +0,0 @@
-"""Claude Code presentation integration.
-
-OpenReflex only installs its status line when the project has no existing custom
-statusLine. A user-owned status line is never replaced.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-
-LEGACY_STATUSLINE_COMMAND = "openreflex statusline"
-
-
-def statusline_command() -> str:
-    """Return the runtime-owned statusline command.
-
-    Plugin-managed runtimes pass OPENREFLEX_RUNTIME_COMMAND so the status line cannot
-    resolve an unrelated or stale global `openreflex` executable from PATH.
-    """
-    runtime = os.environ.get("OPENREFLEX_RUNTIME_COMMAND", "").strip()
-    return f"{runtime} statusline" if runtime else LEGACY_STATUSLINE_COMMAND
-
-
-def _ours(command: object) -> bool:
-    if not isinstance(command, str):
-        return False
-    value = command.replace("\\", "/").lower()
-    return command == LEGACY_STATUSLINE_COMMAND or (
-        ".openreflex/runtime/" in value and value.rstrip().endswith(" statusline")
-    )
-
-
-def _load(path: Path) -> dict:
-    try:
-        value = json.loads(path.read_text(encoding="utf-8"))
-        return value if isinstance(value, dict) else {}
-    except (OSError, ValueError):
-        return {}
-
-
-def _write(path: Path, data: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temp = path.with_suffix(path.suffix + ".tmp")
-    temp.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
-    os.replace(temp, path)
-
-
-def configure_statusline(project: Path) -> str:
-    path = project / ".claude" / "settings.json"
-    data = _load(path)
-    existing = data.get("statusLine")
-    desired = statusline_command()
-    if isinstance(existing, dict):
-        current = existing.get("command")
-        if current == desired:
-            return "already-configured"
-        if not _ours(current):
-            return "preserved-existing"
-        data["statusLine"] = {**existing, "command": desired, "padding": 0, "refreshInterval": 2}
-        _write(path, data)
-        return "updated-runtime"
-    data["statusLine"] = {"type": "command", "command": desired, "padding": 0, "refreshInterval": 2}
-    _write(path, data)
-    return "configured"
-
-
-def remove_statusline(project: Path) -> bool:
-    path = project / ".claude" / "settings.json"
-    data = _load(path)
-    current = data.get("statusLine")
-    if not isinstance(current, dict) or not _ours(current.get("command")):
-        return False
-    data.pop("statusLine", None)
-    _write(path, data)
-    return True