memorybot 0.1.0__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorybot
-Version: 0.1.0
+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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memorybot"
-version = "0.1.0"
+version = "0.2.0"
 description = "MemoryBot CLI — your personal knowledge graph from the command line"
 readme = "README.md"
 requires-python = ">=3.9"

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

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

{memorybot-0.1.0 → memorybot-0.2.0}/src/memorybot/cli.py

@@ -1,10 +1,10 @@
-"""MemoryBot CLI — Typer app."""
+"""MemoryBot CLI — Typer app. All commands route through tool-exec."""
 
 from __future__ import annotations
 
 import json as json_module
 import time
-from typing import Optional
+from typing import Any, Optional
 
 import typer
 from rich.console import Console
@@ -12,7 +12,7 @@ from rich.table import Table
 
 from . import __version__
 from .auth import fetch_user_email, login_flow
-from .client import APIError, Client
+from .client import APIError, Client, ToolError
 from .config import Config, config_path, resolve_server_url
 
 app = typer.Typer(
@@ -43,6 +43,24 @@ def _root(
     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."),
@@ -97,7 +115,7 @@ def whoami() -> None:
     typer.echo(who)
 
 
-def _print_memo_table(memos: list[dict]) -> None:
+def _print_memos_table(memos: list[dict]) -> None:
     if not memos:
         err_console.print("[dim](no results)[/dim]")
         return
@@ -107,7 +125,11 @@ def _print_memo_table(memos: list[dict]) -> None:
     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)"
-        tags = ", ".join(t.get("name", "") for t in m.get("tags", []) if t.get("name"))
+        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)
 
@@ -115,35 +137,39 @@ def _print_memo_table(memos: list[dict]) -> None:
 @memo_app.command("search")
 def memo_search(
     query: str = typer.Argument(..., help="Search query."),
-    limit: int = typer.Option(20, "--limit", "-n", help="Max results (1-100)."),
-    mode: str = typer.Option("combined", "--mode", help="combined | fts | trigram | semantic."),
+    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."""
-    cfg = Config.load()
-    server_url = resolve_server_url(base_url, cfg)
-    client = Client(cfg, server_url)
-
-    params: dict[str, object] = {"q": query, "limit": limit, "mode": mode}
+    """Search memos via manage_memos action=search."""
+    op: dict[str, Any] = {"action": "search", "query": query, "limit": limit}
     if tag_sid:
-        params["tag_sids"] = tag_sid
+        op["tag_sids"] = [s.strip() for s in tag_sid.split(",") if s.strip()]
 
     try:
-        data = client.get("/memory/api/memos/search", params=params)
+        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(data, indent=2))
+        typer.echo(json_module.dumps(inner, indent=2))
         return
-    _print_memo_table(data.get("memos", []))
-    err_console.print(
-        f"[dim]{data.get('count', 0)} of {data.get('total_count', 0)} results "
-        f"(mode: {data.get('mode', mode)})[/dim]"
-    )
+
+    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")
@@ -152,18 +178,20 @@ def memo_get(
     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 by sid."""
-    cfg = Config.load()
-    server_url = resolve_server_url(base_url, cfg)
-    client = Client(cfg, server_url)
+    """Fetch a single memo via manage_memos action=get."""
+    op = {"action": "get", "memo_sids": [sid], "full": True}
 
     try:
-        data = client.get("/memory/api/memos/list", params={"sids": sid})
+        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)
 
-    memos = data.get("memos", [])
+    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)
@@ -176,7 +204,11 @@ def memo_get(
     sd = memo.get("structured_data", {}) or {}
     title = memo.get("title") or sd.get("memo", {}).get("title") or "(untitled)"
     body = sd.get("memo", {}).get("content", "")
-    tags = ", ".join(t.get("name", "") for t in memo.get("tags", []) if t.get("name"))
+    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:
@@ -186,6 +218,46 @@ def memo_get(
         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.1.0/src/memorybot/client.py

@@ -1,37 +0,0 @@
-"""Authenticated HTTP client with auto-refresh on 401."""
-
-from __future__ import annotations
-
-from typing import Any, Optional
-
-import httpx
-
-from .auth import refresh_access_token
-from .config import Config
-
-
-class APIError(RuntimeError):
-    def __init__(self, status: int, body: str) -> None:
-        super().__init__(f"HTTP {status}: {body}")
-        self.status = status
-        self.body = body
-
-
-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}"}
-
-    def get(self, path: str, params: Optional[dict[str, Any]] = None) -> dict:
-        url = f"{self.server_url}{path}"
-        resp = httpx.get(url, headers=self._headers(), params=params, timeout=30.0)
-        if resp.status_code == 401 and refresh_access_token(self.cfg, self.server_url):
-            resp = httpx.get(url, headers=self._headers(), params=params, timeout=30.0)
-        if resp.status_code >= 400:
-            raise APIError(resp.status_code, resp.text)
-        return resp.json()