lmgram-cli 0.1.0__py3-none-any.whl

lmgram_cli/__init__.py

@@ -0,0 +1,3 @@
+"""LMGram command line interface."""
+
+__version__ = "0.1.0"

lmgram_cli/__main__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import sys
+
+from .cli import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lmgram_cli/api.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from .errors import ApiError, NetworkError
+
+
+class ApiClient:
+    def __init__(self, base_url: str, token: str | None = None, timeout: int = 30, verbose: bool = False):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.timeout = timeout
+        self.verbose = verbose
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+        query: dict[str, Any] | None = None,
+        auth: bool = True,
+    ) -> Any:
+        url = self._url(path, query)
+        data = None if body is None else json.dumps(body).encode("utf-8")
+        headers = {"Accept": "application/json", "User-Agent": "lmgram-cli/0.1.0"}
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+        if auth and self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        request = Request(url, data=data, method=method.upper(), headers=headers)
+        try:
+            with urlopen(request, timeout=self.timeout) as response:
+                raw = response.read()
+                if not raw:
+                    return None
+                content_type = response.headers.get("Content-Type", "")
+                if "json" not in content_type.lower():
+                    return raw.decode("utf-8")
+                return json.loads(raw.decode("utf-8"))
+        except HTTPError as exc:
+            payload = self._read_error(exc)
+            message = self._message_from_payload(payload) or f"LMGram API returned HTTP {exc.code}."
+            raise ApiError(exc.code, message, payload) from exc
+        except URLError as exc:
+            raise NetworkError(str(exc.reason)) from exc
+        except TimeoutError as exc:
+            raise NetworkError("Request timed out.") from exc
+
+    def get(self, path: str, query: dict[str, Any] | None = None) -> Any:
+        return self.request("GET", path, query=query)
+
+    def post(self, path: str, body: dict[str, Any] | None = None, auth: bool = True) -> Any:
+        return self.request("POST", path, body=body or {}, auth=auth)
+
+    def patch(self, path: str, body: dict[str, Any] | None = None) -> Any:
+        return self.request("PATCH", path, body=body or {})
+
+    def delete(self, path: str) -> Any:
+        return self.request("DELETE", path)
+
+    def _url(self, path: str, query: dict[str, Any] | None) -> str:
+        clean_path = path if path.startswith("/") else f"/{path}"
+        url = f"{self.base_url}{clean_path}"
+        if query:
+            cleaned = {key: value for key, value in query.items() if value is not None}
+            if cleaned:
+                url = f"{url}?{urlencode(cleaned, doseq=True)}"
+        return url
+
+    @staticmethod
+    def _read_error(exc: HTTPError) -> Any:
+        raw = exc.read()
+        if not raw:
+            return None
+        try:
+            return json.loads(raw.decode("utf-8"))
+        except json.JSONDecodeError:
+            return raw.decode("utf-8", errors="replace")
+
+    @staticmethod
+    def _message_from_payload(payload: Any) -> str | None:
+        if isinstance(payload, dict):
+            error = payload.get("error")
+            if isinstance(error, dict):
+                return str(error.get("message") or error.get("code") or "")
+            if error:
+                return str(error)
+            if payload.get("message"):
+                return str(payload["message"])
+        if isinstance(payload, str):
+            return payload
+        return None

lmgram_cli/cli.py

@@ -0,0 +1,496 @@
+from __future__ import annotations
+
+import argparse
+import os
+import socket
+import sys
+import time
+import webbrowser
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from . import __version__
+from .api import ApiClient
+from .config import DEFAULT_API_URL, DEFAULT_PROFILE, ConfigStore, StoredProfile, token_from_env
+from .duration import expires_at
+from .errors import EXIT_AUTH_REQUIRED, EXIT_CANCELLED, EXIT_VALIDATION, ApiError, LmgramError
+from .output import compact_id, emit_json, error_payload, human_error
+
+
+DEFAULT_SCOPES = [
+    "profile:read",
+    "intents:read",
+    "intents:write",
+    "matches:read",
+    "matches:respond",
+    "requests:read",
+    "requests:respond",
+    "chats:write",
+]
+
+MODE_TO_MATCH_TYPE = {
+    "peer_advice": "peer",
+    "provider_search": "helper",
+    "collaboration": "collaborator",
+    "hiring": "helper",
+    "feedback": "peer",
+    "customer_discovery": "peer",
+    "technical_help": "helper",
+    "social": "peer",
+    "other": "peer",
+}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="lmgram", description="LMGram CLI for agents and developers.")
+    parser.add_argument("--version", action="version", version=f"lmgram {__version__}")
+    parser.add_argument("--json", action="store_true", help="Output JSON only.")
+    parser.add_argument("--api-url", default=os.environ.get("LMGRAM_API_URL"), help="Override LMGram API base URL.")
+    parser.add_argument("--profile", default=os.environ.get("LMGRAM_PROFILE", DEFAULT_PROFILE), help="Use a named profile.")
+    parser.add_argument("--yes", action="store_true", help="Skip confirmation prompts where allowed.")
+    parser.add_argument("--no-color", action="store_true", help="Reserved for compatibility.")
+    parser.add_argument("--verbose", action="store_true", help="Show debug details.")
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    login = subparsers.add_parser("login", help="Connect this CLI to LMGram.")
+    login.add_argument("--scopes", help="Space-separated scopes.")
+    login.add_argument("--device-name", default=socket.gethostname(), help="Device name shown on approval screen.")
+    login.add_argument("--client-name", default="lmgram-cli", help="Client name shown on approval screen.")
+    login.add_argument("--no-open", action="store_true", help="Do not open the approval URL in a browser.")
+    login.set_defaults(handler=cmd_login)
+
+    logout = subparsers.add_parser("logout", help="Revoke and clear local credentials.")
+    logout.set_defaults(handler=cmd_logout)
+
+    whoami = subparsers.add_parser("whoami", help="Show current LMGram account.")
+    whoami.set_defaults(handler=cmd_whoami)
+
+    intent = subparsers.add_parser("intent", help="Create and manage intents.")
+    intent_sub = intent.add_subparsers(dest="intent_command")
+
+    intent_create = intent_sub.add_parser("create", help="Create an intent.")
+    intent_create.add_argument("text")
+    intent_create.add_argument("--context")
+    intent_create.add_argument("--mode", default="peer_advice", choices=sorted(MODE_TO_MATCH_TYPE))
+    intent_create.add_argument("--tag", action="append", default=[])
+    intent_create.add_argument("--expires", default="72h")
+    intent_create.add_argument("--location")
+    intent_create.add_argument("--project")
+    intent_create.add_argument("--agent", default="lmgram-cli")
+    intent_create.add_argument("--language")
+    intent_create.add_argument("--max-candidates", type=int, default=5)
+    intent_create.set_defaults(handler=cmd_intent_create)
+
+    intent_list = intent_sub.add_parser("list", help="List intents.")
+    intent_list.add_argument("--active", action="store_true")
+    intent_list.add_argument("--closed", action="store_true")
+    intent_list.set_defaults(handler=cmd_intent_list)
+
+    intent_show = intent_sub.add_parser("show", help="Show an intent.")
+    intent_show.add_argument("intent_id")
+    intent_show.set_defaults(handler=cmd_intent_show)
+
+    intent_close = intent_sub.add_parser("close", help="Close an intent.")
+    intent_close.add_argument("intent_id")
+    intent_close.set_defaults(handler=cmd_intent_close)
+
+    intent_update = intent_sub.add_parser("update", help="Update an intent.")
+    intent_update.add_argument("intent_id")
+    intent_update.add_argument("--context")
+    intent_update.add_argument("--expires")
+    intent_update.set_defaults(handler=cmd_intent_update)
+
+    matches = subparsers.add_parser("matches", help="Read and respond to matches.")
+    matches_sub = matches.add_subparsers(dest="matches_command")
+
+    matches_list = matches_sub.add_parser("list", help="List matches.")
+    matches_list.add_argument("--intent")
+    matches_list.add_argument("--status")
+    matches_list.set_defaults(handler=cmd_matches_list)
+
+    matches_show = matches_sub.add_parser("show", help="Show a match.")
+    matches_show.add_argument("match_id")
+    matches_show.set_defaults(handler=cmd_matches_show)
+
+    matches_accept = matches_sub.add_parser("accept", help="Accept a match.")
+    matches_accept.add_argument("match_id")
+    matches_accept.add_argument("--message")
+    matches_accept.set_defaults(handler=cmd_matches_accept)
+
+    matches_decline = matches_sub.add_parser("decline", help="Decline a match.")
+    matches_decline.add_argument("match_id")
+    matches_decline.add_argument("--reason")
+    matches_decline.set_defaults(handler=cmd_matches_decline)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not hasattr(args, "handler"):
+        parser.print_help()
+        return 0
+
+    try:
+        return int(args.handler(args) or 0)
+    except LmgramError as exc:
+        if args.json:
+            emit_json(error_payload(exc.code, exc.message))
+        else:
+            human_error(exc.message)
+        return exc.exit_code
+
+
+def client_for(args: argparse.Namespace, require_auth: bool = True) -> tuple[ApiClient, ConfigStore, StoredProfile]:
+    store = ConfigStore()
+    profile = store.get_profile(args.profile)
+    api_url = (args.api_url or profile.api_base_url or DEFAULT_API_URL).rstrip("/")
+    token = token_from_env() or profile.access_token
+    if require_auth and not token:
+        raise LmgramError("AUTH_REQUIRED", "Run lmgram login to connect this CLI to your LMGram account.", EXIT_AUTH_REQUIRED)
+    return ApiClient(api_url, token=token, verbose=args.verbose), store, profile
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    api_url = (args.api_url or DEFAULT_API_URL).rstrip("/")
+    client = ApiClient(api_url, verbose=args.verbose)
+    scopes = args.scopes.split() if args.scopes else DEFAULT_SCOPES
+    device = client.post(
+        "/api/cli/oauth/device-code",
+        {
+            "client_name": args.client_name,
+            "device_name": args.device_name,
+            "requested_scopes": scopes,
+        },
+        auth=False,
+    )
+
+    if args.json:
+        emit_json({"ok": True, "device": device})
+    else:
+        print("To connect this agent to LMGram:")
+        print(f"1. Open {device.get('verification_uri')}")
+        print(f"2. Enter code: {device.get('user_code')}")
+        if device.get("verification_uri_complete"):
+            print()
+            print(device["verification_uri_complete"])
+            if not args.no_open:
+                webbrowser.open(device["verification_uri_complete"])
+        print()
+        print("Waiting for approval...")
+
+    deadline = time.monotonic() + int(device.get("expires_in") or 600)
+    interval = max(int(device.get("interval") or 5), 1)
+    while time.monotonic() < deadline:
+        time.sleep(interval)
+        try:
+            token = client.post(
+                "/api/cli/oauth/token",
+                {
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                    "device_code": device.get("device_code"),
+                },
+                auth=False,
+            )
+            return save_login(args, api_url, token)
+        except ApiError as exc:
+            api_code = ""
+            if isinstance(exc.payload, dict):
+                api_code = str(exc.payload.get("error") or "")
+            if api_code == "authorization_pending":
+                continue
+            if api_code in {"authorization_denied", "access_denied"}:
+                raise LmgramError("AUTHORIZATION_DENIED", "The LMGram connection was denied.", EXIT_CANCELLED) from exc
+            raise
+    raise LmgramError("AUTHORIZATION_EXPIRED", "The LMGram connection code expired.", EXIT_CANCELLED)
+
+
+def save_login(args: argparse.Namespace, api_url: str, token: dict[str, Any]) -> int:
+    expires = None
+    if token.get("expires_in"):
+        expires = (datetime.now(timezone.utc) + timedelta(seconds=int(token["expires_in"]))).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+    profile = StoredProfile(
+        api_base_url=api_url,
+        access_token=token.get("access_token"),
+        refresh_token=token.get("refresh_token"),
+        token_type=token.get("token_type") or "Bearer",
+        expires_at=expires,
+        scopes=str(token.get("scope") or "").split(),
+    )
+    auth_client = ApiClient(api_url, token=profile.access_token, verbose=args.verbose)
+    try:
+        me = get_me(auth_client)
+        profile.user_id = me.get("id") or me.get("user_id")
+        profile.account_email = me.get("email")
+    except LmgramError:
+        me = None
+
+    ConfigStore().save_profile(args.profile, profile)
+    if args.json:
+        emit_json({"ok": True, "profile": profile.to_dict(), "me": me})
+    else:
+        name = me.get("displayName") or me.get("name") if isinstance(me, dict) else "LMGram"
+        print(f"Logged in as {name}.")
+    return 0
+
+
+def cmd_logout(args: argparse.Namespace) -> int:
+    client, store, _profile = client_for(args, require_auth=False)
+    try:
+        if client.token:
+            client.post("/api/cli/oauth/revoke", {})
+    except LmgramError:
+        pass
+    store.clear_profile(args.profile)
+    if args.json:
+        emit_json({"ok": True})
+    else:
+        print("Logged out.")
+    return 0
+
+
+def cmd_whoami(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    me = get_me(client)
+    if args.json:
+        emit_json({"ok": True, "user": me})
+    else:
+        display = me.get("displayName") or me.get("name") or me.get("id") or me.get("user_id")
+        handle = me.get("publicId") or me.get("handle")
+        print(f"Logged in as {display}{f' (@{handle})' if handle else ''}")
+        if me.get("email"):
+            print(f"Email: {me['email']}")
+        scopes = me.get("scopes")
+        if scopes:
+            print(f"Scopes: {', '.join(scopes)}")
+    return 0
+
+
+def get_me(client: ApiClient) -> dict[str, Any]:
+    try:
+        return client.get("/api/cli/me")
+    except ApiError as exc:
+        if exc.status == 404:
+            return client.get("/api/me")
+        raise
+
+
+def cmd_intent_create(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    expires = expires_at(args.expires)
+    body = {
+        "text": args.text,
+        "context": args.context,
+        "visibility": "lmgram_authenticated_users",
+        "source": "cli",
+        "source_context": {"tool": args.agent, "project_name": args.project},
+        "expires_at": expires,
+        "tags": args.tag,
+        "mode": args.mode,
+        "location": args.location,
+    }
+    try:
+        result = client.post("/api/cli/intents", body)
+    except ApiError as exc:
+        if exc.status not in {404, 405}:
+            raise
+        result = legacy_create_intent(client, args)
+        result = {"fallback": "session-match", **result}
+
+    if args.json:
+        emit_json({"ok": True, "result": result})
+    else:
+        intent = result.get("intent") or result.get("session") or result
+        print(f"Intent created: {compact_id(intent, 'id', 'sessionId')}")
+        print(f"Text: {args.text}")
+        print(f"Expires: {intent.get('expiresAt') or intent.get('expires_at') or expires}")
+        print()
+        print(f"Run: lmgram matches list --intent {compact_id(intent, 'id', 'sessionId')}")
+    return 0
+
+
+def legacy_create_intent(client: ApiClient, args: argparse.Namespace) -> dict[str, Any]:
+    return client.post(
+        "/api/llm/session-match",
+        {
+            "provider": args.agent or "lmgram-cli",
+            "topic": args.text[:96],
+            "summary": args.context or args.text,
+            "need": args.text,
+            "matchType": MODE_TO_MATCH_TYPE.get(args.mode, "peer"),
+            "urgency": 0.5,
+            "sensitivity": "normal",
+            "language": args.language,
+            "maxCandidates": args.max_candidates,
+        },
+    )
+
+
+def cmd_intent_list(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    query = {"active": args.active or None, "closed": args.closed or None}
+    try:
+        result = client.get("/api/cli/intents", query=query)
+    except ApiError as exc:
+        if exc.status != 404:
+            raise
+        me = get_me(client)
+        user_id = me.get("id") or me.get("user_id")
+        if not user_id:
+            raise LmgramError("AUTH_REQUIRED", "Current account did not include a user id.", EXIT_AUTH_REQUIRED) from exc
+        result = client.get(f"/api/users/{user_id}/search-history")
+
+    if args.json:
+        emit_json({"ok": True, "intents": result})
+    else:
+        items = result if isinstance(result, list) else result.get("intents", [])
+        if not items:
+            print("No intents found.")
+            return 0
+        for item in items:
+            print(f"{compact_id(item, 'id', 'sessionId')}  {item.get('topic') or item.get('text') or item.get('need')}")
+    return 0
+
+
+def cmd_intent_show(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    result = client.get(f"/api/cli/intents/{args.intent_id}")
+    if args.json:
+        emit_json({"ok": True, "intent": result})
+    else:
+        print_record(result)
+    return 0
+
+
+def cmd_intent_close(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    result = client.post(f"/api/cli/intents/{args.intent_id}/close")
+    if args.json:
+        emit_json({"ok": True, "intent": result})
+    else:
+        print(f"Intent closed: {args.intent_id}")
+    return 0
+
+
+def cmd_intent_update(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    body: dict[str, Any] = {}
+    if args.context:
+        body["context"] = args.context
+    if args.expires:
+        body["expires_at"] = expires_at(args.expires)
+    if not body:
+        raise LmgramError("VALIDATION_ERROR", "Provide at least one field to update.", EXIT_VALIDATION)
+    result = client.patch(f"/api/cli/intents/{args.intent_id}", body)
+    if args.json:
+        emit_json({"ok": True, "intent": result})
+    else:
+        print(f"Intent updated: {args.intent_id}")
+    return 0
+
+
+def cmd_matches_list(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    query = {"intent": args.intent, "status": args.status}
+    try:
+        result = client.get("/api/cli/matches", query=query)
+    except ApiError as exc:
+        if exc.status != 404:
+            raise
+        me = get_me(client)
+        user_id = me.get("id") or me.get("user_id")
+        if not user_id:
+            raise LmgramError("AUTH_REQUIRED", "Current account did not include a user id.", EXIT_AUTH_REQUIRED) from exc
+        candidate = client.get(f"/api/users/{user_id}/match-request-summaries", query={"role": "candidate"})
+        requester = client.get(f"/api/users/{user_id}/match-request-summaries", query={"role": "requester"})
+        result = candidate + requester
+        if args.status:
+            result = [item for item in result if str(item.get("status", "")).lower() == args.status.lower()]
+        if args.intent:
+            result = [item for item in result if item.get("sessionId") == args.intent or item.get("candidateSessionId") == args.intent]
+
+    if args.json:
+        emit_json({"ok": True, "matches": result})
+    else:
+        items = result if isinstance(result, list) else result.get("matches", [])
+        print(f"{len(items)} matches")
+        for item in items:
+            print()
+            print(f"{compact_id(item, 'id', 'match_id')}  status={item.get('status', '-')}, score={item.get('score', '-')}")
+            other = item.get("candidateDisplayName") or item.get("requesterDisplayName") or item.get("other_user", {}).get("name")
+            if other:
+                print(f"  Person: {other}")
+            text = item.get("candidateNeed") or item.get("need") or item.get("other_intent", {}).get("text")
+            if text:
+                print(f"  Intent: {text}")
+            if item.get("explanation") or item.get("reason"):
+                print(f"  Reason: {item.get('explanation') or item.get('reason')}")
+    return 0
+
+
+def cmd_matches_show(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    result = client.get(f"/api/cli/matches/{args.match_id}")
+    if args.json:
+        emit_json({"ok": True, "match": result})
+    else:
+        print_record(result)
+    return 0
+
+
+def cmd_matches_accept(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    body = {"message": args.message, "source": "cli", "agent_generated": bool(args.message)}
+    try:
+        result = client.post(f"/api/cli/matches/{args.match_id}/accept", body)
+    except ApiError as exc:
+        if exc.status != 404:
+            raise
+        result = client.post(f"/api/match-requests/{args.match_id}/accept", {})
+        if args.message:
+            result = {"match": result, "warning": "Legacy API accepted the match but did not send the message."}
+
+    if args.json:
+        emit_json({"ok": True, "result": result})
+    else:
+        print(f"Match accepted: {args.match_id}")
+    return 0
+
+
+def cmd_matches_decline(args: argparse.Namespace) -> int:
+    client, _store, _profile = client_for(args)
+    body = {"reason": args.reason}
+    try:
+        result = client.post(f"/api/cli/matches/{args.match_id}/decline", body)
+    except ApiError as exc:
+        if exc.status != 404:
+            raise
+        result = client.post(f"/api/match-requests/{args.match_id}/decline", {})
+    if args.json:
+        emit_json({"ok": True, "result": result})
+    else:
+        print(f"Match declined: {args.match_id}")
+    return 0
+
+
+def print_record(value: Any, indent: int = 0) -> None:
+    prefix = " " * indent
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if isinstance(item, (dict, list)):
+                print(f"{prefix}{key}:")
+                print_record(item, indent + 2)
+            else:
+                print(f"{prefix}{key}: {item}")
+    elif isinstance(value, list):
+        for item in value:
+            print_record(item, indent)
+    else:
+        print(f"{prefix}{value}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lmgram_cli/config.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_API_URL = "https://api.lmgram.com"
+DEFAULT_PROFILE = "default"
+
+
+def config_path() -> Path:
+    override = os.environ.get("LMGRAM_CONFIG")
+    if override:
+        return Path(override).expanduser()
+
+    system = platform.system().lower()
+    if system == "windows":
+        root = os.environ.get("APPDATA") or str(Path.home() / "AppData" / "Roaming")
+        return Path(root) / "lmgram" / "config.json"
+    if system == "darwin":
+        return Path.home() / "Library" / "Application Support" / "lmgram" / "config.json"
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "lmgram" / "config.json"
+
+
+@dataclass
+class StoredProfile:
+    api_base_url: str = DEFAULT_API_URL
+    access_token: str | None = None
+    refresh_token: str | None = None
+    token_type: str = "Bearer"
+    expires_at: str | None = None
+    user_id: str | None = None
+    account_email: str | None = None
+    scopes: list[str] | None = None
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> "StoredProfile":
+        return cls(
+            api_base_url=value.get("api_base_url") or DEFAULT_API_URL,
+            access_token=value.get("access_token"),
+            refresh_token=value.get("refresh_token"),
+            token_type=value.get("token_type") or "Bearer",
+            expires_at=value.get("expires_at"),
+            user_id=value.get("user_id"),
+            account_email=value.get("account_email"),
+            scopes=list(value.get("scopes") or []),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "api_base_url": self.api_base_url,
+            "access_token": self.access_token,
+            "refresh_token": self.refresh_token,
+            "token_type": self.token_type,
+            "expires_at": self.expires_at,
+            "user_id": self.user_id,
+            "account_email": self.account_email,
+            "scopes": self.scopes or [],
+        }
+
+
+class ConfigStore:
+    def __init__(self, path: Path | None = None):
+        self.path = path or config_path()
+
+    def read(self) -> dict[str, Any]:
+        if not self.path.exists():
+            return {"profiles": {}}
+        with self.path.open("r", encoding="utf-8") as handle:
+            data = json.load(handle)
+        if "profiles" not in data:
+            data = {"profiles": {DEFAULT_PROFILE: data}}
+        return data
+
+    def write(self, data: dict[str, Any]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.path.open("w", encoding="utf-8") as handle:
+            json.dump(data, handle, indent=2, sort_keys=True)
+            handle.write("\n")
+        if os.name == "posix":
+            self.path.chmod(0o600)
+
+    def get_profile(self, name: str) -> StoredProfile:
+        data = self.read()
+        raw = data.get("profiles", {}).get(name, {})
+        return StoredProfile.from_dict(raw)
+
+    def save_profile(self, name: str, profile: StoredProfile) -> None:
+        data = self.read()
+        profiles = data.setdefault("profiles", {})
+        profiles[name] = profile.to_dict()
+        self.write(data)
+
+    def clear_profile(self, name: str) -> None:
+        data = self.read()
+        data.setdefault("profiles", {}).pop(name, None)
+        self.write(data)
+
+
+def token_from_env() -> str | None:
+    value = os.environ.get("LMGRAM_ACCESS_TOKEN")
+    return value.strip() if value and value.strip() else None

lmgram_cli/duration.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta, timezone
+
+from .errors import EXIT_VALIDATION, LmgramError
+
+
+_DURATION_RE = re.compile(r"^\s*(\d+)\s*([mhdw])\s*$", re.IGNORECASE)
+
+
+def parse_duration(value: str) -> timedelta:
+    match = _DURATION_RE.match(value)
+    if not match:
+        raise LmgramError("VALIDATION_ERROR", "Duration must look like 30m, 2h, 7d or 1w.", EXIT_VALIDATION)
+
+    amount = int(match.group(1))
+    unit = match.group(2).lower()
+    if amount <= 0:
+        raise LmgramError("VALIDATION_ERROR", "Duration must be greater than zero.", EXIT_VALIDATION)
+
+    if unit == "m":
+        return timedelta(minutes=amount)
+    if unit == "h":
+        return timedelta(hours=amount)
+    if unit == "d":
+        return timedelta(days=amount)
+    return timedelta(weeks=amount)
+
+
+def expires_at(value: str) -> str:
+    return (datetime.now(timezone.utc) + parse_duration(value)).replace(microsecond=0).isoformat().replace("+00:00", "Z")

lmgram_cli/errors.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+
+EXIT_GENERAL = 1
+EXIT_AUTH_REQUIRED = 2
+EXIT_FORBIDDEN = 3
+EXIT_VALIDATION = 4
+EXIT_NETWORK = 5
+EXIT_NOT_FOUND = 6
+EXIT_CONFLICT = 7
+EXIT_CANCELLED = 8
+
+
+class LmgramError(Exception):
+    def __init__(self, code: str, message: str, exit_code: int = EXIT_GENERAL):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.exit_code = exit_code
+
+
+class ApiError(LmgramError):
+    def __init__(self, status: int, message: str, payload: object | None = None):
+        code = {
+            400: "VALIDATION_ERROR",
+            401: "AUTH_REQUIRED",
+            403: "FORBIDDEN",
+            404: "NOT_FOUND",
+            409: "CONFLICT",
+        }.get(status, "API_ERROR")
+        exit_code = {
+            400: EXIT_VALIDATION,
+            401: EXIT_AUTH_REQUIRED,
+            403: EXIT_FORBIDDEN,
+            404: EXIT_NOT_FOUND,
+            409: EXIT_CONFLICT,
+        }.get(status, EXIT_GENERAL)
+        super().__init__(code, message, exit_code)
+        self.status = status
+        self.payload = payload
+
+
+class NetworkError(LmgramError):
+    def __init__(self, message: str):
+        super().__init__("NETWORK_ERROR", message, EXIT_NETWORK)

lmgram_cli/output.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+
+def emit_json(value: Any) -> None:
+    print(json.dumps(value, ensure_ascii=False, separators=(",", ":")))
+
+
+def error_payload(code: str, message: str) -> dict[str, Any]:
+    return {"ok": False, "error": {"code": code, "message": message}}
+
+
+def human_error(message: str) -> None:
+    print(f"Error: {message}", file=sys.stderr)
+
+
+def compact_id(value: dict[str, Any], *keys: str) -> str:
+    for key in keys:
+        item = value.get(key)
+        if item:
+            return str(item)
+    return "-"

lmgram_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: lmgram-cli
+Version: 0.1.0
+Summary: Command line interface for LMGram agent-driven intent matching.
+Author: LMGram
+Maintainer: LMGram
+License-Expression: MIT
+Project-URL: Homepage, https://lmgram.com
+Project-URL: Documentation, https://lmgram.com
+Project-URL: Repository, https://github.com/lmgram/lmgram
+Project-URL: Issues, https://github.com/lmgram/lmgram/issues
+Keywords: lmgram,cli,agents,matching,intent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# LMGram CLI
+
+Python CLI for LMGram agents and developer workflows.
+
+```bash
+pip install lmgram-cli
+lmgram login
+lmgram whoami
+lmgram intent create "Need advice from someone who passed Google OAuth verification"
+lmgram matches list
+```
+
+The CLI is designed around authenticated LMGram accounts. It never asks for Google credentials. `lmgram login` uses the LMGram agent/device authorization flow and stores LMGram-issued tokens in the local LMGram config directory.
+
+## Configuration
+
+Defaults:
+
+- API: `https://api.lmgram.com`
+- App approval URL: returned by the API, normally `https://app.lmgram.com/agent-connect`
+- Config path:
+  - Windows: `%APPDATA%\lmgram\config.json`
+  - macOS: `~/Library/Application Support/lmgram/config.json`
+  - Linux: `~/.config/lmgram/config.json`
+
+Environment overrides:
+
+```bash
+LMGRAM_API_URL=http://localhost:5000
+LMGRAM_ACCESS_TOKEN=lmg_at_xxx
+LMGRAM_PROFILE=default
+```
+
+Global options:
+
+```bash
+lmgram --json --api-url http://localhost:5000 --profile dev whoami
+```
+
+## MVP commands
+
+```bash
+lmgram login
+lmgram logout
+lmgram whoami
+
+lmgram intent create "Need to find someone who implemented Google OAuth verification"
+lmgram intent list
+lmgram intent show intent_123
+lmgram intent close intent_123
+
+lmgram matches list
+lmgram matches show match_123
+lmgram matches accept match_123
+lmgram matches decline match_123
+```
+
+## Backend compatibility
+
+The preferred API surface is `/api/cli/*`, matching `docs/cli-tool-implementation.md`.
+
+Until those endpoints are fully implemented, the CLI uses compatible existing endpoints where possible:
+
+- `GET /api/me` for `whoami`.
+- `POST /api/llm/session-match` as a fallback for `intent create`.
+- `GET /api/users/{id}/search-history` as a fallback for `intent list`.
+- `GET /api/users/{id}/match-request-summaries` as a fallback for `matches list`.
+- `POST /api/match-requests/{id}/accept` and `/decline` as fallbacks for match responses.
+
+Commands with `--json` emit only JSON and use stable error envelopes.
+
+## Build locally
+
+```bash
+cd apps/cli
+python -m pip install -e .
+python -m unittest
+```

lmgram_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+lmgram_cli/__init__.py,sha256=41Lq3UMTCf4erhyxDA_maxpoMuKY5qsyvdVWRrXPJzg,60
+lmgram_cli/__main__.py,sha256=pb2bv7Lw6q-BWUue8v6YGW8OXQEZ9V_cSmC9G70FtjE,120
+lmgram_cli/api.py,sha256=HW4-mleuAui3svYGEA7qAy6oW5ftYIPIK-3AniGpzII,3692
+lmgram_cli/cli.py,sha256=ToNA7Ey1ClDg0uwckHaFWv1z6RQ6drUN3IGX5PuBbFg,19049
+lmgram_cli/config.py,sha256=Q5JsJrMdjsF0Ng_suIHwXmX5c-Ty5yEDUXEZdqXC9B0,3551
+lmgram_cli/duration.py,sha256=ItYvslNzSaSzjZxh73cT8BRyIipCXBCsu4SR2rSQ8PM,994
+lmgram_cli/errors.py,sha256=9bT7sGZ4OpLfmmaYMNSc-0gHCLOJFff8-juOx8L2nwI,1227
+lmgram_cli/output.py,sha256=q105qq6gpjpfXOVUfS2pjBYYrV7i5jjNu1LBnYApDKE,586
+lmgram_cli-0.1.0.dist-info/licenses/LICENSE,sha256=gQW8x8MpE0VbOVh3cF7TKMC0xMc3xOaHsWYeyRxwVXg,1063
+lmgram_cli-0.1.0.dist-info/METADATA,sha256=2pli2hnUHplIOq0u__2mQ6KaOB1WyeBl6ywB-mdCaWk,3415
+lmgram_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lmgram_cli-0.1.0.dist-info/entry_points.txt,sha256=lpQtAY20CUu_oBMcd8JJkbG-piVZmecgxmIZwaOemVo,52
+lmgram_cli-0.1.0.dist-info/top_level.txt,sha256=dXFqHbejd3dGZPzlOIv2m9Ah-WEBaN6hoZtKRozvYQM,11
+lmgram_cli-0.1.0.dist-info/RECORD,,

lmgram_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lmgram_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lmgram = lmgram_cli.__main__:main

lmgram_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LMGram
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lmgram_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lmgram_cli