the-office-cli 1.0.0__py3-none-any.whl

the_office_cli/a2a.py

@@ -0,0 +1,93 @@
+# *[Michael hands out business cards at the conference]*
+
+"""
+a2a.py — The business card.
+
+The Agent Card for the A2A protocol. When another agent
+asks "who are you and what can you do?" — this is what
+they get back. Skills are derived from the command
+registry so the card is always in sync with the CLI.
+"""
+
+from the_office_cli.config import get_api_url
+from the_office_cli.utils.registry import get_registry
+
+PROTOCOL_VERSION = "0.2.1"
+AGENT_VERSION = "1.0.0"
+
+def _to_json_schema(fields: dict) -> dict:
+    """Turn the CLI's inline input/output shape into proper
+    JSON Schema — required fields lifted to the top."""
+    properties: dict = {}
+    required: list[str] = []
+    for field_name, field_def in fields.items():
+        if isinstance(field_def, dict):
+            prop = {k: v for k, v in field_def.items() if k != "required"}
+            properties[field_name] = prop
+            if field_def.get("required"):
+                required.append(field_name)
+        else:
+            properties[field_name] = field_def
+    schema = {"type": "object", "properties": properties}
+    if required:
+        schema["required"] = required
+    return schema
+
+def _to_skill(config: dict) -> dict:
+    """Turn a registered command into an A2A skill — id,
+    name, description, schemas, example invocation."""
+    s = config["schema"]
+    full_name = config.get("full_name") or (
+        f"{config.get('_group', '')} {config['name']}".strip()
+    )
+    return {
+        "id": full_name.replace(" ", "-"),
+        "name": full_name.title(),
+        "description": config.get("description", ""),
+        "tags": [config.get("_group", "")],
+        "inputSchema": _to_json_schema(s.get("input", {})),
+        "outputSchema": _to_json_schema(s.get("output", {})),
+        "examples": [f"the-office {full_name}"],
+    }
+
+def _build_card(base_url: str) -> dict:
+    """Print a fresh business card with today's skills."""
+    return {
+        "protocolVersion": PROTOCOL_VERSION,
+        "id": "the-office",
+        "name": "the-office",
+        "description": "The World's Best Sales Agent CLI.",
+        "url": base_url,
+        "version": AGENT_VERSION,
+        "provider": {
+            "organization": "The Office",
+        },
+        "capabilities": {
+            "streaming": False,
+            "pushNotifications": False,
+            "extendedAgentCard": False,
+            "cardSigning": False,
+            "taskStore": False,
+        },
+        "interfaces": [
+            {"protocolBinding": "JSONRPC", "url": f"{base_url}/rpc"},
+        ],
+        "securitySchemes": {
+            "bearerJwt": {
+                "type": "http",
+                "scheme": "bearer",
+                "bearerFormat": "JWT",
+            },
+        },
+        "security": [{"bearerJwt": []}],
+        "defaultInputModes": ["application/json"],
+        "defaultOutputModes": ["application/json"],
+        "skills": [_to_skill(cfg) for cfg in get_registry()],
+    }
+
+def get_agent_card(base_url: str | None = None) -> dict:
+    """Hand out the business card — URL defaults to the API
+    the CLI is currently pointed at."""
+    return _build_card(base_url or get_api_url())
+
+# Card handed out.

the_office_cli/cli/decorators.py

@@ -0,0 +1,179 @@
+# *[sets up the projector in the conference room]*
+
+"""
+decorators.py — Sales training.
+
+Before a command hits the floor, it goes through
+training — learns the script (validation), does a
+dry run (preview), and gets cleared for live calls.
+"""
+
+import json
+import sys
+from typing import Callable
+
+import click
+
+from the_office_cli.cli.flags import (
+    confirm_option,
+    dry_run_option,
+    idempotency_key_option,
+    schema_option,
+)
+from the_office_cli.network.errors import ApiError
+from the_office_cli.network import session
+from the_office_cli.network.session import set_idempotency_key
+from the_office_cli.utils.output import EXIT_SUCCESS, error_stderr, output_stdout
+from the_office_cli.utils.schema import print_schema
+
+def _read_stdin(schema: dict, stdin_error: str) -> dict:
+    """Read the training materials. If the basics are
+    missing, you're not ready for the floor."""
+    body = session.input_stdin()
+    if not body:
+        error_stderr("INVALID_INPUT", stdin_error)
+    for field_name, field_def in schema.get("input", {}).items():
+        if (
+            isinstance(field_def, dict)
+            and field_def.get("required")
+            and field_name not in body
+        ):
+            error_stderr("INVALID_INPUT", f"Missing required field: {field_name}")
+    return body
+
+def _print_dry_run(command: str, schema: dict, kwargs: dict) -> None:
+    """Roleplay the call without a real client on the
+    line — practice round, then stop."""
+    click.echo(
+        json.dumps(
+            {
+                "status": "dry_run",
+                "command": command,
+                "would_call": {
+                    "method": schema["method"],
+                    "endpoint": schema["endpoint"],
+                },
+                "with_options": {
+                    k: v for k, v in kwargs.items() if v is not None
+                },
+            }
+        )
+    )
+    sys.exit(EXIT_SUCCESS)
+
+def _require_confirm(command: str) -> None:
+    """Firing a client is permanent. Say it out loud
+    first. DELETEs need --confirm."""
+    error_stderr("CONFIRMATION_REQUIRED", f"Pass --confirm to execute: {command}")
+
+def _execute(fn: Callable, kwargs: dict) -> None:
+    """Training's over. Make the real call. If it lands,
+    print the win. If not, file the loss."""
+    try:
+        result = fn(**kwargs)
+        result = _apply_pagination(result, kwargs)
+        output_stdout(result)
+    except ApiError as e:
+        error_stderr(
+            e.code,
+            str(e),
+            exit_code=e.exit_code,
+            retry=e.retry,
+            retry_after=e.retry_after,
+        )
+    except SystemExit:
+        raise
+    except Exception as e:
+        error_stderr("UNKNOWN_ERROR", str(e))
+
+def _apply_pagination(result: dict, kwargs: dict) -> dict:
+    """When the call returns a long list, add page numbers
+    so the caller knows where they are."""
+    if "items" not in result:
+        return result
+    page = kwargs.get("page")
+    per_page = kwargs.get("per_page")
+    if page is None or per_page is None:
+        return result
+    items = result["items"]
+    result["page"] = page
+    result["per_page"] = per_page
+    if isinstance(items, list):
+        result["has_next"] = len(items) >= per_page
+    return result
+
+def command(
+    *,
+    name: str,
+    description: str,
+    schema: dict,
+    full_name: str | None = None,
+    input_stdin: bool = False,
+    stdin_error: str = "Pipe JSON to stdin",
+) -> Callable[[Callable], click.Command]:
+    """Sales training — turn a plain function into a command
+    that knows the script and can handle errors."""
+
+    def decorator(fn: Callable) -> click.Command:
+        user_params = list(reversed(getattr(fn, "__click_params__", [])))
+        params: list[click.Parameter] = list(user_params)
+
+        params.append(dry_run_option())
+
+        method = schema.get("method", "GET")
+        if method in ("POST", "PUT"):
+            params.append(idempotency_key_option())
+        if method == "DELETE":
+            params.append(confirm_option())
+
+        config: dict = {
+            "name": name,
+            "description": description,
+            "schema": schema,
+            "full_name": full_name,
+        }
+
+        params.append(schema_option(_schema_callback(config)))
+
+        command_name = full_name or name
+
+        def callback(**kwargs):
+            dry_run = kwargs.pop("dry_run", False)
+            confirm = kwargs.pop("confirm", False)
+            idempotency_key = kwargs.pop("idempotency_key", None)
+            set_idempotency_key(idempotency_key)
+
+            if input_stdin:
+                kwargs["_body"] = _read_stdin(schema, stdin_error)
+
+            if dry_run:
+                _print_dry_run(command_name, schema, kwargs)
+
+            if method == "DELETE" and not confirm:
+                _require_confirm(command_name)
+
+            _execute(fn, kwargs)
+
+        cmd = click.Command(
+            name=name,
+            callback=callback,
+            params=params,
+            help=description,
+        )
+        cmd._command_config = config
+        return cmd
+
+    return decorator
+
+def _schema_callback(config: dict):
+    """Hand out the product sheet before training starts
+    — print the contract and exit."""
+
+    def cb(ctx, _param, value):
+        if not value or ctx.resilient_parsing:
+            return
+        print_schema(config)
+
+    return cb
+
+# Training complete. You're cleared for the floor.

the_office_cli/cli/flags.py

@@ -0,0 +1,54 @@
+# *[opens the employee handbook to the rules page]*
+
+"""
+flags.py — The employee handbook.
+
+Standard flags every command carries — schema, dry-run,
+idempotency, confirm. Added at build time so nobody
+has to remember them.
+"""
+
+import click
+
+def schema_option(callback) -> click.Option:
+    """--schema — show the command's full contract and exit
+    before anything runs."""
+    return click.Option(
+        ["--schema"],
+        is_flag=True,
+        hidden=True,
+        is_eager=True,
+        expose_value=False,
+        callback=callback,
+    )
+
+def dry_run_option() -> click.Option:
+    """--dry-run — rehearse the call without dialing."""
+    return click.Option(
+        ["--dry-run", "dry_run"],
+        is_flag=True,
+        help="Validate inputs and show what would execute, no API call",
+    )
+
+def idempotency_key_option() -> click.Option:
+    """--idempotency-key — a receipt number so retries don't
+    send the same thing twice."""
+    return click.Option(
+        ["--idempotency-key", "idempotency_key"],
+        hidden=True,
+        help=(
+            "UUID for safe retries — same key = same result, "
+            "prevents double-sends"
+        ),
+    )
+
+def confirm_option() -> click.Option:
+    """--confirm — required for DELETEs. No accidental
+    shredding."""
+    return click.Option(
+        ["--confirm"],
+        is_flag=True,
+        help="Confirm the destructive operation",
+    )
+
+# Handbook closed.

the_office_cli/cli/main.py

@@ -0,0 +1,211 @@
+# *[taps the directory board by the elevator]*
+
+"""
+cli/main.py — The sales floor directory.
+
+Every command is listed here under its department. Pure
+wiring — no business logic, just which group owns what.
+"""
+
+from importlib.metadata import version
+
+import click
+
+from the_office_cli.commands import (
+    account,
+    auth,
+    campaign,
+    dashboard,
+    lead,
+    linkedin,
+    info,
+    outreach,
+    report,
+    settings,
+    task,
+    user,
+)
+from the_office_cli.utils.registry import register
+
+
+@click.group()
+@click.version_option(version("the-office-cli"))
+def cli() -> None:
+    """The Office — AI Sales Agent CLI. JSON in, JSON out."""
+
+
+# Auth
+register(cli, auth.login, group_name="auth")
+register(cli, auth.logout, group_name="auth")
+register(cli, auth.whoami, group_name="auth")
+register(cli, auth.create_account, group_name="auth")
+register(cli, auth.fire_drill, group_name="auth")
+
+# Campaign
+campaign_group = click.Group("campaign", help="Campaign management (8 commands)")
+register(campaign_group, campaign.list_)
+register(campaign_group, campaign.get_)
+register(campaign_group, campaign.update)
+register(campaign_group, campaign.delete_)
+register(campaign_group, campaign.status)
+
+create_group = click.Group("create", help="Create campaign (custom | ai | signals)")
+register(create_group, campaign.create_custom, group_name="campaign")
+register(create_group, campaign.create_ai, group_name="campaign")
+register(create_group, campaign.create_signals, group_name="campaign")
+campaign_group.add_command(create_group)
+
+cli.add_command(campaign_group)
+
+# Lead
+lead_group = click.Group("lead", help="Lead management (6 commands)")
+register(lead_group, lead.list_)
+register(lead_group, lead.get_)
+register(lead_group, lead.create)
+register(lead_group, lead.update)
+register(lead_group, lead.delete_)
+register(lead_group, lead.batch_create)
+cli.add_command(lead_group)
+
+# LinkedIn
+linkedin_group = click.Group("linkedin", help="LinkedIn via Unipile API (20 commands)")
+
+register(linkedin_group, linkedin.retrieve_own_profile)
+
+# LinkedIn connect account
+linkedin_connect_group = click.Group("connect", help="Connect LinkedIn account")
+register(linkedin_connect_group, linkedin.connect_account, group_name="linkedin")
+linkedin_group.add_command(linkedin_connect_group)
+
+# LinkedIn reconnect account
+linkedin_reconnect_group = click.Group("reconnect", help="Reconnect LinkedIn account")
+register(linkedin_reconnect_group, linkedin.reconnect_account, group_name="linkedin")
+linkedin_group.add_command(linkedin_reconnect_group)
+
+# LinkedIn check account
+linkedin_check_group = click.Group("check", help="Check LinkedIn connection status")
+register(linkedin_check_group, linkedin.check_account, group_name="linkedin")
+linkedin_group.add_command(linkedin_check_group)
+
+# LinkedIn retrieve profile and company
+linkedin_retrieve_group = click.Group("retrieve", help="Retrieve profiles and companies")
+register(linkedin_retrieve_group, linkedin.retrieve_profile, group_name="linkedin")
+register(linkedin_retrieve_group, linkedin.retrieve_company, group_name="linkedin")
+linkedin_group.add_command(linkedin_retrieve_group)
+
+# LinkedIn send invitation and message
+linkedin_send_group = click.Group("send", help="Send invitations and messages")
+register(linkedin_send_group, linkedin.send_invite, group_name="linkedin")
+register(linkedin_send_group, linkedin.send_message, group_name="linkedin")
+linkedin_group.add_command(linkedin_send_group)
+
+# LinkedIn list relations, chats, and messages
+linkedin_list_group = click.Group("list", help="List connections, chats, and messages")
+register(linkedin_list_group, linkedin.list_relations, group_name="linkedin")
+register(linkedin_list_group, linkedin.list_chats, group_name="linkedin")
+register(linkedin_list_group, linkedin.list_messages, group_name="linkedin")
+
+# LinkedIn list user messages
+linkedin_list_user_group = click.Group("user", help="Per-user message history")
+register(linkedin_list_user_group, linkedin.list_user_messages, group_name="linkedin")
+linkedin_list_group.add_command(linkedin_list_user_group)
+
+linkedin_group.add_command(linkedin_list_group)
+
+# LinkedIn start chat
+linkedin_start_group = click.Group("start", help="Start new conversations")
+register(linkedin_start_group, linkedin.start_chat, group_name="linkedin")
+linkedin_group.add_command(linkedin_start_group)
+
+# LinkedIn search parameters
+search_group = click.Group("search", help="LinkedIn search (7 subcommands)")
+register(search_group, linkedin.search_parameters, group_name="linkedin")
+
+# LinkedIn search classic leads, accounts, posts, jobs
+classic_group = click.Group("classic", help="Classic LinkedIn search -- leads, accounts, posts, jobs")
+register(classic_group, linkedin.search_classic_leads, group_name="linkedin")
+register(classic_group, linkedin.search_classic_accounts, group_name="linkedin")
+register(classic_group, linkedin.search_classic_posts, group_name="linkedin")
+register(classic_group, linkedin.search_classic_jobs, group_name="linkedin")
+search_group.add_command(classic_group)
+
+# LinkedIn search sales navigator leads, accounts
+sales_navigator_group = click.Group("sales", help="Sales Navigator search")
+navigator_group = click.Group("navigator", help="Sales Navigator search -- leads, accounts")
+register(navigator_group, linkedin.search_sales_navigator_leads, group_name="linkedin")
+register(navigator_group, linkedin.search_sales_navigator_accounts, group_name="linkedin")
+sales_navigator_group.add_command(navigator_group)
+search_group.add_command(sales_navigator_group)
+
+linkedin_group.add_command(search_group)
+cli.add_command(linkedin_group)
+
+# Accounts
+account_group = click.Group("account", help="Target company accounts (3 commands)")
+register(account_group, account.list_)
+register(account_group, account.get_)
+register(account_group, account.delete_)
+cli.add_command(account_group)
+
+# Dashboard
+register(dashboard.group, dashboard.funnel)
+register(dashboard.group, dashboard.conversations)
+cli.add_command(dashboard.group)
+
+# Report
+report_group = click.Group("report", help="Performance report (1 command)")
+register(report_group, report.generate)
+cli.add_command(report_group)
+
+# Outreach
+outreach_group = click.Group("outreach", help="Outreach tracking (1 command)")
+register(outreach_group, outreach.list_)
+cli.add_command(outreach_group)
+
+# User
+user_group = click.Group("user", help="Team member management (5 commands)")
+register(user_group, user.list_)
+register(user_group, user.get_)
+register(user_group, user.create)
+register(user_group, user.update)
+register(user_group, user.delete_)
+cli.add_command(user_group)
+
+# Settings
+settings_group = click.Group("settings", help="View and update settings (2 commands)")
+register(settings_group, settings.get_)
+register(settings_group, settings.update)
+cli.add_command(settings_group)
+
+# Task
+task_group = click.Group("task", help="Celery task triggers and polling (6 commands)")
+
+# Task find leads
+task_find_group = click.Group("find", help="Find and source leads")
+register(task_find_group, task.find_leads, group_name="task")
+task_group.add_command(task_find_group)
+
+# Task send invites
+task_send_group = click.Group("send", help="Send outreach")
+register(task_send_group, task.send_invites, group_name="task")
+task_group.add_command(task_send_group)
+
+# Task follow up
+register(task_group, task.follow_up)
+
+# Task sync accepted
+task_sync_group = click.Group("sync", help="Sync LinkedIn data")
+register(task_sync_group, task.sync_accepted, group_name="task")
+register(task_sync_group, task.sync_conversations, group_name="task")
+task_group.add_command(task_sync_group)
+
+# Task status
+register(task_group, task.status)
+
+cli.add_command(task_group)
+
+# Info
+register(cli, info.tour, group_name="info")
+cli.add_command(info.completion)
+
+# Directory posted.

the_office_cli/commands/account.py

@@ -0,0 +1,137 @@
+# *[highlights a company name on the whiteboard]*
+
+"""
+account.py — The target accounts.
+
+The companies your signals campaigns are watching.
+List them, pull one up, or remove it from the board.
+"""
+
+import click
+
+from the_office_cli.cli.decorators import command
+from the_office_cli.network.session import delete, get
+
+@command(
+    name="list",
+    description="Use this command to list all target accounts tracked by signals campaigns, with their buying signals tracked, findings, citations, and confidence levels. Prefer `lead list` when the user wants leads instead of accounts.",
+    schema={
+        "endpoint": "/accounts", "method": "GET",
+        "input": {
+            "page": {"type": "integer", "default": 1},
+            "per_page": {"type": "integer", "default": 10000},
+        },
+        "output": {
+            "id": {"type": "integer"},
+            "campaign_id": {"type": "integer"},
+            "campaign": {"type": "string"},
+            "website": {"type": "string", "format": "uri"},
+            "company_name": {"type": "string"},
+            "logo": {"type": "string", "format": "uri"},
+            "description": {"type": "string"},
+            "days_back": {"type": "integer"},
+            "response": {"type": "string"},
+            "citations": {"type": "array"},
+            "response_summary": {"type": "string"},
+            "created_at": {"type": "string", "format": "date-time"},
+            "updated_at": {"type": "string", "format": "date-time"},
+        },
+        "example": {
+            "input": {"page": 1},
+            "output": {
+                "id": 1,
+                "campaign_id": 6,
+                "campaign": "Vance Refrigeration Takedown",
+                "website": "https://vancerefrigeration.com",
+                "company_name": "Vance Refrigeration",
+                "logo": "https://logo.clearbit.com/vancerefrigeration.com",
+                "description": "Bob Vance, Vance Refrigeration. They keep things cold. We keep things personal.",
+                "days_back": 365,
+                "response": "Vance Refrigeration is a regional commercial HVAC supplier based in Scranton, PA...",
+                "citations": [
+                    {"url": "https://vancerefrigeration.com/about", "title": "About Vance Refrigeration"},
+                ],
+                "response_summary": "Regional supplier, 50 employees, expanding to Wilkes-Barre.",
+                "created_at": "2026-03-15T09:00:00+00:00",
+                "updated_at": "2026-04-08T11:30:00+00:00",
+            },
+        },
+    },
+)
+@click.option("--page", type=click.INT, default=1, help="Page number for pagination (default: 1)")
+@click.option("--per-page", "per_page", type=click.INT, default=10000, help="Results per page (default: 10000)")
+def list_(page, per_page, **_):
+    return {
+        "object": "AccountList",
+        "items": get("/accounts", params={"page": page, "per_page": per_page}),
+    }
+
+@command(
+    name="get",
+    description="Use this command to get a target account and its buying signals with findings, citations, and confidence levels.",
+    schema={
+        "endpoint": "/accounts/<id>", "method": "GET",
+        "input": {"id": {"type": "integer", "required": True}},
+        "output": {
+            "id": {"type": "integer"},
+            "campaign_id": {"type": "integer"},
+            "website": {"type": "string", "format": "uri"},
+            "company_name": {"type": "string"},
+            "logo": {"type": "string", "format": "uri"},
+            "description": {"type": "string"},
+            "days_back": {"type": "integer"},
+            "response": {"type": "string"},
+            "citations": {"type": "array"},
+            "response_gemini": {"type": "string"},
+            "citations_gemini": {"type": "array"},
+            "response_summary": {"type": "string"},
+            "created_at": {"type": "string", "format": "date-time"},
+            "updated_at": {"type": "string", "format": "date-time"},
+        },
+        "example": {
+            "input": {"id": 1},
+            "output": {
+                "id": 1,
+                "campaign_id": 6,
+                "website": "https://vancerefrigeration.com",
+                "company_name": "Vance Refrigeration",
+                "logo": "https://logo.clearbit.com/vancerefrigeration.com",
+                "description": "Bob Vance, Vance Refrigeration. They keep things cold. We keep things personal.",
+                "days_back": 365,
+                "response": "Vance Refrigeration is a regional commercial HVAC supplier...",
+                "citations": [
+                    {"url": "https://vancerefrigeration.com/about", "title": "About"},
+                ],
+                "response_gemini": "Based on recent data, Vance Refrigeration has been expanding operations...",
+                "citations_gemini": [
+                    {"url": "https://scrantontimes.com/business/vance-expansion", "title": "Vance announces Wilkes-Barre warehouse"},
+                ],
+                "response_summary": "Bob Vance runs a tight ship. 50 employees, growing 12% YoY. Expanding warehouse operations.",
+                "created_at": "2026-03-15T09:00:00+00:00",
+                "updated_at": "2026-04-08T11:30:00+00:00",
+            },
+        },
+    },
+)
+@click.option("--id", type=click.INT, required=True)
+def get_(id, **_):
+    return {"object": "Account", **get(f"/accounts/{id}")}
+
+@command(
+    name="delete",
+    description="Use this command to permanently delete a target account.",
+    schema={
+        "endpoint": "/accounts/<id>", "method": "DELETE",
+        "input": {"id": {"type": "integer", "required": True}},
+        "output": {"message": {"type": "string"}},
+        "example": {
+            "input": {"id": 2},
+            "output": {"message": "Account deleted successfully!"},
+        },
+    },
+)
+@click.option("--id", type=click.INT, required=True)
+def delete_(id, **_):
+    return {"object": "Account", **delete(f"/accounts/{id}")}
+
+# Accounts reviewed.