memorybot 0.0.2__tar.gz → 0.2.0__tar.gz

{memorybot-0.0.2 → memorybot-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorybot
-Version: 0.0.2
+Version: 0.2.0
 Summary: MemoryBot CLI — your personal knowledge graph from the command line
 Project-URL: Homepage, https://www.memorybot.com
 Project-URL: Repository, https://github.com/nolanlove/memorybot-cli
@@ -20,36 +20,48 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 
 # MemoryBot CLI
 
 > Your personal knowledge graph from the command line.
 
-**This is a placeholder release reserving the `memorybot` package name on PyPI.**
-
-The full MemoryBot CLI is under active development. Visit
-[memorybot.com](https://www.memorybot.com) to learn more about the platform.
-
 ## Install
 
 ```bash
-pip install memorybot
+pipx install memorybot
 ```
 
-or, recommended for CLI tools:
+(or `pip install memorybot` inside a venv).
+
+## Quick start
 
 ```bash
-pipx install memorybot
+mb login              # opens browser, OAuth flow
+mb memo search "..."  # full-text + semantic search
+mb memo get <SID>     # fetch a memo by sid
 ```
 
-## Usage
+`--json` on any command emits machine-readable output for piping into `jq`.
 
-```bash
-mb
-```
+## Configuration
+
+- **`MEMORYBOT_URL`** — server URL (default `https://www.memorybot.com`).
+- **`--base-url`** — per-command override.
+
+Credentials are stored at `~/.config/memorybot/config.json` (mode 0600).
+
+## Auth
+
+`mb login` runs the OAuth 2.0 authorization-code flow with PKCE: it registers a
+client via Dynamic Client Registration (RFC 7591), opens your browser to the
+authorize endpoint, and captures the callback on a one-shot loopback server.
+Tokens auto-refresh on 401.
 
-Currently prints a placeholder banner. Real commands coming soon.
+`mb logout` clears stored credentials.
 
 ## License
 

memorybot-0.2.0/README.md

@@ -0,0 +1,41 @@
+# MemoryBot CLI
+
+> Your personal knowledge graph from the command line.
+
+## Install
+
+```bash
+pipx install memorybot
+```
+
+(or `pip install memorybot` inside a venv).
+
+## Quick start
+
+```bash
+mb login              # opens browser, OAuth flow
+mb memo search "..."  # full-text + semantic search
+mb memo get <SID>     # fetch a memo by sid
+```
+
+`--json` on any command emits machine-readable output for piping into `jq`.
+
+## Configuration
+
+- **`MEMORYBOT_URL`** — server URL (default `https://www.memorybot.com`).
+- **`--base-url`** — per-command override.
+
+Credentials are stored at `~/.config/memorybot/config.json` (mode 0600).
+
+## Auth
+
+`mb login` runs the OAuth 2.0 authorization-code flow with PKCE: it registers a
+client via Dynamic Client Registration (RFC 7591), opens your browser to the
+authorize endpoint, and captures the callback on a one-shot loopback server.
+Tokens auto-refresh on 401.
+
+`mb logout` clears stored credentials.
+
+## License
+
+MIT

{memorybot-0.0.2 → memorybot-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memorybot"
-version = "0.0.2"
+version = "0.2.0"
 description = "MemoryBot CLI — your personal knowledge graph from the command line"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -26,7 +26,11 @@ classifiers = [
     "Topic :: Software Development :: Libraries",
     "Topic :: Utilities",
 ]
-dependencies = []
+dependencies = [
+    "typer>=0.12",
+    "httpx>=0.27",
+    "rich>=13",
+]
 
 [project.urls]
 Homepage = "https://www.memorybot.com"

{memorybot-0.0.2 → memorybot-0.2.0}/src/memorybot/__init__.py

@@ -1,3 +1,3 @@
 """MemoryBot CLI."""
 
-__version__ = "0.0.2"
+__version__ = "0.2.0"

memorybot-0.2.0/src/memorybot/__main__.py

@@ -0,0 +1,9 @@
+"""MemoryBot CLI entry point."""
+
+import sys
+
+from .cli import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

memorybot-0.2.0/src/memorybot/auth.py

@@ -0,0 +1,206 @@
+"""OAuth 2.0 authorization-code flow with PKCE and a one-shot local callback server."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import http.server
+import secrets
+import socket
+import threading
+import time
+import urllib.parse
+import webbrowser
+from typing import Optional
+
+import httpx
+
+from .config import Config
+
+CLIENT_NAME = "MemoryBot CLI"
+SCOPES = "read write"
+
+
+def _b64url(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
+
+
+def _make_pkce() -> tuple[str, str]:
+    verifier = _b64url(secrets.token_bytes(32))
+    challenge = _b64url(hashlib.sha256(verifier.encode()).digest())
+    return verifier, challenge
+
+
+def _pick_free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+class _CallbackHandler(http.server.BaseHTTPRequestHandler):
+    captured: dict = {}
+
+    def do_GET(self) -> None:  # noqa: N802
+        parsed = urllib.parse.urlparse(self.path)
+        if parsed.path != "/callback":
+            self.send_response(404)
+            self.end_headers()
+            return
+        params = urllib.parse.parse_qs(parsed.query)
+        type(self).captured = {k: v[0] for k, v in params.items()}
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.end_headers()
+        body = (
+            "<html><body style='font-family:system-ui;padding:2rem;'>"
+            "<h2>MemoryBot CLI — login complete</h2>"
+            "<p>You can close this tab and return to your terminal.</p>"
+            "</body></html>"
+        )
+        self.wfile.write(body.encode())
+
+    def log_message(self, format: str, *args: object) -> None:  # noqa: A002
+        pass
+
+
+def _register_client(server_url: str, redirect_uri: str) -> tuple[str, str]:
+    """Dynamic client registration (RFC 7591). Returns (client_id, client_secret)."""
+    resp = httpx.post(
+        f"{server_url}/oauth/register/",
+        json={
+            "client_name": CLIENT_NAME,
+            "redirect_uris": [redirect_uri],
+        },
+        timeout=15.0,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return data["client_id"], data["client_secret"]
+
+
+def _exchange_code(
+    server_url: str,
+    client_id: str,
+    client_secret: str,
+    code: str,
+    redirect_uri: str,
+    verifier: str,
+) -> dict:
+    resp = httpx.post(
+        f"{server_url}/oauth/token/",
+        data={
+            "grant_type": "authorization_code",
+            "code": code,
+            "redirect_uri": redirect_uri,
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "code_verifier": verifier,
+        },
+        timeout=15.0,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+def refresh_access_token(cfg: Config, server_url: str) -> bool:
+    """Use refresh_token to get a new access_token. Returns True on success."""
+    if not (cfg.refresh_token and cfg.client_id and cfg.client_secret):
+        return False
+    try:
+        resp = httpx.post(
+            f"{server_url}/oauth/token/",
+            data={
+                "grant_type": "refresh_token",
+                "refresh_token": cfg.refresh_token,
+                "client_id": cfg.client_id,
+                "client_secret": cfg.client_secret,
+            },
+            timeout=15.0,
+        )
+        resp.raise_for_status()
+    except httpx.HTTPError:
+        return False
+    data = resp.json()
+    cfg.access_token = data["access_token"]
+    cfg.refresh_token = data.get("refresh_token", cfg.refresh_token)
+    cfg.expires_at = time.time() + int(data.get("expires_in", 36000))
+    cfg.save()
+    return True
+
+
+def login_flow(server_url: str, timeout_seconds: int = 300) -> dict:
+    """Run the full auth-code + PKCE flow. Returns the token response dict.
+
+    Side effect: opens the user's browser to the authorize URL.
+    """
+    port = _pick_free_port()
+    redirect_uri = f"http://127.0.0.1:{port}/callback"
+
+    client_id, client_secret = _register_client(server_url, redirect_uri)
+
+    verifier, challenge = _make_pkce()
+    state = secrets.token_urlsafe(16)
+
+    authorize_url = (
+        f"{server_url}/oauth/authorize/?"
+        + urllib.parse.urlencode(
+            {
+                "response_type": "code",
+                "client_id": client_id,
+                "redirect_uri": redirect_uri,
+                "scope": SCOPES,
+                "state": state,
+                "code_challenge": challenge,
+                "code_challenge_method": "S256",
+            }
+        )
+    )
+
+    server = http.server.HTTPServer(("127.0.0.1", port), _CallbackHandler)
+    _CallbackHandler.captured = {}
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+
+    try:
+        webbrowser.open(authorize_url)
+        deadline = time.time() + timeout_seconds
+        while time.time() < deadline and not _CallbackHandler.captured:
+            time.sleep(0.1)
+    finally:
+        server.shutdown()
+
+    captured = _CallbackHandler.captured
+    if not captured:
+        raise TimeoutError("Timed out waiting for OAuth callback.")
+    if captured.get("state") != state:
+        raise RuntimeError("OAuth state mismatch — possible CSRF.")
+    if "error" in captured:
+        raise RuntimeError(f"Authorization denied: {captured['error']}")
+    if "code" not in captured:
+        raise RuntimeError("No authorization code received.")
+
+    token_resp = _exchange_code(
+        server_url=server_url,
+        client_id=client_id,
+        client_secret=client_secret,
+        code=captured["code"],
+        redirect_uri=redirect_uri,
+        verifier=verifier,
+    )
+    token_resp["_client_id"] = client_id
+    token_resp["_client_secret"] = client_secret
+    return token_resp
+
+
+def fetch_user_email(server_url: str, access_token: str) -> Optional[str]:
+    try:
+        resp = httpx.get(
+            f"{server_url}/api/auth/user/",
+            headers={"Authorization": f"Bearer {access_token}"},
+            timeout=10.0,
+        )
+        if resp.status_code != 200:
+            return None
+        return resp.json().get("email")
+    except httpx.HTTPError:
+        return None

memorybot-0.2.0/src/memorybot/cli.py

@@ -0,0 +1,263 @@
+"""MemoryBot CLI — Typer app. All commands route through tool-exec."""
+
+from __future__ import annotations
+
+import json as json_module
+import time
+from typing import Any, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from . import __version__
+from .auth import fetch_user_email, login_flow
+from .client import APIError, Client, ToolError
+from .config import Config, config_path, resolve_server_url
+
+app = typer.Typer(
+    name="mb",
+    help="MemoryBot CLI — your personal knowledge graph from the command line.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+memo_app = typer.Typer(name="memo", help="Search, get, and manage memos.", no_args_is_help=True)
+app.add_typer(memo_app)
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"mb {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _root(
+    version: Optional[bool] = typer.Option(
+        None, "--version", callback=_version_callback, is_eager=True, help="Show version and exit."
+    ),
+) -> None:
+    pass
+
+
+def _client(base_url: Optional[str]) -> Client:
+    cfg = Config.load()
+    server_url = resolve_server_url(base_url, cfg)
+    return Client(cfg, server_url)
+
+
+def _unwrap_single_op(result: dict) -> dict:
+    """manage_* responses come wrapped as {results: [op_result]}.
+
+    Single-op CLI commands want the inner result directly.
+    """
+    if isinstance(result, dict) and "results" in result and isinstance(result["results"], list):
+        items = result["results"]
+        if len(items) == 1:
+            return items[0]
+    return result
+
+
+@app.command()
+def login(
+    base_url: Optional[str] = typer.Option(None, "--base-url", help="Override server URL for this run."),
+) -> None:
+    """Authenticate via browser-based OAuth (authorization code + PKCE)."""
+    cfg = Config.load()
+    server_url = resolve_server_url(base_url, cfg)
+    cfg.server_url = server_url
+
+    err_console.print(f"Logging in to [bold]{server_url}[/bold]...")
+    err_console.print("Opening browser for authorization. Waiting for callback...")
+
+    try:
+        token_resp = login_flow(server_url)
+    except Exception as e:
+        err_console.print(f"[red]Login failed:[/red] {e}")
+        raise typer.Exit(code=1)
+
+    cfg.client_id = token_resp["_client_id"]
+    cfg.client_secret = token_resp["_client_secret"]
+    cfg.access_token = token_resp["access_token"]
+    cfg.refresh_token = token_resp.get("refresh_token")
+    cfg.expires_at = time.time() + int(token_resp.get("expires_in", 36000))
+
+    cfg.user_email = fetch_user_email(server_url, cfg.access_token)
+    cfg.save()
+
+    who = cfg.user_email or "(email not available)"
+    err_console.print(f"[green]Logged in as[/green] [bold]{who}[/bold]")
+    err_console.print(f"Credentials saved to {config_path()}")
+
+
+@app.command()
+def logout() -> None:
+    """Clear stored credentials."""
+    cfg = Config.load()
+    cfg.clear_tokens()
+    cfg.client_id = None
+    cfg.client_secret = None
+    cfg.save()
+    err_console.print("Logged out.")
+
+
+@app.command()
+def whoami() -> None:
+    """Show the currently logged-in user."""
+    cfg = Config.load()
+    if not cfg.access_token:
+        err_console.print("Not logged in. Run `mb login`.")
+        raise typer.Exit(code=1)
+    who = cfg.user_email or "(unknown)"
+    typer.echo(who)
+
+
+def _print_memos_table(memos: list[dict]) -> None:
+    if not memos:
+        err_console.print("[dim](no results)[/dim]")
+        return
+    table = Table(show_lines=False)
+    table.add_column("SID", style="cyan", no_wrap=True)
+    table.add_column("Title")
+    table.add_column("Tags", style="magenta")
+    for m in memos:
+        title = m.get("title") or m.get("structured_data", {}).get("memo", {}).get("title") or "(untitled)"
+        tag_field = m.get("tags") or []
+        if tag_field and isinstance(tag_field[0], dict):
+            tags = ", ".join(t.get("name", "") for t in tag_field if t.get("name"))
+        else:
+            tags = ", ".join(str(t) for t in tag_field)
+        table.add_row(m.get("sid", ""), title, tags)
+    console.print(table)
+
+
+@memo_app.command("search")
+def memo_search(
+    query: str = typer.Argument(..., help="Search query."),
+    limit: int = typer.Option(20, "--limit", "-n", help="Max results."),
+    tag_sid: Optional[str] = typer.Option(None, "--tag-sid", help="Filter under tag sid(s), comma-separated."),
+    json: bool = typer.Option(False, "--json", help="Emit raw JSON."),
+    base_url: Optional[str] = typer.Option(None, "--base-url", help="Override server URL for this run."),
+) -> None:
+    """Search memos via manage_memos action=search."""
+    op: dict[str, Any] = {"action": "search", "query": query, "limit": limit}
+    if tag_sid:
+        op["tag_sids"] = [s.strip() for s in tag_sid.split(",") if s.strip()]
+
+    try:
+        result = _client(base_url).tool_exec("manage_memos", {"operations": [op]})
+    except APIError as e:
+        err_console.print(f"[red]API error:[/red] {e}")
+        raise typer.Exit(code=1)
+    except ToolError as e:
+        err_console.print(f"[red]Tool error:[/red] {e.message}")
+        raise typer.Exit(code=1)
+
+    inner = _unwrap_single_op(result)
+
+    if json:
+        typer.echo(json_module.dumps(inner, indent=2))
+        return
+
+    memos = inner.get("memos") if isinstance(inner, dict) else None
+    if memos is None and isinstance(inner, list):
+        memos = inner
+    _print_memos_table(memos or [])
+    if isinstance(inner, dict):
+        count = inner.get("count", len(memos or []))
+        total = inner.get("total_count", count)
+        err_console.print(f"[dim]{count} of {total} results[/dim]")
+
+
+@memo_app.command("get")
+def memo_get(
+    sid: str = typer.Argument(..., help="Memo sid (10-char base62)."),
+    json: bool = typer.Option(False, "--json", help="Emit raw JSON."),
+    base_url: Optional[str] = typer.Option(None, "--base-url", help="Override server URL for this run."),
+) -> None:
+    """Fetch a single memo via manage_memos action=get."""
+    op = {"action": "get", "memo_sids": [sid], "full": True}
+
+    try:
+        result = _client(base_url).tool_exec("manage_memos", {"operations": [op]})
+    except APIError as e:
+        err_console.print(f"[red]API error:[/red] {e}")
+        raise typer.Exit(code=1)
+    except ToolError as e:
+        err_console.print(f"[red]Tool error:[/red] {e.message}")
+        raise typer.Exit(code=1)
+
+    inner = _unwrap_single_op(result)
+    memos = inner.get("memos") if isinstance(inner, dict) else (inner if isinstance(inner, list) else [])
+    if not memos:
+        err_console.print(f"[red]No memo found with sid {sid}.[/red]")
+        raise typer.Exit(code=1)
+    memo = memos[0]
+
+    if json:
+        typer.echo(json_module.dumps(memo, indent=2))
+        return
+
+    sd = memo.get("structured_data", {}) or {}
+    title = memo.get("title") or sd.get("memo", {}).get("title") or "(untitled)"
+    body = sd.get("memo", {}).get("content", "")
+    tag_field = memo.get("tags") or []
+    if tag_field and isinstance(tag_field[0], dict):
+        tags = ", ".join(t.get("name", "") for t in tag_field if t.get("name"))
+    else:
+        tags = ", ".join(str(t) for t in tag_field)
+
+    console.print(f"[bold cyan]{memo.get('sid', '')}[/bold cyan]  [bold]{title}[/bold]")
+    if tags:
+        console.print(f"[magenta]tags:[/magenta] {tags}")
+    if body:
+        console.print()
+        console.print(body)
+
+
+@app.command("query")
+def query_cmd(
+    sql: str = typer.Argument(..., help="A read-only SELECT against the v_* views."),
+    json: bool = typer.Option(False, "--json", help="Emit raw JSON."),
+    base_url: Optional[str] = typer.Option(None, "--base-url", help="Override server URL for this run."),
+) -> None:
+    """Run a read-only SQL query against the user's data (run_query tool)."""
+    try:
+        result = _client(base_url).tool_exec("run_query", {"sql": sql})
+    except APIError as e:
+        err_console.print(f"[red]API error:[/red] {e}")
+        raise typer.Exit(code=1)
+    except ToolError as e:
+        err_console.print(f"[red]Query error:[/red] {e.message}")
+        raise typer.Exit(code=1)
+
+    if json:
+        typer.echo(json_module.dumps(result, indent=2))
+        return
+
+    columns = result.get("columns", [])
+    rows = result.get("rows", [])
+    if not rows:
+        err_console.print("[dim](no rows)[/dim]")
+        return
+
+    table = Table(show_lines=False)
+    for col in columns:
+        table.add_column(col, overflow="fold")
+    for row in rows:
+        if isinstance(row, dict):
+            table.add_row(*[str(row.get(c, "")) for c in columns])
+        else:
+            table.add_row(*[str(v) for v in row])
+    console.print(table)
+
+    suffix = " (truncated at 200)" if result.get("truncated") else ""
+    err_console.print(f"[dim]{result.get('row_count', len(rows))} rows{suffix}[/dim]")
+
+
+def main() -> int:
+    app()
+    return 0

memorybot-0.2.0/src/memorybot/client.py

@@ -0,0 +1,61 @@
+"""Authenticated HTTP client for the MemoryBot tool-exec endpoint."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .auth import refresh_access_token
+from .config import Config
+
+TOOL_EXEC_PATH = "/memory/api/tool-exec/"
+
+
+class APIError(RuntimeError):
+    def __init__(self, status: int, body: str) -> None:
+        super().__init__(f"HTTP {status}: {body}")
+        self.status = status
+        self.body = body
+
+
+class ToolError(RuntimeError):
+    """Raised when the server returns 200 with a {'error': ...} body."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message
+
+
+class Client:
+    def __init__(self, cfg: Config, server_url: str) -> None:
+        self.cfg = cfg
+        self.server_url = server_url
+
+    def _headers(self) -> dict[str, str]:
+        if not self.cfg.access_token:
+            raise RuntimeError("Not logged in. Run `mb login`.")
+        return {
+            "Authorization": f"Bearer {self.cfg.access_token}",
+            "Content-Type": "application/json",
+        }
+
+    def tool_exec(self, tool: str, arguments: dict[str, Any]) -> dict:
+        """Call POST /api/tool-exec/ with {tool, arguments}. Returns parsed JSON.
+
+        Raises APIError on HTTP error, ToolError if the response body has
+        {'error': ...} (the executor's own validation/errors).
+        """
+        url = f"{self.server_url}{TOOL_EXEC_PATH}"
+        body = {"tool": tool, "arguments": arguments}
+
+        resp = httpx.post(url, headers=self._headers(), json=body, timeout=60.0)
+        if resp.status_code == 401 and refresh_access_token(self.cfg, self.server_url):
+            resp = httpx.post(url, headers=self._headers(), json=body, timeout=60.0)
+        if resp.status_code >= 400:
+            raise APIError(resp.status_code, resp.text)
+
+        data = resp.json()
+        if isinstance(data, dict) and "error" in data and len(data) == 1:
+            raise ToolError(data["error"])
+        return data

memorybot-0.2.0/src/memorybot/config.py

@@ -0,0 +1,64 @@
+"""Persistent CLI config: server URL, OAuth client credentials, tokens."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Optional
+
+DEFAULT_SERVER_URL = "https://www.memorybot.com"
+
+
+def config_dir() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "memorybot"
+
+
+def config_path() -> Path:
+    return config_dir() / "config.json"
+
+
+@dataclass
+class Config:
+    server_url: str = DEFAULT_SERVER_URL
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    access_token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    expires_at: Optional[float] = None  # epoch seconds
+    user_email: Optional[str] = None
+
+    @classmethod
+    def load(cls) -> "Config":
+        path = config_path()
+        if not path.exists():
+            return cls()
+        with path.open() as f:
+            data = json.load(f)
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+    def save(self) -> None:
+        path = config_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(".json.tmp")
+        with tmp.open("w") as f:
+            json.dump(asdict(self), f, indent=2)
+        tmp.chmod(0o600)
+        tmp.replace(path)
+
+    def clear_tokens(self) -> None:
+        self.access_token = None
+        self.refresh_token = None
+        self.expires_at = None
+        self.user_email = None
+
+
+def resolve_server_url(cli_override: Optional[str], cfg: Config) -> str:
+    """Precedence: --base-url flag > MEMORYBOT_URL env > config > default."""
+    if cli_override:
+        return cli_override.rstrip("/")
+    env = os.environ.get("MEMORYBOT_URL")
+    if env:
+        return env.rstrip("/")
+    return cfg.server_url.rstrip("/")

memorybot-0.0.2/README.md

@@ -1,32 +0,0 @@
-# MemoryBot CLI
-
-> Your personal knowledge graph from the command line.
-
-**This is a placeholder release reserving the `memorybot` package name on PyPI.**
-
-The full MemoryBot CLI is under active development. Visit
-[memorybot.com](https://www.memorybot.com) to learn more about the platform.
-
-## Install
-
-```bash
-pip install memorybot
-```
-
-or, recommended for CLI tools:
-
-```bash
-pipx install memorybot
-```
-
-## Usage
-
-```bash
-mb
-```
-
-Currently prints a placeholder banner. Real commands coming soon.
-
-## License
-
-MIT

memorybot-0.0.2/src/memorybot/__main__.py

@@ -1,29 +0,0 @@
-"""MemoryBot CLI entry point."""
-
-import sys
-
-
-BANNER = r"""
-  __  __                                 ____        _
- |  \/  | ___ _ __ ___   ___  _ __ _   _| __ )  ___ | |_
- | |\/| |/ _ \ '_ ` _ \ / _ \| '__| | | |  _ \ / _ \| __|
- | |  | |  __/ | | | | | (_) | |  | |_| | |_) | (_) | |_
- |_|  |_|\___|_| |_| |_|\___/|_|   \__, |____/ \___/ \__|
-                                   |___/
-"""
-
-
-def main() -> int:
-    """Entry point for the `mb` command."""
-    print(BANNER)
-    print("MemoryBot CLI — coming soon.")
-    print()
-    print("This is a placeholder release. The full CLI is under construction.")
-    print("Learn more: https://www.memorybot.com")
-    print()
-    print("Installed version: 0.0.2")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())