rebob 0.1.0__tar.gz

rebob-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: rebob
+Version: 0.1.0
+Summary: Persistent memory for IBM Bob 2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: ibm-watsonx-ai<2,>=1.7
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+
+# ReBOB — Memory for IBM Bob
+
+ReBOB gives [IBM Bob](https://www.ibm.com/products/watson) persistent memory across conversations.
+It captures, indexes, and retrieves context so Bob can remember what matters.
+
+## Install
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate          # Windows
+# source .venv/bin/activate     # macOS/Linux
+
+pip install -e .                # from a source checkout
+# or: pip install git+https://github.com/<org>/ReBOB.git
+```
+
+## Set up a project
+
+From inside the project you want Bob to remember things about:
+
+```bash
+rebob init
+```
+
+This writes `.env` (watsonx credentials), `.bob/mcp.json`, `.bob/settings.json`, and the `/mem`
+command/rules templates. Non-interactive (for scripting or CI):
+
+```bash
+rebob init --non-interactive --api-key <key> --project-id <id>
+```
+
+Then verify everything resolved correctly:
+
+```bash
+rebob doctor
+```
+
+`rebob doctor` prints every path ReBOB resolved (project root, data directory, `.env`, etc.) —
+if something looks wrong, that's the first place to look. `rebob doctor --fix` rewrites stale
+Bob config (e.g. after moving the project or reinstalling the venv).
+
+`rebob path` prints the same resolved paths as JSON, useful for scripting.
+
+## How path resolution works
+
+ReBOB never hardcodes `.rebob/` relative to the package install location — that broke under
+`pip install` (data was written inside `site-packages/`). Instead, in priority order:
+
+1. `REBOB_HOME` env var, if set (used verbatim as the data directory)
+2. `REBOB_PROJECT_ROOT` env var, if set (data dir becomes `$REBOB_PROJECT_ROOT/.rebob`)
+3. Walk upward from the current directory looking for an existing `.rebob/`, then `.bob/`,
+   then `pyproject.toml`, then `.git/` — first match wins
+4. Fall back to the current directory
+
+`rebob init` sets `REBOB_HOME` explicitly in the MCP server's `env` block, so Bob finds the
+right data directory regardless of what working directory it happens to launch the server with.
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -v
+```
+
+## Transport
+
+Default is `stdio` — Bob spawns a fresh process per tool call, zero setup required. If you hit
+timeouts on cold start (heavy imports, slow disk), switch to a persistent HTTP server:
+
+```bash
+rebob init --transport sse --port 8000
+rebob serve --transport sse --port 8000    # keep this running
+```

rebob-0.1.0/README.md

@@ -0,0 +1,73 @@
+# ReBOB — Memory for IBM Bob
+
+ReBOB gives [IBM Bob](https://www.ibm.com/products/watson) persistent memory across conversations.
+It captures, indexes, and retrieves context so Bob can remember what matters.
+
+## Install
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate          # Windows
+# source .venv/bin/activate     # macOS/Linux
+
+pip install -e .                # from a source checkout
+# or: pip install git+https://github.com/<org>/ReBOB.git
+```
+
+## Set up a project
+
+From inside the project you want Bob to remember things about:
+
+```bash
+rebob init
+```
+
+This writes `.env` (watsonx credentials), `.bob/mcp.json`, `.bob/settings.json`, and the `/mem`
+command/rules templates. Non-interactive (for scripting or CI):
+
+```bash
+rebob init --non-interactive --api-key <key> --project-id <id>
+```
+
+Then verify everything resolved correctly:
+
+```bash
+rebob doctor
+```
+
+`rebob doctor` prints every path ReBOB resolved (project root, data directory, `.env`, etc.) —
+if something looks wrong, that's the first place to look. `rebob doctor --fix` rewrites stale
+Bob config (e.g. after moving the project or reinstalling the venv).
+
+`rebob path` prints the same resolved paths as JSON, useful for scripting.
+
+## How path resolution works
+
+ReBOB never hardcodes `.rebob/` relative to the package install location — that broke under
+`pip install` (data was written inside `site-packages/`). Instead, in priority order:
+
+1. `REBOB_HOME` env var, if set (used verbatim as the data directory)
+2. `REBOB_PROJECT_ROOT` env var, if set (data dir becomes `$REBOB_PROJECT_ROOT/.rebob`)
+3. Walk upward from the current directory looking for an existing `.rebob/`, then `.bob/`,
+   then `pyproject.toml`, then `.git/` — first match wins
+4. Fall back to the current directory
+
+`rebob init` sets `REBOB_HOME` explicitly in the MCP server's `env` block, so Bob finds the
+right data directory regardless of what working directory it happens to launch the server with.
+
+## Tests
+
+```bash
+pip install -e ".[dev]"
+pytest tests/ -v
+```
+
+## Transport
+
+Default is `stdio` — Bob spawns a fresh process per tool call, zero setup required. If you hit
+timeouts on cold start (heavy imports, slow disk), switch to a persistent HTTP server:
+
+```bash
+rebob init --transport sse --port 8000
+rebob serve --transport sse --port 8000    # keep this running
+```

rebob-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rebob"
+version = "0.1.0"
+description = "Persistent memory for IBM Bob 2.0"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "fastmcp>=2.0",
+  "python-dotenv>=1.0",
+  "ibm-watsonx-ai>=1.7,<2",
+  "numpy>=1.24",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "build>=1.0",
+]
+
+[project.scripts]
+rebob = "rebob.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["rebob*"]
+
+[tool.setuptools.package-data]
+rebob = ["templates/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

rebob-0.1.0/rebob/__init__.py

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

rebob-0.1.0/rebob/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m rebob` — delegates to the CLI."""
+
+from rebob.cli import main
+
+if __name__ == "__main__":
+    main()

rebob-0.1.0/rebob/cli.py

@@ -0,0 +1,69 @@
+"""rebob — command-line entry point (argparse subcommands)."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="rebob", description="ReBOB — persistent memory for Bob.")
+    sub = parser.add_subparsers(dest="command")
+
+    p_init = sub.add_parser("init", help="Configure ReBOB in the current project")
+    p_init.add_argument("--non-interactive", "--yes", dest="non_interactive", action="store_true")
+    p_init.add_argument("--api-key", default="", help="IBM_CLOUD_API_KEY (for --non-interactive)")
+    p_init.add_argument("--project-id", default="", help="WATSONX_PROJECT_ID (for --non-interactive)")
+    p_init.add_argument("--url", default="", help="WATSONX_URL (for --non-interactive)")
+    p_init.add_argument("--transport", choices=["stdio", "sse"], default="stdio")
+    p_init.add_argument("--port", type=int, default=8000)
+
+    p_doctor = sub.add_parser("doctor", help="Diagnose a ReBOB installation")
+    p_doctor.add_argument("--fix", action="store_true", help="Rewrite stale Bob config")
+
+    p_serve = sub.add_parser("serve", help="Run the ReBOB MCP server")
+    p_serve.add_argument("--transport", choices=["stdio", "sse"], default="stdio")
+    p_serve.add_argument("--port", type=int, default=8000)
+
+    sub.add_parser("path", help="Print resolved ReBOB paths as JSON")
+    sub.add_parser("version", help="Print ReBOB version and environment info")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv if argv is not None else sys.argv[1:])
+
+    if args.command is None:
+        parser.print_help()
+        raise SystemExit(0)
+
+    if args.command == "init":
+        from rebob.commands.init import run_init
+        run_init(
+            non_interactive=args.non_interactive,
+            api_key=args.api_key,
+            project_id=args.project_id,
+            url=args.url,
+            transport=args.transport,
+            port=args.port,
+        )
+    elif args.command == "doctor":
+        from rebob.commands.doctor import run_doctor
+        run_doctor(fix=args.fix)
+    elif args.command == "serve":
+        from rebob.commands.serve import run_serve
+        run_serve(transport=args.transport, port=args.port)
+    elif args.command == "path":
+        from rebob.commands.path import run_path
+        run_path()
+    elif args.command == "version":
+        import platform
+
+        from rebob import __version__
+        print(f"rebob {__version__}")
+        print(f"python {platform.python_version()} on {platform.system()}")
+    else:
+        parser.print_help()
+        raise SystemExit(1)

rebob-0.1.0/rebob/commands/_util.py

@@ -0,0 +1,204 @@
+"""Shared helpers for rebob init / doctor / serve."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from importlib import resources
+from pathlib import Path
+
+
+def load_template(name: str) -> str:
+    return resources.files("rebob").joinpath("templates", name).read_text(encoding="utf-8")
+
+
+def resolve_python() -> Path:
+    """Prefer the active venv's interpreter, else the current interpreter.
+
+    Checks both the Windows layout (Scripts\\python.exe) and the POSIX
+    layout (bin/python) under VIRTUAL_ENV, so this works correctly
+    regardless of host OS.
+    """
+    venv = os.environ.get("VIRTUAL_ENV")
+    if venv:
+        venv_path = Path(venv)
+        candidates = [
+            venv_path / "Scripts" / "python.exe",  # Windows
+            venv_path / "bin" / "python3",  # POSIX
+            venv_path / "bin" / "python",  # POSIX
+        ]
+        for candidate in candidates:
+            if candidate.exists():
+                return candidate
+    return Path(sys.executable)
+
+
+def quote_cmd(path: Path) -> str:
+    """Quote a path for hook command strings (Windows-safe, spaces-safe)."""
+    return f'"{path}"'
+
+
+def hook_command(python: Path, hook_type: str) -> str:
+    """Build the hook invocation as a module launch: `<python> -m rebob.hook <type>`.
+
+    Using `-m rebob.hook` instead of a script path means there is no second
+    absolute path to go stale — only the interpreter path needs to be right.
+    """
+    return f"{quote_cmd(python)} -m rebob.hook {hook_type}"
+
+
+def build_settings(python: Path) -> dict:
+    """Build Bob settings.json hook config with JSON-safe command strings."""
+
+    def hook_entry(hook_type: str, timeout: int) -> dict:
+        return {
+            "hooks": [
+                {
+                    "type": "command",
+                    "command": hook_command(python, hook_type),
+                    "timeout": timeout,
+                }
+            ]
+        }
+
+    return {
+        "hooks": {
+            "UserPromptSubmit": [hook_entry("prompt", 8000)],
+            "PostToolUse": [hook_entry("tool", 5000)],
+            "Stop": [hook_entry("stop", 5000)],
+        }
+    }
+
+
+def build_mcp(python: Path, project_root: Path, *, transport: str = "stdio", port: int = 8000) -> dict:
+    """Build Bob mcp.json using module launch (portable across installs).
+
+    REBOB_HOME is set explicitly in the env block so the server finds the
+    right data directory regardless of what cwd Bob actually launches it
+    with — belt and braces alongside the `cwd` field.
+    """
+    rebob_home = str((project_root / ".rebob").resolve())
+    env = {
+        "REBOB_HOME": rebob_home,
+        "PYTHONIOENCODING": "utf-8",
+        "PYTHONUTF8": "1",
+    }
+
+    if transport == "stdio":
+        server_entry = {
+            "command": str(python),
+            "args": ["-m", "rebob.server"],
+            "cwd": str(project_root),
+            "env": env,
+        }
+    else:
+        server_entry = {
+            "url": f"http://127.0.0.1:{port}/{'sse' if transport == 'sse' else 'mcp'}",
+        }
+
+    return {"mcpServers": {"rebob": server_entry}}
+
+
+_HOOK_CMD_RE = re.compile(r'"([^"]*)"')
+
+
+def parse_hook_command(command: str) -> tuple[Path, str]:
+    """Parse a Bob hook command string (`"<python>" -m rebob.hook <type>`)
+    into (python, hook_type).
+    """
+    parts = _HOOK_CMD_RE.findall(command)
+    if not parts:
+        raise ValueError(f"invalid hook command: {command!r}")
+    hook_type = command.strip().split()[-1]
+    return Path(parts[0]), hook_type
+
+
+def load_json(path: Path) -> tuple[dict | None, str | None]:
+    """Load JSON from *path*. Returns (data, error)."""
+    if not path.is_file():
+        return None, "file missing"
+    try:
+        return json.loads(path.read_text(encoding="utf-8")), None
+    except json.JSONDecodeError as e:
+        return None, f"invalid JSON: {e}"
+
+
+def write_json(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
+def write_text(path: Path, content: str, *, overwrite: bool = True) -> bool:
+    """Write text to *path*. Returns True if written, False if skipped."""
+    if path.exists() and not overwrite:
+        return False
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    return True
+
+
+def merge_mcp(existing: dict | None, new: dict) -> dict:
+    """Merge the rebob server entry into an existing mcp.json, preserving
+    any other MCP servers the user already configured.
+    """
+    merged = dict(existing) if existing else {}
+    servers = dict(merged.get("mcpServers", {}))
+    servers.update(new.get("mcpServers", {}))
+    merged["mcpServers"] = servers
+    return merged
+
+
+def merge_settings(existing: dict | None, new: dict) -> dict:
+    """Merge rebob's hook entries into an existing settings.json, preserving
+    any other hooks the user already configured for the same event names.
+
+    For each hook event (UserPromptSubmit, PostToolUse, Stop), drops any
+    prior entry whose command was a rebob hook invocation, then appends
+    the fresh one — avoiding duplicate rebob entries across repeated
+    `rebob init` runs while leaving unrelated hooks untouched.
+    """
+    merged = dict(existing) if existing else {}
+    hooks = dict(merged.get("hooks", {}))
+
+    for event, entries in new.get("hooks", {}).items():
+        existing_entries = list(hooks.get(event, []))
+        kept = [
+            e for e in existing_entries
+            if not _is_rebob_hook_entry(e)
+        ]
+        hooks[event] = kept + entries
+
+    merged["hooks"] = hooks
+    return merged
+
+
+def _is_rebob_hook_entry(entry: dict) -> bool:
+    for h in entry.get("hooks", []):
+        if "rebob.hook" in h.get("command", ""):
+            return True
+    return False
+
+
+def ensure_gitignore_entries(root: Path, entries: list[str]) -> list[str]:
+    """Append any missing entries to .gitignore. Returns the list actually added."""
+    gitignore = root / ".gitignore"
+    existing_lines = set()
+    if gitignore.exists():
+        existing_lines = {ln.strip() for ln in gitignore.read_text(encoding="utf-8").splitlines()}
+
+    to_add = [e for e in entries if e not in existing_lines]
+    if to_add:
+        with gitignore.open("a", encoding="utf-8") as f:
+            if gitignore.exists() and gitignore.stat().st_size > 0:
+                f.write("\n")
+            f.write("# ReBOB (added by `rebob init`)\n")
+            for e in to_add:
+                f.write(e + "\n")
+    return to_add
+
+
+def confirm_overwrite(path: Path) -> bool:
+    answer = input(f"{path} already exists - overwrite? [y/N]: ").strip().lower()
+    return answer in ("y", "yes")

rebob-0.1.0/rebob/commands/doctor.py

@@ -0,0 +1,125 @@
+"""rebob doctor — diagnose a ReBOB installation."""
+
+from __future__ import annotations
+
+import platform
+import sys
+
+from rebob import paths
+from rebob.commands._util import (
+    build_mcp,
+    build_settings,
+    load_json,
+    merge_mcp,
+    merge_settings,
+    resolve_python,
+    write_json,
+)
+
+_REQUIRED_ENV = ("IBM_CLOUD_API_KEY", "WATSONX_PROJECT_ID", "WATSONX_URL")
+
+
+def _check(label: str, ok: bool, detail: str = "") -> bool:
+    status = "[ok]" if ok else "[FAIL]"
+    line = f"  {status} {label}"
+    if detail:
+        line += f" - {detail}"
+    print(line)
+    return ok
+
+
+def _check_mcp_import() -> tuple[bool, str]:
+    try:
+        import fastmcp  # noqa: F401
+
+        from rebob import server  # noqa: F401
+
+        return True, f"fastmcp {getattr(fastmcp, '__version__', '?')}"
+    except Exception as e:
+        return False, str(e)
+
+
+def run_doctor(*, fix: bool = False) -> None:
+    root = paths.project_root()
+    python = resolve_python()
+
+    print(f"ReBOB doctor - project: {root}")
+    print(f"Python: {python} ({platform.python_version()} on {platform.system()})")
+    if fix:
+        print("Mode: --fix (will rewrite stale Bob config)")
+    print()
+
+    print("Resolved paths:")
+    for key, value in paths.describe().items():
+        print(f"  {key}: {value}")
+    print()
+
+    all_ok = True
+
+    env_path = paths.env_file()
+    if env_path.exists():
+        from dotenv import dotenv_values
+
+        env_vars = dotenv_values(env_path)
+        missing = [k for k in _REQUIRED_ENV if not env_vars.get(k)]
+        all_ok &= _check(
+            ".env has required keys",
+            not missing,
+            f"missing: {', '.join(missing)}" if missing else "ok",
+        )
+    else:
+        all_ok &= _check(".env exists", False, str(env_path))
+
+    mcp_path = root / ".bob" / "mcp.json"
+    settings_path = root / ".bob" / "settings.json"
+
+    all_ok &= _check(".bob/mcp.json exists", mcp_path.is_file(), str(mcp_path))
+    all_ok &= _check(".bob/settings.json exists", settings_path.is_file(), str(settings_path))
+
+    if fix:
+        print()
+        print("Repairing Bob config from live values...")
+        existing_mcp, _ = load_json(mcp_path)
+        transport = "stdio"
+        if existing_mcp and "url" in existing_mcp.get("mcpServers", {}).get("rebob", {}):
+            transport = "sse"
+        write_json(mcp_path, merge_mcp(existing_mcp, build_mcp(python, root, transport=transport)))
+        print(f"  rewrote {mcp_path}")
+
+        existing_settings, _ = load_json(settings_path)
+        write_json(settings_path, merge_settings(existing_settings, build_settings(python)))
+        print(f"  rewrote {settings_path}")
+
+    mcp_data, mcp_err = load_json(mcp_path)
+    settings_data, settings_err = load_json(settings_path)
+
+    rebob_entry = (mcp_data or {}).get("mcpServers", {}).get("rebob")
+    mcp_problem = mcp_err or ("no 'rebob' entry in mcpServers" if not rebob_entry else None)
+    all_ok &= _check("mcp.json valid", mcp_problem is None, mcp_problem or "ok")
+
+    settings_problem = settings_err
+    all_ok &= _check("settings.json valid", settings_problem is None, settings_problem or "ok")
+
+    import_ok, import_detail = _check_mcp_import()
+    all_ok &= _check("MCP server import", import_ok, import_detail)
+
+    try:
+        from rebob.core.store import count_by_status, init_db
+
+        init_db()
+        counts = count_by_status()
+        all_ok &= _check(
+            "memory store readable",
+            True,
+            f"{counts['total']} total ({counts['active']} active)",
+        )
+    except Exception as e:
+        all_ok &= _check("memory store readable", False, str(e))
+
+    print()
+    if all_ok:
+        print("All checks passed.")
+    else:
+        hint = "rebob doctor --fix" if not fix else "rebob init"
+        print(f"Some checks failed. Run: {hint}")
+        raise SystemExit(1)