discolike-cli 0.1.0__py3-none-any.whl

discolike_cli/_output.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import functools
+import json
+import sys
+from collections.abc import Callable
+from typing import Any
+from typing import ParamSpec
+from typing import Protocol
+from typing import TypeVar
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from discolike._exceptions import APIConnectionError
+from discolike._exceptions import AuthenticationError
+from discolike._exceptions import DiscolikeError
+from discolike._exceptions import NotFoundError
+from discolike._exceptions import PlanAccessError
+from discolike._exceptions import RateLimitError
+from discolike._exceptions import ValidationError
+from discolike._models import DiscolikeModel
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+EXIT_CODES: dict[type, int] = {
+    ValidationError: 2,
+    AuthenticationError: 3,
+    PlanAccessError: 3,
+    RateLimitError: 4,
+    APIConnectionError: 5,
+    NotFoundError: 6,
+}
+DEFAULT_EXIT_CODE = 1
+
+
+class _JobStatusLike(Protocol):
+    results: Any
+
+    @property
+    def progress(self) -> int | None: ...
+
+    def to_dict(self) -> dict[str, Any]: ...
+
+
+class SupportsWait(Protocol):
+    task_id: str
+    task_family: str
+
+    def wait(self, *, timeout: float, on_poll: Callable[[_JobStatusLike], None] | None = None) -> _JobStatusLike: ...
+
+
+def _normalize(data: Any) -> Any:  # noqa: ANN401 -- accepts arbitrary JSON-serializable CLI output data
+    if isinstance(data, DiscolikeModel):
+        return data.to_dict()
+    if isinstance(data, list):
+        return [item.to_dict() if isinstance(item, DiscolikeModel) else item for item in data]
+    return data
+
+
+def _is_flat_dict(value: Any) -> bool:  # noqa: ANN401 -- runtime-narrowed via isinstance, not a fixed shape
+    return isinstance(value, dict) and not any(isinstance(v, (dict, list)) for v in value.values())
+
+
+def _qualifies_for_table(data: Any) -> bool:  # noqa: ANN401 -- runtime-narrowed via isinstance, not a fixed shape
+    return isinstance(data, list) and len(data) > 0 and all(_is_flat_dict(item) for item in data)
+
+
+def _render_table(rows: list[dict[str, Any]]) -> None:
+    table = Table()
+    columns = list(rows[0].keys())
+    for column in columns:
+        table.add_column(column)
+    for row in rows:
+        table.add_row(*(str(row.get(column, "")) for column in columns))
+    Console().print(table)
+
+
+def emit(data: Any, *, fmt: str | None = None) -> None:  # noqa: ANN401 -- accepts arbitrary JSON-serializable CLI output data
+    normalized = _normalize(data)
+    want_table = fmt == "table" or (fmt is None and sys.stdout.isatty())
+    if want_table and _qualifies_for_table(normalized):
+        _render_table(normalized)
+        return
+    print(json.dumps(normalized, indent=2, default=str))
+
+
+def fail(exc: DiscolikeError) -> typer.Exit:
+    payload: dict[str, Any] = {
+        "error": type(exc).__name__,
+        "message": str(exc),
+        "status_code": exc.status_code,
+    }
+    if isinstance(exc, RateLimitError) and exc.retry_after is not None:
+        payload["retry_after"] = exc.retry_after
+    print(json.dumps(payload), file=sys.stderr)
+    return typer.Exit(code=EXIT_CODES.get(type(exc), DEFAULT_EXIT_CODE))
+
+
+def call_typed(fn: Callable[..., R], **kwargs: Any) -> R:  # noqa: ANN401 -- forwarded to a typed SDK method signature
+    try:
+        return fn(**kwargs)
+    except TypeError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+
+
+def handle_errors(fn: Callable[P, R]) -> Callable[P, R]:
+    @functools.wraps(fn)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return fn(*args, **kwargs)
+        except DiscolikeError as exc:
+            raise fail(exc) from exc
+
+    return wrapper
+
+
+def run_job(job: SupportsWait, *, wait: bool, timeout: float) -> None:
+    if not wait:
+        emit(
+            {
+                "task_id": job.task_id,
+                "task_family": job.task_family,
+                "hint": f"poll with: discolike discogen status {job.task_id} --family {job.task_family}",
+            }
+        )
+        return
+
+    def _on_poll(status: _JobStatusLike) -> None:
+        sys.stderr.write(f"progress: {status.progress}%\n")
+
+    final = job.wait(timeout=timeout, on_poll=_on_poll)
+    emit(final.results if final.results is not None else final.to_dict())

discolike_cli/account.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import typer
+
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+app = typer.Typer(help="Account usage and billing")
+
+
+@app.command("usage")
+@handle_errors
+def usage_command(ctx: typer.Context) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).account.usage())

discolike_cli/auth.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+import typer
+
+from discolike._config import ENV_API_KEY
+from discolike._config import KEYS_URL
+from discolike._config import delete_config
+from discolike._config import load_config
+from discolike._config import resolve_api_key
+from discolike._config import save_config
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+app = typer.Typer(help="Manage API credentials")
+
+MASKED_VISIBLE_CHARS = 4
+
+
+def _mask(key: str) -> str:
+    return "…" + key[-MASKED_VISIBLE_CHARS:]
+
+
+@app.command()
+@handle_errors
+def login(
+    api_key: str | None = typer.Option(None, help=f"API key. Create one at {KEYS_URL}"),
+) -> None:
+    from discolike_cli.main import build_client
+
+    key = api_key or typer.prompt("API key", hide_input=True)
+    build_client(api_key=key).account.usage()
+    save_config({"auth_method": "api_key", "api_key": key})
+    print(json.dumps({"logged_in": True, "source": "api_key"}), file=sys.stderr)
+
+
+@app.command()
+@handle_errors
+def status() -> None:
+    from discolike_cli.main import build_client
+
+    key = os.environ.get(ENV_API_KEY)
+    source = "env"
+    if not key:
+        key = load_config().get("api_key")
+        source = "config"
+    if not key:
+        resolve_api_key(None)
+    build_client(api_key=key).account.usage()
+    emit({"source": source, "api_key": _mask(str(key)), "valid": True})
+
+
+@app.command()
+@handle_errors
+def logout() -> None:
+    delete_config()
+    emit({"logged_out": True})

discolike_cli/company.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import typer
+
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+app = typer.Typer(help="Look up company data by domain")
+
+
+@app.command()
+@handle_errors
+def data(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.data(domain=domain))
+
+
+@app.command()
+@handle_errors
+def score(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.score(domain=domain))
+
+
+@app.command()
+@handle_errors
+def growth(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.growth(domain=domain))
+
+
+@app.command()
+@handle_errors
+def metrics(ctx: typer.Context, domain: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.metrics(domain=domain))
+
+
+@app.command()
+@handle_errors
+def history(ctx: typer.Context, domain: str, max_records: int | None = typer.Option(None, "--max-records")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.history(domain=domain, max_records=max_records))
+
+
+@app.command()
+@handle_errors
+def redirects(ctx: typer.Context, domain: str, match: str | None = typer.Option(None, "--match")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.redirects(domain=domain, match=match))
+
+
+@app.command()
+@handle_errors
+def vendors(ctx: typer.Context, domain: str, match: str | None = typer.Option(None, "--match")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.vendors(domain=domain, match=match))
+
+
+@app.command()
+@handle_errors
+def subsidiaries(ctx: typer.Context, domain: str, match: str | None = typer.Option(None, "--match")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.subsidiaries(domain=domain, match=match))
+
+
+@app.command(name="public-links")
+@handle_errors
+def public_links(ctx: typer.Context, domain: str, source: str = typer.Option(..., "--source")) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.public_links(domain=domain, source=source))
+
+
+@handle_errors
+def extract_command(ctx: typer.Context, url: str) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).companies.extract(url=url))

discolike_cli/contacts.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import json
+import pathlib
+
+import typer
+
+from discolike_cli._output import call_typed
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+from discolike_cli._output import run_job
+from discolike_cli.discover import _merge_params
+
+DEFAULT_WAIT_TIMEOUT_SECONDS = 900.0
+
+app = typer.Typer(help="Search, match, and enrich contacts")
+
+
+@app.command("search")
+@handle_errors
+def search_command(
+    ctx: typer.Context,
+    icp_prompt: str | None = typer.Option(None),
+    icp_text: str | None = typer.Option(None),
+    seniority: list[str] | None = typer.Option(None),
+    department: list[str] | None = typer.Option(None),
+    title: list[str] | None = typer.Option(None),
+    domain: list[str] | None = typer.Option(None),
+    person_country: list[str] | None = typer.Option(None),
+    filter_industry: list[str] | None = typer.Option(None),
+    filter_country: list[str] | None = typer.Option(None),
+    employee_range: str | None = typer.Option(None),
+    has_email: bool | None = typer.Option(None, "--has-email/--no-has-email"),
+    max_records: int | None = typer.Option(None),
+    offset: int | None = typer.Option(None),
+    fmt: str | None = typer.Option(None, "--format"),
+    param: list[str] | None = typer.Option(None, "--param"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    kwargs = _merge_params(
+        param,
+        icp_prompt=icp_prompt,
+        icp_text=icp_text,
+        seniority=seniority,
+        department=department,
+        title=title,
+        domain=domain,
+        person_country=person_country,
+        filter_industry=filter_industry,
+        filter_country=filter_country,
+        employee_range=employee_range,
+        has_email=has_email,
+        max_records=max_records,
+        offset=offset,
+    )
+    emit(call_typed(get_client(ctx).contacts.search, **kwargs), fmt=fmt)
+
+
+@app.command("count")
+@handle_errors
+def count_command(
+    ctx: typer.Context,
+    icp_prompt: str | None = typer.Option(None),
+    icp_text: str | None = typer.Option(None),
+    seniority: list[str] | None = typer.Option(None),
+    department: list[str] | None = typer.Option(None),
+    title: list[str] | None = typer.Option(None),
+    domain: list[str] | None = typer.Option(None),
+    person_country: list[str] | None = typer.Option(None),
+    filter_industry: list[str] | None = typer.Option(None),
+    filter_country: list[str] | None = typer.Option(None),
+    employee_range: str | None = typer.Option(None),
+    has_email: bool | None = typer.Option(None, "--has-email/--no-has-email"),
+    fmt: str | None = typer.Option(None, "--format"),
+    param: list[str] | None = typer.Option(None, "--param"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    kwargs = _merge_params(
+        param,
+        icp_prompt=icp_prompt,
+        icp_text=icp_text,
+        seniority=seniority,
+        department=department,
+        title=title,
+        domain=domain,
+        person_country=person_country,
+        filter_industry=filter_industry,
+        filter_country=filter_country,
+        employee_range=employee_range,
+        has_email=has_email,
+    )
+    emit(call_typed(get_client(ctx).contacts.count, **kwargs), fmt=fmt)
+
+
+@app.command("lookup")
+@handle_errors
+def lookup_command(
+    ctx: typer.Context,
+    persona_id: int | None = typer.Option(None, "--persona-id"),
+    linkedin: str | None = typer.Option(None, "--linkedin"),
+    email: str | None = typer.Option(None, "--email"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).contacts.lookup(persona_id=persona_id, linkedin=linkedin, email=email))
+
+
+@app.command("match")
+@handle_errors
+def match_command(
+    ctx: typer.Context,
+    name: str = typer.Argument(...),
+    company_name: str | None = typer.Option(None, "--company-name"),
+    domain: str | None = typer.Option(None, "--domain"),
+    person_country: str | None = typer.Option(None, "--person-country"),
+    limit: int | None = typer.Option(None, "--limit"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    emit(
+        get_client(ctx).contacts.match(
+            name=name,
+            company_name=company_name,
+            domain=domain,
+            person_country=person_country,
+            limit=limit,
+        )
+    )
+
+
+@app.command("bulk-match")
+@handle_errors
+def bulk_match_command(
+    ctx: typer.Context,
+    queries_file: pathlib.Path = typer.Option(..., "--queries-file"),
+    enrich: bool | None = typer.Option(None, "--enrich/--no-enrich"),
+    limit: int | None = typer.Option(None, "--limit"),
+    wait: bool = typer.Option(False, "--wait"),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    try:
+        queries = json.loads(queries_file.read_text())
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"--queries-file must contain valid JSON: {exc}") from exc
+    if not isinstance(queries, list):
+        raise typer.BadParameter("--queries-file must contain a JSON array of objects")
+
+    job = get_client(ctx).contacts.bulk_match(queries=queries, enrich=enrich, limit=limit)
+    run_job(job, wait=wait, timeout=timeout)
+
+
+@app.command("discover")
+@handle_errors
+def discover_command(
+    ctx: typer.Context,
+    icp_prompt: str | None = typer.Option(None),
+    icp_text: str | None = typer.Option(None),
+    seniority: list[str] | None = typer.Option(None),
+    department: list[str] | None = typer.Option(None),
+    title: list[str] | None = typer.Option(None),
+    domain: list[str] | None = typer.Option(None),
+    person_country: list[str] | None = typer.Option(None),
+    filter_industry: list[str] | None = typer.Option(None),
+    filter_country: list[str] | None = typer.Option(None),
+    employee_range: str | None = typer.Option(None),
+    has_email: bool | None = typer.Option(None, "--has-email/--no-has-email"),
+    max_records: int | None = typer.Option(None),
+    offset: int | None = typer.Option(None),
+    results_by_company: int | None = typer.Option(None, "--results-by-company"),
+    include_search_contacts: bool | None = typer.Option(None, "--include-search-contacts/--no-include-search-contacts"),
+    consensus: int | None = typer.Option(None, "--consensus"),
+    fmt: str | None = typer.Option(None, "--format"),
+    param: list[str] | None = typer.Option(None, "--param"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    kwargs = _merge_params(
+        param,
+        icp_prompt=icp_prompt,
+        icp_text=icp_text,
+        seniority=seniority,
+        department=department,
+        title=title,
+        domain=domain,
+        person_country=person_country,
+        filter_industry=filter_industry,
+        filter_country=filter_country,
+        employee_range=employee_range,
+        has_email=has_email,
+        max_records=max_records,
+        offset=offset,
+        results_by_company=results_by_company,
+        include_search_contacts=include_search_contacts,
+        consensus=consensus,
+    )
+    emit(call_typed(get_client(ctx).contacts.discover, **kwargs), fmt=fmt)
+
+
+@app.command("generate")
+@handle_errors
+def generate_command(
+    ctx: typer.Context,
+    icp_text: str = typer.Option(..., "--icp-text"),
+    domain: list[str] = typer.Option(..., "--domain"),
+    context_mode: str | None = typer.Option(None, "--context-mode"),
+    integration_id: str | None = typer.Option(None, "--integration-id"),
+    search_provider_id: str | None = typer.Option(None, "--search-provider-id"),
+    search_context_size: str | None = typer.Option(None, "--search-context-size"),
+    max_contacts_per_domain: int | None = typer.Option(None, "--max-contacts-per-domain"),
+    max_company_records: int | None = typer.Option(None, "--max-company-records"),
+    wait: bool = typer.Option(False, "--wait"),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    job = get_client(ctx).contacts.generate(
+        icp_text=icp_text,
+        domains=domain,
+        context_mode=context_mode,
+        integration_id=integration_id,
+        search_provider_id=search_provider_id,
+        search_context_size=search_context_size,
+        max_contacts_per_domain=max_contacts_per_domain,
+        max_company_records=max_company_records,
+    )
+    run_job(job, wait=wait, timeout=timeout)

discolike_cli/discogen.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import enum
+
+import typer
+
+from discolike._jobs import Job
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+from discolike_cli._output import run_job
+
+DEFAULT_WAIT_TIMEOUT_SECONDS = 900.0
+
+app = typer.Typer(help="Run DiscoGen research and manage async tasks")
+
+
+class TaskFamily(str, enum.Enum):
+    discogen = "discogen"
+    bulkmatch = "bulkmatch"
+    contactmatch = "contactmatch"
+    segment = "segment"
+
+
+@app.command("run")
+@handle_errors
+def run_command(
+    ctx: typer.Context,
+    query: str = typer.Option(..., "--query"),
+    domain: list[str] = typer.Option(..., "--domain"),
+    integration_id: str | None = typer.Option(None, "--integration-id"),
+    web_search: bool | None = typer.Option(None, "--web-search/--no-web-search"),
+    context_mode: str | None = typer.Option(None, "--context-mode"),
+    include_x_search: bool | None = typer.Option(None, "--include-x-search/--no-include-x-search"),
+    search_provider_id: str | None = typer.Option(None, "--search-provider-id"),
+    search_context_size: str | None = typer.Option(None, "--search-context-size"),
+    wait: bool = typer.Option(False, "--wait"),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    job = get_client(ctx).discogen.process(
+        query=query,
+        domains=domain,
+        integration_id=integration_id,
+        web_search=web_search,
+        context_mode=context_mode,
+        include_x_search=include_x_search,
+        search_provider_id=search_provider_id,
+        search_context_size=search_context_size,
+    )
+    run_job(job, wait=wait, timeout=timeout)
+
+
+@app.command("run-personas")
+@handle_errors
+def run_personas_command(
+    ctx: typer.Context,
+    query: str = typer.Option(..., "--query"),
+    persona_id: list[int] = typer.Option(..., "--persona-id"),
+    integration_id: str | None = typer.Option(None, "--integration-id"),
+    web_search: bool | None = typer.Option(None, "--web-search/--no-web-search"),
+    context_mode: str | None = typer.Option(None, "--context-mode"),
+    include_x_search: bool | None = typer.Option(None, "--include-x-search/--no-include-x-search"),
+    search_provider_id: str | None = typer.Option(None, "--search-provider-id"),
+    search_context_size: str | None = typer.Option(None, "--search-context-size"),
+    wait: bool = typer.Option(False, "--wait"),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    job = get_client(ctx).discogen.process_personas(
+        query=query,
+        persona_ids=persona_id,
+        integration_id=integration_id,
+        web_search=web_search,
+        context_mode=context_mode,
+        include_x_search=include_x_search,
+        search_provider_id=search_provider_id,
+        search_context_size=search_context_size,
+    )
+    run_job(job, wait=wait, timeout=timeout)
+
+
+@app.command("models")
+@handle_errors
+def models_command(ctx: typer.Context) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).discogen.models())
+
+
+def _build_job(ctx: typer.Context, family: TaskFamily, task_id: str) -> Job:
+    from discolike_cli.main import get_client
+
+    client = get_client(ctx)
+    if family is TaskFamily.discogen:
+        return client.discogen.job(task_id)
+    return Job(client._transport, task_family=family.value, task_id=task_id)
+
+
+@app.command("status")
+@handle_errors
+def status_command(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(...),
+    family: TaskFamily = typer.Option(TaskFamily.discogen, "--family"),
+) -> None:
+    emit(_build_job(ctx, family, task_id).status())
+
+
+@app.command("cancel")
+@handle_errors
+def cancel_command(
+    ctx: typer.Context,
+    task_id: str = typer.Argument(...),
+    family: TaskFamily = typer.Option(TaskFamily.discogen, "--family"),
+) -> None:
+    _build_job(ctx, family, task_id).cancel()
+    emit({"cancelled": task_id})

discolike_cli/discover.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from discolike_cli._output import call_typed
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+PARAM_SEPARATOR = "="
+LIST_VALUE_SEPARATOR = ","
+
+
+def _parse_param(raw: str) -> tuple[str, str | list[str]]:
+    if PARAM_SEPARATOR not in raw:
+        raise typer.BadParameter(f"--param must be in KEY=VALUE form, got {raw!r}")
+    key, _, value = raw.partition(PARAM_SEPARATOR)
+    if LIST_VALUE_SEPARATOR in value:
+        return key, value.split(LIST_VALUE_SEPARATOR)
+    return key, value
+
+
+def _merge_params(param: list[str] | None, **options: Any) -> dict[str, Any]:  # noqa: ANN401 -- forwarded as **kwargs to typed resource/client methods
+    kwargs: dict[str, Any] = dict(_parse_param(raw) for raw in param or [])
+    kwargs.update({key: value for key, value in options.items() if value is not None})
+    return kwargs
+
+
+@handle_errors
+def discover_command(
+    ctx: typer.Context,
+    icp_prompt: str | None = typer.Option(None),
+    icp_text: str | None = typer.Option(None),
+    domain: list[str] | None = typer.Option(None),
+    phrase_match: list[str] | None = typer.Option(None),
+    category: list[str] | None = typer.Option(None),
+    country: list[str] | None = typer.Option(None),
+    state: list[str] | None = typer.Option(None),
+    employee_range: str | None = typer.Option(None),
+    revenue_range: str | None = typer.Option(None),
+    business_model: list[str] | None = typer.Option(None),
+    tech_stack: list[str] | None = typer.Option(None),
+    min_digital_footprint: int | None = typer.Option(None),
+    max_digital_footprint: int | None = typer.Option(None),
+    exclude_domain: list[str] | None = typer.Option(None),
+    exclusion_query_id: list[str] | None = typer.Option(None),
+    max_records: int | None = typer.Option(None),
+    offset: int | None = typer.Option(None),
+    fmt: str | None = typer.Option(None, "--format"),
+    param: list[str] | None = typer.Option(None, "--param"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    kwargs = _merge_params(
+        param,
+        icp_prompt=icp_prompt,
+        icp_text=icp_text,
+        domain=domain,
+        phrase_match=phrase_match,
+        category=category,
+        country=country,
+        state=state,
+        employee_range=employee_range,
+        revenue_range=revenue_range,
+        business_model=business_model,
+        tech_stack=tech_stack,
+        min_digital_footprint=min_digital_footprint,
+        max_digital_footprint=max_digital_footprint,
+        exclude_domain=exclude_domain,
+        exclusion_query_id=exclusion_query_id,
+        max_records=max_records,
+        offset=offset,
+    )
+    companies = call_typed(get_client(ctx).discover, **kwargs)
+    emit(companies, fmt=fmt)
+
+
+@handle_errors
+def count_command(
+    ctx: typer.Context,
+    phrase_match: list[str] | None = typer.Option(None),
+    category: list[str] | None = typer.Option(None),
+    country: list[str] | None = typer.Option(None),
+    state: list[str] | None = typer.Option(None),
+    employee_range: str | None = typer.Option(None),
+    revenue_range: str | None = typer.Option(None),
+    business_model: list[str] | None = typer.Option(None),
+    tech_stack: list[str] | None = typer.Option(None),
+    min_digital_footprint: int | None = typer.Option(None),
+    max_digital_footprint: int | None = typer.Option(None),
+    fmt: str | None = typer.Option(None, "--format"),
+    param: list[str] | None = typer.Option(None, "--param"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    kwargs = _merge_params(
+        param,
+        phrase_match=phrase_match,
+        category=category,
+        country=country,
+        state=state,
+        employee_range=employee_range,
+        revenue_range=revenue_range,
+        business_model=business_model,
+        tech_stack=tech_stack,
+        min_digital_footprint=min_digital_footprint,
+        max_digital_footprint=max_digital_footprint,
+    )
+    count = call_typed(get_client(ctx).count, **kwargs)
+    emit(count, fmt=fmt)

discolike_cli/enrich.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import pathlib
+
+import typer
+
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+from discolike_cli._output import run_job
+
+DEFAULT_WAIT_TIMEOUT_SECONDS = 900.0
+
+
+@handle_errors
+def validate_icp_command(
+    ctx: typer.Context,
+    icp: str = typer.Option(..., "--icp"),
+    domain: list[str] | None = typer.Option(None, "--domain"),
+    file: pathlib.Path | None = typer.Option(None, "--file"),
+    context_mode: str | None = typer.Option(None, "--context-mode"),
+    integration_id: str | None = typer.Option(None, "--integration-id"),
+    web_search: bool | None = typer.Option(None, "--web-search/--no-web-search"),
+    search_provider_id: str | None = typer.Option(None, "--search-provider-id"),
+    wait: bool = typer.Option(False, "--wait"),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    if (not domain) == (file is None):
+        raise typer.BadParameter("Provide exactly one of --domain or --file")
+
+    if file is not None:
+        domains = [line.strip() for line in file.read_text().splitlines() if line.strip()]
+    else:
+        assert domain is not None
+        domains = domain
+
+    job = get_client(ctx).validate_icp(
+        icp_text=icp,
+        domains=domains,
+        context_mode=context_mode,
+        integration_id=integration_id,
+        web_search=web_search,
+        search_provider_id=search_provider_id,
+    )
+    run_job(job, wait=wait, timeout=timeout)
+
+
+@handle_errors
+def append_command(
+    ctx: typer.Context,
+    file: pathlib.Path = typer.Argument(...),
+    dataset: list[str] | None = typer.Option(None, "--dataset"),
+    domain_column: str | None = typer.Option(None, "--domain-column"),
+    csv: bool | None = typer.Option(None, "--csv/--no-csv"),
+    output: pathlib.Path | None = typer.Option(None, "--output"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    result = get_client(ctx).append(file=file, dataset=dataset, domain_column=domain_column, csv=csv)
+    if isinstance(result, bytes):
+        if output is None:
+            raise typer.BadParameter("--output is required when the response is CSV bytes")
+        output.write_bytes(result)
+        emit({"written": str(output), "bytes": len(result)})
+        return
+    emit(result)
+
+
+@handle_errors
+def segment_command(
+    ctx: typer.Context,
+    domain: list[str] | None = typer.Option(None, "--domain"),
+    file: pathlib.Path | None = typer.Option(None, "--file"),
+    domain_column: str | None = typer.Option(None, "--domain-column"),
+    max_segments: int | None = typer.Option(None, "--max-segments"),
+    wait: bool = typer.Option(False, "--wait"),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    if (not domain) == (file is None):
+        raise typer.BadParameter("Provide exactly one of --domain or --file")
+
+    job = get_client(ctx).segment(
+        domains=domain or None,
+        file=file,
+        domain_column=domain_column,
+        max_segments=max_segments,
+    )
+    run_job(job, wait=wait, timeout=timeout)

discolike_cli/main.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from importlib.metadata import version as package_version
+from typing import Any
+
+import typer
+
+from discolike import Discolike
+from discolike import __version__ as sdk_version
+from discolike_cli import account
+from discolike_cli import auth
+from discolike_cli import company
+from discolike_cli import contacts
+from discolike_cli import discogen
+from discolike_cli import discover
+from discolike_cli import enrich
+from discolike_cli import match
+from discolike_cli import queries
+
+app = typer.Typer(
+    name="discolike",
+    no_args_is_help=True,
+    help="DiscoLike API from your terminal — https://docs.discolike.com",
+)
+
+build_client = Discolike
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    api_key: str | None = typer.Option(None, envvar="DISCOLIKE_API_KEY"),
+    base_url: str | None = typer.Option(None),
+    version: bool = typer.Option(False, "--version"),
+) -> None:
+    if version:
+        typer.echo(f"discolike-cli {package_version('discolike-cli')} (discolike {sdk_version})")
+        raise typer.Exit
+    ctx.obj = {"api_key": api_key, "base_url": base_url}
+
+
+def get_client(ctx: typer.Context) -> Discolike:
+    kwargs: dict[str, Any] = {k: v for k, v in ctx.obj.items() if v is not None}
+    return build_client(**kwargs)
+
+
+app.add_typer(auth.app, name="auth")
+app.add_typer(company.app, name="company")
+app.add_typer(contacts.app, name="contacts")
+app.add_typer(discogen.app, name="discogen")
+app.add_typer(queries.app, name="queries")
+app.add_typer(account.app, name="account")
+app.command(name="discover")(discover.discover_command)
+app.command(name="count")(discover.count_command)
+app.command(name="match")(match.match_command)
+app.command(name="extract")(company.extract_command)
+app.command(name="validate-icp")(enrich.validate_icp_command)
+app.command(name="append")(enrich.append_command)
+app.command(name="segment")(enrich.segment_command)

discolike_cli/match.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import pathlib
+
+import typer
+
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+from discolike_cli._output import run_job
+
+DEFAULT_WAIT_TIMEOUT_SECONDS = 900.0
+DEFAULT_NAME_COLUMN = "name"
+
+
+@handle_errors
+def match_command(
+    ctx: typer.Context,
+    name: str | None = typer.Argument(None),
+    phone: str | None = typer.Option(None),
+    city: str | None = typer.Option(None),
+    state: str | None = typer.Option(None),
+    country: str | None = typer.Option(None),
+    zip_code: str | None = typer.Option(None),
+    strict: bool | None = typer.Option(None, "--strict/--no-strict"),
+    local_mode: bool | None = typer.Option(None, "--local-mode/--no-local-mode"),
+    file: pathlib.Path | None = typer.Option(None, "--file"),
+    name_column: str = typer.Option(DEFAULT_NAME_COLUMN, "--name-column"),
+    wait: bool = typer.Option(False, "--wait"),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout"),
+    fmt: str | None = typer.Option(None, "--format"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    if (name is None) == (file is None):
+        raise typer.BadParameter("Provide exactly one of NAME or --file")
+
+    client = get_client(ctx)
+    if name is not None:
+        response = client.match.company(
+            name=name,
+            phone=phone,
+            city=city,
+            state=state,
+            country=country,
+            zip_code=zip_code,
+            strict=strict,
+            local_mode=local_mode,
+        )
+        emit(response, fmt=fmt)
+        return
+
+    assert file is not None
+    job = client.match.bulk(file=file, name_column=name_column, strict=strict, local_mode=local_mode)
+    run_job(job, wait=wait, timeout=timeout)

discolike_cli/queries.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import typer
+
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+
+app = typer.Typer(help="Manage saved queries and exclusion lists")
+
+
+@app.command("list")
+@handle_errors
+def list_command(
+    ctx: typer.Context,
+    max_records: int | None = typer.Option(None, "--max-records"),
+    offset: int | None = typer.Option(None, "--offset"),
+    action: str | None = typer.Option(None, "--action"),
+    tag: list[str] | None = typer.Option(None, "--tag"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).queries.list(max_records=max_records, offset=offset, action=action, tags=tag))
+
+
+@app.command("create-exclusion-list")
+@handle_errors
+def create_exclusion_list_command(
+    ctx: typer.Context,
+    name: str = typer.Option(..., "--name"),
+    domain: list[str] | None = typer.Option(None, "--domain"),
+    persona_id: list[int] | None = typer.Option(None, "--persona-id"),
+    tag: list[str] | None = typer.Option(None, "--tag"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    emit(
+        get_client(ctx).queries.create_exclusion_list(
+            query_name=name,
+            domains=domain,
+            persona_ids=persona_id,
+            tags=tag,
+        )
+    )
+
+
+@app.command("update")
+@handle_errors
+def update_command(
+    ctx: typer.Context,
+    query_id: str = typer.Argument(...),
+    name: str | None = typer.Option(None, "--name"),
+    tag: list[str] | None = typer.Option(None, "--tag"),
+) -> None:
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).queries.update(query_id=query_id, query_name=name, tags=tag))
+
+
+@app.command("delete")
+@handle_errors
+def delete_command(ctx: typer.Context, query_id: str = typer.Argument(...)) -> None:
+    from discolike_cli.main import get_client
+
+    get_client(ctx).queries.delete(query_id=query_id)
+    emit({"deleted": query_id})

discolike_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: discolike-cli
+Version: 0.1.0
+Summary: Official CLI for the DiscoLike API
+Project-URL: Homepage, https://www.discolike.com
+Project-URL: Documentation, https://docs.discolike.com
+Project-URL: Repository, https://github.com/Discolike/discolike-python
+Author-email: DiscoLike <support@discolike.com>
+License-Expression: MIT
+Keywords: business-data,cli,discolike,enrichment
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: discolike>=0.1.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# discolike-cli
+
+Official CLI for the [DiscoLike API](https://www.discolike.com) — the `discolike` command from your terminal. Built on the [`discolike`](https://pypi.org/project/discolike/) SDK.
+
+## Installation
+
+```bash
+pip install discolike-cli
+```
+
+Or run it without installing:
+
+```bash
+uvx --from discolike-cli discolike --help
+```
+
+Requires Python 3.10+. Installing this package gives you the `discolike` command.
+
+## Authentication
+
+```bash
+discolike auth login
+```
+
+Prompts for an API key (or pass `--api-key`) and verifies it against your account. Create a key at [app.discolike.com/account/management/keys](https://app.discolike.com/account/management/keys). You can also set `DISCOLIKE_API_KEY` in the environment instead.
+
+## Quickstart
+
+```bash
+discolike discover --icp-text "managed IT services for SMBs" --country US --max-records 25
+discolike match "Stripe Inc" --city "San Francisco"
+discolike match --file companies.csv --name-column company_name --wait
+discolike count --phrase-match "book a demo" --country US
+discolike company data stripe.com
+discolike extract https://stripe.com/enterprise
+```
+
+Top-level commands: `discover`, `count`, `match`, `extract`, `validate-icp`, `append`, `segment` — plus `auth`, `company`, `contacts`, `discogen`, `queries`, and `account` command groups.
+
+### Conventions
+
+- Results print as JSON to stdout; errors print as JSON (`error`, `message`, `status_code`) to stderr.
+- Pass `--format table` for a human-readable table — used automatically when stdout is a TTY.
+- Async endpoints (`match --file`, `discogen run`, `discogen run-personas`, `segment`, `validate-icp`) take `--wait` to block until the job finishes. Without it, you get a `task_id` back to poll with `discolike discogen status <task_id> --family <family>`. `append` is synchronous — it returns enriched rows directly (or writes CSV bytes to `--output`).
+
+### Exit codes
+
+| Exit code | Meaning |
+|---|---|
+| 0 | Success |
+| 1 | Server error or unexpected failure |
+| 2 | Validation error |
+| 3 | Authentication or plan-access error |
+| 4 | Rate limited |
+| 5 | Network error |
+| 6 | Not found |
+
+## Links
+
+- **API documentation**: [docs.discolike.com](https://docs.discolike.com)
+- **Source**: [github.com/Discolike/discolike-python](https://github.com/Discolike/discolike-python)
+
+## License
+
+[MIT](https://github.com/Discolike/discolike-python/blob/main/LICENSE)

discolike_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+discolike_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+discolike_cli/_output.py,sha256=e1hjf1RTNxiXFJzUd0-3iEk8objeqTX59SgKsUQyfx4,4270
+discolike_cli/account.py,sha256=l6Xnx4D77CsiamTNyhfpJmxErU_TGD8rh-uoJdJ7J30,365
+discolike_cli/auth.py,sha256=Lm099QKljDgOM3EEh29yd7RYZzikXN_G5lAJbriEjKc,1534
+discolike_cli/company.py,sha256=ctE-zqQUAinS4VLqxVm_-WszhPWOZZgMJu94Q-8ldeU,2470
+discolike_cli/contacts.py,sha256=HJafEy3hkWdLuPYfivsZFKfyF35hoBWnY3spmb6WtbQ,8423
+discolike_cli/discogen.py,sha256=3a9MzP_ev1xsYhbVtUQF8GX5fK06QW_WXRiMMYDX_8I,4035
+discolike_cli/discover.py,sha256=HbW_sUIn54QnThoM-4OW-gjKZQn8p6bFNUj_WFfuzHU,4085
+discolike_cli/enrich.py,sha256=tlxlvRNkMnPP6WAnzA9ZfPyeRs6vYivJRr3SGifgLQQ,3200
+discolike_cli/main.py,sha256=yomidRmXoGsXa6MsQ-H9tQyNud0YFPttFi8qDLqhZTM,1943
+discolike_cli/match.py,sha256=MeIiiNyHMMB94763s9NaQqcyUVl9vBT38J9E7uSw1V8,1780
+discolike_cli/queries.py,sha256=WHuhihvRs6SS1HFMe3GOYMJ2wdtf17NsLgIDtIOryBY,1927
+discolike_cli-0.1.0.dist-info/METADATA,sha256=k_Uijf6u-kvxXdd5k8gfU2prR4X9804Uo0u4Hu4x9oU,3330
+discolike_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+discolike_cli-0.1.0.dist-info/entry_points.txt,sha256=j3pX_qdZxguS3cAlIQwl8QYNyG9-eOWg4R1aOpk6zis,53
+discolike_cli-0.1.0.dist-info/RECORD,,

discolike_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

discolike_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+discolike = discolike_cli.main:app