oto-cli 1.0.0__py3-none-any.whl

oto/commands/folk.py

@@ -0,0 +1,238 @@
+"""Folk CRM commands."""
+
+import json
+import typer
+from typing import Optional
+
+app = typer.Typer(help="Folk CRM — contacts, companies, deals, notes")
+
+
+def _out(data):
+    print(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def _client():
+    from oto.tools.folk import FolkClient
+    return FolkClient()
+
+
+# --- Groups ---
+
+@app.command("groups")
+def groups():
+    """List all groups (pipelines)."""
+    items = _client().list_groups()
+    _out({"count": len(items), "groups": items})
+
+
+# --- People ---
+
+@app.command("people")
+def people(
+    search: Optional[str] = typer.Argument(None, help="Search by name"),
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Filter by group ID"),
+):
+    """List contacts."""
+    c = _client()
+    filters = {}
+    if search:
+        filters["fullName"] = search
+    items = c.list_people(**filters)
+    result = []
+    for p in items:
+        result.append({
+            "id": p["id"],
+            "name": p.get("fullName") or f"{p.get('firstName','')} {p.get('lastName','')}".strip(),
+            "jobTitle": p.get("jobTitle", ""),
+            "emails": p.get("emails", []),
+            "companies": [co.get("name", "") for co in p.get("companies", [])],
+        })
+    _out({"count": len(result), "people": result})
+
+
+@app.command("person")
+def person(person_id: str = typer.Argument(..., help="Person ID (per_...)")):
+    """Get a person's details."""
+    _out(_client().get_person(person_id))
+
+
+@app.command("add-person")
+def add_person(
+    first_name: str = typer.Argument(...),
+    last_name: Optional[str] = typer.Option(None, "--last", "-l"),
+    email: Optional[str] = typer.Option(None, "--email", "-e"),
+    phone: Optional[str] = typer.Option(None, "--phone"),
+    job_title: Optional[str] = typer.Option(None, "--title", "-t"),
+    company: Optional[str] = typer.Option(None, "--company", "-c", help="Company name (creates if needed)"),
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Group ID"),
+):
+    """Create a contact."""
+    emails = [email] if email else None
+    phones = [phone] if phone else None
+    group_ids = [group] if group else None
+    result = _client().create_person(
+        first_name=first_name, last_name=last_name,
+        emails=emails, phones=phones, job_title=job_title,
+        company_name=company, group_ids=group_ids,
+    )
+    _out(result)
+
+
+@app.command("update-person")
+def update_person(
+    person_id: str = typer.Argument(..., help="Person ID (per_...)"),
+    first_name: Optional[str] = typer.Option(None, "--first"),
+    last_name: Optional[str] = typer.Option(None, "--last"),
+    email: Optional[str] = typer.Option(None, "--email", "-e"),
+    job_title: Optional[str] = typer.Option(None, "--title", "-t"),
+    company: Optional[str] = typer.Option(None, "--company", "-c"),
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Set group (replaces all)"),
+):
+    """Update a contact."""
+    fields = {}
+    if first_name:
+        fields["firstName"] = first_name
+    if last_name:
+        fields["lastName"] = last_name
+    if email:
+        fields["emails"] = [email]
+    if job_title:
+        fields["jobTitle"] = job_title
+    if company:
+        fields["companies"] = [{"name": company}]
+    if group:
+        fields["groups"] = [{"id": group}]
+    _out(_client().update_person(person_id, **fields))
+
+
+@app.command("delete-person")
+def delete_person(person_id: str = typer.Argument(..., help="Person ID (per_...)")):
+    """Delete a contact."""
+    _client().delete_person(person_id)
+    print(f"Deleted {person_id}")
+
+
+# --- Companies ---
+
+@app.command("companies")
+def companies(search: Optional[str] = typer.Argument(None, help="Search by name")):
+    """List companies."""
+    filters = {}
+    if search:
+        filters["name"] = search
+    items = _client().list_companies(**filters)
+    _out({"count": len(items), "companies": items})
+
+
+def _parse_fields(fields: Optional[list[str]]) -> dict:
+    """Parse --field key=value pairs into a dict."""
+    if not fields:
+        return {}
+    result = {}
+    for f in fields:
+        if "=" not in f:
+            raise typer.BadParameter(f"Invalid field format: {f!r} (expected key=value)")
+        key, value = f.split("=", 1)
+        result[key] = value
+    return result
+
+
+@app.command("add-company")
+def add_company(
+    name: str = typer.Argument(...),
+    industry: Optional[str] = typer.Option(None, "--industry", "-i"),
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Group ID"),
+    fields: Optional[list[str]] = typer.Option(None, "--field", "-f", help="Custom field key=value (requires --group)"),
+):
+    """Create a company."""
+    extra: dict = {}
+    if group:
+        extra["groups"] = [{"id": group}]
+    custom = _parse_fields(fields)
+    if custom:
+        if not group:
+            raise typer.BadParameter("--field requires --group")
+        extra["customFieldValues"] = {group: custom}
+    _out(_client().create_company(name=name, industry=industry, **extra))
+
+
+@app.command("update-company")
+def update_company(
+    company_id: str = typer.Argument(..., help="Company ID (com_...)"),
+    name: Optional[str] = typer.Option(None, "--name", "-n"),
+    industry: Optional[str] = typer.Option(None, "--industry", "-i"),
+    group: Optional[str] = typer.Option(None, "--group", "-g", help="Group ID"),
+    fields: Optional[list[str]] = typer.Option(None, "--field", "-f", help="Custom field key=value (requires --group)"),
+):
+    """Update a company."""
+    data: dict = {}
+    if name:
+        data["name"] = name
+    if industry:
+        data["industry"] = industry
+    if group:
+        data["groups"] = [{"id": group}]
+    custom = _parse_fields(fields)
+    if custom:
+        if not group:
+            raise typer.BadParameter("--field requires --group")
+        data["customFieldValues"] = {group: custom}
+    _out(_client().update_company(company_id, **data))
+
+
+@app.command("delete-company")
+def delete_company(company_id: str = typer.Argument(..., help="Company ID (com_...)")):
+    """Delete a company."""
+    _client().delete_company(company_id)
+    print(f"Deleted {company_id}")
+
+
+# --- Deals ---
+
+@app.command("deals")
+def deals(
+    group: str = typer.Option(None, "--group", "-g", help="Group ID (default: first group)"),
+    object_type: str = typer.Option("deals", "--type", "-t", help="Object type name"),
+):
+    """List deals in a pipeline group."""
+    c = _client()
+    if not group:
+        groups = c.list_groups()
+        if not groups:
+            print("No groups found.")
+            raise typer.Exit(1)
+        group = groups[0]["id"]
+    items = c.list_deals(group, object_type)
+    _out({"count": len(items), "group": group, "deals": items})
+
+
+# --- Notes ---
+
+@app.command("notes")
+def notes(entity_id: str = typer.Argument(..., help="Entity ID (per_/com_/obj_)")):
+    """List notes for an entity."""
+    items = _client().list_notes(entity_id)
+    _out({"count": len(items), "notes": items})
+
+
+@app.command("add-note")
+def add_note(
+    entity_id: str = typer.Argument(..., help="Entity ID"),
+    content: str = typer.Argument(..., help="Note content (markdown)"),
+):
+    """Add a note to a person/company/deal."""
+    _out(_client().create_note(entity_id, content))
+
+
+# --- Interactions ---
+
+@app.command("add-interaction")
+def add_interaction(
+    entity_id: str = typer.Argument(..., help="Person or company ID"),
+    type: str = typer.Argument(..., help="Type: call, meeting, email, linkedin, etc."),
+    title: str = typer.Argument(..., help="Short title"),
+    content: Optional[str] = typer.Option(None, "--content", "-c"),
+    date: Optional[str] = typer.Option(None, "--date", "-d", help="ISO datetime"),
+):
+    """Log an interaction (call, meeting, email...)."""
+    _out(_client().create_interaction(entity_id, type, title, content, date))

oto/commands/google.py

@@ -0,0 +1,355 @@
+"""Google Workspace commands (Drive, Docs, Sheets, Slides, Gmail, Calendar, Auth)."""
+
+import typer
+from typing import Optional
+
+app = typer.Typer(help="Google Workspace tools (Drive, Docs, Sheets, Slides, Gmail, Calendar)")
+
+
+def _apply_signature(client, body: str, html: Optional[str]) -> Optional[str]:
+    """Convert plain text body to HTML with Gmail signature appended."""
+    import html as html_mod
+    signature = client.get_signature()
+    if not signature:
+        return html
+    body_html = html or '<div dir="ltr">' + html_mod.escape(body).replace('\n', '<br>') + '</div>'
+    return body_html + '<br>--<br>' + signature
+
+
+@app.command("drive-list")
+def drive_list(
+    folder_id: Optional[str] = typer.Option(None, help="Filter by parent folder ID"),
+    query: Optional[str] = typer.Option(None, help="Custom query filter"),
+    limit: int = typer.Option(100, help="Max results"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """List files in Google Drive."""
+    from oto.tools.google.drive.lib.drive_client import DriveClient
+    import json
+
+    client = DriveClient(account=account)
+    files = client.list_files(folder_id=folder_id, query=query, page_size=limit)
+    print(json.dumps({"count": len(files), "files": files}, indent=2))
+
+
+@app.command("drive-download")
+def drive_download(
+    file_id: str = typer.Argument(..., help="Google Drive file ID"),
+    output: str = typer.Argument(..., help="Output path"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Download a file from Google Drive."""
+    from oto.tools.google.drive.lib.drive_client import DriveClient
+
+    client = DriveClient(account=account)
+    result = client.download_file(file_id, output)
+    print(f"Downloaded: {result['filename']} -> {result['output_path']}")
+
+
+@app.command("drive-upload")
+def drive_upload(
+    file_path: str = typer.Argument(..., help="Local file path to upload"),
+    folder_id: Optional[str] = typer.Option(None, help="Target folder ID in Drive"),
+    name: Optional[str] = typer.Option(None, help="Custom filename (defaults to local name)"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Upload a file to Google Drive."""
+    from oto.tools.google.drive.lib.drive_client import DriveClient
+    import json
+
+    client = DriveClient(account=account)
+    result = client.upload_file(local_path=file_path, folder_id=folder_id, file_name=name)
+    print(json.dumps(result, indent=2))
+
+
+@app.command("docs-headings")
+def docs_headings(
+    doc_id: str = typer.Argument(..., help="Google Docs document ID"),
+):
+    """List headings in a Google Doc."""
+    from oto.tools.google.docs.lib.docs_client import DocsClient
+    import json
+
+    client = DocsClient()
+    headings = client.list_headings(doc_id)
+    print(json.dumps(headings, indent=2))
+
+
+@app.command("docs-section")
+def docs_section(
+    doc_id: str = typer.Argument(..., help="Google Docs document ID"),
+    heading: str = typer.Argument(..., help="Heading text to find"),
+):
+    """Get content of a section in a Google Doc."""
+    from oto.tools.google.docs.lib.docs_client import DocsClient
+
+    client = DocsClient()
+    section = client.get_section_content(doc_id, heading)
+    if section:
+        print(f"# {section.title}\n")
+        print(section.content)
+    else:
+        print(f"Section not found: {heading}")
+        raise typer.Exit(1)
+
+
+@app.command("auth")
+def auth(
+    name: str = typer.Argument("default", help="Account name (e.g. 'gmail', 'work')"),
+    list_accounts: bool = typer.Option(False, "--list", "-l", help="List configured accounts"),
+):
+    """Set up or list Google OAuth accounts."""
+    from oto.tools.google.credentials import list_accounts as _list_accounts, setup_account, DEFAULT_SCOPES as DRIVE_SCOPES
+    from oto.tools.google.gmail.lib.gmail_client import SCOPES as GMAIL_SCOPES
+    from oto.tools.google.calendar.lib.calendar_client import SCOPES as CALENDAR_SCOPES
+
+    ALL_SCOPES = list(set(GMAIL_SCOPES + CALENDAR_SCOPES + DRIVE_SCOPES))
+
+    if list_accounts:
+        accounts = _list_accounts()
+        if not accounts:
+            print("No accounts configured. Run: oto google auth <name>")
+        else:
+            for a in accounts:
+                print(f"  {a}")
+        return
+
+    print(f"Setting up account '{name}'... Opening browser for Google consent.")
+    setup_account(name, ALL_SCOPES)
+    print(f"Account '{name}' configured.")
+
+
+@app.command("calendar-list")
+def calendar_list(
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """List available calendars."""
+    from oto.tools.google.calendar.lib.calendar_client import CalendarClient
+    import json
+
+    client = CalendarClient(account=account)
+    calendars = client.list_calendars()
+    print(json.dumps({"count": len(calendars), "calendars": calendars}, indent=2, ensure_ascii=False))
+
+
+@app.command("calendar-today")
+def calendar_today(
+    calendar_id: str = typer.Option("primary", "--calendar", "-c", help="Calendar ID"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """List today's events."""
+    from oto.tools.google.calendar.lib.calendar_client import CalendarClient
+    import json
+
+    client = CalendarClient(account=account)
+    events = client.today(calendar_id=calendar_id)
+    print(json.dumps({"count": len(events), "events": events}, indent=2, ensure_ascii=False))
+
+
+@app.command("calendar-upcoming")
+def calendar_upcoming(
+    days: int = typer.Option(7, "--days", "-d", help="Number of days ahead"),
+    calendar_id: str = typer.Option("primary", "--calendar", "-c", help="Calendar ID"),
+    limit: int = typer.Option(50, "--limit", "-n", help="Max events"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """List upcoming events (default: next 7 days)."""
+    from oto.tools.google.calendar.lib.calendar_client import CalendarClient
+    import json
+
+    client = CalendarClient(account=account)
+    events = client.upcoming(days=days, calendar_id=calendar_id, max_results=limit)
+    print(json.dumps({"count": len(events), "events": events}, indent=2, ensure_ascii=False))
+
+
+@app.command("calendar-search")
+def calendar_search(
+    query: str = typer.Argument(..., help="Search query"),
+    days: int = typer.Option(30, "--days", "-d", help="Search window in days"),
+    calendar_id: str = typer.Option("primary", "--calendar", "-c", help="Calendar ID"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Max events"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Search calendar events."""
+    from oto.tools.google.calendar.lib.calendar_client import CalendarClient
+    from datetime import datetime, timedelta, timezone
+    import json
+
+    client = CalendarClient(account=account)
+    now = datetime.now(timezone.utc)
+    events = client.list_events(
+        calendar_id=calendar_id,
+        time_min=now.isoformat(),
+        time_max=(now + timedelta(days=days)).isoformat(),
+        max_results=limit,
+        query=query,
+    )
+    print(json.dumps({"count": len(events), "events": events}, indent=2, ensure_ascii=False))
+
+
+@app.command("calendar-get")
+def calendar_get(
+    event_id: str = typer.Argument(..., help="Event ID"),
+    calendar_id: str = typer.Option("primary", "--calendar", "-c", help="Calendar ID"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Get details of a calendar event."""
+    from oto.tools.google.calendar.lib.calendar_client import CalendarClient
+    import json
+
+    client = CalendarClient(account=account)
+    event = client.get_event(event_id, calendar_id=calendar_id)
+    print(json.dumps(event, indent=2, ensure_ascii=False))
+
+
+@app.command("gmail-list")
+def gmail_list(
+    query: Optional[str] = typer.Option(None, help="Gmail search query"),
+    label: Optional[str] = typer.Option(None, help="Filter by label ID"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Max messages"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """List recent Gmail messages."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    label_ids = [label] if label else None
+    messages = client.list_messages(query=query, label_ids=label_ids, max_results=limit)
+    print(json.dumps({"count": len(messages), "messages": messages}, indent=2, ensure_ascii=False))
+
+
+@app.command("gmail-search")
+def gmail_search(
+    query: str = typer.Argument(..., help="Gmail search query (e.g. 'is:unread', 'from:user@example.com')"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Max messages"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Search Gmail messages."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    messages = client.search(query=query, max_results=limit)
+    print(json.dumps({"count": len(messages), "messages": messages}, indent=2, ensure_ascii=False))
+
+
+@app.command("gmail-get")
+def gmail_get(
+    message_id: str = typer.Argument(..., help="Gmail message ID"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Read a Gmail message."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    message = client.get_message(message_id)
+    print(json.dumps(message, indent=2, ensure_ascii=False))
+
+
+@app.command("gmail-attachments")
+def gmail_attachments(
+    message_id: str = typer.Argument(..., help="Gmail message ID"),
+    output: str = typer.Option(".", "--output", "-o", help="Output directory"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Download attachments from a Gmail message."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    files = client.download_attachments(message_id, output)
+    print(json.dumps({"count": len(files), "files": files}, indent=2, ensure_ascii=False))
+
+
+@app.command("gmail-draft")
+def gmail_draft(
+    to: Optional[str] = typer.Option(None, help="Recipient email (auto-detected with --reply-to)"),
+    subject: Optional[str] = typer.Option(None, help="Email subject (auto-detected with --reply-to)"),
+    body: str = typer.Option(..., help="Email body (plain text)"),
+    html: Optional[str] = typer.Option(None, help="Email body (HTML). If provided, sent as multipart alternative with plain text."),
+    cc: Optional[str] = typer.Option(None, help="CC recipients"),
+    bcc: Optional[str] = typer.Option(None, help="BCC recipients"),
+    reply_to: Optional[str] = typer.Option(None, "--reply-to", "-r", help="Message ID to reply to (threads the draft)"),
+    attach: Optional[list[str]] = typer.Option(None, "--attach", "-f", help="File paths to attach"),
+    sign: bool = typer.Option(True, "--sign/--no-sign", help="Append Gmail signature"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Create a draft email in Gmail. Use --reply-to for threaded replies."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    final_html = _apply_signature(client, body, html) if sign else html
+    if reply_to:
+        result = client.create_draft_reply(message_id=reply_to, body=body, html=final_html, cc=cc, attachments=attach)
+    else:
+        if not to or not subject:
+            raise typer.BadParameter("--to and --subject are required (unless using --reply-to)")
+        result = client.create_draft(to=to, subject=subject, body=body, html=final_html, cc=cc, bcc=bcc, attachments=attach)
+    print(json.dumps(result, indent=2))
+
+
+@app.command("gmail-reply")
+def gmail_reply(
+    message_id: str = typer.Argument(..., help="Gmail message ID to reply to"),
+    body: str = typer.Option(..., help="Reply body (plain text)"),
+    html: Optional[str] = typer.Option(None, help="Reply body (HTML)"),
+    cc: Optional[str] = typer.Option(None, help="CC recipients"),
+    attach: Optional[list[str]] = typer.Option(None, "--attach", "-f", help="File paths to attach"),
+    sign: bool = typer.Option(True, "--sign/--no-sign", help="Append Gmail signature"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Reply to a Gmail message (preserves thread)."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    final_html = _apply_signature(client, body, html) if sign else html
+    result = client.reply(message_id=message_id, body=body, html=final_html, cc=cc, attachments=attach)
+    print(json.dumps(result, indent=2))
+
+
+@app.command("gmail-send")
+def gmail_send(
+    to: str = typer.Option(..., help="Recipient email"),
+    subject: str = typer.Option(..., help="Email subject"),
+    body: str = typer.Option(..., help="Email body (plain text)"),
+    html: Optional[str] = typer.Option(None, help="Email body (HTML)"),
+    cc: Optional[str] = typer.Option(None, help="CC recipients"),
+    bcc: Optional[str] = typer.Option(None, help="BCC recipients"),
+    attach: Optional[list[str]] = typer.Option(None, "--attach", "-f", help="File paths to attach"),
+    sign: bool = typer.Option(True, "--sign/--no-sign", help="Append Gmail signature"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Send an email via Gmail."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    final_html = _apply_signature(client, body, html) if sign else html
+    result = client.send(to=to, subject=subject, body=body, html=final_html, cc=cc, bcc=bcc, attachments=attach)
+    print(json.dumps(result, indent=2))
+
+
+@app.command("gmail-archive")
+def gmail_archive(
+    message_ids: Optional[list[str]] = typer.Argument(None, help="Gmail message IDs to archive"),
+    query: Optional[str] = typer.Option(None, "--query", "-q", help="Archive all messages matching this Gmail query"),
+    account: Optional[str] = typer.Option(None, "--account", "-a", help="Google account name"),
+):
+    """Archive Gmail messages (remove from inbox)."""
+    from oto.tools.google.gmail.lib.gmail_client import GmailClient
+    import json
+
+    client = GmailClient(account=account)
+    ids = list(message_ids or [])
+    if query:
+        msgs = client.search(query=query, max_results=100)
+        ids.extend(m['id'] for m in msgs if 'INBOX' in m.get('labelIds', []))
+    if not ids:
+        print(json.dumps({"archived": 0, "message": "No messages to archive"}))
+        return
+    results = client.archive_messages(ids)
+    print(json.dumps({"archived": len(results), "results": results}, indent=2))

oto/commands/notion.py

@@ -0,0 +1,58 @@
+"""Notion commands (search, page, database)."""
+
+import typer
+from typing import Optional
+
+app = typer.Typer(help="Notion tools")
+
+
+@app.command("search")
+def search(
+    query: str = typer.Argument(..., help="Search query"),
+    filter_type: Optional[str] = typer.Option(None, help="Filter by type (page, database)"),
+):
+    """Search Notion workspace."""
+    from oto.tools.notion.lib.notion_client import NotionClient
+    import json
+
+    client = NotionClient()
+    results = client.search(query, filter_type=filter_type)
+    print(json.dumps(results, indent=2, ensure_ascii=False))
+
+
+@app.command("page")
+def page(
+    page_id: str = typer.Argument(..., help="Notion page ID"),
+    blocks: bool = typer.Option(False, "--blocks", "-b", help="Include page blocks/content"),
+):
+    """Get a Notion page."""
+    from oto.tools.notion.lib.notion_client import NotionClient
+    import json
+
+    client = NotionClient()
+    page = client.get_page(page_id)
+
+    if blocks:
+        page["blocks"] = client.get_page_blocks(page_id, recursive=True)
+
+    print(json.dumps(page, indent=2, ensure_ascii=False))
+
+
+@app.command("database")
+def database(
+    database_id: str = typer.Argument(..., help="Notion database ID"),
+    query: bool = typer.Option(False, "--query", "-q", help="Query database entries"),
+    limit: int = typer.Option(100, help="Max results when querying"),
+):
+    """Get a Notion database schema or query its entries."""
+    from oto.tools.notion.lib.notion_client import NotionClient
+    import json
+
+    client = NotionClient()
+
+    if query:
+        results = client.query_database(database_id, page_size=limit)
+        print(json.dumps(results, indent=2, ensure_ascii=False))
+    else:
+        db = client.get_database(database_id)
+        print(json.dumps(db, indent=2, ensure_ascii=False))