sibyl-memory-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{sibyl_memory_cli-0.1.2 → sibyl_memory_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT
@@ -18,8 +18,9 @@ Classifier: Environment :: Console
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: sibyl-memory-client>=0.3.3
-Requires-Dist: sibyl-memory-hermes>=0.3.1
+Requires-Dist: sibyl-memory-client>=0.4.0
+Requires-Dist: sibyl-memory-hermes>=0.3.2
+Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 

{sibyl_memory_cli-0.1.2 → sibyl_memory_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sibyl-memory-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats."
 authors = [{ name = "SIBYL, Sibyl Labs LLC", email = "sibyl@sibyllabs.org" }]
 license = { text = "MIT" }
@@ -23,8 +23,9 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 dependencies = [
-  "sibyl-memory-client>=0.3.3",
-  "sibyl-memory-hermes>=0.3.1",
+  "sibyl-memory-client>=0.4.0",
+  "sibyl-memory-hermes>=0.3.2",
+  "pyyaml>=6.0",
 ]
 
 [project.optional-dependencies]

{sibyl_memory_cli-0.1.2 → sibyl_memory_cli-0.1.4}/src/sibyl_memory_cli/cli.py

@@ -629,6 +629,38 @@ def build_parser() -> argparse.ArgumentParser:
     p_h = sub.add_parser("health", help="Run the provider self-check")
     p_h.set_defaults(func=cmd_health)
 
+    # v0.1.4: one-command auto-detect-and-wire setup for any agent stack
+    from .setup import cmd_setup
+    p_setup = sub.add_parser(
+        "setup",
+        help="Auto-detect Hermes / Claude Code and wire SIBYL as the memory provider",
+    )
+    p_setup.add_argument(
+        "target", nargs="?", choices=list(["hermes", "claude-code"]),
+        help="Wire just this framework (default: detect all)",
+    )
+    p_setup.add_argument(
+        "--yes", "-y", action="store_true",
+        help="Skip prompts, accept defaults (still respects destructive-default-NO unless --force)",
+    )
+    p_setup.add_argument(
+        "--force", action="store_true",
+        help="Overwrite existing non-SIBYL memory provider configs",
+    )
+    p_setup.add_argument(
+        "--dry-run", action="store_true",
+        help="Print what would change without writing",
+    )
+    p_setup.add_argument(
+        "--hermes-home", default=None,
+        help="Override HERMES_HOME autodetection",
+    )
+    p_setup.add_argument(
+        "--claude-settings", default=None,
+        help="Override ~/.claude/settings.json autodetection",
+    )
+    p_setup.set_defaults(func=cmd_setup)
+
     return p
 
 

sibyl_memory_cli-0.1.4/src/sibyl_memory_cli/setup.py

@@ -0,0 +1,493 @@
+"""`sibyl setup`: auto-detect agent frameworks and wire SIBYL as memory provider.
+
+Maximum-efficiency onboarding command. Single-command path for the user:
+
+    pip install sibyl-memory-cli
+    sibyl setup          # auto-detects Hermes + Claude Code, prompts per stack, wires
+
+Two wirers in v0.1.4:
+  - HermesWirer:     install-plugin + edit $HERMES_HOME/config.yaml (memory.provider)
+  - ClaudeCodeWirer: edit ~/.claude/settings.json (mcpServers.sibyl-memory)
+
+Each wirer follows the same protocol:
+  is_present()       -> bool          (filesystem + PATH detect)
+  current_state()    -> dict          (configured? wired-with-sibyl? current-value?)
+  wire(force, dry_run, prompt_fn) -> WireOutcome
+
+Destructive operations (overwriting an existing non-SIBYL config) default to NO
+on the prompt. Fresh adds default to YES. --force overrides destructive guards.
+--yes accepts all defaults (still respects the destructive-default-NO unless
+--force is also passed). --dry-run prints intent without writing.
+
+All config edits are atomic: backup to <file>.bak, write to <file>.tmp, rename.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Optional, Union
+
+# Color helpers re-imported from cli module via late binding to avoid circular dep.
+# When called via `sibyl setup` they resolve through the cli module's tty detection.
+def _color_fns():
+    from .cli import bold, cyan, dim, green, red, yellow
+    return bold, cyan, dim, green, red, yellow
+
+
+# ----------------------------------------------------------------------
+# WireOutcome
+# ----------------------------------------------------------------------
+
+@dataclass
+class WireOutcome:
+    """Result of a wirer.wire() call. Composable across multiple wirers."""
+    name: str
+    status: str          # 'wired' / 'already' / 'skipped' / 'dry-run' / 'error'
+    message: str
+    backup_path: Optional[Path] = None
+
+
+# ----------------------------------------------------------------------
+# Lazy YAML import. Hermes wirer needs it; Claude-only users do not.
+# ----------------------------------------------------------------------
+
+def _import_yaml():
+    try:
+        import yaml
+        return yaml
+    except ImportError:
+        return None
+
+
+# ----------------------------------------------------------------------
+# HermesWirer
+# ----------------------------------------------------------------------
+
+class HermesWirer:
+    name = "hermes"
+    display_name = "Hermes"
+    initial = "h"
+
+    def __init__(self, *, hermes_home: Optional[Union[str, Path]] = None):
+        self.hermes_home = (
+            Path(hermes_home).expanduser() if hermes_home
+            else self._auto_hermes_home()
+        )
+        self.config_path = self.hermes_home / "config.yaml"
+        self.plugin_dir = self.hermes_home / "plugins" / "sibyl"
+
+    @staticmethod
+    def _auto_hermes_home() -> Path:
+        env = os.environ.get("HERMES_HOME")
+        if env:
+            return Path(env).expanduser()
+        return Path.home() / ".hermes"
+
+    def is_present(self) -> bool:
+        # Present if HERMES_HOME exists OR `hermes` binary on PATH
+        if self.hermes_home.exists():
+            return True
+        if shutil.which("hermes"):
+            return True
+        return False
+
+    def current_state(self) -> dict:
+        config_exists = self.config_path.exists()
+        plugin_installed = (self.plugin_dir / "__init__.py").exists()
+        memory_provider: Optional[str] = None
+        if config_exists:
+            yaml = _import_yaml()
+            if yaml is not None:
+                try:
+                    raw = self.config_path.read_text(encoding="utf-8")
+                    cfg = yaml.safe_load(raw) or {}
+                    if isinstance(cfg, dict):
+                        mem = cfg.get("memory")
+                        if isinstance(mem, dict):
+                            memory_provider = mem.get("provider")
+                except Exception:
+                    pass
+        return {
+            "hermes_home": str(self.hermes_home),
+            "config_path": str(self.config_path),
+            "config_exists": config_exists,
+            "plugin_installed": plugin_installed,
+            "memory_provider": memory_provider,
+            "wired_with_sibyl": memory_provider == "sibyl",
+        }
+
+    def wire(self, *, force: bool = False, dry_run: bool = False,
+             prompt_fn: Optional[Callable[..., str]] = None) -> WireOutcome:
+        state = self.current_state()
+        yaml = _import_yaml()
+        if yaml is None:
+            return WireOutcome(
+                self.name, "error",
+                "PyYAML not installed. Run `pip install pyyaml` and retry.",
+            )
+
+        # 1. Install plugin if missing
+        if not state["plugin_installed"]:
+            if dry_run:
+                pass  # report at the end
+            else:
+                try:
+                    self._install_plugin()
+                except Exception as e:
+                    return WireOutcome(
+                        self.name, "error",
+                        f"install-plugin failed: {type(e).__name__}: {e}",
+                    )
+
+        # 2. Already wired? no-op
+        if state["wired_with_sibyl"] and state["plugin_installed"]:
+            return WireOutcome(
+                self.name, "already",
+                f"Hermes already has SIBYL as memory provider in {self.config_path}",
+            )
+
+        # 3. Existing non-SIBYL provider? confirm or refuse
+        if state["memory_provider"] and state["memory_provider"] != "sibyl" and not force:
+            if prompt_fn is None:
+                return WireOutcome(
+                    self.name, "skipped",
+                    f"Existing memory.provider '{state['memory_provider']}'. Use --force to overwrite.",
+                )
+            ans = prompt_fn(
+                f"Hermes currently uses '{state['memory_provider']}' as memory provider. Overwrite with SIBYL?",
+                default="N",
+            )
+            if ans != "y":
+                return WireOutcome(self.name, "skipped", "Memory provider overwrite declined.")
+
+        # 4. Dry-run report
+        if dry_run:
+            actions = []
+            if not state["plugin_installed"]:
+                actions.append(f"install plugin at {self.plugin_dir}")
+            actions.append(f"set memory.provider=sibyl in {self.config_path}")
+            return WireOutcome(self.name, "dry-run", "Would: " + "; ".join(actions))
+
+        # 5. Real write. Backup, then atomic rename.
+        backup = self._backup_config()
+        try:
+            self._write_config_with_sibyl(yaml)
+        except Exception as e:
+            return WireOutcome(
+                self.name, "error",
+                f"config write failed: {type(e).__name__}: {e}",
+                backup_path=backup,
+            )
+        return WireOutcome(
+            self.name, "wired",
+            f"Wired memory.provider=sibyl in {self.config_path}",
+            backup_path=backup,
+        )
+
+    def _install_plugin(self) -> None:
+        from sibyl_memory_hermes.install_plugin import install
+        install(hermes_home=str(self.hermes_home))
+
+    def _backup_config(self) -> Optional[Path]:
+        if not self.config_path.exists():
+            return None
+        backup = self.config_path.with_suffix(".yaml.bak")
+        shutil.copy2(self.config_path, backup)
+        return backup
+
+    def _write_config_with_sibyl(self, yaml) -> None:
+        cfg: dict = {}
+        if self.config_path.exists():
+            raw = self.config_path.read_text(encoding="utf-8")
+            loaded = yaml.safe_load(raw)
+            if isinstance(loaded, dict):
+                cfg = loaded
+        if not isinstance(cfg.get("memory"), dict):
+            cfg["memory"] = {}
+        cfg["memory"]["provider"] = "sibyl"
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.config_path.with_suffix(".yaml.tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            yaml.safe_dump(cfg, f, sort_keys=False, default_flow_style=False)
+        os.replace(tmp, self.config_path)
+
+
+# ----------------------------------------------------------------------
+# ClaudeCodeWirer
+# ----------------------------------------------------------------------
+
+class ClaudeCodeWirer:
+    name = "claude-code"
+    display_name = "Claude Code"
+    initial = "c"
+
+    SIBYL_MCP_BLOCK = {"command": "sibyl-memory-mcp"}
+
+    def __init__(self, *, settings_path: Optional[Union[str, Path]] = None):
+        self.settings_path = (
+            Path(settings_path).expanduser() if settings_path
+            else Path.home() / ".claude" / "settings.json"
+        )
+
+    def is_present(self) -> bool:
+        if self.settings_path.exists():
+            return True
+        if shutil.which("claude"):
+            return True
+        return False
+
+    def current_state(self) -> dict:
+        settings_exists = self.settings_path.exists()
+        mcp_servers: dict = {}
+        sibyl_block: Optional[dict] = None
+        if settings_exists:
+            try:
+                cfg = json.loads(self.settings_path.read_text(encoding="utf-8"))
+                if isinstance(cfg, dict):
+                    raw_servers = cfg.get("mcpServers", {})
+                    if isinstance(raw_servers, dict):
+                        mcp_servers = raw_servers
+                        sibyl_block = mcp_servers.get("sibyl-memory")
+            except Exception:
+                pass
+        return {
+            "settings_path": str(self.settings_path),
+            "settings_exists": settings_exists,
+            "mcp_servers_count": len(mcp_servers),
+            "sibyl_mcp": sibyl_block,
+            "wired_with_sibyl": sibyl_block == self.SIBYL_MCP_BLOCK,
+        }
+
+    def wire(self, *, force: bool = False, dry_run: bool = False,
+             prompt_fn: Optional[Callable[..., str]] = None) -> WireOutcome:
+        state = self.current_state()
+
+        if state["wired_with_sibyl"]:
+            return WireOutcome(
+                self.name, "already",
+                f"Claude Code already has SIBYL Memory MCP server in {self.settings_path}",
+            )
+
+        if state["sibyl_mcp"] and not force:
+            if prompt_fn is None:
+                return WireOutcome(
+                    self.name, "skipped",
+                    "Existing sibyl-memory MCP entry differs. Use --force to overwrite.",
+                )
+            ans = prompt_fn(
+                "Claude Code has 'sibyl-memory' MCP entry but pointing elsewhere. Update?",
+                default="N",
+            )
+            if ans != "y":
+                return WireOutcome(self.name, "skipped", "MCP entry update declined.")
+
+        if dry_run:
+            verb = "update" if state["sibyl_mcp"] else "add"
+            return WireOutcome(
+                self.name, "dry-run",
+                f"Would {verb} mcpServers.sibyl-memory in {self.settings_path}",
+            )
+
+        backup = self._backup_settings()
+        try:
+            self._write_settings_with_sibyl()
+        except Exception as e:
+            return WireOutcome(
+                self.name, "error",
+                f"settings write failed: {type(e).__name__}: {e}",
+                backup_path=backup,
+            )
+        return WireOutcome(
+            self.name, "wired",
+            f"Added SIBYL Memory MCP server to {self.settings_path}",
+            backup_path=backup,
+        )
+
+    def _backup_settings(self) -> Optional[Path]:
+        if not self.settings_path.exists():
+            return None
+        backup = self.settings_path.with_suffix(".json.bak")
+        shutil.copy2(self.settings_path, backup)
+        return backup
+
+    def _write_settings_with_sibyl(self) -> None:
+        cfg: dict = {}
+        if self.settings_path.exists():
+            try:
+                loaded = json.loads(self.settings_path.read_text(encoding="utf-8"))
+                if isinstance(loaded, dict):
+                    cfg = loaded
+            except Exception:
+                cfg = {}
+        if not isinstance(cfg.get("mcpServers"), dict):
+            cfg["mcpServers"] = {}
+        cfg["mcpServers"]["sibyl-memory"] = self.SIBYL_MCP_BLOCK
+        self.settings_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.settings_path.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(cfg, indent=2) + "\n", encoding="utf-8")
+        os.replace(tmp, self.settings_path)
+
+
+# ----------------------------------------------------------------------
+# Registry + dispatch
+# ----------------------------------------------------------------------
+
+ALL_WIRERS: dict = {
+    "hermes": HermesWirer,
+    "claude-code": ClaudeCodeWirer,
+}
+
+
+def _interactive_prompt(question: str, *, default: str = "Y") -> str:
+    """Yes/no prompt. default 'Y' or 'N'. Returns 'y' or 'n'."""
+    default_label = "[Y/n]" if default.upper() == "Y" else "[y/N]"
+    try:
+        ans = input(f"{question} {default_label}: ").strip()
+    except EOFError:
+        return default.lower()
+    if not ans:
+        return default.lower()
+    return "y" if ans[:1].lower() == "y" else "n"
+
+
+def _accept_defaults_prompt(question: str, *, default: str = "Y") -> str:
+    """Non-interactive prompt. Returns the default. Used with --yes."""
+    return default.lower()
+
+
+def _wirer_kwargs(args: argparse.Namespace, name: str) -> dict:
+    kw: dict = {}
+    if name == "hermes" and getattr(args, "hermes_home", None):
+        kw["hermes_home"] = args.hermes_home
+    if name == "claude-code" and getattr(args, "claude_settings", None):
+        kw["settings_path"] = args.claude_settings
+    return kw
+
+
+def cmd_setup(args: argparse.Namespace) -> int:
+    """`sibyl setup` entry point. Auto-detect, then wire."""
+    bold, cyan, dim, green, red, yellow = _color_fns()
+
+    # Resolve target wirers
+    target = getattr(args, "target", None)
+    if target:
+        if target not in ALL_WIRERS:
+            print(red(f"Unknown setup target: {target}"))
+            print(f"Available: {', '.join(ALL_WIRERS)}")
+            return 1
+        wirers: dict = {target: ALL_WIRERS[target](**_wirer_kwargs(args, target))}
+        skip_present_check = True   # explicit target = wire it even if not detected on PATH
+    else:
+        wirers = {name: cls(**_wirer_kwargs(args, name)) for name, cls in ALL_WIRERS.items()}
+        skip_present_check = False
+
+    print()
+    print(bold("Sibyl Memory Plugin setup"))
+    print()
+
+    # Detection
+    if skip_present_check:
+        detected = wirers
+    else:
+        detected = {n: w for n, w in wirers.items() if w.is_present()}
+
+    if not detected:
+        print(yellow("No agent frameworks detected on this machine."))
+        print()
+        print(dim("Looked for:"))
+        for name, w in wirers.items():
+            st = w.current_state()
+            loc = st.get("hermes_home") or st.get("settings_path")
+            print(f"  {w.display_name}: {loc}")
+        print()
+        print(dim("To override detection, point setup at a custom path:"))
+        print(f"  {cyan('sibyl setup --hermes-home /custom/path')}")
+        print(f"  {cyan('sibyl setup --claude-settings /custom/settings.json')}")
+        print()
+        return 0
+
+    # Detection summary
+    print(dim("Detected:"))
+    for name, w in detected.items():
+        st = w.current_state()
+        loc = st.get("hermes_home") or st.get("settings_path")
+        print(f"  {w.display_name} at {loc}")
+    print()
+
+    # Multi-framework picker
+    selected = list(detected.keys())
+    if len(detected) > 1 and not args.yes:
+        choices = ", ".join(f"[{w.initial}]{w.display_name}" for w in detected.values())
+        ans = input(
+            f"Wire which? {choices}, [a]ll, [n]one (default: all): "
+        ).strip().lower()
+        if ans in ("n", "none"):
+            print(dim("Skipping all."))
+            print()
+            return 0
+        elif ans in ("", "a", "all"):
+            pass
+        else:
+            picked = [n for n, w in detected.items() if w.initial == ans[:1]]
+            if not picked:
+                print(red(f"No match for '{ans}'. Aborting."))
+                return 1
+            selected = picked
+
+    # Per-stack execution
+    outcomes: list = []
+    prompt_fn = _accept_defaults_prompt if args.yes else _interactive_prompt
+
+    for name in selected:
+        wirer = detected[name]
+        st = wirer.current_state()
+
+        # Pre-prompt for fresh adds (interactive only). Already-wired and
+        # existing-other-provider are handled inside wire() itself.
+        if (
+            not args.yes
+            and not st.get("wired_with_sibyl")
+            and not st.get("memory_provider")
+            and not st.get("sibyl_mcp")
+        ):
+            if name == "hermes":
+                q = f"Set SIBYL as default memory provider in {wirer.display_name}?"
+            else:
+                q = f"Add SIBYL Memory as an MCP server in {wirer.display_name}?"
+            ans = _interactive_prompt(q, default="Y")
+            if ans != "y":
+                outcomes.append(WireOutcome(name, "skipped", "Declined by user."))
+                continue
+
+        outcomes.append(
+            wirer.wire(force=args.force, dry_run=args.dry_run, prompt_fn=prompt_fn)
+        )
+
+    # Report
+    print()
+    any_wired = False
+    for o in outcomes:
+        marker = {
+            "wired": green("✓"),
+            "already": green("·"),
+            "skipped": yellow("·"),
+            "dry-run": cyan("→"),
+            "error": red("✗"),
+        }.get(o.status, "?")
+        print(f"  {marker} {o.name}: {o.message}")
+        if o.backup_path:
+            print(f"      {dim('backup at')} {o.backup_path}")
+        if o.status == "wired":
+            any_wired = True
+    print()
+
+    if any_wired:
+        print(green("Restart your agent(s) to load the new memory provider."))
+        print()
+
+    return 0 if all(o.status != "error" for o in outcomes) else 2

{sibyl_memory_cli-0.1.2 → sibyl_memory_cli-0.1.4}/src/sibyl_memory_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT
@@ -18,8 +18,9 @@ Classifier: Environment :: Console
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: sibyl-memory-client>=0.3.3
-Requires-Dist: sibyl-memory-hermes>=0.3.1
+Requires-Dist: sibyl-memory-client>=0.4.0
+Requires-Dist: sibyl-memory-hermes>=0.3.2
+Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 

{sibyl_memory_cli-0.1.2 → sibyl_memory_cli-0.1.4}/src/sibyl_memory_cli.egg-info/SOURCES.txt

@@ -3,9 +3,11 @@ pyproject.toml
 src/sibyl_memory_cli/__init__.py
 src/sibyl_memory_cli/_banner.py
 src/sibyl_memory_cli/cli.py
+src/sibyl_memory_cli/setup.py
 src/sibyl_memory_cli.egg-info/PKG-INFO
 src/sibyl_memory_cli.egg-info/SOURCES.txt
 src/sibyl_memory_cli.egg-info/dependency_links.txt
 src/sibyl_memory_cli.egg-info/entry_points.txt
 src/sibyl_memory_cli.egg-info/requires.txt
-src/sibyl_memory_cli.egg-info/top_level.txt
+src/sibyl_memory_cli.egg-info/top_level.txt
+tests/test_setup.py

sibyl_memory_cli-0.1.4/src/sibyl_memory_cli.egg-info/requires.txt

@@ -0,0 +1,6 @@
+sibyl-memory-client>=0.4.0
+sibyl-memory-hermes>=0.3.2
+pyyaml>=6.0
+
+[dev]
+pytest>=7.0

sibyl_memory_cli-0.1.4/tests/test_setup.py

@@ -0,0 +1,381 @@
+"""Tests for the v0.1.4 `sibyl setup` command.
+
+Covers:
+- Hermes wirer: fresh, existing-no-memory, existing-sibyl, existing-other-provider,
+  force-overwrite, dry-run, plugin-install side-effect.
+- Claude Code wirer: fresh-no-file, fresh-with-other-mcps, existing-sibyl,
+  existing-sibyl-mismatch, force-overwrite, dry-run.
+- Detection: is_present logic for both wirers.
+- Outcomes: WireOutcome status field correctness.
+- Atomic writes + backup files land at the expected paths.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from sibyl_memory_cli.setup import (  # noqa: E402
+    ALL_WIRERS,
+    ClaudeCodeWirer,
+    HermesWirer,
+    WireOutcome,
+    _accept_defaults_prompt,
+    _interactive_prompt,
+)
+
+
+# ----------------------------------------------------------------------
+# Helpers
+# ----------------------------------------------------------------------
+
+def _stub_install_plugin(hermes_home: str):
+    """Replacement for sibyl_memory_hermes.install_plugin.install — drops a fake
+    adapter file so the wirer sees plugin_installed=True afterwards."""
+    plugin_dir = Path(hermes_home) / "plugins" / "sibyl"
+    plugin_dir.mkdir(parents=True, exist_ok=True)
+    (plugin_dir / "__init__.py").write_text("# stub plugin\n")
+
+
+# ----------------------------------------------------------------------
+# WireOutcome basics
+# ----------------------------------------------------------------------
+
+def test_outcome_dataclass_basic():
+    o = WireOutcome("hermes", "wired", "test")
+    assert o.name == "hermes" and o.status == "wired" and o.backup_path is None
+    o2 = WireOutcome("claude-code", "skipped", "no", backup_path=Path("/tmp/x.bak"))
+    assert o2.backup_path == Path("/tmp/x.bak")
+
+
+# ----------------------------------------------------------------------
+# Prompt helpers
+# ----------------------------------------------------------------------
+
+def test_interactive_prompt_default_y_empty_input(monkeypatch):
+    monkeypatch.setattr("builtins.input", lambda _: "")
+    assert _interactive_prompt("Q?", default="Y") == "y"
+
+
+def test_interactive_prompt_default_n_empty_input(monkeypatch):
+    monkeypatch.setattr("builtins.input", lambda _: "")
+    assert _interactive_prompt("Q?", default="N") == "n"
+
+
+def test_interactive_prompt_explicit_y(monkeypatch):
+    monkeypatch.setattr("builtins.input", lambda _: "y")
+    assert _interactive_prompt("Q?", default="N") == "y"
+
+
+def test_interactive_prompt_explicit_n(monkeypatch):
+    monkeypatch.setattr("builtins.input", lambda _: "no")
+    assert _interactive_prompt("Q?", default="Y") == "n"
+
+
+def test_accept_defaults_prompt_returns_default():
+    assert _accept_defaults_prompt("Q?", default="Y") == "y"
+    assert _accept_defaults_prompt("Q?", default="N") == "n"
+
+
+# ----------------------------------------------------------------------
+# HermesWirer
+# ----------------------------------------------------------------------
+
+def test_hermes_wirer_auto_home_env(monkeypatch, tmp_path):
+    monkeypatch.setenv("HERMES_HOME", str(tmp_path / "custom-hermes"))
+    w = HermesWirer()
+    assert w.hermes_home == tmp_path / "custom-hermes"
+
+
+def test_hermes_wirer_auto_home_default(monkeypatch):
+    monkeypatch.delenv("HERMES_HOME", raising=False)
+    w = HermesWirer()
+    assert w.hermes_home == Path.home() / ".hermes"
+
+
+def test_hermes_is_present_false_when_no_dir_no_bin(monkeypatch, tmp_path):
+    monkeypatch.delenv("HERMES_HOME", raising=False)
+    w = HermesWirer(hermes_home=tmp_path / "nope")
+    with patch("sibyl_memory_cli.setup.shutil.which", return_value=None):
+        assert not w.is_present()
+
+
+def test_hermes_is_present_true_when_dir_exists(tmp_path):
+    (tmp_path / "hermes-home").mkdir()
+    w = HermesWirer(hermes_home=tmp_path / "hermes-home")
+    assert w.is_present()
+
+
+def test_hermes_state_fresh(tmp_path):
+    w = HermesWirer(hermes_home=tmp_path / "hermes-home")
+    st = w.current_state()
+    assert st["config_exists"] is False
+    assert st["plugin_installed"] is False
+    assert st["memory_provider"] is None
+    assert st["wired_with_sibyl"] is False
+
+
+def test_hermes_state_existing_sibyl(tmp_path):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    (home / "config.yaml").write_text("memory:\n  provider: sibyl\n")
+    w = HermesWirer(hermes_home=home)
+    st = w.current_state()
+    assert st["memory_provider"] == "sibyl"
+    assert st["wired_with_sibyl"] is True
+
+
+def test_hermes_state_existing_other_provider(tmp_path):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    (home / "config.yaml").write_text("memory:\n  provider: mem0\nother: thing\n")
+    w = HermesWirer(hermes_home=home)
+    st = w.current_state()
+    assert st["memory_provider"] == "mem0"
+    assert st["wired_with_sibyl"] is False
+
+
+def test_hermes_wire_fresh_creates_config_and_installs_plugin(tmp_path, monkeypatch):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    w = HermesWirer(hermes_home=home)
+    # Stub the install_plugin import via the wirer's _install_plugin override
+    monkeypatch.setattr(
+        HermesWirer, "_install_plugin",
+        lambda self: _stub_install_plugin(str(self.hermes_home)),
+    )
+    outcome = w.wire()
+    assert outcome.status == "wired"
+    # Config now has memory.provider: sibyl
+    import yaml
+    cfg = yaml.safe_load((home / "config.yaml").read_text())
+    assert cfg == {"memory": {"provider": "sibyl"}}
+    # Plugin "installed" (stub created the file)
+    assert (home / "plugins" / "sibyl" / "__init__.py").exists()
+
+
+def test_hermes_wire_existing_sibyl_is_noop(tmp_path, monkeypatch):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    (home / "config.yaml").write_text("memory:\n  provider: sibyl\n")
+    # Also pre-install the plugin so the noop path is true end-to-end
+    (home / "plugins" / "sibyl").mkdir(parents=True)
+    (home / "plugins" / "sibyl" / "__init__.py").write_text("# stub\n")
+    w = HermesWirer(hermes_home=home)
+    outcome = w.wire()
+    assert outcome.status == "already"
+
+
+def test_hermes_wire_existing_other_provider_refused_without_force(tmp_path, monkeypatch):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    (home / "config.yaml").write_text("memory:\n  provider: mem0\n")
+    monkeypatch.setattr(
+        HermesWirer, "_install_plugin",
+        lambda self: _stub_install_plugin(str(self.hermes_home)),
+    )
+    w = HermesWirer(hermes_home=home)
+    # No prompt_fn means non-interactive refusal
+    outcome = w.wire()
+    assert outcome.status == "skipped"
+    # Config UNCHANGED
+    assert "mem0" in (home / "config.yaml").read_text()
+
+
+def test_hermes_wire_existing_other_provider_with_force(tmp_path, monkeypatch):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    (home / "config.yaml").write_text("memory:\n  provider: mem0\n")
+    monkeypatch.setattr(
+        HermesWirer, "_install_plugin",
+        lambda self: _stub_install_plugin(str(self.hermes_home)),
+    )
+    w = HermesWirer(hermes_home=home)
+    outcome = w.wire(force=True)
+    assert outcome.status == "wired"
+    import yaml
+    cfg = yaml.safe_load((home / "config.yaml").read_text())
+    assert cfg["memory"]["provider"] == "sibyl"
+    # Backup landed
+    assert (home / "config.yaml.bak").exists()
+    assert "mem0" in (home / "config.yaml.bak").read_text()
+
+
+def test_hermes_wire_existing_other_provider_prompt_y_accepts(tmp_path, monkeypatch):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    (home / "config.yaml").write_text("memory:\n  provider: mem0\n")
+    monkeypatch.setattr(
+        HermesWirer, "_install_plugin",
+        lambda self: _stub_install_plugin(str(self.hermes_home)),
+    )
+    w = HermesWirer(hermes_home=home)
+    outcome = w.wire(prompt_fn=lambda q, *, default: "y")
+    assert outcome.status == "wired"
+
+
+def test_hermes_wire_dry_run_no_writes(tmp_path):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    w = HermesWirer(hermes_home=home)
+    outcome = w.wire(dry_run=True)
+    assert outcome.status == "dry-run"
+    assert not (home / "config.yaml").exists()
+    assert not (home / "plugins" / "sibyl" / "__init__.py").exists()
+
+
+def test_hermes_wire_preserves_other_top_level_keys(tmp_path, monkeypatch):
+    home = tmp_path / "hermes-home"
+    home.mkdir()
+    (home / "config.yaml").write_text(
+        "model:\n  name: gpt-4\ntools:\n  - search\n  - file\n"
+    )
+    monkeypatch.setattr(
+        HermesWirer, "_install_plugin",
+        lambda self: _stub_install_plugin(str(self.hermes_home)),
+    )
+    w = HermesWirer(hermes_home=home)
+    w.wire()
+    import yaml
+    cfg = yaml.safe_load((home / "config.yaml").read_text())
+    assert cfg["model"]["name"] == "gpt-4"
+    assert cfg["tools"] == ["search", "file"]
+    assert cfg["memory"]["provider"] == "sibyl"
+
+
+# ----------------------------------------------------------------------
+# ClaudeCodeWirer
+# ----------------------------------------------------------------------
+
+def test_claude_is_present_false_when_no_settings_no_bin(monkeypatch, tmp_path):
+    w = ClaudeCodeWirer(settings_path=tmp_path / "no.json")
+    with patch("sibyl_memory_cli.setup.shutil.which", return_value=None):
+        assert not w.is_present()
+
+
+def test_claude_is_present_true_when_settings_exists(tmp_path):
+    p = tmp_path / "settings.json"
+    p.write_text("{}")
+    w = ClaudeCodeWirer(settings_path=p)
+    assert w.is_present()
+
+
+def test_claude_state_fresh(tmp_path):
+    w = ClaudeCodeWirer(settings_path=tmp_path / "settings.json")
+    st = w.current_state()
+    assert st["settings_exists"] is False
+    assert st["mcp_servers_count"] == 0
+    assert st["sibyl_mcp"] is None
+    assert st["wired_with_sibyl"] is False
+
+
+def test_claude_state_existing_sibyl(tmp_path):
+    p = tmp_path / "settings.json"
+    p.write_text(json.dumps({"mcpServers": {"sibyl-memory": {"command": "sibyl-memory-mcp"}}}))
+    w = ClaudeCodeWirer(settings_path=p)
+    st = w.current_state()
+    assert st["wired_with_sibyl"] is True
+
+
+def test_claude_state_existing_other_mcps_no_sibyl(tmp_path):
+    p = tmp_path / "settings.json"
+    p.write_text(json.dumps({
+        "mcpServers": {"github": {"command": "gh-mcp"}, "filesystem": {"command": "fs-mcp"}}
+    }))
+    w = ClaudeCodeWirer(settings_path=p)
+    st = w.current_state()
+    assert st["mcp_servers_count"] == 2
+    assert st["sibyl_mcp"] is None
+    assert st["wired_with_sibyl"] is False
+
+
+def test_claude_wire_fresh_no_settings_creates(tmp_path):
+    p = tmp_path / "subdir" / "settings.json"  # parent doesn't exist yet
+    w = ClaudeCodeWirer(settings_path=p)
+    outcome = w.wire()
+    assert outcome.status == "wired"
+    cfg = json.loads(p.read_text())
+    assert cfg["mcpServers"]["sibyl-memory"] == {"command": "sibyl-memory-mcp"}
+
+
+def test_claude_wire_fresh_preserves_other_mcps(tmp_path):
+    p = tmp_path / "settings.json"
+    p.write_text(json.dumps({
+        "mcpServers": {"github": {"command": "gh-mcp"}},
+        "theme": "dark",
+    }))
+    w = ClaudeCodeWirer(settings_path=p)
+    outcome = w.wire()
+    assert outcome.status == "wired"
+    cfg = json.loads(p.read_text())
+    assert cfg["mcpServers"]["github"] == {"command": "gh-mcp"}
+    assert cfg["mcpServers"]["sibyl-memory"] == {"command": "sibyl-memory-mcp"}
+    assert cfg["theme"] == "dark"
+    # backup landed
+    assert (tmp_path / "settings.json.bak").exists()
+
+
+def test_claude_wire_existing_sibyl_is_noop(tmp_path):
+    p = tmp_path / "settings.json"
+    p.write_text(json.dumps({"mcpServers": {"sibyl-memory": {"command": "sibyl-memory-mcp"}}}))
+    w = ClaudeCodeWirer(settings_path=p)
+    outcome = w.wire()
+    assert outcome.status == "already"
+    # No backup written for no-op
+    assert not (tmp_path / "settings.json.bak").exists()
+
+
+def test_claude_wire_mismatched_sibyl_refused_without_force(tmp_path):
+    p = tmp_path / "settings.json"
+    # sibyl-memory key exists but command is different
+    p.write_text(json.dumps({"mcpServers": {"sibyl-memory": {"command": "/some/other/path"}}}))
+    w = ClaudeCodeWirer(settings_path=p)
+    outcome = w.wire()
+    assert outcome.status == "skipped"
+    # File UNCHANGED
+    assert "/some/other/path" in p.read_text()
+
+
+def test_claude_wire_mismatched_sibyl_with_force(tmp_path):
+    p = tmp_path / "settings.json"
+    p.write_text(json.dumps({"mcpServers": {"sibyl-memory": {"command": "/some/other/path"}}}))
+    w = ClaudeCodeWirer(settings_path=p)
+    outcome = w.wire(force=True)
+    assert outcome.status == "wired"
+    cfg = json.loads(p.read_text())
+    assert cfg["mcpServers"]["sibyl-memory"]["command"] == "sibyl-memory-mcp"
+
+
+def test_claude_wire_dry_run_no_writes(tmp_path):
+    p = tmp_path / "settings.json"
+    w = ClaudeCodeWirer(settings_path=p)
+    outcome = w.wire(dry_run=True)
+    assert outcome.status == "dry-run"
+    assert not p.exists()
+
+
+def test_claude_wire_mismatched_dry_run(tmp_path):
+    p = tmp_path / "settings.json"
+    p.write_text(json.dumps({"mcpServers": {"sibyl-memory": {"command": "/old"}}}))
+    w = ClaudeCodeWirer(settings_path=p, )
+    outcome = w.wire(dry_run=True, force=True)
+    assert outcome.status == "dry-run"
+    assert "update" in outcome.message
+    # Still no write
+    assert "/old" in p.read_text()
+
+
+# ----------------------------------------------------------------------
+# Registry
+# ----------------------------------------------------------------------
+
+def test_registry_has_both_wirers():
+    assert set(ALL_WIRERS) == {"hermes", "claude-code"}
+    assert ALL_WIRERS["hermes"] is HermesWirer
+    assert ALL_WIRERS["claude-code"] is ClaudeCodeWirer

sibyl_memory_cli-0.1.2/src/sibyl_memory_cli.egg-info/requires.txt

@@ -1,5 +0,0 @@
-sibyl-memory-client>=0.3.3
-sibyl-memory-hermes>=0.3.1
-
-[dev]
-pytest>=7.0